| 
					
				 | 
			
			
				@@ -459,14 +459,12 @@ selector: "instVarAt:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 category: 'accessing', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 fn: function (aSymbol){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx) { var varname; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-varname=_st(aSymbol)._asString(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return self['@'+varname]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx) { return self['@'+aSymbol._asString()]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 ; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, self, "instVarAt:", [aSymbol], smalltalk.Object)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aSymbol"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "instVarAt: aSymbol\x0a\x09| varname |\x0a\x09varname := aSymbol asString.\x0a\x09<return self['@'+varname]>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["asString"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "instVarAt: aSymbol\x0a\x09<return self['@'+aSymbol._asString()]>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.Object); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -478,14 +476,12 @@ selector: "instVarAt:put:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 category: 'accessing', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 fn: function (aSymbol,anObject){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx) { var varname; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-varname=_st(aSymbol)._asString(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self['@' + varname] = anObject; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx) { self['@' + aSymbol._asString()] = anObject; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 ; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, self, "instVarAt:put:", [aSymbol,anObject], smalltalk.Object)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aSymbol", "anObject"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "instVarAt: aSymbol put: anObject\x0a\x09| varname |\x0a\x09varname := aSymbol asString.\x0a\x09<self['@' + varname] = anObject>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["asString"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "instVarAt: aSymbol put: anObject\x0a\x09<self['@' + aSymbol._asString()] = anObject>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.Object); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -707,14 +703,12 @@ selector: "perform:withArguments:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 category: 'message handling', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 fn: function (aSymbol,aCollection){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx) { var selector; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-selector=_st(aSymbol)._asSelector(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.send(self, selector, aCollection); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx) { return smalltalk.send(self, aSymbol._asSelector(), aCollection); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 ; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, self, "perform:withArguments:", [aSymbol,aCollection], smalltalk.Object)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aSymbol", "aCollection"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "perform: aSymbol withArguments: aCollection\x0a\x09| selector |\x0a\x09selector := aSymbol asSelector.\x0a\x09<return smalltalk.send(self, selector, aCollection)>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["asSelector"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "perform: aSymbol withArguments: aCollection\x0a\x09<return smalltalk.send(self, aSymbol._asSelector(), aCollection)>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.Object); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -1452,6 +1446,24 @@ referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.CompiledMethod); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+"_printString", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "printString", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+category: 'accessing', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx) { var $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$1=_st(_st(_st(_st(self)._methodClass())._name()).__comma(" >> ")).__comma(_st(self)._selector()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, self, "printString", [], smalltalk.CompiledMethod)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "printString\x0a\x09^ self methodClass name, ' >> ', self selector", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: [",", "selector", "name", "methodClass"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.CompiledMethod); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 "_protocol", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.method({ 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2268,14 +2280,12 @@ selector: "at:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 category: 'accessing', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 fn: function (aSymbol){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx) { var attr; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-attr=_st(aSymbol)._asString(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return self['@jsObject'][attr]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx) { return self['@jsObject'][aSymbol._asString()]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 ; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, self, "at:", [aSymbol], smalltalk.JSObjectProxy)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aSymbol"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "at: aSymbol\x0a\x09| attr |\x0a\x09attr := aSymbol asString.\x0a\x09<return self['@jsObject'][attr]>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["asString"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "at: aSymbol\x0a\x09<return self['@jsObject'][aSymbol._asString()]>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.JSObjectProxy); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2287,14 +2297,29 @@ selector: "at:put:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 category: 'accessing', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 fn: function (aSymbol,anObject){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx) { var attr; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-attr=_st(aSymbol)._asString(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self['@jsObject'][attr] = anObject; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx) { self['@jsObject'][aSymbol._asString()] = anObject; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 ; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, self, "at:put:", [aSymbol,anObject], smalltalk.JSObjectProxy)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aSymbol", "anObject"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "at: aSymbol put: anObject\x0a\x09| attr |\x0a\x09attr := aSymbol asString.\x0a\x09<self['@jsObject'][attr] = anObject>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["asString"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "at: aSymbol put: anObject\x0a\x09<self['@jsObject'][aSymbol._asString()] = anObject>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.JSObjectProxy); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+"_canUnderstand_", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "canUnderstand:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+category: 'proxy', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (aSelector){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx) { return self._jsObject()[aSelector._asJavaScriptSelector()] != undefined; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return self}, self, "canUnderstand:", [aSelector], smalltalk.JSObjectProxy)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: ["aSelector"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "canUnderstand: aSelector\x0a\x09<return self._jsObject()[aSelector._asJavaScriptSelector()] != undefined>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.JSObjectProxy); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2306,7 +2331,8 @@ selector: "doesNotUnderstand:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 category: 'proxy', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 fn: function (aMessage){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx) { var obj; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx) { var $1,$2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var obj; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var selector; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var jsSelector; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var arguments; 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2314,14 +2340,17 @@ obj=_st(self)._jsObject(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 selector=_st(aMessage)._selector(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 jsSelector=_st(selector)._asJavaScriptSelector(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 arguments=_st(aMessage)._arguments(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-if(obj[jsSelector] != undefined) {return smalltalk.send(obj, jsSelector, arguments)}; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$1=_st(self)._canUnderstand_(selector); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+if(smalltalk.assert($1)){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$2=_st(_st((smalltalk.Smalltalk || Smalltalk))._current())._basicSend_to_arguments_(jsSelector,obj,arguments); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return $2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.Object.fn.prototype._doesNotUnderstand_.apply(_st(self), [aMessage]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, self, "doesNotUnderstand:", [aMessage], smalltalk.JSObjectProxy)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aMessage"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "doesNotUnderstand: aMessage\x0a\x09| obj selector jsSelector arguments |\x0a\x09obj := self jsObject.\x0a\x09selector := aMessage selector.\x0a\x09jsSelector := selector asJavaScriptSelector.\x0a\x09arguments := aMessage arguments.\x0a\x09<if(obj[jsSelector] != undefined) {return smalltalk.send(obj, jsSelector, arguments)}>.\x0a\x09super doesNotUnderstand: aMessage", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["jsObject", "selector", "asJavaScriptSelector", "arguments", "doesNotUnderstand:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "doesNotUnderstand: aMessage\x0a\x09| obj selector jsSelector arguments |\x0a\x09obj := self jsObject.\x0a\x09selector := aMessage selector.\x0a\x09jsSelector := selector asJavaScriptSelector.\x0a\x09arguments := aMessage arguments.\x0a    (self canUnderstand: selector) ifTrue: [\x0a      \x09^ Smalltalk current basicSend: jsSelector to: obj arguments: arguments ].\x0a\x09super doesNotUnderstand: aMessage", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["jsObject", "selector", "asJavaScriptSelector", "arguments", "ifTrue:", "basicSend:to:arguments:", "current", "canUnderstand:", "doesNotUnderstand:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: ["Smalltalk"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.JSObjectProxy); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -2333,19 +2362,38 @@ category: 'proxy', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 fn: function (anInspector){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx) { var variables; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-variables=_st((smalltalk.Dictionary || Dictionary))._new(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+variables=_st(self)._inspectorVariables(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(variables)._at_put_("#self",_st(self)._jsObject()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(anInspector)._setLabel_(_st(self)._printString()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-for(var i in self['@jsObject']) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-		variables._at_put_(i, self['@jsObject'][i]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-	}; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(anInspector)._setVariables_(variables); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, self, "inspectOn:", [anInspector], smalltalk.JSObjectProxy)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anInspector"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "inspectOn: anInspector\x0a\x09| variables |\x0a\x09variables := Dictionary new.\x0a\x09variables at: '#self' put: self jsObject.\x0a\x09anInspector setLabel: self printString.\x0a\x09<for(var i in self['@jsObject']) {\x0a\x09\x09variables._at_put_(i, self['@jsObject'][i]);\x0a\x09}>.\x0a\x09anInspector setVariables: variables", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["new", "at:put:", "jsObject", "setLabel:", "printString", "setVariables:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: ["Dictionary"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "inspectOn: anInspector\x0a\x09| variables |\x0a\x09variables := self inspectorVariables.\x0a\x09variables at: '#self' put: self jsObject.\x0a\x09anInspector setLabel: self printString.\x0a\x09anInspector setVariables: variables", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["inspectorVariables", "at:put:", "jsObject", "setLabel:", "printString", "setVariables:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.JSObjectProxy); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+"_inspectorVariables", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "inspectorVariables", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+category: 'proxy', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    	var variables = smalltalk.Dictionary._new(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        for(var i in self['@jsObject']) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+			variables._at_put_(i, self['@jsObject'][i]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+		}; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        return variables 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return self}, self, "inspectorVariables", [], smalltalk.JSObjectProxy)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "inspectorVariables\x0a\x09<\x0a    \x09var variables = smalltalk.Dictionary._new();\x0a        for(var i in self['@jsObject']) {\x0a\x09\x09\x09variables._at_put_(i, self['@jsObject'][i]);\x0a\x09\x09};\x0a        return variables\x0a    >", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.JSObjectProxy); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -3265,21 +3313,18 @@ selector: "truncated", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 category: 'converting', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx) { var $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var result; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$1=_st(self).__gt_eq((0)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-if(smalltalk.assert($1)){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-result = Math.floor(self);; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-} else { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-result = (Math.floor(self * (-1)) * (-1));; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    	if(self >= 0) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        	return Math.floor(self); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        } else { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        	return Math.floor(self * (-1)) * (-1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 ; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return result; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, self, "truncated", [], smalltalk.Number)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return self}, self, "truncated", [], smalltalk.Number)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "truncated\x0a|result|\x0a\x0a    self >= 0 \x0a        ifTrue: [<result = Math.floor(self);>]\x0a        ifFalse: [<result = (Math.floor(self * (-1)) * (-1));>].\x0a\x0a    ^ result", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifTrue:ifFalse:", ">="], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "truncated\x0a\x09<\x0a    \x09if(self >>= 0) {\x0a        \x09return Math.floor(self);\x0a        } else {\x0a        \x09return Math.floor(self * (-1)) * (-1);\x0a        }\x0a    >", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.Number); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -3638,8 +3683,7 @@ selector: "properties:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 category: 'accessing', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 fn: function (aDict){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx) { var object; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-object = {};; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx) { var object = {};; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 ; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(aDict)._keysAndValuesDo_((function(key,value){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return object[key] = value; 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -3649,7 +3693,7 @@ return self.properties = object; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 ; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, self, "properties:", [aDict], smalltalk.Package)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aDict"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "properties: aDict\x0a\x09\x22We store it as a javascript object.\x22\x0a\x09\x0a\x09| object |\x0a\x09<object = {};>.\x0a\x09aDict keysAndValuesDo: [:key :value |\x0a\x09\x09<object[key] = value>.\x0a\x09].\x0a\x09<return self.properties = object>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "properties: aDict\x0a\x09\x22We store it as a javascript object.\x22\x0a\x09\x0a\x09<var object = {};>.\x0a\x09aDict keysAndValuesDo: [:key :value |\x0a\x09\x09<object[key] = value>.\x0a\x09].\x0a\x09<return self.properties = object>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 messageSends: ["keysAndValuesDo:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -4324,6 +4368,23 @@ referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.Smalltalk); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+"_basicSend_to_arguments_", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "basicSend:to:arguments:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+category: 'accessing', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (aSelector,anObject,aCollection){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx) { return self.send(anObject, aSelector, aCollection); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return self}, self, "basicSend:to:arguments:", [aSelector,anObject,aCollection], smalltalk.Smalltalk)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: ["aSelector", "anObject", "aCollection"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "basicSend: aSelector to: anObject arguments: aCollection\x0a\x09<return self.send(anObject, aSelector, aCollection)>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.Smalltalk); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 "_classes", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.method({ 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -4365,8 +4426,7 @@ selector: "createPackage:properties:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 category: 'private', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 fn: function (packageName,aDict){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx) { var object; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-object = {};; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx) { var object = {};; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 ; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(aDict)._keysAndValuesDo_((function(key,value){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return object[key] = value; 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -4376,7 +4436,7 @@ return smalltalk.addPackage(packageName, object); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 ; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, self, "createPackage:properties:", [packageName,aDict], smalltalk.Smalltalk)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["packageName", "aDict"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "createPackage: packageName properties: aDict\x0a\x09\x22Create and bind a new package with given name and return it.\x22\x0a\x0a\x09| object |\x0a\x09<object = {};>.\x0a\x09aDict keysAndValuesDo: [:key :value |\x0a\x09\x09<object[key] = value>.\x0a\x09].\x0a       <return smalltalk.addPackage(packageName, object)>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "createPackage: packageName properties: aDict\x0a\x09\x22Create and bind a new package with given name and return it.\x22\x0a\x0a\x09<var object = {};>.\x0a\x09aDict keysAndValuesDo: [:key :value |\x0a\x09\x09<object[key] = value>.\x0a\x09].\x0a       <return smalltalk.addPackage(packageName, object)>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 messageSends: ["keysAndValuesDo:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -4452,6 +4512,23 @@ referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.Smalltalk); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+"_packageAt_put_", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "packageAt:put:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+category: 'packages', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (packageName,aPackage){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx) { return self.packages[packageName] = aPackage; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return self}, self, "packageAt:put:", [packageName,aPackage], smalltalk.Smalltalk)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: ["packageName", "aPackage"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "packageAt: packageName put: aPackage\x0a       <return self.packages[packageName] = aPackage>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.Smalltalk); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 "_packages", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.method({ 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -4506,10 +4583,9 @@ var message; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var lines; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var badLine; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var code; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-row = anException.line; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-	col = anException.column; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-	message = anException.message;; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+row=_st(anException)._basicAt_("line"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+col=_st(anException)._basicAt_("column"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+message=_st(anException)._basicAt_("message"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 lines=_st(aString)._lines(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 badLine=_st(lines)._at_(row); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 badLine=_st(_st(_st(badLine)._copyFrom_to_((1),_st(col).__minus((1)))).__comma(" ===>")).__comma(_st(badLine)._copyFrom_to_(col,_st(badLine)._size())); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -4523,8 +4599,8 @@ $1=_st(_st((smalltalk.ParseError || ParseError))._new())._messageText_(_st(_st(_ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }, self, "parseError:parsing:", [anException,aString], smalltalk.Smalltalk)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["anException", "aString"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "parseError: anException parsing: aString\x0a\x09| row col message lines badLine code |\x0a\x09<row = anException.line;\x0a\x09col = anException.column;\x0a\x09message = anException.message;>.\x0a\x09lines := aString lines.\x0a\x09badLine := lines at: row.\x0a\x09badLine := (badLine copyFrom: 1 to: col - 1), ' ===>', (badLine copyFrom:  col to: badLine size).\x0a\x09lines at: row put: badLine.\x0a\x09code := String streamContents: [:s |\x0a                  lines withIndexDo: [:l :i |\x0a                     s nextPutAll: i asString, ': ', l, String lf]].\x0a\x09^ ParseError new messageText: ('Parse error on line ' , row , ' column ' , col , ' : ' , message , ' Below is code with line numbers and ===> marker inserted:' , String lf, code)", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["lines", "at:", ",", "copyFrom:to:", "size", "-", "at:put:", "streamContents:", "withIndexDo:", "nextPutAll:", "lf", "asString", "messageText:", "new"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "parseError: anException parsing: aString\x0a\x09| row col message lines badLine code |\x0a\x09row := anException basicAt: 'line'.\x0a    col := anException basicAt: 'column'.\x0a    message := anException basicAt: 'message'.\x0a\x09lines := aString lines.\x0a\x09badLine := lines at: row.\x0a\x09badLine := (badLine copyFrom: 1 to: col - 1), ' ===>', (badLine copyFrom:  col to: badLine size).\x0a\x09lines at: row put: badLine.\x0a\x09code := String streamContents: [:s |\x0a                  lines withIndexDo: [:l :i |\x0a                     s nextPutAll: i asString, ': ', l, String lf]].\x0a\x09^ ParseError new messageText: ('Parse error on line ' , row , ' column ' , col , ' : ' , message , ' Below is code with line numbers and ===> marker inserted:' , String lf, code)", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["basicAt:", "lines", "at:", ",", "copyFrom:to:", "size", "-", "at:put:", "streamContents:", "withIndexDo:", "nextPutAll:", "lf", "asString", "messageText:", "new"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: ["String", "ParseError"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.Smalltalk); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -4634,14 +4710,13 @@ $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 } else { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(self)._error_(_st("Already exists a package called: ").__comma(newName)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.packages[newName] = smalltalk.packages[packageName]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st(self)._packageAt_put_(newName,pkg); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(pkg)._name_(newName); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st(self)._deletePackage_(packageName); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, self, "renamePackage:to:", [packageName,newName], smalltalk.Smalltalk)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["packageName", "newName"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "renamePackage: packageName to: newName\x0a\x09\x22Rename a package.\x22\x0a\x0a\x09| pkg |\x0a\x09pkg := self packageAt: packageName ifAbsent: [self error: 'Missing package: ', packageName].\x0a\x09(self packageAt: newName) ifNotNil: [self error: 'Already exists a package called: ', newName].\x0a\x09<smalltalk.packages[newName] = smalltalk.packages[packageName]>.\x0a\x09pkg name: newName.\x0a\x09self deletePackage: packageName.", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["packageAt:ifAbsent:", "error:", ",", "ifNotNil:", "packageAt:", "name:", "deletePackage:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "renamePackage: packageName to: newName\x0a\x09\x22Rename a package.\x22\x0a\x0a\x09| pkg |\x0a\x09pkg := self packageAt: packageName ifAbsent: [self error: 'Missing package: ', packageName].\x0a\x09(self packageAt: newName) ifNotNil: [self error: 'Already exists a package called: ', newName].\x0a\x09self packageAt: newName put: pkg.\x0a\x09pkg name: newName.\x0a\x09self deletePackage: packageName.", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["packageAt:ifAbsent:", "error:", ",", "ifNotNil:", "packageAt:", "packageAt:put:", "name:", "deletePackage:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.Smalltalk); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -4670,14 +4745,13 @@ selector: "send:to:arguments:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 category: 'accessing', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 fn: function (aSelector,anObject,aCollection){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx) { var selector; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-selector=_st(_st(aSelector)._asString())._asSelector(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return self.send(anObject, selector, aCollection); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return self}, self, "send:to:arguments:", [aSelector,anObject,aCollection], smalltalk.Smalltalk)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx) { var $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$1=_st(self)._basicSend_to_arguments_(_st(_st(aSelector)._asString())._asSelector(),anObject,aCollection); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, self, "send:to:arguments:", [aSelector,anObject,aCollection], smalltalk.Smalltalk)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aSelector", "anObject", "aCollection"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "send: aSelector to: anObject arguments: aCollection\x0a\x09| selector |\x0a\x09selector := aSelector asString asSelector.\x0a\x09<return self.send(anObject, selector, aCollection)>", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["asSelector", "asString"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "send: aSelector to: anObject arguments: aCollection\x0a\x09^ self basicSend: aSelector asString asSelector to: anObject arguments: aCollection", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["basicSend:to:arguments:", "asSelector", "asString"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.Smalltalk); 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -4704,6 +4778,21 @@ smalltalk.Smalltalk.klass); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.addClass('UndefinedObject', smalltalk.Object, [], 'Kernel-Objects'); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.UndefinedObject.comment="UndefinedObject describes the behavior of its sole instance, `nil`. `nil` represents a prior value for variables that have not been initialized, or for results which are meaningless.\x0a\x0a`nil` is the Smalltalk representation of the `undefined` JavaScript object." 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+"_accept_", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "accept:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+category: 'converting', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (aVisitor){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx) { return self}, self, "accept:", [aVisitor], smalltalk.UndefinedObject)}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: ["aVisitor"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "accept: aVisitor", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.UndefinedObject); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 "_asJSON", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.method({ 
			 |