export/compile uses globals

js/Benchfib.js

@@ -1,8 +1,8 @@
-define("amber_core/Benchfib", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st){
+define("amber_core/Benchfib", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Benchfib');
 smalltalk.packages["Benchfib"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('Benchfib', smalltalk.Object, [], 'Benchfib');
+smalltalk.addClass('Benchfib', globals.Object, [], 'Benchfib');
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -14,13 +14,13 @@ var result;
 return smalltalk.withContext(function($ctx1) { 
 result=(0)._tinyBenchmarks();
 _st(console)._log_("0 tinyBenchmarks => ".__comma(result));
-return self}, function($ctx1) {$ctx1.fill(self,"main",{result:result},smalltalk.Benchfib.klass)})},
+return self}, function($ctx1) {$ctx1.fill(self,"main",{result:result},globals.Benchfib.klass)})},
 args: [],
 source: "main\x0a\x0a\x09| result |\x0a\x09result := 0 tinyBenchmarks.\x0a\x09console log: '0 tinyBenchmarks => ' , result",
 messageSends: ["tinyBenchmarks", "log:", ","],
 referencedClasses: []
 }),
-smalltalk.Benchfib.klass);
+globals.Benchfib.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -43,13 +43,13 @@ $1=_st($3).__plus((1));
 $ctx1.sendIdx["+"]=1;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"benchFib",{},smalltalk.Number)})},
+}, function($ctx1) {$ctx1.fill(self,"benchFib",{},globals.Number)})},
 args: [],
 source: "benchFib\x0a\x09\x22Handy send-heavy benchmark\x22\x0a\x09\x22(result // seconds to run) = approx calls per second\x22\x0a\x09\x22\x09| r t |\x0a\x09\x09t := Time millisecondsToRun: [r := 26 benchFib].\x0a\x09\x09(r * 1000) // t\x22\x0a\x09\x22138000 on a Mac 8100/100\x22\x0a\x09^ self < 2\x0a\x09\x09ifTrue: [1]\x0a\x09\x09ifFalse: [(self-1) benchFib + (self-2) benchFib + 1]",
 messageSends: ["ifTrue:ifFalse:", "<", "+", "benchFib", "-"],
 referencedClasses: []
 }),
-smalltalk.Number);
+globals.Number);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -58,7 +58,7 @@ protocol: '*Benchfib',
 fn: function (){
 var self=this;
 var size,flags,prime,k,count;
-function $Array(){return smalltalk.Array||(typeof Array=="undefined"?nil:Array)}
+function $Array(){return globals.Array||(typeof Array=="undefined"?nil:Array)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
 size=(8190);
@@ -100,13 +100,13 @@ return count;
 $ctx1.sendIdx["to:do:"]=1;
 $2=count;
 return $2;
-}, function($ctx1) {$ctx1.fill(self,"benchmark",{size:size,flags:flags,prime:prime,k:k,count:count},smalltalk.Number)})},
+}, function($ctx1) {$ctx1.fill(self,"benchmark",{size:size,flags:flags,prime:prime,k:k,count:count},globals.Number)})},
 args: [],
 source: "benchmark\x0a\x09\x22Handy bytecode-heavy benchmark\x22\x0a\x09\x22(500000 // time to run) = approx bytecodes per second\x22\x0a\x09\x225000000 // (Time millisecondsToRun: [10 benchmark]) * 1000\x22\x0a\x09\x223059000 on a Mac 8100/100\x22\x0a\x09| size flags prime k count |\x0a\x09size := 8190.\x0a\x091 to: self do:\x0a\x09\x09[:iter |\x0a\x09\x09count := 0.\x0a\x09\x09flags := Array new.\x0a\x09\x09size timesRepeat: [ flags add: true].\x0a\x09\x091 to: size do:\x0a\x09\x09\x09[:i | (flags at: i) ifTrue:\x0a\x09\x09\x09\x09[prime := i+1.\x0a\x09\x09\x09\x09k := i + prime.\x0a\x09\x09\x09\x09[k <= size] whileTrue:\x0a\x09\x09\x09\x09\x09[flags at: k put: false.\x0a\x09\x09\x09\x09\x09k := k + prime].\x0a\x09\x09\x09\x09count := count + 1]]].\x0a\x09^ count",
 messageSends: ["to:do:", "new", "timesRepeat:", "add:", "ifTrue:", "at:", "+", "whileTrue:", "<=", "at:put:"],
 referencedClasses: ["Array"]
 }),
-smalltalk.Number);
+globals.Number);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -124,7 +124,7 @@ source: "jsbenchFib\x0a\x0a\x09<if (this < 2) {\x0areturn 1;\x0a} else {\x0aretu
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Number);
+globals.Number);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -160,7 +160,7 @@ source: "jsbenchmark\x0a\x0a<\x0avar size = 8190;\x0avar count;\x0afor (var z=0;
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Number);
+globals.Number);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -169,7 +169,7 @@ protocol: '*Benchfib',
 fn: function (){
 var self=this;
 var t1,t2,r,n1,n2;
-function $Date(){return smalltalk.Date||(typeof Date=="undefined"?nil:Date)}
+function $Date(){return globals.Date||(typeof Date=="undefined"?nil:Date)}
 return smalltalk.withContext(function($ctx1) { 
 var $7,$6,$5,$4,$3,$2,$1;
 n1=(1);
@@ -219,13 +219,13 @@ $ctx1.sendIdx[","]=2;
 $1=_st($2).__comma(" sends/sec");
 $ctx1.sendIdx[","]=1;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"jstinyBenchmarks",{t1:t1,t2:t2,r:r,n1:n1,n2:n2},smalltalk.Number)})},
+}, function($ctx1) {$ctx1.fill(self,"jstinyBenchmarks",{t1:t1,t2:t2,r:r,n1:n1,n2:n2},globals.Number)})},
 args: [],
 source: "jstinyBenchmarks\x0a\x09\x220 jstinyBenchmarks\x22\x0a\x0a\x09| t1 t2 r n1 n2 |\x0a\x09n1 := 1.\x0a\x09[t1 := Date millisecondsToRun: [n1 jsbenchmark].\x0a\x09t1 < 1000] whileTrue:[n1 := n1 * 2]. \x22Note: #benchmark's runtime is about O(n)\x22\x0a\x0a\x09n2 := 28.\x0a\x09[t2 := Date millisecondsToRun: [r := n2 jsbenchFib].\x0a\x09t2 < 1000] whileTrue:[n2 := n2 + 1].\x0a\x09\x22Note: #jsbenchFib's runtime is about O(k^n),\x0a\x09\x09where k is the golden number = (1 + 5 sqrt) / 2 = 1.618....\x22\x0a\x0a\x09^ ((n1 * 500000 * 1000) / t1) printString, ' bytecodes/sec; ',\x0a\x09\x09((r * 1000) / t2) printString, ' sends/sec'",
 messageSends: ["whileTrue:", "millisecondsToRun:", "jsbenchmark", "<", "*", "jsbenchFib", "+", ",", "printString", "/"],
 referencedClasses: ["Date"]
 }),
-smalltalk.Number);
+globals.Number);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -234,7 +234,7 @@ protocol: '*Benchfib',
 fn: function (){
 var self=this;
 var t1,t2,r,n1,n2;
-function $Date(){return smalltalk.Date||(typeof Date=="undefined"?nil:Date)}
+function $Date(){return globals.Date||(typeof Date=="undefined"?nil:Date)}
 return smalltalk.withContext(function($ctx1) { 
 var $7,$6,$5,$4,$3,$2,$1;
 n1=(1);
@@ -284,12 +284,12 @@ $ctx1.sendIdx[","]=2;
 $1=_st($2).__comma(" sends/sec");
 $ctx1.sendIdx[","]=1;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"tinyBenchmarks",{t1:t1,t2:t2,r:r,n1:n1,n2:n2},smalltalk.Number)})},
+}, function($ctx1) {$ctx1.fill(self,"tinyBenchmarks",{t1:t1,t2:t2,r:r,n1:n1,n2:n2},globals.Number)})},
 args: [],
 source: "tinyBenchmarks\x0a\x09\x22Report the results of running the two tiny Squeak benchmarks.\x0a\x09ar 9/10/1999: Adjusted to run at least 1 sec to get more stable results\x22\x0a\x09\x220 tinyBenchmarks\x22\x0a\x09\x22On a 292 MHz G3 Mac: 22727272 bytecodes/sec; 984169 sends/sec\x22\x0a\x09\x22On a 400 MHz PII/Win98: 18028169 bytecodes/sec; 1081272 sends/sec\x22\x0a\x09| t1 t2 r n1 n2 |\x0a\x09n1 := 1.\x0a\x09[t1 := Date millisecondsToRun: [n1 benchmark].\x0a\x09t1 < 1000] whileTrue:[n1 := n1 * 2]. \x22Note: #benchmark's runtime is about O(n)\x22\x0a\x0a\x09n2 := 16.\x0a\x09[t2 := Date millisecondsToRun: [r := n2 benchFib].\x0a\x09t2 < 1000] whileTrue:[n2 := n2 + 1].\x0a\x09\x22Note: #benchFib's runtime is about O(k^n),\x0a\x09\x09where k is the golden number = (1 + 5 sqrt) / 2 = 1.618....\x22\x0a\x0a\x09^ ((n1 * 500000 * 1000) / t1) printString, ' bytecodes/sec; ',\x0a\x09\x09((r * 1000) / t2) printString, ' sends/sec'",
 messageSends: ["whileTrue:", "millisecondsToRun:", "benchmark", "<", "*", "benchFib", "+", ",", "printString", "/"],
 referencedClasses: ["Date"]
 }),
-smalltalk.Number);
+globals.Number);
 
 });

js/Compiler-Core.js

@@ -1,9 +1,9 @@
-define("amber_core/Compiler-Core", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Objects", "amber_core/Kernel-Collections"], function(smalltalk,nil,_st){
+define("amber_core/Compiler-Core", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects", "amber_core/Kernel-Collections"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Compiler-Core');
 smalltalk.packages["Compiler-Core"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('AbstractCodeGenerator', smalltalk.Object, ['currentClass', 'source'], 'Compiler-Core');
-smalltalk.AbstractCodeGenerator.comment="I am the abstract super class of all code generators and provide their common API.";
+smalltalk.addClass('AbstractCodeGenerator', globals.Object, ['currentClass', 'source'], 'Compiler-Core');
+globals.AbstractCodeGenerator.comment="I am the abstract super class of all code generators and provide their common API.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "classNameFor:",
@@ -26,13 +26,13 @@ $1=_st(aClass)._name();
 };
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"classNameFor:",{aClass:aClass},smalltalk.AbstractCodeGenerator)})},
+}, function($ctx1) {$ctx1.fill(self,"classNameFor:",{aClass:aClass},globals.AbstractCodeGenerator)})},
 args: ["aClass"],
 source: "classNameFor: aClass\x0a\x09^ aClass isMetaclass\x0a\x09\x09ifTrue: [ aClass instanceClass name, '.klass' ]\x0a\x09\x09ifFalse: [\x0a\x09\x09aClass isNil\x0a\x09\x09\x09ifTrue: [ 'nil' ]\x0a\x09\x09\x09ifFalse: [ aClass name ]]",
 messageSends: ["ifTrue:ifFalse:", "isMetaclass", ",", "name", "instanceClass", "isNil"],
 referencedClasses: []
 }),
-smalltalk.AbstractCodeGenerator);
+globals.AbstractCodeGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -42,13 +42,13 @@ fn: function (aNode){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._subclassResponsibility();
-return self}, function($ctx1) {$ctx1.fill(self,"compileNode:",{aNode:aNode},smalltalk.AbstractCodeGenerator)})},
+return self}, function($ctx1) {$ctx1.fill(self,"compileNode:",{aNode:aNode},globals.AbstractCodeGenerator)})},
 args: ["aNode"],
 source: "compileNode: aNode\x0a\x09self subclassResponsibility",
 messageSends: ["subclassResponsibility"],
 referencedClasses: []
 }),
-smalltalk.AbstractCodeGenerator);
+globals.AbstractCodeGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -65,7 +65,7 @@ source: "currentClass\x0a\x09^ currentClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.AbstractCodeGenerator);
+globals.AbstractCodeGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -80,7 +80,7 @@ source: "currentClass: aClass\x0a\x09currentClass := aClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.AbstractCodeGenerator);
+globals.AbstractCodeGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -88,18 +88,18 @@ selector: "pseudoVariables",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
+function $Smalltalk(){return globals.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
 return smalltalk.withContext(function($ctx1) { 
 var $1;
 $1=_st($Smalltalk())._pseudoVariableNames();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"pseudoVariables",{},smalltalk.AbstractCodeGenerator)})},
+}, function($ctx1) {$ctx1.fill(self,"pseudoVariables",{},globals.AbstractCodeGenerator)})},
 args: [],
 source: "pseudoVariables\x0a\x09^ Smalltalk pseudoVariableNames",
 messageSends: ["pseudoVariableNames"],
 referencedClasses: ["Smalltalk"]
 }),
-smalltalk.AbstractCodeGenerator);
+globals.AbstractCodeGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -116,13 +116,13 @@ $1="";
 $1=$2;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"source",{},smalltalk.AbstractCodeGenerator)})},
+}, function($ctx1) {$ctx1.fill(self,"source",{},globals.AbstractCodeGenerator)})},
 args: [],
 source: "source\x0a\x09^ source ifNil: [ '' ]",
 messageSends: ["ifNil:"],
 referencedClasses: []
 }),
-smalltalk.AbstractCodeGenerator);
+globals.AbstractCodeGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -137,12 +137,12 @@ source: "source: aString\x0a\x09source := aString",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.AbstractCodeGenerator);
+globals.AbstractCodeGenerator);
 
 
 
-smalltalk.addClass('CodeGenerator', smalltalk.AbstractCodeGenerator, [], 'Compiler-Core');
-smalltalk.CodeGenerator.comment="I am a basic code generator. I generate a valid JavaScript output, but no not perform any inlining.\x0aSee `InliningCodeGenerator` for an optimized JavaScript code generation.";
+smalltalk.addClass('CodeGenerator', globals.AbstractCodeGenerator, [], 'Compiler-Core');
+globals.CodeGenerator.comment="I am a basic code generator. I generate a valid JavaScript output, but no not perform any inlining.\x0aSee `InliningCodeGenerator` for an optimized JavaScript code generation.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "compileNode:",
@@ -162,13 +162,13 @@ _st($2)._visit_(ir);
 $3=_st($2)._contents();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"compileNode:",{aNode:aNode,ir:ir,stream:stream},smalltalk.CodeGenerator)})},
+}, function($ctx1) {$ctx1.fill(self,"compileNode:",{aNode:aNode,ir:ir,stream:stream},globals.CodeGenerator)})},
 args: ["aNode"],
 source: "compileNode: aNode\x0a\x09| ir stream |\x0a\x09self semanticAnalyzer visit: aNode.\x0a\x09ir := self translator visit: aNode.\x0a\x09^ self irTranslator\x0a\x09\x09currentClass: self currentClass;\x0a\x09\x09visit: ir;\x0a\x09\x09contents",
 messageSends: ["visit:", "semanticAnalyzer", "translator", "currentClass:", "irTranslator", "currentClass", "contents"],
 referencedClasses: []
 }),
-smalltalk.CodeGenerator);
+globals.CodeGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -176,18 +176,18 @@ selector: "irTranslator",
 protocol: 'compiling',
 fn: function (){
 var self=this;
-function $IRJSTranslator(){return smalltalk.IRJSTranslator||(typeof IRJSTranslator=="undefined"?nil:IRJSTranslator)}
+function $IRJSTranslator(){return globals.IRJSTranslator||(typeof IRJSTranslator=="undefined"?nil:IRJSTranslator)}
 return smalltalk.withContext(function($ctx1) { 
 var $1;
 $1=_st($IRJSTranslator())._new();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"irTranslator",{},smalltalk.CodeGenerator)})},
+}, function($ctx1) {$ctx1.fill(self,"irTranslator",{},globals.CodeGenerator)})},
 args: [],
 source: "irTranslator\x0a\x09^ IRJSTranslator new",
 messageSends: ["new"],
 referencedClasses: ["IRJSTranslator"]
 }),
-smalltalk.CodeGenerator);
+globals.CodeGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -195,18 +195,18 @@ selector: "semanticAnalyzer",
 protocol: 'compiling',
 fn: function (){
 var self=this;
-function $SemanticAnalyzer(){return smalltalk.SemanticAnalyzer||(typeof SemanticAnalyzer=="undefined"?nil:SemanticAnalyzer)}
+function $SemanticAnalyzer(){return globals.SemanticAnalyzer||(typeof SemanticAnalyzer=="undefined"?nil:SemanticAnalyzer)}
 return smalltalk.withContext(function($ctx1) { 
 var $1;
 $1=_st($SemanticAnalyzer())._on_(self._currentClass());
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"semanticAnalyzer",{},smalltalk.CodeGenerator)})},
+}, function($ctx1) {$ctx1.fill(self,"semanticAnalyzer",{},globals.CodeGenerator)})},
 args: [],
 source: "semanticAnalyzer\x0a\x09^ SemanticAnalyzer on: self currentClass",
 messageSends: ["on:", "currentClass"],
 referencedClasses: ["SemanticAnalyzer"]
 }),
-smalltalk.CodeGenerator);
+globals.CodeGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -214,7 +214,7 @@ selector: "translator",
 protocol: 'compiling',
 fn: function (){
 var self=this;
-function $IRASTTranslator(){return smalltalk.IRASTTranslator||(typeof IRASTTranslator=="undefined"?nil:IRASTTranslator)}
+function $IRASTTranslator(){return globals.IRASTTranslator||(typeof IRASTTranslator=="undefined"?nil:IRASTTranslator)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$3,$1;
 $2=_st($IRASTTranslator())._new();
@@ -223,25 +223,25 @@ _st($2)._theClass_(self._currentClass());
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"translator",{},smalltalk.CodeGenerator)})},
+}, function($ctx1) {$ctx1.fill(self,"translator",{},globals.CodeGenerator)})},
 args: [],
 source: "translator\x0a\x09^ IRASTTranslator new\x0a\x09\x09source: self source;\x0a\x09\x09theClass: self currentClass;\x0a\x09\x09yourself",
 messageSends: ["source:", "new", "source", "theClass:", "currentClass", "yourself"],
 referencedClasses: ["IRASTTranslator"]
 }),
-smalltalk.CodeGenerator);
+globals.CodeGenerator);
 
 
 
-smalltalk.addClass('Compiler', smalltalk.Object, ['currentClass', 'source', 'unknownVariables', 'codeGeneratorClass'], 'Compiler-Core');
-smalltalk.Compiler.comment="I provide the public interface for compiling Amber source code into JavaScript.\x0a\x0aThe code generator used to produce JavaScript can be plugged with `#codeGeneratorClass`.\x0aThe default code generator is an instance of `InlinedCodeGenerator`";
+smalltalk.addClass('Compiler', globals.Object, ['currentClass', 'source', 'unknownVariables', 'codeGeneratorClass'], 'Compiler-Core');
+globals.Compiler.comment="I provide the public interface for compiling Amber source code into JavaScript.\x0a\x0aThe code generator used to produce JavaScript can be plugged with `#codeGeneratorClass`.\x0aThe default code generator is an instance of `InlinedCodeGenerator`";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "codeGeneratorClass",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-function $InliningCodeGenerator(){return smalltalk.InliningCodeGenerator||(typeof InliningCodeGenerator=="undefined"?nil:InliningCodeGenerator)}
+function $InliningCodeGenerator(){return globals.InliningCodeGenerator||(typeof InliningCodeGenerator=="undefined"?nil:InliningCodeGenerator)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$1;
 $2=self["@codeGeneratorClass"];
@@ -251,13 +251,13 @@ $1=$InliningCodeGenerator();
 $1=$2;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"codeGeneratorClass",{},smalltalk.Compiler)})},
+}, function($ctx1) {$ctx1.fill(self,"codeGeneratorClass",{},globals.Compiler)})},
 args: [],
 source: "codeGeneratorClass\x0a\x09^ codeGeneratorClass ifNil: [ InliningCodeGenerator ]",
 messageSends: ["ifNil:"],
 referencedClasses: ["InliningCodeGenerator"]
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -272,7 +272,7 @@ source: "codeGeneratorClass: aClass\x0a\x09codeGeneratorClass := aClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -284,13 +284,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._compileNode_(self._parse_(aString));
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"compile:",{aString:aString},smalltalk.Compiler)})},
+}, function($ctx1) {$ctx1.fill(self,"compile:",{aString:aString},globals.Compiler)})},
 args: ["aString"],
 source: "compile: aString\x0a\x09^ self compileNode: (self parse: aString)",
 messageSends: ["compileNode:", "parse:"],
 referencedClasses: []
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -304,13 +304,13 @@ self._currentClass_(aClass);
 self._source_(aString);
 $1=self._compile_(aString);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"compile:forClass:",{aString:aString,aClass:aClass},smalltalk.Compiler)})},
+}, function($ctx1) {$ctx1.fill(self,"compile:forClass:",{aString:aString,aClass:aClass},globals.Compiler)})},
 args: ["aString", "aClass"],
 source: "compile: aString forClass: aClass\x0a\x09self currentClass: aClass.\x0a\x09self source: aString.\x0a\x09^ self compile: aString",
 messageSends: ["currentClass:", "source:", "compile:"],
 referencedClasses: []
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -318,7 +318,7 @@ selector: "compileExpression:",
 protocol: 'compiling',
 fn: function (aString){
 var self=this;
-function $DoIt(){return smalltalk.DoIt||(typeof DoIt=="undefined"?nil:DoIt)}
+function $DoIt(){return globals.DoIt||(typeof DoIt=="undefined"?nil:DoIt)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
 self._currentClass_($DoIt());
@@ -327,13 +327,13 @@ $ctx1.sendIdx[","]=1;
 self._source_($1);
 $2=self._compileNode_(self._parse_(self._source()));
 return $2;
-}, function($ctx1) {$ctx1.fill(self,"compileExpression:",{aString:aString},smalltalk.Compiler)})},
+}, function($ctx1) {$ctx1.fill(self,"compileExpression:",{aString:aString},globals.Compiler)})},
 args: ["aString"],
 source: "compileExpression: aString\x0a\x09self currentClass: DoIt.\x0a\x09self source: 'doIt ^ [ ', aString, ' ] value'.\x0a\x09^ self compileNode: (self parse: self source)",
 messageSends: ["currentClass:", "source:", ",", "compileNode:", "parse:", "source"],
 referencedClasses: ["DoIt"]
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -349,13 +349,13 @@ $ctx1.sendIdx[","]=1;
 self._source_($1);
 $2=self._compileNode_(self._parse_(self._source()));
 return $2;
-}, function($ctx1) {$ctx1.fill(self,"compileExpression:on:",{aString:aString,anObject:anObject},smalltalk.Compiler)})},
+}, function($ctx1) {$ctx1.fill(self,"compileExpression:on:",{aString:aString,anObject:anObject},globals.Compiler)})},
 args: ["aString", "anObject"],
 source: "compileExpression: aString on: anObject\x0a\x09self currentClass: anObject class.\x0a\x09self source: 'xxxDoIt ^ [ ', aString, ' ] value'.\x0a\x09^ self compileNode: (self parse: self source)",
 messageSends: ["currentClass:", "class", "source:", ",", "compileNode:", "parse:", "source"],
 referencedClasses: []
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -374,13 +374,13 @@ result=_st(generator)._compileNode_(aNode);
 self._unknownVariables_([]);
 $3=result;
 return $3;
-}, function($ctx1) {$ctx1.fill(self,"compileNode:",{aNode:aNode,generator:generator,result:result},smalltalk.Compiler)})},
+}, function($ctx1) {$ctx1.fill(self,"compileNode:",{aNode:aNode,generator:generator,result:result},globals.Compiler)})},
 args: ["aNode"],
 source: "compileNode: aNode\x0a\x09| generator result |\x0a\x09generator := self codeGeneratorClass new.\x0a\x09generator\x0a\x09\x09source: self source;\x0a\x09\x09currentClass: self currentClass.\x0a\x09result := generator compileNode: aNode.\x0a\x09self unknownVariables: #().\x0a\x09^ result",
 messageSends: ["new", "codeGeneratorClass", "source:", "source", "currentClass:", "currentClass", "compileNode:", "unknownVariables:"],
 referencedClasses: []
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -397,7 +397,7 @@ source: "currentClass\x0a\x09^ currentClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -412,7 +412,7 @@ source: "currentClass: aClass\x0a\x09currentClass := aClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -427,7 +427,7 @@ source: "eval: aString\x0a\x09<return eval(aString)>",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -435,18 +435,18 @@ selector: "evaluateExpression:",
 protocol: 'compiling',
 fn: function (aString){
 var self=this;
-function $DoIt(){return smalltalk.DoIt||(typeof DoIt=="undefined"?nil:DoIt)}
+function $DoIt(){return globals.DoIt||(typeof DoIt=="undefined"?nil:DoIt)}
 return smalltalk.withContext(function($ctx1) { 
 var $1;
 $1=self._evaluateExpression_on_(aString,_st($DoIt())._new());
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"evaluateExpression:",{aString:aString},smalltalk.Compiler)})},
+}, function($ctx1) {$ctx1.fill(self,"evaluateExpression:",{aString:aString},globals.Compiler)})},
 args: ["aString"],
 source: "evaluateExpression: aString\x0a\x09\x22Unlike #eval: evaluate a Smalltalk expression and answer the returned object\x22\x0a\x09^ self evaluateExpression: aString on: DoIt new",
 messageSends: ["evaluateExpression:on:", "new"],
 referencedClasses: ["DoIt"]
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -466,13 +466,13 @@ result=_st(anObject)._xxxDoIt();
 _st(_st(anObject)._class())._removeCompiledMethod_(method);
 $2=result;
 return $2;
-}, function($ctx1) {$ctx1.fill(self,"evaluateExpression:on:",{aString:aString,anObject:anObject,result:result,method:method},smalltalk.Compiler)})},
+}, function($ctx1) {$ctx1.fill(self,"evaluateExpression:on:",{aString:aString,anObject:anObject,result:result,method:method},globals.Compiler)})},
 args: ["aString", "anObject"],
 source: "evaluateExpression: aString on: anObject\x0a\x09\x22Unlike #eval: evaluate a Smalltalk expression with anObject as the receiver and answer the returned object\x22\x0a\x09| result method |\x0a\x09method := self eval: (self compileExpression: aString on: anObject).\x0a\x09method protocol: 'xxxDoIt'.\x0a\x09anObject class addCompiledMethod: method.\x0a\x09result := anObject xxxDoIt.\x0a\x09anObject class removeCompiledMethod: method.\x0a\x09^ result",
 messageSends: ["eval:", "compileExpression:on:", "protocol:", "addCompiledMethod:", "class", "xxxDoIt", "removeCompiledMethod:"],
 referencedClasses: []
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -480,18 +480,18 @@ selector: "install:forClass:protocol:",
 protocol: 'compiling',
 fn: function (aString,aBehavior,anotherString){
 var self=this;
-function $ClassBuilder(){return smalltalk.ClassBuilder||(typeof ClassBuilder=="undefined"?nil:ClassBuilder)}
+function $ClassBuilder(){return globals.ClassBuilder||(typeof ClassBuilder=="undefined"?nil:ClassBuilder)}
 return smalltalk.withContext(function($ctx1) { 
 var $1;
 $1=_st(_st($ClassBuilder())._new())._installMethod_forClass_protocol_(self._eval_(self._compile_forClass_(aString,aBehavior)),aBehavior,anotherString);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"install:forClass:protocol:",{aString:aString,aBehavior:aBehavior,anotherString:anotherString},smalltalk.Compiler)})},
+}, function($ctx1) {$ctx1.fill(self,"install:forClass:protocol:",{aString:aString,aBehavior:aBehavior,anotherString:anotherString},globals.Compiler)})},
 args: ["aString", "aBehavior", "anotherString"],
 source: "install: aString forClass: aBehavior protocol: anotherString\x0a\x09^ ClassBuilder new\x0a\x09\x09installMethod: (self eval: (self compile: aString forClass: aBehavior))\x0a\x09\x09forClass: aBehavior\x0a\x09\x09protocol: anotherString",
 messageSends: ["installMethod:forClass:protocol:", "new", "eval:", "compile:forClass:"],
 referencedClasses: ["ClassBuilder"]
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -499,18 +499,18 @@ selector: "parse:",
 protocol: 'compiling',
 fn: function (aString){
 var self=this;
-function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
+function $Smalltalk(){return globals.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
 return smalltalk.withContext(function($ctx1) { 
 var $1;
 $1=_st($Smalltalk())._parse_(aString);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"parse:",{aString:aString},smalltalk.Compiler)})},
+}, function($ctx1) {$ctx1.fill(self,"parse:",{aString:aString},globals.Compiler)})},
 args: ["aString"],
 source: "parse: aString\x0a\x09^ Smalltalk parse: aString",
 messageSends: ["parse:"],
 referencedClasses: ["Smalltalk"]
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -524,13 +524,13 @@ $2=_st("doIt ^ [ ".__comma(aString)).__comma(" ] value");
 $ctx1.sendIdx[","]=1;
 $1=self._parse_($2);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"parseExpression:",{aString:aString},smalltalk.Compiler)})},
+}, function($ctx1) {$ctx1.fill(self,"parseExpression:",{aString:aString},globals.Compiler)})},
 args: ["aString"],
 source: "parseExpression: aString\x0a\x09^ self parse: 'doIt ^ [ ', aString, ' ] value'",
 messageSends: ["parse:", ","],
 referencedClasses: []
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -548,13 +548,13 @@ $1=_st(aClass)._isMetaclass();
 if(! smalltalk.assert($1)){
 self._recompile_(_st(aClass)._class());
 };
-return self}, function($ctx1) {$ctx1.fill(self,"recompile:",{aClass:aClass},smalltalk.Compiler)})},
+return self}, function($ctx1) {$ctx1.fill(self,"recompile:",{aClass:aClass},globals.Compiler)})},
 args: ["aClass"],
 source: "recompile: aClass\x0a\x09aClass methodDictionary values\x0a\x09\x09do: [ :each | \x0a\x09\x09\x09self \x0a\x09\x09\x09\x09install: each source \x0a\x09\x09\x09\x09forClass: aClass \x0a\x09\x09\x09\x09protocol: each protocol ]\x0a\x09\x09displayingProgress: 'Recompiling ', aClass name.\x0a\x09aClass isMetaclass ifFalse: [ self recompile: aClass class ]",
 messageSends: ["do:displayingProgress:", "values", "methodDictionary", "install:forClass:protocol:", "source", "protocol", ",", "name", "ifFalse:", "isMetaclass", "recompile:", "class"],
 referencedClasses: []
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -562,19 +562,19 @@ selector: "recompileAll",
 protocol: 'compiling',
 fn: function (){
 var self=this;
-function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
+function $Smalltalk(){return globals.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
 return smalltalk.withContext(function($ctx1) { 
 _st(_st($Smalltalk())._classes())._do_displayingProgress_((function(each){
 return smalltalk.withContext(function($ctx2) {
 return self._recompile_(each);
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}),"Compiling all classes...");
-return self}, function($ctx1) {$ctx1.fill(self,"recompileAll",{},smalltalk.Compiler)})},
+return self}, function($ctx1) {$ctx1.fill(self,"recompileAll",{},globals.Compiler)})},
 args: [],
 source: "recompileAll\x0a\x09Smalltalk classes \x0a\x09\x09do: [ :each | self recompile: each ]\x0a\x09\x09displayingProgress: 'Compiling all classes...'",
 messageSends: ["do:displayingProgress:", "classes", "recompile:"],
 referencedClasses: ["Smalltalk"]
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -591,13 +591,13 @@ $1="";
 $1=$2;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"source",{},smalltalk.Compiler)})},
+}, function($ctx1) {$ctx1.fill(self,"source",{},globals.Compiler)})},
 args: [],
 source: "source\x0a\x09^ source ifNil: [ '' ]",
 messageSends: ["ifNil:"],
 referencedClasses: []
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -612,7 +612,7 @@ source: "source: aString\x0a\x09source := aString",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -629,7 +629,7 @@ source: "unknownVariables\x0a\x09^ unknownVariables",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -644,7 +644,7 @@ source: "unknownVariables: aCollection\x0a\x09unknownVariables := aCollection",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Compiler);
+globals.Compiler);
 
 
 smalltalk.addMethod(
@@ -655,13 +655,13 @@ fn: function (aClass){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._new())._recompile_(aClass);
-return self}, function($ctx1) {$ctx1.fill(self,"recompile:",{aClass:aClass},smalltalk.Compiler.klass)})},
+return self}, function($ctx1) {$ctx1.fill(self,"recompile:",{aClass:aClass},globals.Compiler.klass)})},
 args: ["aClass"],
 source: "recompile: aClass\x0a\x09self new recompile: aClass",
 messageSends: ["recompile:", "new"],
 referencedClasses: []
 }),
-smalltalk.Compiler.klass);
+globals.Compiler.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -669,27 +669,51 @@ selector: "recompileAll",
 protocol: 'compiling',
 fn: function (){
 var self=this;
-function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
+function $Smalltalk(){return globals.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
 return smalltalk.withContext(function($ctx1) { 
 _st(_st($Smalltalk())._classes())._do_((function(each){
 return smalltalk.withContext(function($ctx2) {
 return self._recompile_(each);
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"recompileAll",{},smalltalk.Compiler.klass)})},
+return self}, function($ctx1) {$ctx1.fill(self,"recompileAll",{},globals.Compiler.klass)})},
 args: [],
 source: "recompileAll\x0a\x09Smalltalk classes do: [ :each |\x0a\x09\x09self recompile: each ]",
 messageSends: ["do:", "classes", "recompile:"],
 referencedClasses: ["Smalltalk"]
 }),
-smalltalk.Compiler.klass);
+globals.Compiler.klass);
 
 
-smalltalk.addClass('DoIt', smalltalk.Object, [], 'Compiler-Core');
-smalltalk.DoIt.comment="`DoIt` is the class used to compile and evaluate expressions. See `Compiler >> evaluateExpression:`.";
+smalltalk.addClass('DoIt', globals.Object, [], 'Compiler-Core');
+globals.DoIt.comment="`DoIt` is the class used to compile and evaluate expressions. See `Compiler >> evaluateExpression:`.";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "foo",
+protocol: 'tests',
+fn: function (){
+var self=this;
+function $Array(){return globals.Array||(typeof Array=="undefined"?nil:Array)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$3,$1;
+$2=_st($Array())._new();
+_st($2)._add_((3));
+$ctx1.sendIdx["add:"]=1;
+_st($2)._add_((4));
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"foo",{},globals.DoIt)})},
+args: [],
+source: "foo ^ Array new add: 3; add: 4; yourself",
+messageSends: ["add:", "new", "yourself"],
+referencedClasses: ["Array"]
+}),
+globals.DoIt);
+
 
 
-smalltalk.addClass('NodeVisitor', smalltalk.Object, [], 'Compiler-Core');
-smalltalk.NodeVisitor.comment="I am the abstract super class of all AST node visitors.";
+smalltalk.addClass('NodeVisitor', globals.Object, [], 'Compiler-Core');
+globals.NodeVisitor.comment="I am the abstract super class of all AST node visitors.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "visit:",
@@ -700,13 +724,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(aNode)._accept_(self);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"visit:",{aNode:aNode},smalltalk.NodeVisitor)})},
+}, function($ctx1) {$ctx1.fill(self,"visit:",{aNode:aNode},globals.NodeVisitor)})},
 args: ["aNode"],
 source: "visit: aNode\x0a\x09^ aNode accept: self",
 messageSends: ["accept:"],
 referencedClasses: []
 }),
-smalltalk.NodeVisitor);
+globals.NodeVisitor);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -721,13 +745,13 @@ return smalltalk.withContext(function($ctx2) {
 return self._visit_(each);
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"visitAll:",{aCollection:aCollection},smalltalk.NodeVisitor)})},
+}, function($ctx1) {$ctx1.fill(self,"visitAll:",{aCollection:aCollection},globals.NodeVisitor)})},
 args: ["aCollection"],
 source: "visitAll: aCollection\x0a\x09^ aCollection collect: [ :each | self visit: each ]",
 messageSends: ["collect:", "visit:"],
 referencedClasses: []
 }),
-smalltalk.NodeVisitor);
+globals.NodeVisitor);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -739,13 +763,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._visitNode_(aNode);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"visitAssignmentNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
+}, function($ctx1) {$ctx1.fill(self,"visitAssignmentNode:",{aNode:aNode},globals.NodeVisitor)})},
 args: ["aNode"],
 source: "visitAssignmentNode: aNode\x0a\x09^ self visitNode: aNode",
 messageSends: ["visitNode:"],
 referencedClasses: []
 }),
-smalltalk.NodeVisitor);
+globals.NodeVisitor);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -757,13 +781,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._visitNode_(aNode);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"visitBlockNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
+}, function($ctx1) {$ctx1.fill(self,"visitBlockNode:",{aNode:aNode},globals.NodeVisitor)})},
 args: ["aNode"],
 source: "visitBlockNode: aNode\x0a\x09^ self visitNode: aNode",
 messageSends: ["visitNode:"],
 referencedClasses: []
 }),
-smalltalk.NodeVisitor);
+globals.NodeVisitor);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -775,13 +799,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._visitSequenceNode_(aNode);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"visitBlockSequenceNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
+}, function($ctx1) {$ctx1.fill(self,"visitBlockSequenceNode:",{aNode:aNode},globals.NodeVisitor)})},
 args: ["aNode"],
 source: "visitBlockSequenceNode: aNode\x0a\x09^ self visitSequenceNode: aNode",
 messageSends: ["visitSequenceNode:"],
 referencedClasses: []
 }),
-smalltalk.NodeVisitor);
+globals.NodeVisitor);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -793,13 +817,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._visitNode_(aNode);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"visitCascadeNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
+}, function($ctx1) {$ctx1.fill(self,"visitCascadeNode:",{aNode:aNode},globals.NodeVisitor)})},
 args: ["aNode"],
 source: "visitCascadeNode: aNode\x0a\x09^ self visitNode: aNode",
 messageSends: ["visitNode:"],
 referencedClasses: []
 }),
-smalltalk.NodeVisitor);
+globals.NodeVisitor);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -811,13 +835,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._visitNode_(aNode);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"visitDynamicArrayNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
+}, function($ctx1) {$ctx1.fill(self,"visitDynamicArrayNode:",{aNode:aNode},globals.NodeVisitor)})},
 args: ["aNode"],
 source: "visitDynamicArrayNode: aNode\x0a\x09^ self visitNode: aNode",
 messageSends: ["visitNode:"],
 referencedClasses: []
 }),
-smalltalk.NodeVisitor);
+globals.NodeVisitor);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -829,13 +853,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._visitNode_(aNode);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"visitDynamicDictionaryNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
+}, function($ctx1) {$ctx1.fill(self,"visitDynamicDictionaryNode:",{aNode:aNode},globals.NodeVisitor)})},
 args: ["aNode"],
 source: "visitDynamicDictionaryNode: aNode\x0a\x09^ self visitNode: aNode",
 messageSends: ["visitNode:"],
 referencedClasses: []
 }),
-smalltalk.NodeVisitor);
+globals.NodeVisitor);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -847,13 +871,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._visitNode_(aNode);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"visitJSStatementNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
+}, function($ctx1) {$ctx1.fill(self,"visitJSStatementNode:",{aNode:aNode},globals.NodeVisitor)})},
 args: ["aNode"],
 source: "visitJSStatementNode: aNode\x0a\x09^ self visitNode: aNode",
 messageSends: ["visitNode:"],
 referencedClasses: []
 }),
-smalltalk.NodeVisitor);
+globals.NodeVisitor);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -865,13 +889,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._visitNode_(aNode);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"visitMethodNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
+}, function($ctx1) {$ctx1.fill(self,"visitMethodNode:",{aNode:aNode},globals.NodeVisitor)})},
 args: ["aNode"],
 source: "visitMethodNode: aNode\x0a\x09^ self visitNode: aNode",
 messageSends: ["visitNode:"],
 referencedClasses: []
 }),
-smalltalk.NodeVisitor);
+globals.NodeVisitor);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -883,13 +907,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._visitAll_(_st(aNode)._nodes());
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"visitNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
+}, function($ctx1) {$ctx1.fill(self,"visitNode:",{aNode:aNode},globals.NodeVisitor)})},
 args: ["aNode"],
 source: "visitNode: aNode\x0a\x09^ self visitAll: aNode nodes",
 messageSends: ["visitAll:", "nodes"],
 referencedClasses: []
 }),
-smalltalk.NodeVisitor);
+globals.NodeVisitor);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -901,13 +925,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._visitNode_(aNode);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"visitReturnNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
+}, function($ctx1) {$ctx1.fill(self,"visitReturnNode:",{aNode:aNode},globals.NodeVisitor)})},
 args: ["aNode"],
 source: "visitReturnNode: aNode\x0a\x09^ self visitNode: aNode",
 messageSends: ["visitNode:"],
 referencedClasses: []
 }),
-smalltalk.NodeVisitor);
+globals.NodeVisitor);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -919,13 +943,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._visitNode_(aNode);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"visitSendNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
+}, function($ctx1) {$ctx1.fill(self,"visitSendNode:",{aNode:aNode},globals.NodeVisitor)})},
 args: ["aNode"],
 source: "visitSendNode: aNode\x0a\x09^ self visitNode: aNode",
 messageSends: ["visitNode:"],
 referencedClasses: []
 }),
-smalltalk.NodeVisitor);
+globals.NodeVisitor);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -937,13 +961,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._visitNode_(aNode);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"visitSequenceNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
+}, function($ctx1) {$ctx1.fill(self,"visitSequenceNode:",{aNode:aNode},globals.NodeVisitor)})},
 args: ["aNode"],
 source: "visitSequenceNode: aNode\x0a\x09^ self visitNode: aNode",
 messageSends: ["visitNode:"],
 referencedClasses: []
 }),
-smalltalk.NodeVisitor);
+globals.NodeVisitor);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -955,13 +979,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._visitNode_(aNode);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"visitValueNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
+}, function($ctx1) {$ctx1.fill(self,"visitValueNode:",{aNode:aNode},globals.NodeVisitor)})},
 args: ["aNode"],
 source: "visitValueNode: aNode\x0a\x09^ self visitNode: aNode",
 messageSends: ["visitNode:"],
 referencedClasses: []
 }),
-smalltalk.NodeVisitor);
+globals.NodeVisitor);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -973,13 +997,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._visitNode_(aNode);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"visitVariableNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
+}, function($ctx1) {$ctx1.fill(self,"visitVariableNode:",{aNode:aNode},globals.NodeVisitor)})},
 args: ["aNode"],
 source: "visitVariableNode: aNode\x0a\x09^ self visitNode: aNode",
 messageSends: ["visitNode:"],
 referencedClasses: []
 }),
-smalltalk.NodeVisitor);
+globals.NodeVisitor);
 
 
 smalltalk.addMethod(
@@ -988,7 +1012,7 @@ selector: "asVariableName",
 protocol: '*Compiler-Core',
 fn: function (){
 var self=this;
-function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
+function $Smalltalk(){return globals.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$1;
 $2=_st(_st($Smalltalk())._reservedWords())._includes_(self);
@@ -998,12 +1022,12 @@ $1=self.__comma("_");
 $1=self;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"asVariableName",{},smalltalk.String)})},
+}, function($ctx1) {$ctx1.fill(self,"asVariableName",{},globals.String)})},
 args: [],
 source: "asVariableName\x0a\x09^ (Smalltalk reservedWords includes: self)\x0a\x09\x09ifTrue: [ self, '_' ]\x0a\x09\x09ifFalse: [ self ]",
 messageSends: ["ifTrue:ifFalse:", "includes:", "reservedWords", ","],
 referencedClasses: ["Smalltalk"]
 }),
-smalltalk.String);
+globals.String);
 
 });

js/Compiler-Exceptions.js

@@ -1,25 +1,25 @@
-define("amber_core/Compiler-Exceptions", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Exceptions"], function(smalltalk,nil,_st){
+define("amber_core/Compiler-Exceptions", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Exceptions"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Compiler-Exceptions');
 smalltalk.packages["Compiler-Exceptions"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('CompilerError', smalltalk.Error, [], 'Compiler-Exceptions');
-smalltalk.CompilerError.comment="I am the common superclass of all compiling errors.";
+smalltalk.addClass('CompilerError', globals.Error, [], 'Compiler-Exceptions');
+globals.CompilerError.comment="I am the common superclass of all compiling errors.";
 
 
-smalltalk.addClass('ParseError', smalltalk.CompilerError, [], 'Compiler-Exceptions');
-smalltalk.ParseError.comment="Instance of ParseError are signaled on any parsing error.\x0aSee `Smalltalk >> #parse:`";
+smalltalk.addClass('ParseError', globals.CompilerError, [], 'Compiler-Exceptions');
+globals.ParseError.comment="Instance of ParseError are signaled on any parsing error.\x0aSee `Smalltalk >> #parse:`";
 
 
-smalltalk.addClass('SemanticError', smalltalk.CompilerError, [], 'Compiler-Exceptions');
-smalltalk.SemanticError.comment="I represent an abstract semantic error thrown by the SemanticAnalyzer.\x0aSemantic errors can be unknown variable errors, etc.\x0aSee my subclasses for concrete errors.\x0a\x0aThe IDE should catch instances of Semantic error to deal with them when compiling";
+smalltalk.addClass('SemanticError', globals.CompilerError, [], 'Compiler-Exceptions');
+globals.SemanticError.comment="I represent an abstract semantic error thrown by the SemanticAnalyzer.\x0aSemantic errors can be unknown variable errors, etc.\x0aSee my subclasses for concrete errors.\x0a\x0aThe IDE should catch instances of Semantic error to deal with them when compiling";
 
 
-smalltalk.addClass('InliningError', smalltalk.SemanticError, [], 'Compiler-Exceptions');
-smalltalk.InliningError.comment="Instances of InliningError are signaled when using an `InliningCodeGenerator`in a `Compiler`.";
+smalltalk.addClass('InliningError', globals.SemanticError, [], 'Compiler-Exceptions');
+globals.InliningError.comment="Instances of InliningError are signaled when using an `InliningCodeGenerator`in a `Compiler`.";
 
 
-smalltalk.addClass('InvalidAssignmentError', smalltalk.SemanticError, ['variableName'], 'Compiler-Exceptions');
-smalltalk.InvalidAssignmentError.comment="I get signaled when a pseudo variable gets assigned.";
+smalltalk.addClass('InvalidAssignmentError', globals.SemanticError, ['variableName'], 'Compiler-Exceptions');
+globals.InvalidAssignmentError.comment="I get signaled when a pseudo variable gets assigned.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "messageText",
@@ -30,13 +30,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=" Invalid assignment to variable: ".__comma(self._variableName());
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"messageText",{},smalltalk.InvalidAssignmentError)})},
+}, function($ctx1) {$ctx1.fill(self,"messageText",{},globals.InvalidAssignmentError)})},
 args: [],
 source: "messageText\x0a\x09^ ' Invalid assignment to variable: ', self variableName",
 messageSends: [",", "variableName"],
 referencedClasses: []
 }),
-smalltalk.InvalidAssignmentError);
+globals.InvalidAssignmentError);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -53,7 +53,7 @@ source: "variableName\x0a\x09^ variableName",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.InvalidAssignmentError);
+globals.InvalidAssignmentError);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -68,12 +68,12 @@ source: "variableName: aString\x0a\x09variableName := aString",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.InvalidAssignmentError);
+globals.InvalidAssignmentError);
 
 
 
-smalltalk.addClass('ShadowingVariableError', smalltalk.SemanticError, ['variableName'], 'Compiler-Exceptions');
-smalltalk.ShadowingVariableError.comment="I get signaled when a variable in a block or method scope shadows a variable of the same name in an outer scope.";
+smalltalk.addClass('ShadowingVariableError', globals.SemanticError, ['variableName'], 'Compiler-Exceptions');
+globals.ShadowingVariableError.comment="I get signaled when a variable in a block or method scope shadows a variable of the same name in an outer scope.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "messageText",
@@ -85,13 +85,13 @@ var $1;
 $1=_st("Variable shadowing error: ".__comma(self._variableName())).__comma(" is already defined");
 $ctx1.sendIdx[","]=1;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"messageText",{},smalltalk.ShadowingVariableError)})},
+}, function($ctx1) {$ctx1.fill(self,"messageText",{},globals.ShadowingVariableError)})},
 args: [],
 source: "messageText\x0a\x09^ 'Variable shadowing error: ', self variableName, ' is already defined'",
 messageSends: [",", "variableName"],
 referencedClasses: []
 }),
-smalltalk.ShadowingVariableError);
+globals.ShadowingVariableError);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -108,7 +108,7 @@ source: "variableName\x0a\x09^ variableName",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ShadowingVariableError);
+globals.ShadowingVariableError);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -123,12 +123,12 @@ source: "variableName: aString\x0a\x09variableName := aString",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ShadowingVariableError);
+globals.ShadowingVariableError);
 
 
 
-smalltalk.addClass('UnknownVariableError', smalltalk.SemanticError, ['variableName'], 'Compiler-Exceptions');
-smalltalk.UnknownVariableError.comment="I get signaled when a variable is not defined.\x0aThe default behavior is to allow it, as this is how Amber currently is able to seamlessly send messages to JavaScript objects.";
+smalltalk.addClass('UnknownVariableError', globals.SemanticError, ['variableName'], 'Compiler-Exceptions');
+globals.UnknownVariableError.comment="I get signaled when a variable is not defined.\x0aThe default behavior is to allow it, as this is how Amber currently is able to seamlessly send messages to JavaScript objects.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "messageText",
@@ -140,13 +140,13 @@ var $1;
 $1=_st("Unknown Variable error: ".__comma(self._variableName())).__comma(" is not defined");
 $ctx1.sendIdx[","]=1;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"messageText",{},smalltalk.UnknownVariableError)})},
+}, function($ctx1) {$ctx1.fill(self,"messageText",{},globals.UnknownVariableError)})},
 args: [],
 source: "messageText\x0a\x09^ 'Unknown Variable error: ', self variableName, ' is not defined'",
 messageSends: [",", "variableName"],
 referencedClasses: []
 }),
-smalltalk.UnknownVariableError);
+globals.UnknownVariableError);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -163,7 +163,7 @@ source: "variableName\x0a\x09^ variableName",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.UnknownVariableError);
+globals.UnknownVariableError);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -178,7 +178,7 @@ source: "variableName: aString\x0a\x09variableName := aString",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.UnknownVariableError);
+globals.UnknownVariableError);
 
 
 });

js/Examples.js

@@ -1,9 +1,9 @@
-define("amber_core/Examples", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Canvas"], function(smalltalk,nil,_st){
+define("amber_core/Examples", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Canvas"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Examples');
 smalltalk.packages["Examples"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('Counter', smalltalk.Widget, ['count', 'header'], 'Examples');
-smalltalk.Counter.comment="This is a trivial Widget example mimicking the classic Counter example in Seaside.\x0aIn order to play with it, just evaluate the doit below in a workspace.\x0aThen take a look in the HTML document above the IDE.\x0a\x0a\x09\x09Counter tryExample";
+smalltalk.addClass('Counter', globals.Widget, ['count', 'header'], 'Examples');
+globals.Counter.comment="This is a trivial Widget example mimicking the classic Counter example in Seaside.\x0aIn order to play with it, just evaluate the doit below in a workspace.\x0aThen take a look in the HTML document above the IDE.\x0a\x0a\x09\x09Counter tryExample";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "decrease",
@@ -16,13 +16,13 @@ _st(self["@header"])._contents_((function(html){
 return smalltalk.withContext(function($ctx2) {
 return _st(html)._with_(_st(self["@count"])._asString());
 }, function($ctx2) {$ctx2.fillBlock({html:html},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"decrease",{},smalltalk.Counter)})},
+return self}, function($ctx1) {$ctx1.fill(self,"decrease",{},globals.Counter)})},
 args: [],
 source: "decrease\x0a\x09count := count - 1.\x0a\x09header contents: [ :html | html with: count asString ]",
 messageSends: ["-", "contents:", "with:", "asString"],
 referencedClasses: []
 }),
-smalltalk.Counter);
+globals.Counter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -36,13 +36,13 @@ _st(self["@header"])._contents_((function(html){
 return smalltalk.withContext(function($ctx2) {
 return _st(html)._with_(_st(self["@count"])._asString());
 }, function($ctx2) {$ctx2.fillBlock({html:html},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"increase",{},smalltalk.Counter)})},
+return self}, function($ctx1) {$ctx1.fill(self,"increase",{},globals.Counter)})},
 args: [],
 source: "increase\x0a\x09count := count + 1.\x0a\x09header contents: [ :html | html with: count asString ]",
 messageSends: ["+", "contents:", "with:", "asString"],
 referencedClasses: []
 }),
-smalltalk.Counter);
+globals.Counter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -51,15 +51,15 @@ protocol: 'initialization',
 fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
-smalltalk.Counter.superclass.fn.prototype._initialize.apply(_st(self), []);
+globals.Counter.superclass.fn.prototype._initialize.apply(_st(self), []);
 self["@count"]=(0);
-return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},smalltalk.Counter)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.Counter)})},
 args: [],
 source: "initialize\x0a\x09super initialize.\x0a\x09count := 0",
 messageSends: ["initialize"],
 referencedClasses: []
 }),
-smalltalk.Counter);
+globals.Counter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -89,13 +89,13 @@ $6=_st($5)._onClick_((function(){
 return smalltalk.withContext(function($ctx2) {
 return self._decrease();
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},smalltalk.Counter)})},
+return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},globals.Counter)})},
 args: ["html"],
 source: "renderOn: html\x0a\x09header := html h1\x0a\x09\x09with: count asString;\x0a\x09\x09yourself.\x0a\x09html button\x0a\x09\x09with: '++';\x0a\x09\x09onClick: [ self increase ].\x0a\x09html button\x0a\x09\x09with: '--';\x0a\x09\x09onClick: [ self decrease ]",
 messageSends: ["with:", "h1", "asString", "yourself", "button", "onClick:", "increase", "decrease"],
 referencedClasses: []
 }),
-smalltalk.Counter);
+globals.Counter);
 
 
 smalltalk.addMethod(
@@ -106,12 +106,12 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._new())._appendToJQuery_("body"._asJQuery());
-return self}, function($ctx1) {$ctx1.fill(self,"tryExample",{},smalltalk.Counter.klass)})},
+return self}, function($ctx1) {$ctx1.fill(self,"tryExample",{},globals.Counter.klass)})},
 args: [],
 source: "tryExample\x0a\x09\x22In order to play with the Counter, just select the\x0a\x09doit below and press the Do it button. Then take a\x0a\x09look in the HTML document above the IDE.\x22\x0a\x0a\x09\x22Counter tryExample\x22\x0a\x09\x09self new appendToJQuery: 'body' asJQuery",
 messageSends: ["appendToJQuery:", "new", "asJQuery"],
 referencedClasses: []
 }),
-smalltalk.Counter.klass);
+globals.Counter.klass);
 
 });

js/Helios-Announcements.js

@@ -1,8 +1,8 @@
-define("amber_core/Helios-Announcements", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st){
+define("amber_core/Helios-Announcements", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Helios-Announcements');
 smalltalk.packages["Helios-Announcements"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('HLAboutToChange', smalltalk.Object, ['actionBlock'], 'Helios-Announcements');
+smalltalk.addClass('HLAboutToChange', globals.Object, ['actionBlock'], 'Helios-Announcements');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "actionBlock",
@@ -18,7 +18,7 @@ source: "actionBlock\x0a\x09^ actionBlock",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLAboutToChange);
+globals.HLAboutToChange);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -33,12 +33,12 @@ source: "actionBlock: aBlock\x0a\x09actionBlock := aBlock",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLAboutToChange);
+globals.HLAboutToChange);
 
 
 
-smalltalk.addClass('HLAnnouncement', smalltalk.Object, [], 'Helios-Announcements');
-smalltalk.HLAnnouncement.comment="I am the root of the announcement class hierarchy used in the Helios UI.";
+smalltalk.addClass('HLAnnouncement', globals.Object, [], 'Helios-Announcements');
+globals.HLAnnouncement.comment="I am the root of the announcement class hierarchy used in the Helios UI.";
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -53,11 +53,11 @@ source: "heliosClass\x0a\x09^ 'announcement'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLAnnouncement.klass);
+globals.HLAnnouncement.klass);
 
 
-smalltalk.addClass('HLCodeHandled', smalltalk.HLAnnouncement, ['code'], 'Helios-Announcements');
-smalltalk.HLCodeHandled.comment="I am the root class of announcements emitted by `HLCodeWidget`s";
+smalltalk.addClass('HLCodeHandled', globals.HLAnnouncement, ['code'], 'Helios-Announcements');
+globals.HLCodeHandled.comment="I am the root class of announcements emitted by `HLCodeWidget`s";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "code",
@@ -73,7 +73,7 @@ source: "code\x0a\x0a\x09^ code",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLCodeHandled);
+globals.HLCodeHandled);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -88,7 +88,7 @@ source: "code: aModel\x0a\x0a\x09code := aModel",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLCodeHandled);
+globals.HLCodeHandled);
 
 
 smalltalk.addMethod(
@@ -104,32 +104,32 @@ _st($2)._code_(aCodeModel);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"on:",{aCodeModel:aCodeModel},smalltalk.HLCodeHandled.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"on:",{aCodeModel:aCodeModel},globals.HLCodeHandled.klass)})},
 args: ["aCodeModel"],
 source: "on: aCodeModel\x0a\x0a\x09^ self new \x0a    \x09code: aCodeModel;\x0a        yourself",
 messageSends: ["code:", "new", "yourself"],
 referencedClasses: []
 }),
-smalltalk.HLCodeHandled.klass);
+globals.HLCodeHandled.klass);
 
 
-smalltalk.addClass('HLDoItExecuted', smalltalk.HLCodeHandled, [], 'Helios-Announcements');
-smalltalk.HLDoItExecuted.comment="I am emitted by a `HLCodeWidget` after a DoIt has been executed.";
+smalltalk.addClass('HLDoItExecuted', globals.HLCodeHandled, [], 'Helios-Announcements');
+globals.HLDoItExecuted.comment="I am emitted by a `HLCodeWidget` after a DoIt has been executed.";
 
 
-smalltalk.addClass('HLDoItRequested', smalltalk.HLCodeHandled, [], 'Helios-Announcements');
-smalltalk.HLDoItRequested.comment="I am emitted by a `HLCodeWidget` before a DoIt is executed.";
+smalltalk.addClass('HLDoItRequested', globals.HLCodeHandled, [], 'Helios-Announcements');
+globals.HLDoItRequested.comment="I am emitted by a `HLCodeWidget` before a DoIt is executed.";
 
 
-smalltalk.addClass('HLInspectItRequested', smalltalk.HLCodeHandled, [], 'Helios-Announcements');
-smalltalk.HLInspectItRequested.comment="I am emitted by a `HLCodeWidget` before an object is inspected.";
+smalltalk.addClass('HLInspectItRequested', globals.HLCodeHandled, [], 'Helios-Announcements');
+globals.HLInspectItRequested.comment="I am emitted by a `HLCodeWidget` before an object is inspected.";
 
 
-smalltalk.addClass('HLPrintItRequested', smalltalk.HLCodeHandled, [], 'Helios-Announcements');
-smalltalk.HLPrintItRequested.comment="I am emitted by a `HLCodeWidget` before an object is printed.";
+smalltalk.addClass('HLPrintItRequested', globals.HLCodeHandled, [], 'Helios-Announcements');
+globals.HLPrintItRequested.comment="I am emitted by a `HLCodeWidget` before an object is printed.";
 
 
-smalltalk.addClass('HLDebuggerAnnouncement', smalltalk.HLAnnouncement, ['context'], 'Helios-Announcements');
+smalltalk.addClass('HLDebuggerAnnouncement', globals.HLAnnouncement, ['context'], 'Helios-Announcements');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "context",
@@ -145,7 +145,7 @@ source: "context\x0a\x09^ context",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLDebuggerAnnouncement);
+globals.HLDebuggerAnnouncement);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -160,11 +160,11 @@ source: "context: aContext\x0a\x09context := aContext",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLDebuggerAnnouncement);
+globals.HLDebuggerAnnouncement);
 
 
 
-smalltalk.addClass('HLDebuggerContextSelected', smalltalk.HLDebuggerAnnouncement, [], 'Helios-Announcements');
+smalltalk.addClass('HLDebuggerContextSelected', globals.HLDebuggerAnnouncement, [], 'Helios-Announcements');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "context",
@@ -180,7 +180,7 @@ source: "context\x0a\x09^ context",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLDebuggerContextSelected);
+globals.HLDebuggerContextSelected);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -195,23 +195,23 @@ source: "context: aContext\x0a\x09context := aContext",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLDebuggerContextSelected);
+globals.HLDebuggerContextSelected);
 
 
 
-smalltalk.addClass('HLDebuggerStepped', smalltalk.HLDebuggerAnnouncement, [], 'Helios-Announcements');
+smalltalk.addClass('HLDebuggerStepped', globals.HLDebuggerAnnouncement, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLDebuggerWhere', smalltalk.HLDebuggerAnnouncement, [], 'Helios-Announcements');
+smalltalk.addClass('HLDebuggerWhere', globals.HLDebuggerAnnouncement, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLDiveRequested', smalltalk.HLAnnouncement, [], 'Helios-Announcements');
+smalltalk.addClass('HLDiveRequested', globals.HLAnnouncement, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLEditComment', smalltalk.HLAnnouncement, [], 'Helios-Announcements');
+smalltalk.addClass('HLEditComment', globals.HLAnnouncement, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLErrorRaised', smalltalk.HLAnnouncement, ['error'], 'Helios-Announcements');
+smalltalk.addClass('HLErrorRaised', globals.HLAnnouncement, ['error'], 'Helios-Announcements');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "error",
@@ -227,7 +227,7 @@ source: "error\x0a\x09^ error",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLErrorRaised);
+globals.HLErrorRaised);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -242,14 +242,14 @@ source: "error: anError\x0a\x09error := anError",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLErrorRaised);
+globals.HLErrorRaised);
 
 
 
-smalltalk.addClass('HLCompileErrorRaised', smalltalk.HLErrorRaised, [], 'Helios-Announcements');
+smalltalk.addClass('HLCompileErrorRaised', globals.HLErrorRaised, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLParseErrorRaised', smalltalk.HLErrorRaised, ['line', 'column', 'message'], 'Helios-Announcements');
+smalltalk.addClass('HLParseErrorRaised', globals.HLErrorRaised, ['line', 'column', 'message'], 'Helios-Announcements');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "column",
@@ -265,7 +265,7 @@ source: "column\x0a\x09^ column",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLParseErrorRaised);
+globals.HLParseErrorRaised);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -280,7 +280,7 @@ source: "column: anInteger\x0a\x09column := anInteger",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLParseErrorRaised);
+globals.HLParseErrorRaised);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -297,7 +297,7 @@ source: "line\x0a\x09^ line",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLParseErrorRaised);
+globals.HLParseErrorRaised);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -312,7 +312,7 @@ source: "line: anInteger\x0a\x09line := anInteger",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLParseErrorRaised);
+globals.HLParseErrorRaised);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -329,7 +329,7 @@ source: "message\x0a\x09^ message",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLParseErrorRaised);
+globals.HLParseErrorRaised);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -344,32 +344,32 @@ source: "message: aString\x0a\x09message := aString",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLParseErrorRaised);
+globals.HLParseErrorRaised);
 
 
 
-smalltalk.addClass('HLUnknownVariableErrorRaised', smalltalk.HLErrorRaised, [], 'Helios-Announcements');
+smalltalk.addClass('HLUnknownVariableErrorRaised', globals.HLErrorRaised, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLFocusRequested', smalltalk.HLAnnouncement, [], 'Helios-Announcements');
+smalltalk.addClass('HLFocusRequested', globals.HLAnnouncement, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLClassesFocusRequested', smalltalk.HLFocusRequested, [], 'Helios-Announcements');
+smalltalk.addClass('HLClassesFocusRequested', globals.HLFocusRequested, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLMethodsFocusRequested', smalltalk.HLFocusRequested, [], 'Helios-Announcements');
+smalltalk.addClass('HLMethodsFocusRequested', globals.HLFocusRequested, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLPackagesFocusRequested', smalltalk.HLFocusRequested, [], 'Helios-Announcements');
+smalltalk.addClass('HLPackagesFocusRequested', globals.HLFocusRequested, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLProtocolsFocusRequested', smalltalk.HLFocusRequested, [], 'Helios-Announcements');
+smalltalk.addClass('HLProtocolsFocusRequested', globals.HLFocusRequested, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLSourceCodeFocusRequested', smalltalk.HLFocusRequested, [], 'Helios-Announcements');
+smalltalk.addClass('HLSourceCodeFocusRequested', globals.HLFocusRequested, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLInstVarAdded', smalltalk.HLAnnouncement, ['theClass', 'variableName'], 'Helios-Announcements');
+smalltalk.addClass('HLInstVarAdded', globals.HLAnnouncement, ['theClass', 'variableName'], 'Helios-Announcements');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "theClass",
@@ -385,7 +385,7 @@ source: "theClass\x0a\x09^ theClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLInstVarAdded);
+globals.HLInstVarAdded);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -400,7 +400,7 @@ source: "theClass: aClass\x0a\x09theClass := aClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLInstVarAdded);
+globals.HLInstVarAdded);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -417,7 +417,7 @@ source: "variableName\x0a\x09^ variableName",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLInstVarAdded);
+globals.HLInstVarAdded);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -432,11 +432,11 @@ source: "variableName: aString\x0a\x09variableName := aString",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLInstVarAdded);
+globals.HLInstVarAdded);
 
 
 
-smalltalk.addClass('HLItemSelected', smalltalk.HLAnnouncement, ['item'], 'Helios-Announcements');
+smalltalk.addClass('HLItemSelected', globals.HLAnnouncement, ['item'], 'Helios-Announcements');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "item",
@@ -452,7 +452,7 @@ source: "item\x0a\x09^ item",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLItemSelected);
+globals.HLItemSelected);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -467,7 +467,7 @@ source: "item: anObject\x0a\x09item := anObject",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLItemSelected);
+globals.HLItemSelected);
 
 
 smalltalk.addMethod(
@@ -483,34 +483,34 @@ _st($2)._item_(anItem);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"on:",{anItem:anItem},smalltalk.HLItemSelected.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"on:",{anItem:anItem},globals.HLItemSelected.klass)})},
 args: ["anItem"],
 source: "on: anItem\x0a\x09^ self new\x0a    \x09item: anItem;\x0a        yourself",
 messageSends: ["item:", "new", "yourself"],
 referencedClasses: []
 }),
-smalltalk.HLItemSelected.klass);
+globals.HLItemSelected.klass);
 
 
-smalltalk.addClass('HLClassSelected', smalltalk.HLItemSelected, [], 'Helios-Announcements');
+smalltalk.addClass('HLClassSelected', globals.HLItemSelected, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLInstanceVariableSelected', smalltalk.HLItemSelected, [], 'Helios-Announcements');
+smalltalk.addClass('HLInstanceVariableSelected', globals.HLItemSelected, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLMethodSelected', smalltalk.HLItemSelected, [], 'Helios-Announcements');
+smalltalk.addClass('HLMethodSelected', globals.HLItemSelected, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLPackageSelected', smalltalk.HLItemSelected, [], 'Helios-Announcements');
+smalltalk.addClass('HLPackageSelected', globals.HLItemSelected, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLProtocolSelected', smalltalk.HLItemSelected, [], 'Helios-Announcements');
+smalltalk.addClass('HLProtocolSelected', globals.HLItemSelected, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLSaveSourceCode', smalltalk.HLAnnouncement, [], 'Helios-Announcements');
+smalltalk.addClass('HLSaveSourceCode', globals.HLAnnouncement, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLSearchReferences', smalltalk.HLAnnouncement, ['searchString'], 'Helios-Announcements');
+smalltalk.addClass('HLSearchReferences', globals.HLAnnouncement, ['searchString'], 'Helios-Announcements');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "searchString",
@@ -526,7 +526,7 @@ source: "searchString\x0a\x09^ searchString",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLSearchReferences);
+globals.HLSearchReferences);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -541,16 +541,16 @@ source: "searchString: aString\x0a\x09searchString := aString",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLSearchReferences);
+globals.HLSearchReferences);
 
 
 
-smalltalk.addClass('HLShowCommentToggled', smalltalk.HLAnnouncement, [], 'Helios-Announcements');
+smalltalk.addClass('HLShowCommentToggled', globals.HLAnnouncement, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLShowInstanceToggled', smalltalk.HLAnnouncement, [], 'Helios-Announcements');
+smalltalk.addClass('HLShowInstanceToggled', globals.HLAnnouncement, [], 'Helios-Announcements');
 
 
-smalltalk.addClass('HLSourceCodeSaved', smalltalk.HLAnnouncement, [], 'Helios-Announcements');
+smalltalk.addClass('HLSourceCodeSaved', globals.HLAnnouncement, [], 'Helios-Announcements');
 
 });

js/Helios-Commands-Browser.js

@@ -1,8 +1,8 @@
-define("amber_core/Helios-Commands-Browser", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Helios-Commands-Tools"], function(smalltalk,nil,_st){
+define("amber_core/Helios-Commands-Browser", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Helios-Commands-Tools"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Helios-Commands-Browser');
 smalltalk.packages["Helios-Commands-Browser"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('HLBrowserCommand', smalltalk.HLToolCommand, [], 'Helios-Commands-Browser');
+smalltalk.addClass('HLBrowserCommand', globals.HLToolCommand, [], 'Helios-Commands-Browser');
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -14,16 +14,16 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(aModel)._isBrowserModel();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},smalltalk.HLBrowserCommand.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},globals.HLBrowserCommand.klass)})},
 args: ["aModel"],
 source: "isValidFor: aModel\x0a\x09^ aModel isBrowserModel",
 messageSends: ["isBrowserModel"],
 referencedClasses: []
 }),
-smalltalk.HLBrowserCommand.klass);
+globals.HLBrowserCommand.klass);
 
 
-smalltalk.addClass('HLBrowserGoToCommand', smalltalk.HLBrowserCommand, [], 'Helios-Commands-Browser');
+smalltalk.addClass('HLBrowserGoToCommand', globals.HLBrowserCommand, [], 'Helios-Commands-Browser');
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -35,13 +35,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(aModel)._isBrowserModel();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},smalltalk.HLBrowserGoToCommand.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},globals.HLBrowserGoToCommand.klass)})},
 args: ["aModel"],
 source: "isValidFor: aModel\x0a\x09^ aModel isBrowserModel",
 messageSends: ["isBrowserModel"],
 referencedClasses: []
 }),
-smalltalk.HLBrowserGoToCommand.klass);
+globals.HLBrowserGoToCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -56,7 +56,7 @@ source: "key\x0a\x09^ 'g'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLBrowserGoToCommand.klass);
+globals.HLBrowserGoToCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -71,10 +71,10 @@ source: "label\x0a\x09^ 'Go to'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLBrowserGoToCommand.klass);
+globals.HLBrowserGoToCommand.klass);
 
 
-smalltalk.addClass('HLGoToClassesCommand', smalltalk.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
+smalltalk.addClass('HLGoToClassesCommand', globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute",
@@ -83,13 +83,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._model())._focusOnClasses();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLGoToClassesCommand)})},
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLGoToClassesCommand)})},
 args: [],
 source: "execute\x0a\x09self model focusOnClasses",
 messageSends: ["focusOnClasses", "model"],
 referencedClasses: []
 }),
-smalltalk.HLGoToClassesCommand);
+globals.HLGoToClassesCommand);
 
 
 smalltalk.addMethod(
@@ -105,7 +105,7 @@ source: "key\x0a\x09^ 'c'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGoToClassesCommand.klass);
+globals.HLGoToClassesCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -120,10 +120,10 @@ source: "label\x0a\x09^ 'Classes'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGoToClassesCommand.klass);
+globals.HLGoToClassesCommand.klass);
 
 
-smalltalk.addClass('HLGoToMethodsCommand', smalltalk.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
+smalltalk.addClass('HLGoToMethodsCommand', globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute",
@@ -132,13 +132,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._model())._focusOnMethods();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLGoToMethodsCommand)})},
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLGoToMethodsCommand)})},
 args: [],
 source: "execute\x0a\x09self model focusOnMethods",
 messageSends: ["focusOnMethods", "model"],
 referencedClasses: []
 }),
-smalltalk.HLGoToMethodsCommand);
+globals.HLGoToMethodsCommand);
 
 
 smalltalk.addMethod(
@@ -154,7 +154,7 @@ source: "key\x0a\x09^ 'm'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGoToMethodsCommand.klass);
+globals.HLGoToMethodsCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -169,10 +169,10 @@ source: "label\x0a\x09^ 'Methods'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGoToMethodsCommand.klass);
+globals.HLGoToMethodsCommand.klass);
 
 
-smalltalk.addClass('HLGoToPackagesCommand', smalltalk.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
+smalltalk.addClass('HLGoToPackagesCommand', globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute",
@@ -181,13 +181,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._model())._focusOnPackages();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLGoToPackagesCommand)})},
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLGoToPackagesCommand)})},
 args: [],
 source: "execute\x0a\x09self model focusOnPackages",
 messageSends: ["focusOnPackages", "model"],
 referencedClasses: []
 }),
-smalltalk.HLGoToPackagesCommand);
+globals.HLGoToPackagesCommand);
 
 
 smalltalk.addMethod(
@@ -203,7 +203,7 @@ source: "key\x0a\x09^ 'p'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGoToPackagesCommand.klass);
+globals.HLGoToPackagesCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -218,10 +218,10 @@ source: "label\x0a\x09^ 'Packages'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGoToPackagesCommand.klass);
+globals.HLGoToPackagesCommand.klass);
 
 
-smalltalk.addClass('HLGoToProtocolsCommand', smalltalk.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
+smalltalk.addClass('HLGoToProtocolsCommand', globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute",
@@ -230,13 +230,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._model())._focusOnProtocols();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLGoToProtocolsCommand)})},
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLGoToProtocolsCommand)})},
 args: [],
 source: "execute\x0a\x09self model focusOnProtocols",
 messageSends: ["focusOnProtocols", "model"],
 referencedClasses: []
 }),
-smalltalk.HLGoToProtocolsCommand);
+globals.HLGoToProtocolsCommand);
 
 
 smalltalk.addMethod(
@@ -252,7 +252,7 @@ source: "key\x0a\x09^ 't'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGoToProtocolsCommand.klass);
+globals.HLGoToProtocolsCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -267,10 +267,10 @@ source: "label\x0a\x09^ 'Protocols'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGoToProtocolsCommand.klass);
+globals.HLGoToProtocolsCommand.klass);
 
 
-smalltalk.addClass('HLGoToSourceCodeCommand', smalltalk.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
+smalltalk.addClass('HLGoToSourceCodeCommand', globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute",
@@ -279,13 +279,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._model())._focusOnSourceCode();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLGoToSourceCodeCommand)})},
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLGoToSourceCodeCommand)})},
 args: [],
 source: "execute\x0a\x09self model focusOnSourceCode",
 messageSends: ["focusOnSourceCode", "model"],
 referencedClasses: []
 }),
-smalltalk.HLGoToSourceCodeCommand);
+globals.HLGoToSourceCodeCommand);
 
 
 smalltalk.addMethod(
@@ -301,7 +301,7 @@ source: "key\x0a\x09^ 's'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGoToSourceCodeCommand.klass);
+globals.HLGoToSourceCodeCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -316,10 +316,10 @@ source: "label\x0a\x09^ 'Source code'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGoToSourceCodeCommand.klass);
+globals.HLGoToSourceCodeCommand.klass);
 
 
-smalltalk.addClass('HLEditCommentCommand', smalltalk.HLBrowserCommand, [], 'Helios-Commands-Browser');
+smalltalk.addClass('HLEditCommentCommand', globals.HLBrowserCommand, [], 'Helios-Commands-Browser');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute",
@@ -328,13 +328,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._model())._editComment();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLEditCommentCommand)})},
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLEditCommentCommand)})},
 args: [],
 source: "execute\x0a\x09self model editComment",
 messageSends: ["editComment", "model"],
 referencedClasses: []
 }),
-smalltalk.HLEditCommentCommand);
+globals.HLEditCommentCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -352,13 +352,13 @@ return smalltalk.withContext(function($ctx2) {
 return _st(_st(self._model())._selectedClass())._notNil();
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isActive",{},smalltalk.HLEditCommentCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLEditCommentCommand)})},
 args: [],
 source: "isActive\x0a\x09^ self model showComment and: [ self model selectedClass notNil ]",
 messageSends: ["and:", "showComment", "model", "notNil", "selectedClass"],
 referencedClasses: []
 }),
-smalltalk.HLEditCommentCommand);
+globals.HLEditCommentCommand);
 
 
 smalltalk.addMethod(
@@ -374,7 +374,7 @@ source: "key\x0a\x09^ 'd'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLEditCommentCommand.klass);
+globals.HLEditCommentCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -389,11 +389,11 @@ source: "label\x0a\x09^ 'Edit documentation'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLEditCommentCommand.klass);
+globals.HLEditCommentCommand.klass);
 
 
-smalltalk.addClass('HLGenerateCommand', smalltalk.HLBrowserCommand, [], 'Helios-Commands-Browser');
-smalltalk.HLGenerateCommand.comment="I am a group command used to gather all the commands generating code (`accessors`, `initialize`, etc)";
+smalltalk.addClass('HLGenerateCommand', globals.HLBrowserCommand, [], 'Helios-Commands-Browser');
+globals.HLGenerateCommand.comment="I am a group command used to gather all the commands generating code (`accessors`, `initialize`, etc)";
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -408,7 +408,7 @@ source: "key\x0a\x09^ 'h'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGenerateCommand.klass);
+globals.HLGenerateCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -423,11 +423,11 @@ source: "label\x0a\x09^ 'Generate'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGenerateCommand.klass);
+globals.HLGenerateCommand.klass);
 
 
-smalltalk.addClass('HLCategorizeUnclassifiedCommand', smalltalk.HLGenerateCommand, [], 'Helios-Commands-Browser');
-smalltalk.HLCategorizeUnclassifiedCommand.comment="I am the command used to categorize unclassified methods";
+smalltalk.addClass('HLCategorizeUnclassifiedCommand', globals.HLGenerateCommand, [], 'Helios-Commands-Browser');
+globals.HLCategorizeUnclassifiedCommand.comment="I am the command used to categorize unclassified methods";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute",
@@ -435,7 +435,7 @@ protocol: 'executing',
 fn: function (){
 var self=this;
 var targetClass,unclassified;
-function $HLMethodClassifier(){return smalltalk.HLMethodClassifier||(typeof HLMethodClassifier=="undefined"?nil:HLMethodClassifier)}
+function $HLMethodClassifier(){return globals.HLMethodClassifier||(typeof HLMethodClassifier=="undefined"?nil:HLMethodClassifier)}
 return smalltalk.withContext(function($ctx1) { 
 targetClass=_st(self._model())._selectedClass();
 unclassified=_st(_st(targetClass)._methods())._select_((function(e){
@@ -443,13 +443,13 @@ return smalltalk.withContext(function($ctx2) {
 return _st(_st(e)._protocol()).__eq("as yet unclassified");
 }, function($ctx2) {$ctx2.fillBlock({e:e},$ctx1,1)})}));
 _st(_st($HLMethodClassifier())._new())._classifyAll_(unclassified);
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{targetClass:targetClass,unclassified:unclassified},smalltalk.HLCategorizeUnclassifiedCommand)})},
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{targetClass:targetClass,unclassified:unclassified},globals.HLCategorizeUnclassifiedCommand)})},
 args: [],
 source: "execute\x0a\x09| targetClass unclassified |\x0a\x09targetClass := self model selectedClass.\x0a\x0a\x09unclassified := targetClass methods select:[ :e | e protocol = 'as yet unclassified' ].\x0a\x09\x09\x0a\x09HLMethodClassifier new\x0a\x09\x09classifyAll: unclassified",
 messageSends: ["selectedClass", "model", "select:", "methods", "=", "protocol", "classifyAll:", "new"],
 referencedClasses: ["HLMethodClassifier"]
 }),
-smalltalk.HLCategorizeUnclassifiedCommand);
+globals.HLCategorizeUnclassifiedCommand);
 
 
 smalltalk.addMethod(
@@ -465,7 +465,7 @@ source: "key\x0a\x09^ 'c'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLCategorizeUnclassifiedCommand.klass);
+globals.HLCategorizeUnclassifiedCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -480,11 +480,11 @@ source: "label\x0a\x09^ 'Categorize'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLCategorizeUnclassifiedCommand.klass);
+globals.HLCategorizeUnclassifiedCommand.klass);
 
 
-smalltalk.addClass('HLGenerateAccessorsCommand', smalltalk.HLGenerateCommand, [], 'Helios-Commands-Browser');
-smalltalk.HLGenerateAccessorsCommand.comment="I am the command used to generate the `getter` and the `setter` methods depending of the selected class";
+smalltalk.addClass('HLGenerateAccessorsCommand', globals.HLGenerateCommand, [], 'Helios-Commands-Browser');
+globals.HLGenerateAccessorsCommand.comment="I am the command used to generate the `getter` and the `setter` methods depending of the selected class";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute",
@@ -492,7 +492,7 @@ protocol: 'executing',
 fn: function (){
 var self=this;
 var targetClass,output,first;
-function $HLInitializeGenerator(){return smalltalk.HLInitializeGenerator||(typeof HLInitializeGenerator=="undefined"?nil:HLInitializeGenerator)}
+function $HLInitializeGenerator(){return globals.HLInitializeGenerator||(typeof HLInitializeGenerator=="undefined"?nil:HLInitializeGenerator)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2,$3,$4,$5;
 $1=self._model();
@@ -509,13 +509,13 @@ $4=self._model();
 _st($4)._selectedProtocol_(_st(output)._protocol());
 _st($4)._selectedMethod_(_st(targetClass).__gt_gt(_st(first)._selector()));
 $5=_st($4)._focusOnSourceCode();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{targetClass:targetClass,output:output,first:first},smalltalk.HLGenerateAccessorsCommand)})},
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{targetClass:targetClass,output:output,first:first},globals.HLGenerateAccessorsCommand)})},
 args: [],
 source: "execute\x0a\x09| targetClass output first |\x0a\x09targetClass := self model selectedClass.\x0a\x0a\x09output := HLInitializeGenerator new\x0a\x09\x09class: targetClass;\x0a\x09\x09generate;\x0a\x09\x09output.\x0a\x09\x09\x0a\x09output compile.\x0a\x09first := output sourceCodes first.\x0a\x09self model\x0a\x09\x09selectedProtocol: output protocol;\x0a\x09\x09selectedMethod:(targetClass>>first selector);\x0a\x09\x09focusOnSourceCode",
 messageSends: ["selectedClass", "model", "class:", "new", "generate", "output", "compile", "first", "sourceCodes", "selectedProtocol:", "protocol", "selectedMethod:", ">>", "selector", "focusOnSourceCode"],
 referencedClasses: ["HLInitializeGenerator"]
 }),
-smalltalk.HLGenerateAccessorsCommand);
+globals.HLGenerateAccessorsCommand);
 
 
 smalltalk.addMethod(
@@ -531,7 +531,7 @@ source: "key\x0a\x09^ 'i'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGenerateAccessorsCommand.klass);
+globals.HLGenerateAccessorsCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -546,11 +546,11 @@ source: "label\x0a\x09^ 'Initialize'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGenerateAccessorsCommand.klass);
+globals.HLGenerateAccessorsCommand.klass);
 
 
-smalltalk.addClass('HLGenerateInitializeCommand', smalltalk.HLGenerateCommand, [], 'Helios-Commands-Browser');
-smalltalk.HLGenerateInitializeCommand.comment="I am the command used to generate the `initialize` method depending of the selected class";
+smalltalk.addClass('HLGenerateInitializeCommand', globals.HLGenerateCommand, [], 'Helios-Commands-Browser');
+globals.HLGenerateInitializeCommand.comment="I am the command used to generate the `initialize` method depending of the selected class";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute",
@@ -558,7 +558,7 @@ protocol: 'executing',
 fn: function (){
 var self=this;
 var targetClass,output;
-function $HLAccessorsGenerator(){return smalltalk.HLAccessorsGenerator||(typeof HLAccessorsGenerator=="undefined"?nil:HLAccessorsGenerator)}
+function $HLAccessorsGenerator(){return globals.HLAccessorsGenerator||(typeof HLAccessorsGenerator=="undefined"?nil:HLAccessorsGenerator)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2,$3;
 $1=self._model();
@@ -571,13 +571,13 @@ $3=_st($2)._output();
 output=$3;
 _st(output)._compile();
 _st(self._model())._selectedProtocol_(_st(output)._protocol());
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{targetClass:targetClass,output:output},smalltalk.HLGenerateInitializeCommand)})},
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{targetClass:targetClass,output:output},globals.HLGenerateInitializeCommand)})},
 args: [],
 source: "execute\x0a\x09| targetClass output |\x0a\x09targetClass := self model selectedClass.\x0a\x0a\x09output := HLAccessorsGenerator new\x0a\x09\x09class: targetClass;\x0a\x09\x09generate;\x0a\x09\x09output.\x0a\x09\x09\x0a\x09output compile.\x0a\x09self model selectedProtocol: output protocol",
 messageSends: ["selectedClass", "model", "class:", "new", "generate", "output", "compile", "selectedProtocol:", "protocol"],
 referencedClasses: ["HLAccessorsGenerator"]
 }),
-smalltalk.HLGenerateInitializeCommand);
+globals.HLGenerateInitializeCommand);
 
 
 smalltalk.addMethod(
@@ -593,7 +593,7 @@ source: "key\x0a\x09^ 'a'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGenerateInitializeCommand.klass);
+globals.HLGenerateInitializeCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -608,10 +608,10 @@ source: "label\x0a\x09^ 'Accessors'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGenerateInitializeCommand.klass);
+globals.HLGenerateInitializeCommand.klass);
 
 
-smalltalk.addClass('HLToggleCommand', smalltalk.HLBrowserCommand, [], 'Helios-Commands-Browser');
+smalltalk.addClass('HLToggleCommand', globals.HLBrowserCommand, [], 'Helios-Commands-Browser');
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -626,7 +626,7 @@ source: "key\x0a\x09^ 't'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLToggleCommand.klass);
+globals.HLToggleCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -641,10 +641,10 @@ source: "label\x0a\x09^ 'Toggle'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLToggleCommand.klass);
+globals.HLToggleCommand.klass);
 
 
-smalltalk.addClass('HLToggleClassCommentCommand', smalltalk.HLToggleCommand, [], 'Helios-Commands-Browser');
+smalltalk.addClass('HLToggleClassCommentCommand', globals.HLToggleCommand, [], 'Helios-Commands-Browser');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute",
@@ -656,13 +656,13 @@ var $1;
 $1=self._model();
 $ctx1.sendIdx["model"]=1;
 _st($1)._showComment_(_st(_st(self._model())._showComment())._not());
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLToggleClassCommentCommand)})},
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLToggleClassCommentCommand)})},
 args: [],
 source: "execute\x0a\x09self model showComment: self model showComment not",
 messageSends: ["showComment:", "model", "not", "showComment"],
 referencedClasses: []
 }),
-smalltalk.HLToggleClassCommentCommand);
+globals.HLToggleClassCommentCommand);
 
 
 smalltalk.addMethod(
@@ -678,7 +678,7 @@ source: "key\x0a\x09^ 'd'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLToggleClassCommentCommand.klass);
+globals.HLToggleClassCommentCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -693,10 +693,10 @@ source: "label\x0a\x09^ 'Documentation'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLToggleClassCommentCommand.klass);
+globals.HLToggleClassCommentCommand.klass);
 
 
-smalltalk.addClass('HLToggleClassSideCommand', smalltalk.HLToggleCommand, [], 'Helios-Commands-Browser');
+smalltalk.addClass('HLToggleClassSideCommand', globals.HLToggleCommand, [], 'Helios-Commands-Browser');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute",
@@ -705,13 +705,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._model())._showInstance_(false);
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLToggleClassSideCommand)})},
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLToggleClassSideCommand)})},
 args: [],
 source: "execute\x0a\x09self model showInstance: false",
 messageSends: ["showInstance:", "model"],
 referencedClasses: []
 }),
-smalltalk.HLToggleClassSideCommand);
+globals.HLToggleClassSideCommand);
 
 
 smalltalk.addMethod(
@@ -727,7 +727,7 @@ source: "key\x0a\x09^ 'c'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLToggleClassSideCommand.klass);
+globals.HLToggleClassSideCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -742,10 +742,10 @@ source: "label\x0a\x09^ 'Class side'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLToggleClassSideCommand.klass);
+globals.HLToggleClassSideCommand.klass);
 
 
-smalltalk.addClass('HLToggleInstanceSideCommand', smalltalk.HLToggleCommand, [], 'Helios-Commands-Browser');
+smalltalk.addClass('HLToggleInstanceSideCommand', globals.HLToggleCommand, [], 'Helios-Commands-Browser');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute",
@@ -754,13 +754,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._model())._showInstance_(true);
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLToggleInstanceSideCommand)})},
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLToggleInstanceSideCommand)})},
 args: [],
 source: "execute\x0a\x09self model showInstance: true",
 messageSends: ["showInstance:", "model"],
 referencedClasses: []
 }),
-smalltalk.HLToggleInstanceSideCommand);
+globals.HLToggleInstanceSideCommand);
 
 
 smalltalk.addMethod(
@@ -776,7 +776,7 @@ source: "key\x0a\x09^ 'i'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLToggleInstanceSideCommand.klass);
+globals.HLToggleInstanceSideCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -791,6 +791,6 @@ source: "label\x0a\x09^ 'Instance side'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLToggleInstanceSideCommand.klass);
+globals.HLToggleInstanceSideCommand.klass);
 
 });

js/Helios-Commands-Core.js

@@ -1,15 +1,15 @@
-define("amber_core/Helios-Commands-Core", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st){
+define("amber_core/Helios-Commands-Core", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Helios-Commands-Core');
 smalltalk.packages["Helios-Commands-Core"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('HLCommand', smalltalk.Object, ['input'], 'Helios-Commands-Core');
+smalltalk.addClass('HLCommand', globals.Object, ['input'], 'Helios-Commands-Core');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "asActionBinding",
 protocol: 'converting',
 fn: function (){
 var self=this;
-function $HLBindingAction(){return smalltalk.HLBindingAction||(typeof HLBindingAction=="undefined"?nil:HLBindingAction)}
+function $HLBindingAction(){return globals.HLBindingAction||(typeof HLBindingAction=="undefined"?nil:HLBindingAction)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$3,$1;
 $2=_st($HLBindingAction())._on_labelled_(self._keyCode(),self._label());
@@ -17,13 +17,13 @@ _st($2)._command_(self);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"asActionBinding",{},smalltalk.HLCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"asActionBinding",{},globals.HLCommand)})},
 args: [],
 source: "asActionBinding\x0a\x09^ (HLBindingAction on: self keyCode labelled: self label)\x0a    \x09command: self;\x0a\x09\x09yourself",
 messageSends: ["command:", "on:labelled:", "keyCode", "label", "yourself"],
 referencedClasses: ["HLBindingAction"]
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -40,13 +40,13 @@ $1=self._asGroupBinding();
 $1=self._asActionBinding();
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"asBinding",{},smalltalk.HLCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"asBinding",{},globals.HLCommand)})},
 args: [],
 source: "asBinding\x0a\x09^ self isBindingGroup\x0a\x09\x09ifTrue: [ self asGroupBinding ]\x0a\x09\x09ifFalse: [ self asActionBinding ]",
 messageSends: ["ifTrue:ifFalse:", "isBindingGroup", "asGroupBinding", "asActionBinding"],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -54,18 +54,18 @@ selector: "asGroupBinding",
 protocol: 'converting',
 fn: function (){
 var self=this;
-function $HLBindingGroup(){return smalltalk.HLBindingGroup||(typeof HLBindingGroup=="undefined"?nil:HLBindingGroup)}
+function $HLBindingGroup(){return globals.HLBindingGroup||(typeof HLBindingGroup=="undefined"?nil:HLBindingGroup)}
 return smalltalk.withContext(function($ctx1) { 
 var $1;
 $1=_st($HLBindingGroup())._on_labelled_(self._keyCode(),self._label());
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"asGroupBinding",{},smalltalk.HLCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"asGroupBinding",{},globals.HLCommand)})},
 args: [],
 source: "asGroupBinding\x0a\x09^ HLBindingGroup \x0a\x09\x09on: self keyCode\x0a\x09\x09labelled: self label",
 messageSends: ["on:labelled:", "keyCode", "label"],
 referencedClasses: ["HLBindingGroup"]
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -75,13 +75,13 @@ fn: function (aString){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._error_(aString);
-return self}, function($ctx1) {$ctx1.fill(self,"commandError:",{aString:aString},smalltalk.HLCommand)})},
+return self}, function($ctx1) {$ctx1.fill(self,"commandError:",{aString:aString},globals.HLCommand)})},
 args: ["aString"],
 source: "commandError: aString\x0a\x09self error: aString",
 messageSends: ["error:"],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -96,7 +96,7 @@ source: "defaultInput\x0a\x09^ ''",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -108,13 +108,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self._class())._documentation();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"documentation",{},smalltalk.HLCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"documentation",{},globals.HLCommand)})},
 args: [],
 source: "documentation\x0a\x09^ self class documentation",
 messageSends: ["documentation", "class"],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -128,7 +128,7 @@ source: "execute",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -145,7 +145,7 @@ source: "input\x0a\x09^ input",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -163,7 +163,7 @@ source: "input: aString\x0a\x09^ input := aString",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -180,7 +180,7 @@ source: "inputCompletion\x0a\x09^ #()",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -192,13 +192,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._label();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"inputLabel",{},smalltalk.HLCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"inputLabel",{},globals.HLCommand)})},
 args: [],
 source: "inputLabel\x0a\x09^ self label",
 messageSends: ["label"],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -210,13 +210,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self._isBindingGroup())._not();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isAction",{},smalltalk.HLCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"isAction",{},globals.HLCommand)})},
 args: [],
 source: "isAction\x0a\x09^ self isBindingGroup not",
 messageSends: ["not", "isBindingGroup"],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -231,7 +231,7 @@ source: "isActive\x0a\x09^ true",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -243,13 +243,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(_st(_st(self._class())._methodDictionary())._includesKey_("execute"))._not();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isBindingGroup",{},smalltalk.HLCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"isBindingGroup",{},globals.HLCommand)})},
 args: [],
 source: "isBindingGroup\x0a\x09^ (self class methodDictionary includesKey: 'execute') not",
 messageSends: ["not", "includesKey:", "methodDictionary", "class"],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -264,7 +264,7 @@ source: "isInputRequired\x0a\x09^ false",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -276,13 +276,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self._class())._key();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"key",{},smalltalk.HLCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"key",{},globals.HLCommand)})},
 args: [],
 source: "key\x0a\x09^ self class key",
 messageSends: ["key", "class"],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -294,13 +294,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(_st(self._key())._asUppercase())._charCodeAt_((1));
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"keyCode",{},smalltalk.HLCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"keyCode",{},globals.HLCommand)})},
 args: [],
 source: "keyCode\x0a\x09^ self key asUppercase charCodeAt: 1",
 messageSends: ["charCodeAt:", "asUppercase", "key"],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -312,13 +312,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self._class())._label();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"label",{},smalltalk.HLCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"label",{},globals.HLCommand)})},
 args: [],
 source: "label\x0a\x09^ self class label",
 messageSends: ["label", "class"],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -330,13 +330,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self._class())._menuLabel();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"menuLabel",{},smalltalk.HLCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"menuLabel",{},globals.HLCommand)})},
 args: [],
 source: "menuLabel\x0a\x09^ self class menuLabel",
 messageSends: ["menuLabel", "class"],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -348,13 +348,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(aBinding)._add_(self._asBinding());
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"registerOn:",{aBinding:aBinding},smalltalk.HLCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"registerOn:",{aBinding:aBinding},globals.HLCommand)})},
 args: ["aBinding"],
 source: "registerOn: aBinding\x0a\x09^ aBinding add: self asBinding",
 messageSends: ["add:", "asBinding"],
 referencedClasses: []
 }),
-smalltalk.HLCommand);
+globals.HLCommand);
 
 
 smalltalk.addMethod(
@@ -364,7 +364,7 @@ protocol: 'registration',
 fn: function (){
 var self=this;
 var classes;
-function $OrderedCollection(){return smalltalk.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
 classes=_st($OrderedCollection())._new();
@@ -378,13 +378,13 @@ return _st(classes)._addAll_(_st(each)._concreteClasses());
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,2)})}));
 $2=classes;
 return $2;
-}, function($ctx1) {$ctx1.fill(self,"concreteClasses",{classes:classes},smalltalk.HLCommand.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"concreteClasses",{classes:classes},globals.HLCommand.klass)})},
 args: [],
 source: "concreteClasses\x0a\x09| classes |\x0a\x09\x0a\x09classes := OrderedCollection new.\x0a\x09\x0a\x09self isConcrete\x0a\x09\x09ifTrue: [ classes add: self ].\x0a\x09\x09\x0a\x09self subclasses do: [ :each | \x0a\x09\x09classes addAll: each concreteClasses ].\x0a\x09\x09\x0a\x09^ classes",
 messageSends: ["new", "ifTrue:", "isConcrete", "add:", "do:", "subclasses", "addAll:", "concreteClasses"],
 referencedClasses: ["OrderedCollection"]
 }),
-smalltalk.HLCommand.klass);
+globals.HLCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -399,7 +399,7 @@ source: "documentation\x0a\x09^ ''",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLCommand.klass);
+globals.HLCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -411,13 +411,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self._key())._notNil();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isConcrete",{},smalltalk.HLCommand.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"isConcrete",{},globals.HLCommand.klass)})},
 args: [],
 source: "isConcrete\x0a\x09^ self key notNil",
 messageSends: ["notNil", "key"],
 referencedClasses: []
 }),
-smalltalk.HLCommand.klass);
+globals.HLCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -432,7 +432,7 @@ source: "isValidFor: aModel\x0a\x09^ true",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLCommand.klass);
+globals.HLCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -447,7 +447,7 @@ source: "key\x0a\x09\x22Answer a single character string or nil if no key\x22\x0
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLCommand.klass);
+globals.HLCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -462,7 +462,7 @@ source: "label\x0a\x09^ ''",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLCommand.klass);
+globals.HLCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -474,13 +474,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._label();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"menuLabel",{},smalltalk.HLCommand.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"menuLabel",{},globals.HLCommand.klass)})},
 args: [],
 source: "menuLabel\x0a\x09^ self label",
 messageSends: ["label"],
 referencedClasses: []
 }),
-smalltalk.HLCommand.klass);
+globals.HLCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -503,13 +503,13 @@ _st(self._subclasses())._do_((function(each){
 return smalltalk.withContext(function($ctx2) {
 return _st(each)._registerConcreteClassesOn_(newBinding);
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,3)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"registerConcreteClassesOn:",{aBinding:aBinding,newBinding:newBinding},smalltalk.HLCommand.klass)})},
+return self}, function($ctx1) {$ctx1.fill(self,"registerConcreteClassesOn:",{aBinding:aBinding,newBinding:newBinding},globals.HLCommand.klass)})},
 args: ["aBinding"],
 source: "registerConcreteClassesOn: aBinding\x0a\x09| newBinding |\x0a\x09\x0a\x09self isConcrete\x0a\x09\x09ifTrue: [ newBinding := self registerOn: aBinding ]\x0a\x09\x09ifFalse: [ newBinding := aBinding ].\x0a\x09\x09\x0a\x09self subclasses do: [ :each | each registerConcreteClassesOn: newBinding ]",
 messageSends: ["ifTrue:ifFalse:", "isConcrete", "registerOn:", "do:", "subclasses", "registerConcreteClassesOn:"],
 referencedClasses: []
 }),
-smalltalk.HLCommand.klass);
+globals.HLCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -521,32 +521,32 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self._new())._registerOn_(aBinding);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"registerOn:",{aBinding:aBinding},smalltalk.HLCommand.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"registerOn:",{aBinding:aBinding},globals.HLCommand.klass)})},
 args: ["aBinding"],
 source: "registerOn: aBinding\x0a\x09^ self new registerOn: aBinding",
 messageSends: ["registerOn:", "new"],
 referencedClasses: []
 }),
-smalltalk.HLCommand.klass);
+globals.HLCommand.klass);
 
 
-smalltalk.addClass('HLCloseTabCommand', smalltalk.HLCommand, [], 'Helios-Commands-Core');
+smalltalk.addClass('HLCloseTabCommand', globals.HLCommand, [], 'Helios-Commands-Core');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-function $HLManager(){return smalltalk.HLManager||(typeof HLManager=="undefined"?nil:HLManager)}
+function $HLManager(){return globals.HLManager||(typeof HLManager=="undefined"?nil:HLManager)}
 return smalltalk.withContext(function($ctx1) { 
 _st(_st($HLManager())._current())._removeActiveTab();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLCloseTabCommand)})},
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLCloseTabCommand)})},
 args: [],
 source: "execute\x0a\x09HLManager current removeActiveTab",
 messageSends: ["removeActiveTab", "current"],
 referencedClasses: ["HLManager"]
 }),
-smalltalk.HLCloseTabCommand);
+globals.HLCloseTabCommand);
 
 
 smalltalk.addMethod(
@@ -562,7 +562,7 @@ source: "key\x0a\x09^ 'w'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLCloseTabCommand.klass);
+globals.HLCloseTabCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -577,10 +577,10 @@ source: "label\x0a\x09^ 'Close tab'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLCloseTabCommand.klass);
+globals.HLCloseTabCommand.klass);
 
 
-smalltalk.addClass('HLModelCommand', smalltalk.HLCommand, ['model'], 'Helios-Commands-Core');
+smalltalk.addClass('HLModelCommand', globals.HLCommand, ['model'], 'Helios-Commands-Core');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "model",
@@ -596,7 +596,7 @@ source: "model\x0a\x09^ model",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLModelCommand);
+globals.HLModelCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -611,7 +611,7 @@ source: "model: aModel\x0a\x09model := aModel",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLModelCommand);
+globals.HLModelCommand);
 
 
 smalltalk.addMethod(
@@ -624,13 +624,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._new();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"for:",{aModel:aModel},smalltalk.HLModelCommand.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"for:",{aModel:aModel},globals.HLModelCommand.klass)})},
 args: ["aModel"],
 source: "for: aModel\x0a\x09^ self new",
 messageSends: ["new"],
 referencedClasses: []
 }),
-smalltalk.HLModelCommand.klass);
+globals.HLModelCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -656,13 +656,13 @@ _st(self._subclasses())._do_((function(each){
 return smalltalk.withContext(function($ctx2) {
 return _st(each)._registerConcreteClassesOn_for_(newBinding,aModel);
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,4)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"registerConcreteClassesOn:for:",{aBinding:aBinding,aModel:aModel,newBinding:newBinding},smalltalk.HLModelCommand.klass)})},
+return self}, function($ctx1) {$ctx1.fill(self,"registerConcreteClassesOn:for:",{aBinding:aBinding,aModel:aModel,newBinding:newBinding},globals.HLModelCommand.klass)})},
 args: ["aBinding", "aModel"],
 source: "registerConcreteClassesOn: aBinding for: aModel\x0a\x09| newBinding |\x0a\x09\x0a\x09(self isConcrete and: [ self isValidFor: aModel ])\x0a\x09\x09ifTrue: [ newBinding := self registerOn: aBinding for: aModel ]\x0a\x09\x09ifFalse: [ newBinding := aBinding ].\x0a\x09\x09\x0a\x09self subclasses do: [ :each |\x0a\x09\x09each registerConcreteClassesOn: newBinding for: aModel ]",
 messageSends: ["ifTrue:ifFalse:", "and:", "isConcrete", "isValidFor:", "registerOn:for:", "do:", "subclasses", "registerConcreteClassesOn:for:"],
 referencedClasses: []
 }),
-smalltalk.HLModelCommand.klass);
+globals.HLModelCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -674,16 +674,16 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self._for_(aModel))._registerOn_(aBinding);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"registerOn:for:",{aBinding:aBinding,aModel:aModel},smalltalk.HLModelCommand.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"registerOn:for:",{aBinding:aBinding,aModel:aModel},globals.HLModelCommand.klass)})},
 args: ["aBinding", "aModel"],
 source: "registerOn: aBinding for: aModel\x0a\x09^ (self for: aModel) registerOn: aBinding",
 messageSends: ["registerOn:", "for:"],
 referencedClasses: []
 }),
-smalltalk.HLModelCommand.klass);
+globals.HLModelCommand.klass);
 
 
-smalltalk.addClass('HLOpenCommand', smalltalk.HLCommand, [], 'Helios-Commands-Core');
+smalltalk.addClass('HLOpenCommand', globals.HLCommand, [], 'Helios-Commands-Core');
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -698,7 +698,7 @@ source: "key\x0a\x09^ 'o'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLOpenCommand.klass);
+globals.HLOpenCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -713,28 +713,28 @@ source: "label\x0a\x09^ 'Open'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLOpenCommand.klass);
+globals.HLOpenCommand.klass);
 
 
-smalltalk.addClass('HLOpenBrowserCommand', smalltalk.HLOpenCommand, [], 'Helios-Commands-Core');
+smalltalk.addClass('HLOpenBrowserCommand', globals.HLOpenCommand, [], 'Helios-Commands-Core');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-function $HLBrowser(){return smalltalk.HLBrowser||(typeof HLBrowser=="undefined"?nil:HLBrowser)}
+function $HLBrowser(){return globals.HLBrowser||(typeof HLBrowser=="undefined"?nil:HLBrowser)}
 return smalltalk.withContext(function($ctx1) { 
 var $1;
 $1=_st($HLBrowser())._openAsTab();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLOpenBrowserCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLOpenBrowserCommand)})},
 args: [],
 source: "execute\x0a\x09^ HLBrowser openAsTab",
 messageSends: ["openAsTab"],
 referencedClasses: ["HLBrowser"]
 }),
-smalltalk.HLOpenBrowserCommand);
+globals.HLOpenBrowserCommand);
 
 
 smalltalk.addMethod(
@@ -750,7 +750,7 @@ source: "key\x0a\x09^ 'b'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLOpenBrowserCommand.klass);
+globals.HLOpenBrowserCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -765,28 +765,28 @@ source: "label\x0a\x09^ 'Browser'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLOpenBrowserCommand.klass);
+globals.HLOpenBrowserCommand.klass);
 
 
-smalltalk.addClass('HLOpenWorkspaceCommand', smalltalk.HLOpenCommand, [], 'Helios-Commands-Core');
+smalltalk.addClass('HLOpenWorkspaceCommand', globals.HLOpenCommand, [], 'Helios-Commands-Core');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-function $HLWorkspace(){return smalltalk.HLWorkspace||(typeof HLWorkspace=="undefined"?nil:HLWorkspace)}
+function $HLWorkspace(){return globals.HLWorkspace||(typeof HLWorkspace=="undefined"?nil:HLWorkspace)}
 return smalltalk.withContext(function($ctx1) { 
 var $1;
 $1=_st($HLWorkspace())._openAsTab();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"execute",{},smalltalk.HLOpenWorkspaceCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLOpenWorkspaceCommand)})},
 args: [],
 source: "execute\x0a\x09^ HLWorkspace openAsTab",
 messageSends: ["openAsTab"],
 referencedClasses: ["HLWorkspace"]
 }),
-smalltalk.HLOpenWorkspaceCommand);
+globals.HLOpenWorkspaceCommand);
 
 
 smalltalk.addMethod(
@@ -802,7 +802,7 @@ source: "key\x0a\x09^ 'w'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLOpenWorkspaceCommand.klass);
+globals.HLOpenWorkspaceCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -817,10 +817,10 @@ source: "label\x0a\x09^ 'Workspace'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLOpenWorkspaceCommand.klass);
+globals.HLOpenWorkspaceCommand.klass);
 
 
-smalltalk.addClass('HLSwitchTabCommand', smalltalk.HLCommand, [], 'Helios-Commands-Core');
+smalltalk.addClass('HLSwitchTabCommand', globals.HLCommand, [], 'Helios-Commands-Core');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute",
@@ -828,7 +828,7 @@ protocol: 'executing',
 fn: function (){
 var self=this;
 var activeTab;
-function $HLTabSelectionWidget(){return smalltalk.HLTabSelectionWidget||(typeof HLTabSelectionWidget=="undefined"?nil:HLTabSelectionWidget)}
+function $HLTabSelectionWidget(){return globals.HLTabSelectionWidget||(typeof HLTabSelectionWidget=="undefined"?nil:HLTabSelectionWidget)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$3,$1;
 activeTab=self._selectedTab();
@@ -852,13 +852,13 @@ return _st(activeTab)._activate();
 $3=_st($2)._show();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"execute",{activeTab:activeTab},smalltalk.HLSwitchTabCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"execute",{activeTab:activeTab},globals.HLSwitchTabCommand)})},
 args: [],
 source: "execute\x0a\x09| activeTab |\x0a\x09\x0a\x09activeTab := self selectedTab.\x0a\x09\x0a\x09^ HLTabSelectionWidget new\x0a\x09\x09tabs: self tabs;\x0a\x09\x09selectedTab: self selectedTab;\x0a\x09\x09selectCallback: [ :tab | tab activate ];\x0a\x09\x09confirmCallback: [ :tab | tab focus ];\x0a\x09\x09cancelCallback: [ activeTab activate ];\x0a\x09\x09show",
 messageSends: ["selectedTab", "tabs:", "new", "tabs", "selectedTab:", "selectCallback:", "activate", "confirmCallback:", "focus", "cancelCallback:", "show"],
 referencedClasses: ["HLTabSelectionWidget"]
 }),
-smalltalk.HLSwitchTabCommand);
+globals.HLSwitchTabCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -866,18 +866,18 @@ selector: "selectedTab",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-function $HLManager(){return smalltalk.HLManager||(typeof HLManager=="undefined"?nil:HLManager)}
+function $HLManager(){return globals.HLManager||(typeof HLManager=="undefined"?nil:HLManager)}
 return smalltalk.withContext(function($ctx1) { 
 var $1;
 $1=_st(_st($HLManager())._current())._activeTab();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"selectedTab",{},smalltalk.HLSwitchTabCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"selectedTab",{},globals.HLSwitchTabCommand)})},
 args: [],
 source: "selectedTab\x0a\x09^ HLManager current activeTab",
 messageSends: ["activeTab", "current"],
 referencedClasses: ["HLManager"]
 }),
-smalltalk.HLSwitchTabCommand);
+globals.HLSwitchTabCommand);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -885,18 +885,18 @@ selector: "tabs",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-function $HLManager(){return smalltalk.HLManager||(typeof HLManager=="undefined"?nil:HLManager)}
+function $HLManager(){return globals.HLManager||(typeof HLManager=="undefined"?nil:HLManager)}
 return smalltalk.withContext(function($ctx1) { 
 var $1;
 $1=_st(_st($HLManager())._current())._tabs();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"tabs",{},smalltalk.HLSwitchTabCommand)})},
+}, function($ctx1) {$ctx1.fill(self,"tabs",{},globals.HLSwitchTabCommand)})},
 args: [],
 source: "tabs\x0a\x09^ HLManager current tabs",
 messageSends: ["tabs", "current"],
 referencedClasses: ["HLManager"]
 }),
-smalltalk.HLSwitchTabCommand);
+globals.HLSwitchTabCommand);
 
 
 smalltalk.addMethod(
@@ -912,7 +912,7 @@ source: "key\x0a\x09^ 's'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLSwitchTabCommand.klass);
+globals.HLSwitchTabCommand.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -927,10 +927,10 @@ source: "label\x0a\x09^ 'Switch'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLSwitchTabCommand.klass);
+globals.HLSwitchTabCommand.klass);
 
 
-smalltalk.addClass('HLViewCommand', smalltalk.HLCommand, [], 'Helios-Commands-Core');
+smalltalk.addClass('HLViewCommand', globals.HLCommand, [], 'Helios-Commands-Core');
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -945,6 +945,6 @@ source: "label\x0a\x09^ 'View'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLViewCommand.klass);
+globals.HLViewCommand.klass);
 
 });

js/Helios-Debugger.js

@@ -1,8 +1,8 @@
-define("amber_core/Helios-Debugger", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Objects", "amber_core/Helios-Core", "amber_core/Helios-Workspace"], function(smalltalk,nil,_st){
+define("amber_core/Helios-Debugger", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects", "amber_core/Helios-Core", "amber_core/Helios-Workspace"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Helios-Debugger');
 smalltalk.packages["Helios-Debugger"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('HLContextInspectorDecorator', smalltalk.Object, ['context'], 'Helios-Debugger');
+smalltalk.addClass('HLContextInspectorDecorator', globals.Object, ['context'], 'Helios-Debugger');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "context",
@@ -18,7 +18,7 @@ source: "context\x0a\x09^ context",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLContextInspectorDecorator);
+globals.HLContextInspectorDecorator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -33,7 +33,7 @@ source: "initializeFromContext: aContext\x0a\x09context := aContext",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLContextInspectorDecorator);
+globals.HLContextInspectorDecorator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -42,7 +42,7 @@ protocol: 'inspecting',
 fn: function (anInspector){
 var self=this;
 var variables,inspectedContext;
-function $Dictionary(){return smalltalk.Dictionary||(typeof Dictionary=="undefined"?nil:Dictionary)}
+function $Dictionary(){return globals.Dictionary||(typeof Dictionary=="undefined"?nil:Dictionary)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2,$3,$4;
 variables=_st($Dictionary())._new();
@@ -71,13 +71,13 @@ return _st(variables)._addAll_(_st(inspectedContext)._locals());
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,3)})}));
 _st(anInspector)._setLabel_("Context");
 $4=_st(anInspector)._setVariables_(variables);
-return self}, function($ctx1) {$ctx1.fill(self,"inspectOn:",{anInspector:anInspector,variables:variables,inspectedContext:inspectedContext},smalltalk.HLContextInspectorDecorator)})},
+return self}, function($ctx1) {$ctx1.fill(self,"inspectOn:",{anInspector:anInspector,variables:variables,inspectedContext:inspectedContext},globals.HLContextInspectorDecorator)})},
 args: ["anInspector"],
 source: "inspectOn: anInspector\x0a\x09| variables inspectedContext |\x0a\x09\x0a\x09variables := Dictionary new.\x0a\x09inspectedContext := self context.\x0a\x09\x0a\x09variables addAll: inspectedContext locals.\x0a\x09\x0a\x09[ inspectedContext notNil and: [ inspectedContext isBlockContext ] ] whileTrue: [\x0a\x09\x09inspectedContext := inspectedContext outerContext.\x0a\x09\x09inspectedContext ifNotNil: [\x0a\x09\x09\x09variables addAll: inspectedContext locals ] ].\x0a\x09\x0a\x09anInspector\x0a\x09\x09setLabel: 'Context';\x0a\x09\x09setVariables: variables",
 messageSends: ["new", "context", "addAll:", "locals", "whileTrue:", "and:", "notNil", "isBlockContext", "outerContext", "ifNotNil:", "setLabel:", "setVariables:"],
 referencedClasses: ["Dictionary"]
 }),
-smalltalk.HLContextInspectorDecorator);
+globals.HLContextInspectorDecorator);
 
 
 smalltalk.addMethod(
@@ -93,24 +93,24 @@ _st($2)._initializeFromContext_(aContext);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"on:",{aContext:aContext},smalltalk.HLContextInspectorDecorator.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"on:",{aContext:aContext},globals.HLContextInspectorDecorator.klass)})},
 args: ["aContext"],
 source: "on: aContext\x0a\x09^ self new\x0a\x09\x09initializeFromContext: aContext;\x0a\x09\x09yourself",
 messageSends: ["initializeFromContext:", "new", "yourself"],
 referencedClasses: []
 }),
-smalltalk.HLContextInspectorDecorator.klass);
+globals.HLContextInspectorDecorator.klass);
 
 
-smalltalk.addClass('HLDebugger', smalltalk.HLFocusableWidget, ['model', 'stackListWidget', 'codeWidget', 'inspectorWidget'], 'Helios-Debugger');
-smalltalk.HLDebugger.comment="I am the main widget for the Helios debugger.";
+smalltalk.addClass('HLDebugger', globals.HLFocusableWidget, ['model', 'stackListWidget', 'codeWidget', 'inspectorWidget'], 'Helios-Debugger');
+globals.HLDebugger.comment="I am the main widget for the Helios debugger.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "codeWidget",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-function $HLDebuggerCodeWidget(){return smalltalk.HLDebuggerCodeWidget||(typeof HLDebuggerCodeWidget=="undefined"?nil:HLDebuggerCodeWidget)}
+function $HLDebuggerCodeWidget(){return globals.HLDebuggerCodeWidget||(typeof HLDebuggerCodeWidget=="undefined"?nil:HLDebuggerCodeWidget)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$3,$4,$1;
 $2=self["@codeWidget"];
@@ -124,13 +124,13 @@ $1=self["@codeWidget"];
 $1=$2;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"codeWidget",{},smalltalk.HLDebugger)})},
+}, function($ctx1) {$ctx1.fill(self,"codeWidget",{},globals.HLDebugger)})},
 args: [],
 source: "codeWidget\x0a\x09^ codeWidget ifNil: [ codeWidget := HLDebuggerCodeWidget new\x0a\x09\x09browserModel: self model;\x0a\x09\x09yourself ]",
 messageSends: ["ifNil:", "browserModel:", "new", "model", "yourself"],
 referencedClasses: ["HLDebuggerCodeWidget"]
 }),
-smalltalk.HLDebugger);
+globals.HLDebugger);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -140,13 +140,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._stackListWidget())._focus();
-return self}, function($ctx1) {$ctx1.fill(self,"focus",{},smalltalk.HLDebugger)})},
+return self}, function($ctx1) {$ctx1.fill(self,"focus",{},globals.HLDebugger)})},
 args: [],
 source: "focus\x0a\x09self stackListWidget focus",
 messageSends: ["focus", "stackListWidget"],
 referencedClasses: []
 }),
-smalltalk.HLDebugger);
+globals.HLDebugger);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -154,17 +154,17 @@ selector: "initializeFromMethodContext:",
 protocol: 'accessing',
 fn: function (aMethodContext){
 var self=this;
-function $HLDebuggerModel(){return smalltalk.HLDebuggerModel||(typeof HLDebuggerModel=="undefined"?nil:HLDebuggerModel)}
+function $HLDebuggerModel(){return globals.HLDebuggerModel||(typeof HLDebuggerModel=="undefined"?nil:HLDebuggerModel)}
 return smalltalk.withContext(function($ctx1) { 
 self["@model"]=_st($HLDebuggerModel())._on_(aMethodContext);
 self._observeModel();
-return self}, function($ctx1) {$ctx1.fill(self,"initializeFromMethodContext:",{aMethodContext:aMethodContext},smalltalk.HLDebugger)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initializeFromMethodContext:",{aMethodContext:aMethodContext},globals.HLDebugger)})},
 args: ["aMethodContext"],
 source: "initializeFromMethodContext: aMethodContext\x0a\x09model := HLDebuggerModel on: aMethodContext.\x0a\x09self observeModel",
 messageSends: ["on:", "observeModel"],
 referencedClasses: ["HLDebuggerModel"]
 }),
-smalltalk.HLDebugger);
+globals.HLDebugger);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -172,7 +172,7 @@ selector: "inspectorWidget",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-function $HLInspectorWidget(){return smalltalk.HLInspectorWidget||(typeof HLInspectorWidget=="undefined"?nil:HLInspectorWidget)}
+function $HLInspectorWidget(){return globals.HLInspectorWidget||(typeof HLInspectorWidget=="undefined"?nil:HLInspectorWidget)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$1;
 $2=self["@inspectorWidget"];
@@ -183,13 +183,13 @@ $1=self["@inspectorWidget"];
 $1=$2;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"inspectorWidget",{},smalltalk.HLDebugger)})},
+}, function($ctx1) {$ctx1.fill(self,"inspectorWidget",{},globals.HLDebugger)})},
 args: [],
 source: "inspectorWidget\x0a\x09^ inspectorWidget ifNil: [ \x0a\x09\x09inspectorWidget := HLInspectorWidget new ]",
 messageSends: ["ifNil:", "new"],
 referencedClasses: ["HLInspectorWidget"]
 }),
-smalltalk.HLDebugger);
+globals.HLDebugger);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -197,7 +197,7 @@ selector: "model",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-function $HLDebuggerModel(){return smalltalk.HLDebuggerModel||(typeof HLDebuggerModel=="undefined"?nil:HLDebuggerModel)}
+function $HLDebuggerModel(){return globals.HLDebuggerModel||(typeof HLDebuggerModel=="undefined"?nil:HLDebuggerModel)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$1;
 $2=self["@model"];
@@ -208,13 +208,13 @@ $1=self["@model"];
 $1=$2;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"model",{},smalltalk.HLDebugger)})},
+}, function($ctx1) {$ctx1.fill(self,"model",{},globals.HLDebugger)})},
 args: [],
 source: "model\x0a\x09^ model ifNil: [ model := HLDebuggerModel new ]",
 messageSends: ["ifNil:", "new"],
 referencedClasses: ["HLDebuggerModel"]
 }),
-smalltalk.HLDebugger);
+globals.HLDebugger);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -222,8 +222,8 @@ selector: "observeModel",
 protocol: 'actions',
 fn: function (){
 var self=this;
-function $HLDebuggerContextSelected(){return smalltalk.HLDebuggerContextSelected||(typeof HLDebuggerContextSelected=="undefined"?nil:HLDebuggerContextSelected)}
-function $HLDebuggerStepped(){return smalltalk.HLDebuggerStepped||(typeof HLDebuggerStepped=="undefined"?nil:HLDebuggerStepped)}
+function $HLDebuggerContextSelected(){return globals.HLDebuggerContextSelected||(typeof HLDebuggerContextSelected=="undefined"?nil:HLDebuggerContextSelected)}
+function $HLDebuggerStepped(){return globals.HLDebuggerStepped||(typeof HLDebuggerStepped=="undefined"?nil:HLDebuggerStepped)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$1;
 $2=self._model();
@@ -233,13 +233,13 @@ $ctx1.sendIdx["announcer"]=1;
 _st($1)._on_send_to_($HLDebuggerContextSelected(),"onContextSelected:",self);
 $ctx1.sendIdx["on:send:to:"]=1;
 _st(_st(self._model())._announcer())._on_send_to_($HLDebuggerStepped(),"onContextSelected:",self);
-return self}, function($ctx1) {$ctx1.fill(self,"observeModel",{},smalltalk.HLDebugger)})},
+return self}, function($ctx1) {$ctx1.fill(self,"observeModel",{},globals.HLDebugger)})},
 args: [],
 source: "observeModel\x0a\x09self model announcer \x0a\x09\x09on: HLDebuggerContextSelected\x0a\x09\x09send: #onContextSelected:\x0a\x09\x09to: self.\x0a\x09\x09\x0a\x09self model announcer \x0a\x09\x09on: HLDebuggerStepped\x0a\x09\x09send: #onContextSelected:\x0a\x09\x09to: self",
 messageSends: ["on:send:to:", "announcer", "model"],
 referencedClasses: ["HLDebuggerContextSelected", "HLDebuggerStepped"]
 }),
-smalltalk.HLDebugger);
+globals.HLDebugger);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -247,16 +247,16 @@ selector: "onContextSelected:",
 protocol: 'reactions',
 fn: function (anAnnouncement){
 var self=this;
-function $HLContextInspectorDecorator(){return smalltalk.HLContextInspectorDecorator||(typeof HLContextInspectorDecorator=="undefined"?nil:HLContextInspectorDecorator)}
+function $HLContextInspectorDecorator(){return globals.HLContextInspectorDecorator||(typeof HLContextInspectorDecorator=="undefined"?nil:HLContextInspectorDecorator)}
 return smalltalk.withContext(function($ctx1) { 
 _st(self._inspectorWidget())._inspect_(_st($HLContextInspectorDecorator())._on_(_st(anAnnouncement)._context()));
-return self}, function($ctx1) {$ctx1.fill(self,"onContextSelected:",{anAnnouncement:anAnnouncement},smalltalk.HLDebugger)})},
+return self}, function($ctx1) {$ctx1.fill(self,"onContextSelected:",{anAnnouncement:anAnnouncement},globals.HLDebugger)})},
 args: ["anAnnouncement"],
 source: "onContextSelected: anAnnouncement\x0a\x09self inspectorWidget inspect: (HLContextInspectorDecorator on: anAnnouncement context)",
 messageSends: ["inspect:", "inspectorWidget", "on:", "context"],
 referencedClasses: ["HLContextInspectorDecorator"]
 }),
-smalltalk.HLDebugger);
+globals.HLDebugger);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -264,16 +264,16 @@ selector: "registerBindingsOn:",
 protocol: 'keybindings',
 fn: function (aBindingGroup){
 var self=this;
-function $HLToolCommand(){return smalltalk.HLToolCommand||(typeof HLToolCommand=="undefined"?nil:HLToolCommand)}
+function $HLToolCommand(){return globals.HLToolCommand||(typeof HLToolCommand=="undefined"?nil:HLToolCommand)}
 return smalltalk.withContext(function($ctx1) { 
 _st($HLToolCommand())._registerConcreteClassesOn_for_(aBindingGroup,self._model());
-return self}, function($ctx1) {$ctx1.fill(self,"registerBindingsOn:",{aBindingGroup:aBindingGroup},smalltalk.HLDebugger)})},
+return self}, function($ctx1) {$ctx1.fill(self,"registerBindingsOn:",{aBindingGroup:aBindingGroup},globals.HLDebugger)})},
 args: ["aBindingGroup"],
 source: "registerBindingsOn: aBindingGroup\x0a\x09HLToolCommand \x0a\x09\x09registerConcreteClassesOn: aBindingGroup \x0a\x09\x09for: self model",
 messageSends: ["registerConcreteClassesOn:for:", "model"],
 referencedClasses: ["HLToolCommand"]
 }),
-smalltalk.HLDebugger);
+globals.HLDebugger);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -281,9 +281,9 @@ selector: "renderContentOn:",
 protocol: 'rendering',
 fn: function (html){
 var self=this;
-function $HLContainer(){return smalltalk.HLContainer||(typeof HLContainer=="undefined"?nil:HLContainer)}
-function $HLHorizontalSplitter(){return smalltalk.HLHorizontalSplitter||(typeof HLHorizontalSplitter=="undefined"?nil:HLHorizontalSplitter)}
-function $HLVerticalSplitter(){return smalltalk.HLVerticalSplitter||(typeof HLVerticalSplitter=="undefined"?nil:HLVerticalSplitter)}
+function $HLContainer(){return globals.HLContainer||(typeof HLContainer=="undefined"?nil:HLContainer)}
+function $HLHorizontalSplitter(){return globals.HLHorizontalSplitter||(typeof HLHorizontalSplitter=="undefined"?nil:HLHorizontalSplitter)}
+function $HLVerticalSplitter(){return globals.HLVerticalSplitter||(typeof HLVerticalSplitter=="undefined"?nil:HLVerticalSplitter)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$1;
 $2=_st($HLHorizontalSplitter())._with_with_(self._stackListWidget(),_st($HLVerticalSplitter())._with_with_(self._codeWidget(),self._inspectorWidget()));
@@ -291,13 +291,13 @@ $ctx1.sendIdx["with:with:"]=1;
 $1=_st($HLContainer())._with_($2);
 _st(html)._with_($1);
 $ctx1.sendIdx["with:"]=1;
-return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},smalltalk.HLDebugger)})},
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLDebugger)})},
 args: ["html"],
 source: "renderContentOn: html\x0a\x09html with: (HLContainer with: (HLHorizontalSplitter\x0a\x09\x09with: self stackListWidget\x0a\x09\x09with: (HLVerticalSplitter\x0a\x09\x09\x09with: self codeWidget\x0a\x09\x09\x09with: self inspectorWidget)))",
 messageSends: ["with:", "with:with:", "stackListWidget", "codeWidget", "inspectorWidget"],
 referencedClasses: ["HLContainer", "HLHorizontalSplitter", "HLVerticalSplitter"]
 }),
-smalltalk.HLDebugger);
+globals.HLDebugger);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -305,7 +305,7 @@ selector: "stackListWidget",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-function $HLStackListWidget(){return smalltalk.HLStackListWidget||(typeof HLStackListWidget=="undefined"?nil:HLStackListWidget)}
+function $HLStackListWidget(){return globals.HLStackListWidget||(typeof HLStackListWidget=="undefined"?nil:HLStackListWidget)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$3,$4,$1;
 $2=self["@stackListWidget"];
@@ -319,13 +319,13 @@ $1=self["@stackListWidget"];
 $1=$2;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"stackListWidget",{},smalltalk.HLDebugger)})},
+}, function($ctx1) {$ctx1.fill(self,"stackListWidget",{},globals.HLDebugger)})},
 args: [],
 source: "stackListWidget\x0a\x09^ stackListWidget ifNil: [ \x0a\x09\x09stackListWidget := (HLStackListWidget on: self model)\x0a\x09\x09\x09next: self codeWidget;\x0a\x09\x09\x09yourself ]",
 messageSends: ["ifNil:", "next:", "on:", "model", "codeWidget", "yourself"],
 referencedClasses: ["HLStackListWidget"]
 }),
-smalltalk.HLDebugger);
+globals.HLDebugger);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -334,16 +334,16 @@ protocol: 'actions',
 fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
-smalltalk.HLDebugger.superclass.fn.prototype._unregister.apply(_st(self), []);
+globals.HLDebugger.superclass.fn.prototype._unregister.apply(_st(self), []);
 $ctx1.sendIdx["unregister"]=1;
 _st(self._inspectorWidget())._unregister();
-return self}, function($ctx1) {$ctx1.fill(self,"unregister",{},smalltalk.HLDebugger)})},
+return self}, function($ctx1) {$ctx1.fill(self,"unregister",{},globals.HLDebugger)})},
 args: [],
 source: "unregister\x0a\x09super unregister.\x0a\x09self inspectorWidget unregister",
 messageSends: ["unregister", "inspectorWidget"],
 referencedClasses: []
 }),
-smalltalk.HLDebugger);
+globals.HLDebugger);
 
 
 smalltalk.addMethod(
@@ -359,13 +359,13 @@ _st($2)._initializeFromMethodContext_(aMethodContext);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"on:",{aMethodContext:aMethodContext},smalltalk.HLDebugger.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"on:",{aMethodContext:aMethodContext},globals.HLDebugger.klass)})},
 args: ["aMethodContext"],
 source: "on: aMethodContext\x0a\x09^ self new\x0a\x09\x09initializeFromMethodContext: aMethodContext;\x0a\x09\x09yourself",
 messageSends: ["initializeFromMethodContext:", "new", "yourself"],
 referencedClasses: []
 }),
-smalltalk.HLDebugger.klass);
+globals.HLDebugger.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -380,7 +380,7 @@ source: "tabClass\x0a\x09^ 'debugger'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLDebugger.klass);
+globals.HLDebugger.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -395,10 +395,10 @@ source: "tabLabel\x0a\x09^ 'Debugger'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLDebugger.klass);
+globals.HLDebugger.klass);
 
 
-smalltalk.addClass('HLDebuggerCodeWidget', smalltalk.HLBrowserCodeWidget, [], 'Helios-Debugger');
+smalltalk.addClass('HLDebuggerCodeWidget', globals.HLBrowserCodeWidget, [], 'Helios-Debugger');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "addStopAt:",
@@ -407,13 +407,13 @@ fn: function (anInteger){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self["@editor"])._setGutterMarker_gutter_value_(anInteger,"stops",_st(_st("<div class=\x22stop\x22></stop>"._asJQuery())._toArray())._first());
-return self}, function($ctx1) {$ctx1.fill(self,"addStopAt:",{anInteger:anInteger},smalltalk.HLDebuggerCodeWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"addStopAt:",{anInteger:anInteger},globals.HLDebuggerCodeWidget)})},
 args: ["anInteger"],
 source: "addStopAt: anInteger\x0a\x09editor\x0a\x09\x09setGutterMarker: anInteger\x0a\x09\x09gutter: 'stops'\x0a\x09\x09value: '<div class=\x22stop\x22></stop>' asJQuery toArray first",
 messageSends: ["setGutterMarker:gutter:value:", "first", "toArray", "asJQuery"],
 referencedClasses: []
 }),
-smalltalk.HLDebuggerCodeWidget);
+globals.HLDebuggerCodeWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -423,13 +423,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._editor())._clearGutter_("stops");
-return self}, function($ctx1) {$ctx1.fill(self,"clearHighlight",{},smalltalk.HLDebuggerCodeWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"clearHighlight",{},globals.HLDebuggerCodeWidget)})},
 args: [],
 source: "clearHighlight\x0a\x09self editor clearGutter: 'stops'",
 messageSends: ["clearGutter:", "editor"],
 referencedClasses: []
 }),
-smalltalk.HLDebuggerCodeWidget);
+globals.HLDebuggerCodeWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -439,14 +439,14 @@ fn: function (aString){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._clearHighlight();
-smalltalk.HLDebuggerCodeWidget.superclass.fn.prototype._contents_.apply(_st(self), [aString]);
-return self}, function($ctx1) {$ctx1.fill(self,"contents:",{aString:aString},smalltalk.HLDebuggerCodeWidget)})},
+globals.HLDebuggerCodeWidget.superclass.fn.prototype._contents_.apply(_st(self), [aString]);
+return self}, function($ctx1) {$ctx1.fill(self,"contents:",{aString:aString},globals.HLDebuggerCodeWidget)})},
 args: ["aString"],
 source: "contents: aString\x0a\x09self clearHighlight.\x0a\x09super contents: aString",
 messageSends: ["clearHighlight", "contents:"],
 referencedClasses: []
 }),
-smalltalk.HLDebuggerCodeWidget);
+globals.HLDebuggerCodeWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -456,18 +456,18 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 var $2,$3,$1;
-$2=smalltalk.HLDebuggerCodeWidget.superclass.fn.prototype._editorOptions.apply(_st(self), []);
+$2=globals.HLDebuggerCodeWidget.superclass.fn.prototype._editorOptions.apply(_st(self), []);
 _st($2)._at_put_("gutters",["CodeMirror-linenumbers", "stops"]);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"editorOptions",{},smalltalk.HLDebuggerCodeWidget)})},
+}, function($ctx1) {$ctx1.fill(self,"editorOptions",{},globals.HLDebuggerCodeWidget)})},
 args: [],
 source: "editorOptions\x0a\x09^ super editorOptions\x0a\x09\x09at: 'gutters' put: #('CodeMirror-linenumbers' 'stops');\x0a\x09\x09yourself",
 messageSends: ["at:put:", "editorOptions", "yourself"],
 referencedClasses: []
 }),
-smalltalk.HLDebuggerCodeWidget);
+globals.HLDebuggerCodeWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -477,13 +477,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._highlightNode_(_st(self._browserModel())._nextNode());
-return self}, function($ctx1) {$ctx1.fill(self,"highlight",{},smalltalk.HLDebuggerCodeWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"highlight",{},globals.HLDebuggerCodeWidget)})},
 args: [],
 source: "highlight\x0a\x09self highlightNode: self browserModel nextNode",
 messageSends: ["highlightNode:", "nextNode", "browserModel"],
 referencedClasses: []
 }),
-smalltalk.HLDebuggerCodeWidget);
+globals.HLDebuggerCodeWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -541,13 +541,13 @@ $ctx1.sendIdx["->"]=5;
 $21=smalltalk.HashedCollection._from_([$22,"ch".__minus_gt(_st(token)._end())]);
 _st($14)._setSelection_to_($15,$21);
 };
-return self}, function($ctx1) {$ctx1.fill(self,"highlightNode:",{aNode:aNode,token:token},smalltalk.HLDebuggerCodeWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"highlightNode:",{aNode:aNode,token:token},globals.HLDebuggerCodeWidget)})},
 args: ["aNode"],
 source: "highlightNode: aNode\x0a\x09| token |\x0a\x09\x0a\x09aNode ifNotNil: [\x0a\x09\x09token := self editor getTokenAt: #{ \x0a\x09\x09\x09'line' -> (aNode position x - 1). \x0a\x09\x09\x09'ch' -> aNode position y \x0a\x09\x09}.\x0a\x0a\x09\x09self\x0a\x09\x09\x09clearHighlight;\x0a\x09\x09\x09addStopAt: aNode position x - 1.\x0a\x0a\x09\x09self editor \x0a\x09\x09\x09setSelection: #{ 'line' -> (aNode position x - 1). 'ch' -> token start }\x0a\x09\x09\x09to: #{ 'line' -> (aNode position x - 1). 'ch' -> token end } ]",
 messageSends: ["ifNotNil:", "getTokenAt:", "editor", "->", "-", "x", "position", "y", "clearHighlight", "addStopAt:", "setSelection:to:", "start", "end"],
 referencedClasses: []
 }),
-smalltalk.HLDebuggerCodeWidget);
+globals.HLDebuggerCodeWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -555,12 +555,12 @@ selector: "observeBrowserModel",
 protocol: 'actions',
 fn: function (){
 var self=this;
-function $HLDebuggerContextSelected(){return smalltalk.HLDebuggerContextSelected||(typeof HLDebuggerContextSelected=="undefined"?nil:HLDebuggerContextSelected)}
-function $HLDebuggerStepped(){return smalltalk.HLDebuggerStepped||(typeof HLDebuggerStepped=="undefined"?nil:HLDebuggerStepped)}
-function $HLDebuggerWhere(){return smalltalk.HLDebuggerWhere||(typeof HLDebuggerWhere=="undefined"?nil:HLDebuggerWhere)}
+function $HLDebuggerContextSelected(){return globals.HLDebuggerContextSelected||(typeof HLDebuggerContextSelected=="undefined"?nil:HLDebuggerContextSelected)}
+function $HLDebuggerStepped(){return globals.HLDebuggerStepped||(typeof HLDebuggerStepped=="undefined"?nil:HLDebuggerStepped)}
+function $HLDebuggerWhere(){return globals.HLDebuggerWhere||(typeof HLDebuggerWhere=="undefined"?nil:HLDebuggerWhere)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$1,$4,$3;
-smalltalk.HLDebuggerCodeWidget.superclass.fn.prototype._observeBrowserModel.apply(_st(self), []);
+globals.HLDebuggerCodeWidget.superclass.fn.prototype._observeBrowserModel.apply(_st(self), []);
 $2=self._browserModel();
 $ctx1.sendIdx["browserModel"]=1;
 $1=_st($2)._announcer();
@@ -574,13 +574,13 @@ $ctx1.sendIdx["announcer"]=2;
 _st($3)._on_send_to_($HLDebuggerStepped(),"onContextSelected",self);
 $ctx1.sendIdx["on:send:to:"]=2;
 _st(_st(self._browserModel())._announcer())._on_send_to_($HLDebuggerWhere(),"onContextSelected",self);
-return self}, function($ctx1) {$ctx1.fill(self,"observeBrowserModel",{},smalltalk.HLDebuggerCodeWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"observeBrowserModel",{},globals.HLDebuggerCodeWidget)})},
 args: [],
 source: "observeBrowserModel\x0a\x09super observeBrowserModel.\x0a\x09\x0a\x09self browserModel announcer \x0a\x09\x09on: HLDebuggerContextSelected\x0a\x09\x09send: #onContextSelected\x0a\x09\x09to: self.\x0a\x09\x0a\x09self browserModel announcer \x0a\x09\x09on: HLDebuggerStepped\x0a\x09\x09send: #onContextSelected\x0a\x09\x09to: self.\x0a\x09\x0a\x09self browserModel announcer \x0a\x09\x09on: HLDebuggerWhere\x0a\x09\x09send: #onContextSelected\x0a\x09\x09to: self",
 messageSends: ["observeBrowserModel", "on:send:to:", "announcer", "browserModel"],
 referencedClasses: ["HLDebuggerContextSelected", "HLDebuggerStepped", "HLDebuggerWhere"]
 }),
-smalltalk.HLDebuggerCodeWidget);
+globals.HLDebuggerCodeWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -590,18 +590,18 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._highlight();
-return self}, function($ctx1) {$ctx1.fill(self,"onContextSelected",{},smalltalk.HLDebuggerCodeWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"onContextSelected",{},globals.HLDebuggerCodeWidget)})},
 args: [],
 source: "onContextSelected\x0a\x09self highlight",
 messageSends: ["highlight"],
 referencedClasses: []
 }),
-smalltalk.HLDebuggerCodeWidget);
+globals.HLDebuggerCodeWidget);
 
 
 
-smalltalk.addClass('HLDebuggerModel', smalltalk.HLToolModel, ['rootContext', 'currentContext', 'contexts'], 'Helios-Debugger');
-smalltalk.HLDebuggerModel.comment="I am a model for Helios debugging.\x0a\x0aMy instances hold a reference to an `AIContext` instance, built from a `MethodContext`. The context should be the root of the context stack.";
+smalltalk.addClass('HLDebuggerModel', globals.HLToolModel, ['rootContext', 'currentContext', 'contexts'], 'Helios-Debugger');
+globals.HLDebuggerModel.comment="I am a model for Helios debugging.\x0a\x0aMy instances hold a reference to an `AIContext` instance, built from a `MethodContext`. The context should be the root of the context stack.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "contexts",
@@ -617,7 +617,7 @@ source: "contexts\x0a\x09^ contexts",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLDebuggerModel);
+globals.HLDebuggerModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -635,13 +635,13 @@ $1;
 };
 $2=self["@currentContext"];
 return $2;
-}, function($ctx1) {$ctx1.fill(self,"currentContext",{},smalltalk.HLDebuggerModel)})},
+}, function($ctx1) {$ctx1.fill(self,"currentContext",{},globals.HLDebuggerModel)})},
 args: [],
 source: "currentContext\x0a\x09currentContext ifNil: [ self currentContext: self rootContext ].\x0a\x09^ currentContext",
 messageSends: ["ifNil:", "currentContext:", "rootContext"],
 referencedClasses: []
 }),
-smalltalk.HLDebuggerModel);
+globals.HLDebuggerModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -649,7 +649,7 @@ selector: "currentContext:",
 protocol: 'accessing',
 fn: function (aContext){
 var self=this;
-function $HLDebuggerContextSelected(){return smalltalk.HLDebuggerContextSelected||(typeof HLDebuggerContextSelected=="undefined"?nil:HLDebuggerContextSelected)}
+function $HLDebuggerContextSelected(){return globals.HLDebuggerContextSelected||(typeof HLDebuggerContextSelected=="undefined"?nil:HLDebuggerContextSelected)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
 self._withChangesDo_((function(){
@@ -662,13 +662,13 @@ _st($1)._context_(aContext);
 $2=_st($1)._yourself();
 return _st(self._announcer())._announce_($2);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"currentContext:",{aContext:aContext},smalltalk.HLDebuggerModel)})},
+return self}, function($ctx1) {$ctx1.fill(self,"currentContext:",{aContext:aContext},globals.HLDebuggerModel)})},
 args: ["aContext"],
 source: "currentContext: aContext\x0a\x09self withChangesDo: [ \x0a\x09\x09self selectedMethod: aContext method.\x0a\x09\x09currentContext := aContext.\x0a\x09\x09self announcer announce: (HLDebuggerContextSelected new\x0a\x09\x09\x09context: aContext;\x0a\x09\x09\x09yourself) ]",
 messageSends: ["withChangesDo:", "selectedMethod:", "method", "announce:", "announcer", "context:", "new", "yourself"],
 referencedClasses: ["HLDebuggerContextSelected"]
 }),
-smalltalk.HLDebuggerModel);
+globals.HLDebuggerModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -677,7 +677,7 @@ protocol: 'initialization',
 fn: function (){
 var self=this;
 var context;
-function $OrderedCollection(){return smalltalk.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
 return smalltalk.withContext(function($ctx1) { 
 self["@contexts"]=_st($OrderedCollection())._new();
 context=self._rootContext();
@@ -690,13 +690,13 @@ _st(self["@contexts"])._add_(context);
 context=_st(context)._outerContext();
 return context;
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"initializeContexts",{context:context},smalltalk.HLDebuggerModel)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initializeContexts",{context:context},globals.HLDebuggerModel)})},
 args: [],
 source: "initializeContexts\x0a\x09\x22Flatten the context stack into an OrderedCollection\x22\x0a\x09\x0a\x09| context |\x0a\x09\x0a\x09contexts := OrderedCollection new.\x0a\x09context := self rootContext.\x0a\x09\x0a\x09[ context notNil ] whileTrue: [\x0a\x09\x09contexts add: context.\x0a\x09\x09context := context outerContext ]",
 messageSends: ["new", "rootContext", "whileTrue:", "notNil", "add:", "outerContext"],
 referencedClasses: ["OrderedCollection"]
 }),
-smalltalk.HLDebuggerModel);
+globals.HLDebuggerModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -704,17 +704,17 @@ selector: "initializeFromContext:",
 protocol: 'initialization',
 fn: function (aMethodContext){
 var self=this;
-function $AIContext(){return smalltalk.AIContext||(typeof AIContext=="undefined"?nil:AIContext)}
+function $AIContext(){return globals.AIContext||(typeof AIContext=="undefined"?nil:AIContext)}
 return smalltalk.withContext(function($ctx1) { 
 self["@rootContext"]=_st($AIContext())._fromMethodContext_(aMethodContext);
 self._initializeContexts();
-return self}, function($ctx1) {$ctx1.fill(self,"initializeFromContext:",{aMethodContext:aMethodContext},smalltalk.HLDebuggerModel)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initializeFromContext:",{aMethodContext:aMethodContext},globals.HLDebuggerModel)})},
 args: ["aMethodContext"],
 source: "initializeFromContext: aMethodContext\x0a\x09rootContext := AIContext fromMethodContext: aMethodContext.\x0a\x09self initializeContexts",
 messageSends: ["fromMethodContext:", "initializeContexts"],
 referencedClasses: ["AIContext"]
 }),
-smalltalk.HLDebuggerModel);
+globals.HLDebuggerModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -726,13 +726,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self._currentContext())._interpreter();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"interpreter",{},smalltalk.HLDebuggerModel)})},
+}, function($ctx1) {$ctx1.fill(self,"interpreter",{},globals.HLDebuggerModel)})},
 args: [],
 source: "interpreter\x0a\x09^ self currentContext interpreter",
 messageSends: ["interpreter", "currentContext"],
 referencedClasses: []
 }),
-smalltalk.HLDebuggerModel);
+globals.HLDebuggerModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -744,13 +744,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self._interpreter())._node();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"nextNode",{},smalltalk.HLDebuggerModel)})},
+}, function($ctx1) {$ctx1.fill(self,"nextNode",{},globals.HLDebuggerModel)})},
 args: [],
 source: "nextNode\x0a\x09^ self interpreter node",
 messageSends: ["node", "interpreter"],
 referencedClasses: []
 }),
-smalltalk.HLDebuggerModel);
+globals.HLDebuggerModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -758,7 +758,7 @@ selector: "restart",
 protocol: 'actions',
 fn: function (){
 var self=this;
-function $HLDebuggerStepped(){return smalltalk.HLDebuggerStepped||(typeof HLDebuggerStepped=="undefined"?nil:HLDebuggerStepped)}
+function $HLDebuggerStepped(){return globals.HLDebuggerStepped||(typeof HLDebuggerStepped=="undefined"?nil:HLDebuggerStepped)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
 _st(self._interpreter())._restart();
@@ -766,13 +766,13 @@ $1=_st($HLDebuggerStepped())._new();
 _st($1)._context_(self._currentContext());
 $2=_st($1)._yourself();
 _st(self._announcer())._announce_($2);
-return self}, function($ctx1) {$ctx1.fill(self,"restart",{},smalltalk.HLDebuggerModel)})},
+return self}, function($ctx1) {$ctx1.fill(self,"restart",{},globals.HLDebuggerModel)})},
 args: [],
 source: "restart\x0a\x09self interpreter restart.\x0a\x09self announcer announce: (HLDebuggerStepped new\x0a\x09\x09context: self currentContext;\x0a\x09\x09yourself)",
 messageSends: ["restart", "interpreter", "announce:", "announcer", "context:", "new", "currentContext", "yourself"],
 referencedClasses: ["HLDebuggerStepped"]
 }),
-smalltalk.HLDebuggerModel);
+globals.HLDebuggerModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -789,7 +789,7 @@ source: "rootContext\x0a\x09^ rootContext",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLDebuggerModel);
+globals.HLDebuggerModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -797,7 +797,7 @@ selector: "skip",
 protocol: 'actions',
 fn: function (){
 var self=this;
-function $HLDebuggerStepped(){return smalltalk.HLDebuggerStepped||(typeof HLDebuggerStepped=="undefined"?nil:HLDebuggerStepped)}
+function $HLDebuggerStepped(){return globals.HLDebuggerStepped||(typeof HLDebuggerStepped=="undefined"?nil:HLDebuggerStepped)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
 _st(self._interpreter())._skip();
@@ -805,13 +805,13 @@ $1=_st($HLDebuggerStepped())._new();
 _st($1)._context_(self._currentContext());
 $2=_st($1)._yourself();
 _st(self._announcer())._announce_($2);
-return self}, function($ctx1) {$ctx1.fill(self,"skip",{},smalltalk.HLDebuggerModel)})},
+return self}, function($ctx1) {$ctx1.fill(self,"skip",{},globals.HLDebuggerModel)})},
 args: [],
 source: "skip\x0a\x09self interpreter skip.\x0a\x09self announcer announce: (HLDebuggerStepped new\x0a\x09\x09context: self currentContext;\x0a\x09\x09yourself)",
 messageSends: ["skip", "interpreter", "announce:", "announcer", "context:", "new", "currentContext", "yourself"],
 referencedClasses: ["HLDebuggerStepped"]
 }),
-smalltalk.HLDebuggerModel);
+globals.HLDebuggerModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -819,7 +819,7 @@ selector: "stepOver",
 protocol: 'actions',
 fn: function (){
 var self=this;
-function $HLDebuggerStepped(){return smalltalk.HLDebuggerStepped||(typeof HLDebuggerStepped=="undefined"?nil:HLDebuggerStepped)}
+function $HLDebuggerStepped(){return globals.HLDebuggerStepped||(typeof HLDebuggerStepped=="undefined"?nil:HLDebuggerStepped)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
 _st(self._interpreter())._stepOver();
@@ -827,13 +827,13 @@ $1=_st($HLDebuggerStepped())._new();
 _st($1)._context_(self._currentContext());
 $2=_st($1)._yourself();
 _st(self._announcer())._announce_($2);
-return self}, function($ctx1) {$ctx1.fill(self,"stepOver",{},smalltalk.HLDebuggerModel)})},
+return self}, function($ctx1) {$ctx1.fill(self,"stepOver",{},globals.HLDebuggerModel)})},
 args: [],
 source: "stepOver\x0a\x09self interpreter stepOver.\x0a\x09self announcer announce: (HLDebuggerStepped new\x0a\x09\x09context: self currentContext;\x0a\x09\x09yourself)",
 messageSends: ["stepOver", "interpreter", "announce:", "announcer", "context:", "new", "currentContext", "yourself"],
 referencedClasses: ["HLDebuggerStepped"]
 }),
-smalltalk.HLDebuggerModel);
+globals.HLDebuggerModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -841,16 +841,16 @@ selector: "where",
 protocol: 'actions',
 fn: function (){
 var self=this;
-function $HLDebuggerWhere(){return smalltalk.HLDebuggerWhere||(typeof HLDebuggerWhere=="undefined"?nil:HLDebuggerWhere)}
+function $HLDebuggerWhere(){return globals.HLDebuggerWhere||(typeof HLDebuggerWhere=="undefined"?nil:HLDebuggerWhere)}
 return smalltalk.withContext(function($ctx1) { 
 _st(self._announcer())._announce_(_st($HLDebuggerWhere())._new());
-return self}, function($ctx1) {$ctx1.fill(self,"where",{},smalltalk.HLDebuggerModel)})},
+return self}, function($ctx1) {$ctx1.fill(self,"where",{},globals.HLDebuggerModel)})},
 args: [],
 source: "where\x0a\x09self announcer announce: HLDebuggerWhere new",
 messageSends: ["announce:", "announcer", "new"],
 referencedClasses: ["HLDebuggerWhere"]
 }),
-smalltalk.HLDebuggerModel);
+globals.HLDebuggerModel);
 
 
 smalltalk.addMethod(
@@ -866,25 +866,25 @@ _st($2)._initializeFromContext_(aMethodContext);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"on:",{aMethodContext:aMethodContext},smalltalk.HLDebuggerModel.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"on:",{aMethodContext:aMethodContext},globals.HLDebuggerModel.klass)})},
 args: ["aMethodContext"],
 source: "on: aMethodContext\x0a\x09^ self new\x0a\x09\x09initializeFromContext: aMethodContext;\x0a\x09\x09yourself",
 messageSends: ["initializeFromContext:", "new", "yourself"],
 referencedClasses: []
 }),
-smalltalk.HLDebuggerModel.klass);
+globals.HLDebuggerModel.klass);
 
 
-smalltalk.addClass('HLErrorHandler', smalltalk.Object, [], 'Helios-Debugger');
+smalltalk.addClass('HLErrorHandler', globals.Object, [], 'Helios-Debugger');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "handleError:",
 protocol: 'error handling',
 fn: function (anError){
 var self=this;
-function $HLDebugger(){return smalltalk.HLDebugger||(typeof HLDebugger=="undefined"?nil:HLDebugger)}
-function $Error(){return smalltalk.Error||(typeof Error=="undefined"?nil:Error)}
-function $ErrorHandler(){return smalltalk.ErrorHandler||(typeof ErrorHandler=="undefined"?nil:ErrorHandler)}
+function $HLDebugger(){return globals.HLDebugger||(typeof HLDebugger=="undefined"?nil:HLDebugger)}
+function $Error(){return globals.Error||(typeof Error=="undefined"?nil:Error)}
+function $ErrorHandler(){return globals.ErrorHandler||(typeof ErrorHandler=="undefined"?nil:ErrorHandler)}
 return smalltalk.withContext(function($ctx1) { 
 self._onErrorHandled();
 _st((function(){
@@ -894,13 +894,13 @@ return _st(_st($HLDebugger())._on_(_st(anError)._context()))._openAsTab();
 return smalltalk.withContext(function($ctx2) {
 return _st(_st($ErrorHandler())._new())._handleError_(error);
 }, function($ctx2) {$ctx2.fillBlock({error:error},$ctx1,2)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"handleError:",{anError:anError},smalltalk.HLErrorHandler)})},
+return self}, function($ctx1) {$ctx1.fill(self,"handleError:",{anError:anError},globals.HLErrorHandler)})},
 args: ["anError"],
 source: "handleError: anError\x0a\x09self onErrorHandled.\x0a\x0a\x09[ \x0a\x09\x09(HLDebugger on: anError context) openAsTab \x0a\x09] \x0a\x09\x09on: Error \x0a\x09\x09do: [ :error | ErrorHandler new handleError: error ]",
 messageSends: ["onErrorHandled", "on:do:", "openAsTab", "on:", "context", "handleError:", "new"],
 referencedClasses: ["HLDebugger", "Error", "ErrorHandler"]
 }),
-smalltalk.HLErrorHandler);
+globals.HLErrorHandler);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -908,23 +908,23 @@ selector: "onErrorHandled",
 protocol: 'error handling',
 fn: function (){
 var self=this;
-function $HLProgressWidget(){return smalltalk.HLProgressWidget||(typeof HLProgressWidget=="undefined"?nil:HLProgressWidget)}
+function $HLProgressWidget(){return globals.HLProgressWidget||(typeof HLProgressWidget=="undefined"?nil:HLProgressWidget)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
 $1=_st($HLProgressWidget())._default();
 _st($1)._flush();
 $2=_st($1)._remove();
-return self}, function($ctx1) {$ctx1.fill(self,"onErrorHandled",{},smalltalk.HLErrorHandler)})},
+return self}, function($ctx1) {$ctx1.fill(self,"onErrorHandled",{},globals.HLErrorHandler)})},
 args: [],
 source: "onErrorHandled\x0a\x09\x22when an error is handled, we need to make sure that\x0a\x09any progress bar widget gets removed. Because HLProgressBarWidget is asynchronous,\x0a\x09it has to be done here.\x22\x0a\x09\x0a\x09HLProgressWidget default \x0a\x09\x09flush; \x0a\x09\x09remove",
 messageSends: ["flush", "default", "remove"],
 referencedClasses: ["HLProgressWidget"]
 }),
-smalltalk.HLErrorHandler);
+globals.HLErrorHandler);
 
 
 
-smalltalk.addClass('HLStackListWidget', smalltalk.HLToolListWidget, [], 'Helios-Debugger');
+smalltalk.addClass('HLStackListWidget', globals.HLToolListWidget, [], 'Helios-Debugger');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "items",
@@ -941,13 +941,13 @@ $1=self["@items"];
 $1=$2;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"items",{},smalltalk.HLStackListWidget)})},
+}, function($ctx1) {$ctx1.fill(self,"items",{},globals.HLStackListWidget)})},
 args: [],
 source: "items\x0a\x09^ items ifNil: [ items := self model contexts ]",
 messageSends: ["ifNil:", "contexts", "model"],
 referencedClasses: []
 }),
-smalltalk.HLStackListWidget);
+globals.HLStackListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -962,7 +962,7 @@ source: "label\x0a\x09^ 'Call stack'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLStackListWidget);
+globals.HLStackListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1023,13 +1023,13 @@ return self._skip();
 return $10;
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
 $ctx1.sendIdx["with:"]=1;
-return self}, function($ctx1) {$ctx1.fill(self,"renderButtonsOn:",{html:html},smalltalk.HLStackListWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"renderButtonsOn:",{html:html},globals.HLStackListWidget)})},
 args: ["html"],
 source: "renderButtonsOn: html\x0a\x09html div \x0a\x09\x09class: 'debugger_bar'; \x0a\x09\x09with: [\x0a\x09\x09\x09html button \x0a\x09\x09\x09\x09class: 'btn restart';\x0a\x09\x09\x09\x09with: 'Restart';\x0a\x09\x09\x09\x09onClick: [ self restart ].\x0a\x09\x09\x09html button \x0a\x09\x09\x09\x09class: 'btn where';\x0a\x09\x09\x09\x09with: 'Where';\x0a\x09\x09\x09\x09onClick: [ self where ].\x0a\x09\x09\x09html button \x0a\x09\x09\x09\x09class: 'btn stepOver';\x0a\x09\x09\x09\x09with: 'Step over';\x0a\x09\x09\x09\x09onClick: [ self stepOver ].\x0a\x09\x09\x09html button \x0a\x09\x09\x09\x09class: 'btn skip';\x0a\x09\x09\x09\x09with: 'Skip';\x0a\x09\x09\x09\x09onClick: [ self skip ] ]",
 messageSends: ["class:", "div", "with:", "button", "onClick:", "restart", "where", "stepOver", "skip"],
 referencedClasses: []
 }),
-smalltalk.HLStackListWidget);
+globals.HLStackListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1039,13 +1039,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._model())._restart();
-return self}, function($ctx1) {$ctx1.fill(self,"restart",{},smalltalk.HLStackListWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"restart",{},globals.HLStackListWidget)})},
 args: [],
 source: "restart\x0a\x09self model restart",
 messageSends: ["restart", "model"],
 referencedClasses: []
 }),
-smalltalk.HLStackListWidget);
+globals.HLStackListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1055,13 +1055,13 @@ fn: function (aContext){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._model())._currentContext_(aContext);
-return self}, function($ctx1) {$ctx1.fill(self,"selectItem:",{aContext:aContext},smalltalk.HLStackListWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"selectItem:",{aContext:aContext},globals.HLStackListWidget)})},
 args: ["aContext"],
 source: "selectItem: aContext\x0a   \x09self model currentContext: aContext",
 messageSends: ["currentContext:", "model"],
 referencedClasses: []
 }),
-smalltalk.HLStackListWidget);
+globals.HLStackListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1071,13 +1071,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._model())._skip();
-return self}, function($ctx1) {$ctx1.fill(self,"skip",{},smalltalk.HLStackListWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"skip",{},globals.HLStackListWidget)})},
 args: [],
 source: "skip\x0a\x09self model skip",
 messageSends: ["skip", "model"],
 referencedClasses: []
 }),
-smalltalk.HLStackListWidget);
+globals.HLStackListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1087,13 +1087,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._model())._stepOver();
-return self}, function($ctx1) {$ctx1.fill(self,"stepOver",{},smalltalk.HLStackListWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"stepOver",{},globals.HLStackListWidget)})},
 args: [],
 source: "stepOver\x0a\x09self model stepOver",
 messageSends: ["stepOver", "model"],
 referencedClasses: []
 }),
-smalltalk.HLStackListWidget);
+globals.HLStackListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1103,13 +1103,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._model())._where();
-return self}, function($ctx1) {$ctx1.fill(self,"where",{},smalltalk.HLStackListWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"where",{},globals.HLStackListWidget)})},
 args: [],
 source: "where\x0a\x09self model where",
 messageSends: ["where", "model"],
 referencedClasses: []
 }),
-smalltalk.HLStackListWidget);
+globals.HLStackListWidget);
 
 
 });

js/Helios-Exceptions.js

@@ -1,16 +1,16 @@
-define("amber_core/Helios-Exceptions", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Exceptions"], function(smalltalk,nil,_st){
+define("amber_core/Helios-Exceptions", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Exceptions"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Helios-Exceptions');
 smalltalk.packages["Helios-Exceptions"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('HLError', smalltalk.Error, [], 'Helios-Exceptions');
-smalltalk.HLError.comment="I am the abstract superclass of all Helios-specific errors.";
+smalltalk.addClass('HLError', globals.Error, [], 'Helios-Exceptions');
+globals.HLError.comment="I am the abstract superclass of all Helios-specific errors.";
 
 
-smalltalk.addClass('HLChangeForbidden', smalltalk.HLError, [], 'Helios-Exceptions');
-smalltalk.HLChangeForbidden.comment="I get signaled when a (often user) requested change is forbidden. A confirmation message can then be displayed to the user.\x0a\x0aSee `HLModel >> withChangesDo:`.";
+smalltalk.addClass('HLChangeForbidden', globals.HLError, [], 'Helios-Exceptions');
+globals.HLChangeForbidden.comment="I get signaled when a (often user) requested change is forbidden. A confirmation message can then be displayed to the user.\x0a\x0aSee `HLModel >> withChangesDo:`.";
 
 
-smalltalk.addClass('HLListItemNotFound', smalltalk.HLError, [], 'Helios-Exceptions');
-smalltalk.HLListItemNotFound.comment="I get signaled by a `HLListWidget` when a non-existing item in the list is activated.";
+smalltalk.addClass('HLListItemNotFound', globals.HLError, [], 'Helios-Exceptions');
+globals.HLListItemNotFound.comment="I get signaled by a `HLListWidget` when a non-existing item in the list is activated.";
 
 });

js/Helios-Helpers.js

@@ -1,9 +1,9 @@
-define("amber_core/Helios-Helpers", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st){
+define("amber_core/Helios-Helpers", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Helios-Helpers');
 smalltalk.packages["Helios-Helpers"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('HLClassifier', smalltalk.Object, ['next', 'method'], 'Helios-Helpers');
-smalltalk.HLClassifier.comment="I am an abstract class implementing a link in a `chain of responsibility` pattern.\x0a\x0aSubclasses are in charge of classifying a method according to multiple strategies.";
+smalltalk.addClass('HLClassifier', globals.Object, ['next', 'method'], 'Helios-Helpers');
+globals.HLClassifier.comment="I am an abstract class implementing a link in a `chain of responsibility` pattern.\x0a\x0aSubclasses are in charge of classifying a method according to multiple strategies.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "classify",
@@ -26,13 +26,13 @@ $2=true;
 $2=_st(self._next())._classify();
 };
 return $2;
-}, function($ctx1) {$ctx1.fill(self,"classify",{},smalltalk.HLClassifier)})},
+}, function($ctx1) {$ctx1.fill(self,"classify",{},globals.HLClassifier)})},
 args: [],
 source: "classify\x0a\x09self next ifNil: [ ^ false ].\x0a\x09\x0a\x09^ self doClassify\x0a\x09\x09ifTrue: [ true ]\x0a\x09\x09ifFalse: [ self next classify ]",
 messageSends: ["ifNil:", "next", "ifTrue:ifFalse:", "doClassify", "classify"],
 referencedClasses: []
 }),
-smalltalk.HLClassifier);
+globals.HLClassifier);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -42,13 +42,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._subclassResponsibility();
-return self}, function($ctx1) {$ctx1.fill(self,"doClassify",{},smalltalk.HLClassifier)})},
+return self}, function($ctx1) {$ctx1.fill(self,"doClassify",{},globals.HLClassifier)})},
 args: [],
 source: "doClassify\x0a\x09self subclassResponsibility",
 messageSends: ["subclassResponsibility"],
 referencedClasses: []
 }),
-smalltalk.HLClassifier);
+globals.HLClassifier);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -65,7 +65,7 @@ source: "method\x0a\x09^ method",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLClassifier);
+globals.HLClassifier);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -84,13 +84,13 @@ var nextLink;
 nextLink=$receiver;
 _st(nextLink)._method_(anObject);
 };
-return self}, function($ctx1) {$ctx1.fill(self,"method:",{anObject:anObject},smalltalk.HLClassifier)})},
+return self}, function($ctx1) {$ctx1.fill(self,"method:",{anObject:anObject},globals.HLClassifier)})},
 args: ["anObject"],
 source: "method: anObject\x0a\x09method := anObject.\x0a\x09self next\x0a\x09\x09ifNotNil: [ :nextLink | nextLink method: anObject ]",
 messageSends: ["ifNotNil:", "next", "method:"],
 referencedClasses: []
 }),
-smalltalk.HLClassifier);
+globals.HLClassifier);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -107,7 +107,7 @@ source: "next\x0a\x09^ next",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLClassifier);
+globals.HLClassifier);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -122,12 +122,12 @@ source: "next: anObject\x0a\x09next := anObject",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLClassifier);
+globals.HLClassifier);
 
 
 
-smalltalk.addClass('HLAccessorClassifier', smalltalk.HLClassifier, [], 'Helios-Helpers');
-smalltalk.HLAccessorClassifier.comment="I am a classifier checking the method selector matches an instance variable name.";
+smalltalk.addClass('HLAccessorClassifier', globals.HLClassifier, [], 'Helios-Helpers');
+globals.HLAccessorClassifier.comment="I am a classifier checking the method selector matches an instance variable name.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "doClassify",
@@ -150,18 +150,18 @@ return false;
 };
 _st(self["@method"])._protocol_("accessing");
 return true;
-}, function($ctx1) {$ctx1.fill(self,"doClassify",{names:names,selector:selector},smalltalk.HLAccessorClassifier)})},
+}, function($ctx1) {$ctx1.fill(self,"doClassify",{names:names,selector:selector},globals.HLAccessorClassifier)})},
 args: [],
 source: "doClassify\x0a\x09| names selector |\x0a\x09\x0a\x09names := method methodClass allInstanceVariableNames.\x0a\x09selector := method selector.\x0a\x09\x0a\x09(selector last = ':')\x0a\x09\x09ifTrue: [ \x22selector might be a setter\x22\x0a\x09\x09\x09selector := selector allButLast ].\x0a\x09\x0a\x09(names includes: selector)\x0a\x09\x09ifFalse: [ ^ false ].\x0a\x09\x09\x0a\x09method protocol: 'accessing'.\x0a\x09^ true.",
 messageSends: ["allInstanceVariableNames", "methodClass", "selector", "ifTrue:", "=", "last", "allButLast", "ifFalse:", "includes:", "protocol:"],
 referencedClasses: []
 }),
-smalltalk.HLAccessorClassifier);
+globals.HLAccessorClassifier);
 
 
 
-smalltalk.addClass('HLImplementorClassifier', smalltalk.HLClassifier, [], 'Helios-Helpers');
-smalltalk.HLImplementorClassifier.comment="I am a classifier checking the other implementations of the same selector and choose the protocol the most populated.";
+smalltalk.addClass('HLImplementorClassifier', globals.HLClassifier, [], 'Helios-Helpers');
+globals.HLImplementorClassifier.comment="I am a classifier checking the other implementations of the same selector and choose the protocol the most populated.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "doClassify",
@@ -195,25 +195,25 @@ throw $early=[true];
 return false;
 }
 catch(e) {if(e===$early)return e[0]; throw e}
-}, function($ctx1) {$ctx1.fill(self,"doClassify",{currentClass:currentClass},smalltalk.HLImplementorClassifier)})},
+}, function($ctx1) {$ctx1.fill(self,"doClassify",{currentClass:currentClass},globals.HLImplementorClassifier)})},
 args: [],
 source: "doClassify\x0a\x09| currentClass |\x0a\x09currentClass := method methodClass.\x0a\x09\x0a\x09[ currentClass superclass isNil ] whileFalse: [\x0a\x09\x09currentClass := currentClass superclass.\x0a\x09\x09(currentClass includesSelector: method selector)\x0a\x09\x09\x09ifTrue: [ \x0a\x09\x09\x09\x09method protocol: (currentClass >> method selector) protocol.\x0a\x09\x09\x09\x09^ true ]].\x0a\x09\x0a\x09^ false.",
 messageSends: ["methodClass", "whileFalse:", "isNil", "superclass", "ifTrue:", "includesSelector:", "selector", "protocol:", "protocol", ">>"],
 referencedClasses: []
 }),
-smalltalk.HLImplementorClassifier);
+globals.HLImplementorClassifier);
 
 
 
-smalltalk.addClass('HLPrefixClassifier', smalltalk.HLClassifier, ['prefixMapping'], 'Helios-Helpers');
-smalltalk.HLPrefixClassifier.comment="I am classifier checking the method selector to know if it begins with a known prefix.";
+smalltalk.addClass('HLPrefixClassifier', globals.HLClassifier, ['prefixMapping'], 'Helios-Helpers');
+globals.HLPrefixClassifier.comment="I am classifier checking the method selector to know if it begins with a known prefix.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "buildPrefixDictionary",
 protocol: 'initialization',
 fn: function (){
 var self=this;
-function $Dictionary(){return smalltalk.Dictionary||(typeof Dictionary=="undefined"?nil:Dictionary)}
+function $Dictionary(){return globals.Dictionary||(typeof Dictionary=="undefined"?nil:Dictionary)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
 self["@prefixMapping"]=_st($Dictionary())._new();
@@ -241,13 +241,13 @@ $ctx1.sendIdx["at:put:"]=10;
 _st($1)._at_put_("as","converting");
 $ctx1.sendIdx["at:put:"]=11;
 $2=_st($1)._at_put_("new","instance creation");
-return self}, function($ctx1) {$ctx1.fill(self,"buildPrefixDictionary",{},smalltalk.HLPrefixClassifier)})},
+return self}, function($ctx1) {$ctx1.fill(self,"buildPrefixDictionary",{},globals.HLPrefixClassifier)})},
 args: [],
 source: "buildPrefixDictionary\x0a\x09prefixMapping := Dictionary new.\x0a\x09prefixMapping \x0a\x09\x09at: 'test' put: 'tests';\x0a\x09 \x09at: 'bench' put: 'benchmarking';\x0a\x09 \x09at: 'copy' put: 'copying';\x0a\x09\x09at: 'initialize' put: 'initialization';\x0a\x09\x09at: 'accept' put: 'visitor';\x0a\x09\x09at: 'visit' put: 'visitor';\x0a\x09\x09at: 'signal' put: 'signalling';\x0a\x09\x09at: 'parse' put: 'parsing';\x0a\x09\x09at: 'add' put: 'adding';\x0a\x09\x09at: 'is' put: 'testing';\x0a\x09\x09at: 'as' put: 'converting';\x0a\x09\x09at: 'new' put: 'instance creation'.",
 messageSends: ["new", "at:put:"],
 referencedClasses: ["Dictionary"]
 }),
-smalltalk.HLPrefixClassifier);
+globals.HLPrefixClassifier);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -270,13 +270,13 @@ throw $early=[true];
 return false;
 }
 catch(e) {if(e===$early)return e[0]; throw e}
-}, function($ctx1) {$ctx1.fill(self,"doClassify",{},smalltalk.HLPrefixClassifier)})},
+}, function($ctx1) {$ctx1.fill(self,"doClassify",{},globals.HLPrefixClassifier)})},
 args: [],
 source: "doClassify\x0a\x09prefixMapping keysAndValuesDo: [ :prefix :protocol |\x0a\x09\x09(method selector beginsWith: prefix)\x0a\x09\x09\x09ifTrue: [\x0a\x09\x09\x09\x09method protocol: protocol.\x0a\x09\x09\x09\x09^ true ]].\x0a\x09^ false.",
 messageSends: ["keysAndValuesDo:", "ifTrue:", "beginsWith:", "selector", "protocol:"],
 referencedClasses: []
 }),
-smalltalk.HLPrefixClassifier);
+globals.HLPrefixClassifier);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -285,20 +285,20 @@ protocol: 'initialization',
 fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
-smalltalk.HLPrefixClassifier.superclass.fn.prototype._initialize.apply(_st(self), []);
+globals.HLPrefixClassifier.superclass.fn.prototype._initialize.apply(_st(self), []);
 self._buildPrefixDictionary();
-return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},smalltalk.HLPrefixClassifier)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.HLPrefixClassifier)})},
 args: [],
 source: "initialize\x0a\x09super initialize.\x0a\x0a\x09self buildPrefixDictionary",
 messageSends: ["initialize", "buildPrefixDictionary"],
 referencedClasses: []
 }),
-smalltalk.HLPrefixClassifier);
+globals.HLPrefixClassifier);
 
 
 
-smalltalk.addClass('HLSuperclassClassifier', smalltalk.HLClassifier, [], 'Helios-Helpers');
-smalltalk.HLSuperclassClassifier.comment="I am a classifier checking the superclass chain to find a matching selector.";
+smalltalk.addClass('HLSuperclassClassifier', globals.HLClassifier, [], 'Helios-Helpers');
+globals.HLSuperclassClassifier.comment="I am a classifier checking the superclass chain to find a matching selector.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "doClassify",
@@ -306,8 +306,8 @@ protocol: 'private',
 fn: function (){
 var self=this;
 var protocolBag,methods,protocolToUse,counter;
-function $Dictionary(){return smalltalk.Dictionary||(typeof Dictionary=="undefined"?nil:Dictionary)}
-function $HLReferencesModel(){return smalltalk.HLReferencesModel||(typeof HLReferencesModel=="undefined"?nil:HLReferencesModel)}
+function $Dictionary(){return globals.Dictionary||(typeof Dictionary=="undefined"?nil:Dictionary)}
+function $HLReferencesModel(){return globals.HLReferencesModel||(typeof HLReferencesModel=="undefined"?nil:HLReferencesModel)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$1,$4,$3,$5;
 var $early={};
@@ -365,18 +365,18 @@ _st(self["@method"])._protocol_(protocolToUse);
 return true;
 }
 catch(e) {if(e===$early)return e[0]; throw e}
-}, function($ctx1) {$ctx1.fill(self,"doClassify",{protocolBag:protocolBag,methods:methods,protocolToUse:protocolToUse,counter:counter},smalltalk.HLSuperclassClassifier)})},
+}, function($ctx1) {$ctx1.fill(self,"doClassify",{protocolBag:protocolBag,methods:methods,protocolToUse:protocolToUse,counter:counter},globals.HLSuperclassClassifier)})},
 args: [],
 source: "doClassify\x0a\x09| protocolBag methods protocolToUse counter |\x0a\x09\x0a\x09protocolBag := Dictionary new.\x0a\x09methods := HLReferencesModel new implementorsOf: method selector.\x0a\x09methods\x0a\x09\x09ifEmpty: [ ^ false ]\x0a\x09\x09ifNotEmpty: [\x0a\x09\x09\x09methods \x0a\x09\x09\x09\x09do: [ :aMethod || protocol |\x0a\x09\x09\x09\x09\x09protocol := aMethod method protocol.\x0a\x09\x09\x09\x09\x09(method methodClass = aMethod methodClass)\x0a\x09\x09\x09\x09\x09\x09ifFalse: [\x0a\x09\x09\x09\x09\x09\x09((protocol first = '*') or: [ protocol = method defaultProtocol ])\x0a\x09\x09\x09\x09\x09\x09\x09ifFalse: [ \x0a\x09\x09\x09\x09\x09\x09\x09\x09protocolBag \x0a\x09\x09\x09\x09\x09\x09\x09\x09\x09at: protocol \x0a\x09\x09\x09\x09\x09\x09\x09\x09\x09put: (protocolBag at: protocol ifAbsent: [ 0 ]) + 1 ] ] ] ].\x0a\x09\x09\x09\x0a\x09protocolBag ifEmpty: [ ^ false ].\x0a\x09protocolToUse := nil.\x0a\x09counter := 0.\x0a\x09protocolBag keysAndValuesDo: [ :key :value | value > counter \x0a\x09\x09ifTrue: [\x0a\x09\x09\x09counter := value.\x0a\x09\x09\x09protocolToUse := key ] ].\x0a\x09method protocol: protocolToUse.\x0a\x09^ true",
 messageSends: ["new", "implementorsOf:", "selector", "ifEmpty:ifNotEmpty:", "do:", "protocol", "method", "ifFalse:", "=", "methodClass", "or:", "first", "defaultProtocol", "at:put:", "+", "at:ifAbsent:", "ifEmpty:", "keysAndValuesDo:", "ifTrue:", ">", "protocol:"],
 referencedClasses: ["Dictionary", "HLReferencesModel"]
 }),
-smalltalk.HLSuperclassClassifier);
+globals.HLSuperclassClassifier);
 
 
 
-smalltalk.addClass('HLGenerationOutput', smalltalk.Object, ['sourceCodes', 'protocol', 'targetClass'], 'Helios-Helpers');
-smalltalk.HLGenerationOutput.comment="I am a simple data object used to store the result of a generation process.";
+smalltalk.addClass('HLGenerationOutput', globals.Object, ['sourceCodes', 'protocol', 'targetClass'], 'Helios-Helpers');
+globals.HLGenerationOutput.comment="I am a simple data object used to store the result of a generation process.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "addSourceCode:",
@@ -385,13 +385,13 @@ fn: function (aString){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self["@sourceCodes"])._add_(aString);
-return self}, function($ctx1) {$ctx1.fill(self,"addSourceCode:",{aString:aString},smalltalk.HLGenerationOutput)})},
+return self}, function($ctx1) {$ctx1.fill(self,"addSourceCode:",{aString:aString},globals.HLGenerationOutput)})},
 args: ["aString"],
 source: "addSourceCode: aString\x0a\x09sourceCodes add: aString",
 messageSends: ["add:"],
 referencedClasses: []
 }),
-smalltalk.HLGenerationOutput);
+globals.HLGenerationOutput);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -408,13 +408,13 @@ if(! smalltalk.assert($1)){
 return _st(self["@targetClass"])._compile_protocol_(_st(methodSourceCode)._sourceCode(),self["@protocol"]);
 };
 }, function($ctx2) {$ctx2.fillBlock({methodSourceCode:methodSourceCode},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"compile",{},smalltalk.HLGenerationOutput)})},
+return self}, function($ctx1) {$ctx1.fill(self,"compile",{},globals.HLGenerationOutput)})},
 args: [],
 source: "compile\x0a\x09sourceCodes do: [ :methodSourceCode |\x0a\x09\x09(targetClass includesSelector: methodSourceCode selector)\x0a\x09\x09\x09ifFalse: [ \x0a\x09\x09\x09\x09targetClass \x0a\x09\x09\x09\x09\x09compile: methodSourceCode sourceCode\x0a\x09\x09\x09\x09\x09protocol: protocol ] ]",
 messageSends: ["do:", "ifFalse:", "includesSelector:", "selector", "compile:protocol:", "sourceCode"],
 referencedClasses: []
 }),
-smalltalk.HLGenerationOutput);
+globals.HLGenerationOutput);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -422,17 +422,17 @@ selector: "initialize",
 protocol: 'initialization',
 fn: function (){
 var self=this;
-function $OrderedCollection(){return smalltalk.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
 return smalltalk.withContext(function($ctx1) { 
-smalltalk.HLGenerationOutput.superclass.fn.prototype._initialize.apply(_st(self), []);
+globals.HLGenerationOutput.superclass.fn.prototype._initialize.apply(_st(self), []);
 self["@sourceCodes"]=_st($OrderedCollection())._new();
-return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},smalltalk.HLGenerationOutput)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.HLGenerationOutput)})},
 args: [],
 source: "initialize\x0a\x09super initialize.\x0a\x09\x0a\x09sourceCodes := OrderedCollection new",
 messageSends: ["initialize", "new"],
 referencedClasses: ["OrderedCollection"]
 }),
-smalltalk.HLGenerationOutput);
+globals.HLGenerationOutput);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -449,7 +449,7 @@ source: "protocol\x0a\x09^ protocol",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGenerationOutput);
+globals.HLGenerationOutput);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -464,7 +464,7 @@ source: "protocol: aString\x0a\x09protocol := aString",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGenerationOutput);
+globals.HLGenerationOutput);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -481,7 +481,7 @@ source: "sourceCodes\x0a\x09^ sourceCodes",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGenerationOutput);
+globals.HLGenerationOutput);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -496,7 +496,7 @@ source: "sourceCodes: aCollection\x0a\x09sourceCodes := aCollection",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGenerationOutput);
+globals.HLGenerationOutput);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -513,7 +513,7 @@ source: "targetClass\x0a\x09^ targetClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGenerationOutput);
+globals.HLGenerationOutput);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -528,12 +528,12 @@ source: "targetClass: aClass\x0a\x09targetClass := aClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLGenerationOutput);
+globals.HLGenerationOutput);
 
 
 
-smalltalk.addClass('HLMethodClassifier', smalltalk.Object, ['firstClassifier'], 'Helios-Helpers');
-smalltalk.HLMethodClassifier.comment="I am in charge of categorizing methods following this strategy:\x0a\x0a- is it an accessor?\x0a- is it overriding a superclass method?\x0a- is it starting with a know prefix?\x0a- how are categorized the other implementations?";
+smalltalk.addClass('HLMethodClassifier', globals.Object, ['firstClassifier'], 'Helios-Helpers');
+globals.HLMethodClassifier.comment="I am in charge of categorizing methods following this strategy:\x0a\x0a- is it an accessor?\x0a- is it overriding a superclass method?\x0a- is it starting with a know prefix?\x0a- how are categorized the other implementations?";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "addClassifier:",
@@ -543,13 +543,13 @@ var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(aClassifier)._next_(self["@firstClassifier"]);
 self["@firstClassifier"]=aClassifier;
-return self}, function($ctx1) {$ctx1.fill(self,"addClassifier:",{aClassifier:aClassifier},smalltalk.HLMethodClassifier)})},
+return self}, function($ctx1) {$ctx1.fill(self,"addClassifier:",{aClassifier:aClassifier},globals.HLMethodClassifier)})},
 args: ["aClassifier"],
 source: "addClassifier: aClassifier\x0a\x09aClassifier next: firstClassifier.\x0a\x09firstClassifier := aClassifier",
 messageSends: ["next:"],
 referencedClasses: []
 }),
-smalltalk.HLMethodClassifier);
+globals.HLMethodClassifier);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -562,13 +562,13 @@ var $1,$2;
 $1=self["@firstClassifier"];
 _st($1)._method_(aMethod);
 $2=_st($1)._classify();
-return self}, function($ctx1) {$ctx1.fill(self,"classify:",{aMethod:aMethod},smalltalk.HLMethodClassifier)})},
+return self}, function($ctx1) {$ctx1.fill(self,"classify:",{aMethod:aMethod},globals.HLMethodClassifier)})},
 args: ["aMethod"],
 source: "classify: aMethod\x0a\x09firstClassifier\x0a\x09\x09method: aMethod;\x0a\x09\x09classify",
 messageSends: ["method:", "classify"],
 referencedClasses: []
 }),
-smalltalk.HLMethodClassifier);
+globals.HLMethodClassifier);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -581,13 +581,13 @@ _st(aCollectionOfMethods)._do_((function(method){
 return smalltalk.withContext(function($ctx2) {
 return self._classify_(method);
 }, function($ctx2) {$ctx2.fillBlock({method:method},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"classifyAll:",{aCollectionOfMethods:aCollectionOfMethods},smalltalk.HLMethodClassifier)})},
+return self}, function($ctx1) {$ctx1.fill(self,"classifyAll:",{aCollectionOfMethods:aCollectionOfMethods},globals.HLMethodClassifier)})},
 args: ["aCollectionOfMethods"],
 source: "classifyAll: aCollectionOfMethods\x0a\x09aCollectionOfMethods do: [ :method |\x0a\x09\x09self classify: method ]",
 messageSends: ["do:", "classify:"],
 referencedClasses: []
 }),
-smalltalk.HLMethodClassifier);
+globals.HLMethodClassifier);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -596,15 +596,15 @@ protocol: 'initialization',
 fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
-smalltalk.HLMethodClassifier.superclass.fn.prototype._initialize.apply(_st(self), []);
+globals.HLMethodClassifier.superclass.fn.prototype._initialize.apply(_st(self), []);
 self._setupClassifiers();
-return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},smalltalk.HLMethodClassifier)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.HLMethodClassifier)})},
 args: [],
 source: "initialize\x0a\x09super initialize.\x0a\x09\x0a\x09self setupClassifiers",
 messageSends: ["initialize", "setupClassifiers"],
 referencedClasses: []
 }),
-smalltalk.HLMethodClassifier);
+globals.HLMethodClassifier);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -612,10 +612,10 @@ selector: "setupClassifiers",
 protocol: 'initialization',
 fn: function (){
 var self=this;
-function $HLImplementorClassifier(){return smalltalk.HLImplementorClassifier||(typeof HLImplementorClassifier=="undefined"?nil:HLImplementorClassifier)}
-function $HLPrefixClassifier(){return smalltalk.HLPrefixClassifier||(typeof HLPrefixClassifier=="undefined"?nil:HLPrefixClassifier)}
-function $HLSuperclassClassifier(){return smalltalk.HLSuperclassClassifier||(typeof HLSuperclassClassifier=="undefined"?nil:HLSuperclassClassifier)}
-function $HLAccessorClassifier(){return smalltalk.HLAccessorClassifier||(typeof HLAccessorClassifier=="undefined"?nil:HLAccessorClassifier)}
+function $HLImplementorClassifier(){return globals.HLImplementorClassifier||(typeof HLImplementorClassifier=="undefined"?nil:HLImplementorClassifier)}
+function $HLPrefixClassifier(){return globals.HLPrefixClassifier||(typeof HLPrefixClassifier=="undefined"?nil:HLPrefixClassifier)}
+function $HLSuperclassClassifier(){return globals.HLSuperclassClassifier||(typeof HLSuperclassClassifier=="undefined"?nil:HLSuperclassClassifier)}
+function $HLAccessorClassifier(){return globals.HLAccessorClassifier||(typeof HLAccessorClassifier=="undefined"?nil:HLAccessorClassifier)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2,$3;
 $1=_st($HLImplementorClassifier())._new();
@@ -631,18 +631,18 @@ $ctx1.sendIdx["new"]=3;
 self._addClassifier_($3);
 $ctx1.sendIdx["addClassifier:"]=3;
 self._addClassifier_(_st($HLAccessorClassifier())._new());
-return self}, function($ctx1) {$ctx1.fill(self,"setupClassifiers",{},smalltalk.HLMethodClassifier)})},
+return self}, function($ctx1) {$ctx1.fill(self,"setupClassifiers",{},globals.HLMethodClassifier)})},
 args: [],
 source: "setupClassifiers\x0a\x09self addClassifier: HLImplementorClassifier new.\x0a\x09self addClassifier: HLPrefixClassifier new.\x0a\x09self addClassifier: HLSuperclassClassifier new.\x0a\x09self addClassifier: HLAccessorClassifier new",
 messageSends: ["addClassifier:", "new"],
 referencedClasses: ["HLImplementorClassifier", "HLPrefixClassifier", "HLSuperclassClassifier", "HLAccessorClassifier"]
 }),
-smalltalk.HLMethodClassifier);
+globals.HLMethodClassifier);
 
 
 
-smalltalk.addClass('HLMethodGenerator', smalltalk.Object, ['output'], 'Helios-Helpers');
-smalltalk.HLMethodGenerator.comment="I am the abstract super class of the method generators.\x0a\x0aMy main method is `generate` which produce an `output` object";
+smalltalk.addClass('HLMethodGenerator', globals.Object, ['output'], 'Helios-Helpers');
+globals.HLMethodGenerator.comment="I am the abstract super class of the method generators.\x0a\x0aMy main method is `generate` which produce an `output` object";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "class:",
@@ -651,13 +651,13 @@ fn: function (aClass){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self["@output"])._targetClass_(aClass);
-return self}, function($ctx1) {$ctx1.fill(self,"class:",{aClass:aClass},smalltalk.HLMethodGenerator)})},
+return self}, function($ctx1) {$ctx1.fill(self,"class:",{aClass:aClass},globals.HLMethodGenerator)})},
 args: ["aClass"],
 source: "class: aClass\x0a\x09output targetClass: aClass",
 messageSends: ["targetClass:"],
 referencedClasses: []
 }),
-smalltalk.HLMethodGenerator);
+globals.HLMethodGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -673,13 +673,13 @@ self._error_("class should not be nil");
 } else {
 $1;
 };
-return self}, function($ctx1) {$ctx1.fill(self,"generate",{},smalltalk.HLMethodGenerator)})},
+return self}, function($ctx1) {$ctx1.fill(self,"generate",{},globals.HLMethodGenerator)})},
 args: [],
 source: "generate\x0a\x09output targetClass ifNil: [ self error: 'class should not be nil'].",
 messageSends: ["ifNil:", "targetClass", "error:"],
 referencedClasses: []
 }),
-smalltalk.HLMethodGenerator);
+globals.HLMethodGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -687,17 +687,17 @@ selector: "initialize",
 protocol: 'initialization',
 fn: function (){
 var self=this;
-function $HLGenerationOutput(){return smalltalk.HLGenerationOutput||(typeof HLGenerationOutput=="undefined"?nil:HLGenerationOutput)}
+function $HLGenerationOutput(){return globals.HLGenerationOutput||(typeof HLGenerationOutput=="undefined"?nil:HLGenerationOutput)}
 return smalltalk.withContext(function($ctx1) { 
-smalltalk.HLMethodGenerator.superclass.fn.prototype._initialize.apply(_st(self), []);
+globals.HLMethodGenerator.superclass.fn.prototype._initialize.apply(_st(self), []);
 self["@output"]=_st($HLGenerationOutput())._new();
-return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},smalltalk.HLMethodGenerator)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.HLMethodGenerator)})},
 args: [],
 source: "initialize\x0a\x09super initialize.\x0a\x09\x0a\x09output := HLGenerationOutput new",
 messageSends: ["initialize", "new"],
 referencedClasses: ["HLGenerationOutput"]
 }),
-smalltalk.HLMethodGenerator);
+globals.HLMethodGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -714,12 +714,12 @@ source: "output\x0a\x09^ output",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLMethodGenerator);
+globals.HLMethodGenerator);
 
 
 
-smalltalk.addClass('HLAccessorsGenerator', smalltalk.HLMethodGenerator, [], 'Helios-Helpers');
-smalltalk.HLAccessorsGenerator.comment="I am a generator used to compile the getters/setters of a class";
+smalltalk.addClass('HLAccessorsGenerator', globals.HLMethodGenerator, [], 'Helios-Helpers');
+globals.HLAccessorsGenerator.comment="I am a generator used to compile the getters/setters of a class";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "accessorProtocolForObject",
@@ -728,13 +728,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self["@output"])._protocol_("accessing");
-return self}, function($ctx1) {$ctx1.fill(self,"accessorProtocolForObject",{},smalltalk.HLAccessorsGenerator)})},
+return self}, function($ctx1) {$ctx1.fill(self,"accessorProtocolForObject",{},globals.HLAccessorsGenerator)})},
 args: [],
 source: "accessorProtocolForObject\x0a\x09output protocol: 'accessing'",
 messageSends: ["protocol:"],
 referencedClasses: []
 }),
-smalltalk.HLAccessorsGenerator);
+globals.HLAccessorsGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -743,7 +743,7 @@ protocol: 'double-dispatch',
 fn: function (){
 var self=this;
 var sources;
-function $OrderedCollection(){return smalltalk.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
 sources=_st($OrderedCollection())._new();
@@ -756,13 +756,13 @@ $2=_st($1)._add_(self._setterFor_(each));
 return $2;
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
 _st(self["@output"])._sourceCodes_(sources);
-return self}, function($ctx1) {$ctx1.fill(self,"accessorsForObject",{sources:sources},smalltalk.HLAccessorsGenerator)})},
+return self}, function($ctx1) {$ctx1.fill(self,"accessorsForObject",{sources:sources},globals.HLAccessorsGenerator)})},
 args: [],
 source: "accessorsForObject\x0a\x09| sources |\x0a\x09\x0a\x09sources := OrderedCollection new.\x0a\x09output targetClass instanceVariableNames sorted do: [ :each | \x0a\x09\x09sources \x0a\x09\x09\x09add: (self getterFor: each);\x0a\x09\x09\x09add: (self setterFor: each) ].\x0a\x09output sourceCodes: sources",
 messageSends: ["new", "do:", "sorted", "instanceVariableNames", "targetClass", "add:", "getterFor:", "setterFor:", "sourceCodes:"],
 referencedClasses: ["OrderedCollection"]
 }),
-smalltalk.HLAccessorsGenerator);
+globals.HLAccessorsGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -772,17 +772,17 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
-smalltalk.HLAccessorsGenerator.superclass.fn.prototype._generate.apply(_st(self), []);
+globals.HLAccessorsGenerator.superclass.fn.prototype._generate.apply(_st(self), []);
 $1=_st(self["@output"])._targetClass();
 _st($1)._accessorsSourceCodesWith_(self);
 $2=_st($1)._accessorProtocolWith_(self);
-return self}, function($ctx1) {$ctx1.fill(self,"generate",{},smalltalk.HLAccessorsGenerator)})},
+return self}, function($ctx1) {$ctx1.fill(self,"generate",{},globals.HLAccessorsGenerator)})},
 args: [],
 source: "generate\x0a\x09super generate.\x0a\x09\x0a\x09output targetClass \x0a\x09\x09accessorsSourceCodesWith: self;\x0a\x09\x09accessorProtocolWith: self",
 messageSends: ["generate", "accessorsSourceCodesWith:", "targetClass", "accessorProtocolWith:"],
 referencedClasses: []
 }),
-smalltalk.HLAccessorsGenerator);
+globals.HLAccessorsGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -790,8 +790,8 @@ selector: "getterFor:",
 protocol: 'private',
 fn: function (anInstanceVariable){
 var self=this;
-function $HLMethodSourceCode(){return smalltalk.HLMethodSourceCode||(typeof HLMethodSourceCode=="undefined"?nil:HLMethodSourceCode)}
-function $String(){return smalltalk.String||(typeof String=="undefined"?nil:String)}
+function $HLMethodSourceCode(){return globals.HLMethodSourceCode||(typeof HLMethodSourceCode=="undefined"?nil:HLMethodSourceCode)}
+function $String(){return globals.String||(typeof String=="undefined"?nil:String)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$3,$1;
 $2=_st($HLMethodSourceCode())._new();
@@ -806,13 +806,13 @@ $ctx2.sendIdx["<<"]=2;
 }, function($ctx2) {$ctx2.fillBlock({stream:stream},$ctx1,1)})})));
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"getterFor:",{anInstanceVariable:anInstanceVariable},smalltalk.HLAccessorsGenerator)})},
+}, function($ctx1) {$ctx1.fill(self,"getterFor:",{anInstanceVariable:anInstanceVariable},globals.HLAccessorsGenerator)})},
 args: ["anInstanceVariable"],
 source: "getterFor: anInstanceVariable\x0a\x09^ HLMethodSourceCode new\x0a\x09\x09selector:anInstanceVariable;\x0a\x09\x09sourceCode: (String streamContents: [ :stream |\x0a\x09\x09stream << anInstanceVariable.\x0a\x09\x09stream cr tab.\x0a\x09\x09stream << '^ ' << anInstanceVariable ])",
 messageSends: ["selector:", "new", "sourceCode:", "streamContents:", "<<", "tab", "cr"],
 referencedClasses: ["HLMethodSourceCode", "String"]
 }),
-smalltalk.HLAccessorsGenerator);
+globals.HLAccessorsGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -820,8 +820,8 @@ selector: "setterFor:",
 protocol: 'private',
 fn: function (anInstanceVariable){
 var self=this;
-function $HLMethodSourceCode(){return smalltalk.HLMethodSourceCode||(typeof HLMethodSourceCode=="undefined"?nil:HLMethodSourceCode)}
-function $String(){return smalltalk.String||(typeof String=="undefined"?nil:String)}
+function $HLMethodSourceCode(){return globals.HLMethodSourceCode||(typeof HLMethodSourceCode=="undefined"?nil:HLMethodSourceCode)}
+function $String(){return globals.String||(typeof String=="undefined"?nil:String)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$4,$3,$1;
 $2=_st($HLMethodSourceCode())._new();
@@ -838,18 +838,18 @@ $ctx2.sendIdx["<<"]=3;
 }, function($ctx2) {$ctx2.fillBlock({stream:stream},$ctx1,1)})})));
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"setterFor:",{anInstanceVariable:anInstanceVariable},smalltalk.HLAccessorsGenerator)})},
+}, function($ctx1) {$ctx1.fill(self,"setterFor:",{anInstanceVariable:anInstanceVariable},globals.HLAccessorsGenerator)})},
 args: ["anInstanceVariable"],
 source: "setterFor: anInstanceVariable\x0a\x09^ HLMethodSourceCode new\x0a\x09\x09selector: anInstanceVariable, ':';\x0a\x09\x09sourceCode: (String streamContents: [ :stream |\x0a\x09\x09stream << anInstanceVariable << ': anObject'.\x0a\x09\x09stream cr tab.\x0a\x09\x09stream << anInstanceVariable << ' := anObject' ])",
 messageSends: ["selector:", "new", ",", "sourceCode:", "streamContents:", "<<", "tab", "cr"],
 referencedClasses: ["HLMethodSourceCode", "String"]
 }),
-smalltalk.HLAccessorsGenerator);
+globals.HLAccessorsGenerator);
 
 
 
-smalltalk.addClass('HLInitializeGenerator', smalltalk.HLMethodGenerator, [], 'Helios-Helpers');
-smalltalk.HLInitializeGenerator.comment="I am used to double-dispatch the `initialize` method(s) generation.\x0a\x0aUsage:\x0a\x0a    ^ HLInitializeGenerator new\x0a        class: aClass;\x0a        generate;\x0a        output\x0a\x0aI am a disposable object";
+smalltalk.addClass('HLInitializeGenerator', globals.HLMethodGenerator, [], 'Helios-Helpers');
+globals.HLInitializeGenerator.comment="I am used to double-dispatch the `initialize` method(s) generation.\x0a\x0aUsage:\x0a\x0a    ^ HLInitializeGenerator new\x0a        class: aClass;\x0a        generate;\x0a        output\x0a\x0aI am a disposable object";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "generate",
@@ -858,17 +858,17 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
-smalltalk.HLInitializeGenerator.superclass.fn.prototype._generate.apply(_st(self), []);
+globals.HLInitializeGenerator.superclass.fn.prototype._generate.apply(_st(self), []);
 $1=_st(self["@output"])._targetClass();
 _st($1)._initializeSourceCodesWith_(self);
 $2=_st($1)._initializeProtocolWith_(self);
-return self}, function($ctx1) {$ctx1.fill(self,"generate",{},smalltalk.HLInitializeGenerator)})},
+return self}, function($ctx1) {$ctx1.fill(self,"generate",{},globals.HLInitializeGenerator)})},
 args: [],
 source: "generate\x0a\x09super generate.\x0a\x09\x0a\x09output targetClass \x0a\x09\x09initializeSourceCodesWith: self;\x0a\x09\x09initializeProtocolWith: self",
 messageSends: ["generate", "initializeSourceCodesWith:", "targetClass", "initializeProtocolWith:"],
 referencedClasses: []
 }),
-smalltalk.HLInitializeGenerator);
+globals.HLInitializeGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -876,7 +876,7 @@ selector: "generateInitializeCodeForObject",
 protocol: 'private',
 fn: function (){
 var self=this;
-function $String(){return smalltalk.String||(typeof String=="undefined"?nil:String)}
+function $String(){return globals.String||(typeof String=="undefined"?nil:String)}
 return smalltalk.withContext(function($ctx1) { 
 var $3,$2,$4,$5,$6,$7,$8,$1;
 $1=_st($String())._streamContents_((function(str){
@@ -919,13 +919,13 @@ return _st(str).__lt_lt(".");
 }, function($ctx3) {$ctx3.fillBlock({name:name,index:index},$ctx2,2)})}));
 }, function($ctx2) {$ctx2.fillBlock({str:str,instVars:instVars,size:size},$ctx1,1)})}));
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"generateInitializeCodeForObject",{},smalltalk.HLInitializeGenerator)})},
+}, function($ctx1) {$ctx1.fill(self,"generateInitializeCodeForObject",{},globals.HLInitializeGenerator)})},
 args: [],
 source: "generateInitializeCodeForObject\x09\x0a\x09^ String streamContents: [ :str || instVars size |\x0a\x09\x09instVars := output targetClass instanceVariableNames sorted.\x0a\x09\x09size := instVars size.\x0a\x09\x09str << 'initialize'.\x0a\x09\x09str cr tab << 'super initialize.';cr.\x0a\x09\x09str cr tab.\x0a\x09\x09instVars withIndexDo: [ :name :index |\x0a\x09\x09\x09index ~= 1 ifTrue: [ str cr tab ].\x0a\x09\x09\x09str << name << ' := nil'.\x0a\x09\x09\x09index ~= size ifTrue: [ str << '.' ] ] ].",
 messageSends: ["streamContents:", "sorted", "instanceVariableNames", "targetClass", "size", "<<", "tab", "cr", "withIndexDo:", "ifTrue:", "~="],
 referencedClasses: ["String"]
 }),
-smalltalk.HLInitializeGenerator);
+globals.HLInitializeGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -935,13 +935,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self["@output"])._addSourceCode_(self._initializeMethodForObject());
-return self}, function($ctx1) {$ctx1.fill(self,"initializeForObject",{},smalltalk.HLInitializeGenerator)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initializeForObject",{},globals.HLInitializeGenerator)})},
 args: [],
 source: "initializeForObject\x0a\x09output addSourceCode: self initializeMethodForObject",
 messageSends: ["addSourceCode:", "initializeMethodForObject"],
 referencedClasses: []
 }),
-smalltalk.HLInitializeGenerator);
+globals.HLInitializeGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -949,7 +949,7 @@ selector: "initializeMethodForObject",
 protocol: 'private',
 fn: function (){
 var self=this;
-function $HLMethodSourceCode(){return smalltalk.HLMethodSourceCode||(typeof HLMethodSourceCode=="undefined"?nil:HLMethodSourceCode)}
+function $HLMethodSourceCode(){return globals.HLMethodSourceCode||(typeof HLMethodSourceCode=="undefined"?nil:HLMethodSourceCode)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$3,$1;
 $2=_st($HLMethodSourceCode())._new();
@@ -958,13 +958,13 @@ _st($2)._sourceCode_(self._generateInitializeCodeForObject());
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"initializeMethodForObject",{},smalltalk.HLInitializeGenerator)})},
+}, function($ctx1) {$ctx1.fill(self,"initializeMethodForObject",{},globals.HLInitializeGenerator)})},
 args: [],
 source: "initializeMethodForObject\x09\x0a\x09^ HLMethodSourceCode new\x0a\x09\x09selector: 'initialize';\x0a\x09\x09sourceCode: self generateInitializeCodeForObject;\x0a\x09\x09yourself",
 messageSends: ["selector:", "new", "sourceCode:", "generateInitializeCodeForObject", "yourself"],
 referencedClasses: ["HLMethodSourceCode"]
 }),
-smalltalk.HLInitializeGenerator);
+globals.HLInitializeGenerator);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -974,18 +974,18 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self["@output"])._protocol_("initialization");
-return self}, function($ctx1) {$ctx1.fill(self,"initializeProtocolForObject",{},smalltalk.HLInitializeGenerator)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initializeProtocolForObject",{},globals.HLInitializeGenerator)})},
 args: [],
 source: "initializeProtocolForObject\x0a\x09output protocol: 'initialization'",
 messageSends: ["protocol:"],
 referencedClasses: []
 }),
-smalltalk.HLInitializeGenerator);
+globals.HLInitializeGenerator);
 
 
 
-smalltalk.addClass('HLMethodSourceCode', smalltalk.Object, ['selector', 'sourceCode'], 'Helios-Helpers');
-smalltalk.HLMethodSourceCode.comment="I am a simple data object keeping track of the information about a method that will be compiled at the end of the generation process";
+smalltalk.addClass('HLMethodSourceCode', globals.Object, ['selector', 'sourceCode'], 'Helios-Helpers');
+globals.HLMethodSourceCode.comment="I am a simple data object keeping track of the information about a method that will be compiled at the end of the generation process";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "selector",
@@ -1001,7 +1001,7 @@ source: "selector\x0a\x09^ selector",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLMethodSourceCode);
+globals.HLMethodSourceCode);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1016,7 +1016,7 @@ source: "selector: aSelector\x0a\x09selector := aSelector",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLMethodSourceCode);
+globals.HLMethodSourceCode);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1033,7 +1033,7 @@ source: "sourceCode\x0a\x09^ sourceCode",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLMethodSourceCode);
+globals.HLMethodSourceCode);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1048,7 +1048,7 @@ source: "sourceCode: aString\x0a\x09sourceCode := aString",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLMethodSourceCode);
+globals.HLMethodSourceCode);
 
 
 });

js/Helios-Layout.js

@@ -1,8 +1,8 @@
-define("amber_core/Helios-Layout", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Helios-Core", "amber_core/Canvas", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st){
+define("amber_core/Helios-Layout", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Helios-Core", "amber_core/Canvas", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Helios-Layout');
 smalltalk.packages["Helios-Layout"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('HLContainer', smalltalk.HLWidget, ['splitter'], 'Helios-Layout');
+smalltalk.addClass('HLContainer', globals.HLWidget, ['splitter'], 'Helios-Layout');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "renderOn:",
@@ -14,13 +14,13 @@ var $1,$2;
 $1=_st(html)._div();
 _st($1)._class_("tool_container");
 $2=_st($1)._with_(self._splitter());
-return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},smalltalk.HLContainer)})},
+return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},globals.HLContainer)})},
 args: ["html"],
 source: "renderOn: html\x0a\x09html div \x0a    \x09class: 'tool_container'; \x0a        with: self splitter",
 messageSends: ["class:", "div", "with:", "splitter"],
 referencedClasses: []
 }),
-smalltalk.HLContainer);
+globals.HLContainer);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -37,7 +37,7 @@ source: "splitter\x0a\x09^ splitter",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLContainer);
+globals.HLContainer);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -52,7 +52,7 @@ source: "splitter: aSplitter\x0a\x09splitter := aSplitter",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLContainer);
+globals.HLContainer);
 
 
 smalltalk.addMethod(
@@ -68,16 +68,16 @@ _st($2)._splitter_(aSplitter);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"with:",{aSplitter:aSplitter},smalltalk.HLContainer.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"with:",{aSplitter:aSplitter},globals.HLContainer.klass)})},
 args: ["aSplitter"],
 source: "with: aSplitter\x0a\x09^ self new \x0a    \x09splitter: aSplitter; \x0a        yourself",
 messageSends: ["splitter:", "new", "yourself"],
 referencedClasses: []
 }),
-smalltalk.HLContainer.klass);
+globals.HLContainer.klass);
 
 
-smalltalk.addClass('HLSplitter', smalltalk.Widget, ['firstWidget', 'secondWidget', 'firstPane', 'secondPane', 'splitter'], 'Helios-Layout');
+smalltalk.addClass('HLSplitter', globals.Widget, ['firstWidget', 'secondWidget', 'firstPane', 'secondPane', 'splitter'], 'Helios-Layout');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "cssClass",
@@ -91,7 +91,7 @@ source: "cssClass\x0a\x09^ 'splitter'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLSplitter);
+globals.HLSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -108,7 +108,7 @@ source: "firstWidget\x0a\x09^ firstWidget",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLSplitter);
+globals.HLSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -123,7 +123,7 @@ source: "firstWidget: aWidget\x0a\x09firstWidget := aWidget",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLSplitter);
+globals.HLSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -138,7 +138,7 @@ source: "isHeliosSplitter\x0a\x09^ true",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLSplitter);
+globals.HLSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -153,7 +153,7 @@ source: "panesCssClass\x0a\x09^ 'panes'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLSplitter);
+globals.HLSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -190,13 +190,13 @@ return self["@secondPane"];
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
 $ctx1.sendIdx["with:"]=1;
 self._setupSplitter();
-return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},smalltalk.HLSplitter)})},
+return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},globals.HLSplitter)})},
 args: ["html"],
 source: "renderOn: html\x0a\x09html div class: self panesCssClass; with: [\x0a\x09\x09firstPane := html div class: 'pane'; with: self firstWidget.\x0a    \x09splitter := html div class: self cssClass.\x0a    \x09secondPane := html div class: 'pane'; with: self secondWidget ].\x0a        \x0a\x09self setupSplitter",
 messageSends: ["class:", "div", "panesCssClass", "with:", "firstWidget", "cssClass", "secondWidget", "setupSplitter"],
 referencedClasses: []
 }),
-smalltalk.HLSplitter);
+globals.HLSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -210,7 +210,7 @@ source: "resize",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLSplitter);
+globals.HLSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -227,7 +227,7 @@ source: "secondWidget\x0a\x09^ secondWidget",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLSplitter);
+globals.HLSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -242,7 +242,7 @@ source: "secondWidget: aWidget\x0a\x09secondWidget := aWidget",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLSplitter);
+globals.HLSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -256,7 +256,7 @@ source: "setupSplitter",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLSplitter);
+globals.HLSplitter);
 
 
 smalltalk.addMethod(
@@ -273,16 +273,16 @@ _st($2)._secondWidget_(anotherWidget);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"with:with:",{aWidget:aWidget,anotherWidget:anotherWidget},smalltalk.HLSplitter.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"with:with:",{aWidget:aWidget,anotherWidget:anotherWidget},globals.HLSplitter.klass)})},
 args: ["aWidget", "anotherWidget"],
 source: "with: aWidget with: anotherWidget\x0a\x09^ self new\x0a    \x09\x09firstWidget: aWidget;\x0a            secondWidget: anotherWidget;\x0a            yourself",
 messageSends: ["firstWidget:", "new", "secondWidget:", "yourself"],
 referencedClasses: []
 }),
-smalltalk.HLSplitter.klass);
+globals.HLSplitter.klass);
 
 
-smalltalk.addClass('HLHorizontalSplitter', smalltalk.HLSplitter, [], 'Helios-Layout');
+smalltalk.addClass('HLHorizontalSplitter', globals.HLSplitter, [], 'Helios-Layout');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "cssClass",
@@ -291,15 +291,15 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 var $1;
-$1=_st(smalltalk.HLHorizontalSplitter.superclass.fn.prototype._cssClass.apply(_st(self), [])).__comma(" horizontal");
+$1=_st(globals.HLHorizontalSplitter.superclass.fn.prototype._cssClass.apply(_st(self), [])).__comma(" horizontal");
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"cssClass",{},smalltalk.HLHorizontalSplitter)})},
+}, function($ctx1) {$ctx1.fill(self,"cssClass",{},globals.HLHorizontalSplitter)})},
 args: [],
 source: "cssClass\x0a\x09^ super cssClass, ' horizontal'",
 messageSends: [",", "cssClass"],
 referencedClasses: []
 }),
-smalltalk.HLHorizontalSplitter);
+globals.HLHorizontalSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -309,15 +309,15 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 var $1;
-$1=_st(smalltalk.HLHorizontalSplitter.superclass.fn.prototype._panesCssClass.apply(_st(self), [])).__comma(" horizontal");
+$1=_st(globals.HLHorizontalSplitter.superclass.fn.prototype._panesCssClass.apply(_st(self), [])).__comma(" horizontal");
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"panesCssClass",{},smalltalk.HLHorizontalSplitter)})},
+}, function($ctx1) {$ctx1.fill(self,"panesCssClass",{},globals.HLHorizontalSplitter)})},
 args: [],
 source: "panesCssClass\x0a\x09^ super panesCssClass, ' horizontal'",
 messageSends: [",", "panesCssClass"],
 referencedClasses: []
 }),
-smalltalk.HLHorizontalSplitter);
+globals.HLHorizontalSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -327,13 +327,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._resize_(_st(_st(self["@splitter"])._asJQuery())._css_("top"));
-return self}, function($ctx1) {$ctx1.fill(self,"resize",{},smalltalk.HLHorizontalSplitter)})},
+return self}, function($ctx1) {$ctx1.fill(self,"resize",{},globals.HLHorizontalSplitter)})},
 args: [],
 source: "resize\x0a\x09self resize: (splitter asJQuery css: 'top')",
 messageSends: ["resize:", "css:", "asJQuery"],
 referencedClasses: []
 }),
-smalltalk.HLHorizontalSplitter);
+globals.HLHorizontalSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -379,13 +379,13 @@ $ctx1.sendIdx[","]=2;
 _st($11)._css_put_("top",$12);
 $ctx1.sendIdx["css:put:"]=2;
 _st(_st(self["@secondPane"])._asJQuery())._css_put_("top",_st(_st((100).__minus(percentage))._asString()).__comma("%"));
-return self}, function($ctx1) {$ctx1.fill(self,"resize:",{anInteger:anInteger,container:container,size:size,offset:offset,percentage:percentage},smalltalk.HLHorizontalSplitter)})},
+return self}, function($ctx1) {$ctx1.fill(self,"resize:",{anInteger:anInteger,container:container,size:size,offset:offset,percentage:percentage},globals.HLHorizontalSplitter)})},
 args: ["anInteger"],
 source: "resize: anInteger\x0a\x09| container size offset percentage |\x0a    \x0a    container := firstPane asJQuery parent.\x0a\x09offset := firstPane asJQuery offset top.\x0a    size := container height.\x0a\x09\x0a\x09percentage := (size - (anInteger - offset)) / size * 100.\x0a\x09percentage := 80 min: (percentage max: 20).\x0a\x09\x0a    firstPane asJQuery css: 'bottom' put: percentage asString, '%'.\x0a\x09\x0a\x09splitter asJQuery css: 'top' put: (100 - percentage) asString, '%'.\x0a\x09secondPane asJQuery css: 'top' put: (100 - percentage) asString, '%'",
 messageSends: ["parent", "asJQuery", "top", "offset", "height", "*", "/", "-", "min:", "max:", "css:put:", ",", "asString"],
 referencedClasses: []
 }),
-smalltalk.HLHorizontalSplitter);
+globals.HLHorizontalSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -413,13 +413,13 @@ return smalltalk.withContext(function($ctx2) {
 return self._resize_(_st(_st(ui)._offset())._top());
 }, function($ctx2) {$ctx2.fillBlock({e:e,ui:ui},$ctx1,2)})}))]);
 _st($1)._draggable_($2);
-return self}, function($ctx1) {$ctx1.fill(self,"setupSplitter",{},smalltalk.HLHorizontalSplitter)})},
+return self}, function($ctx1) {$ctx1.fill(self,"setupSplitter",{},globals.HLHorizontalSplitter)})},
 args: [],
 source: "setupSplitter\x0a\x09splitter asJQuery draggable: #{ \x0a    \x09'axis' -> 'y'. \x0a        'containment' -> splitter asJQuery parent.\x0a        'helper' -> 'clone'.\x0a        'start' -> [ :e :ui | self startResizing: ui helper ].\x0a        'drag' -> [ :e :ui | self resize: ui offset top ] }",
 messageSends: ["draggable:", "asJQuery", "->", "parent", "startResizing:", "helper", "resize:", "top", "offset"],
 referencedClasses: []
 }),
-smalltalk.HLHorizontalSplitter);
+globals.HLHorizontalSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -429,17 +429,17 @@ fn: function (aSplitter){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(aSplitter)._width_(_st(_st(self["@splitter"])._asJQuery())._width());
-return self}, function($ctx1) {$ctx1.fill(self,"startResizing:",{aSplitter:aSplitter},smalltalk.HLHorizontalSplitter)})},
+return self}, function($ctx1) {$ctx1.fill(self,"startResizing:",{aSplitter:aSplitter},globals.HLHorizontalSplitter)})},
 args: ["aSplitter"],
 source: "startResizing: aSplitter\x0a\x09aSplitter width: splitter asJQuery width",
 messageSends: ["width:", "width", "asJQuery"],
 referencedClasses: []
 }),
-smalltalk.HLHorizontalSplitter);
+globals.HLHorizontalSplitter);
 
 
 
-smalltalk.addClass('HLVerticalSplitter', smalltalk.HLSplitter, [], 'Helios-Layout');
+smalltalk.addClass('HLVerticalSplitter', globals.HLSplitter, [], 'Helios-Layout');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "cssClass",
@@ -448,15 +448,15 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 var $1;
-$1=_st(smalltalk.HLVerticalSplitter.superclass.fn.prototype._cssClass.apply(_st(self), [])).__comma(" vertical");
+$1=_st(globals.HLVerticalSplitter.superclass.fn.prototype._cssClass.apply(_st(self), [])).__comma(" vertical");
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"cssClass",{},smalltalk.HLVerticalSplitter)})},
+}, function($ctx1) {$ctx1.fill(self,"cssClass",{},globals.HLVerticalSplitter)})},
 args: [],
 source: "cssClass\x0a\x09^ super cssClass, ' vertical'",
 messageSends: [",", "cssClass"],
 referencedClasses: []
 }),
-smalltalk.HLVerticalSplitter);
+globals.HLVerticalSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -466,15 +466,15 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 var $1;
-$1=_st(smalltalk.HLVerticalSplitter.superclass.fn.prototype._panesCssClass.apply(_st(self), [])).__comma(" vertical");
+$1=_st(globals.HLVerticalSplitter.superclass.fn.prototype._panesCssClass.apply(_st(self), [])).__comma(" vertical");
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"panesCssClass",{},smalltalk.HLVerticalSplitter)})},
+}, function($ctx1) {$ctx1.fill(self,"panesCssClass",{},globals.HLVerticalSplitter)})},
 args: [],
 source: "panesCssClass\x0a\x09^ super panesCssClass, ' vertical'",
 messageSends: [",", "panesCssClass"],
 referencedClasses: []
 }),
-smalltalk.HLVerticalSplitter);
+globals.HLVerticalSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -484,13 +484,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._resize_(_st(_st(self["@splitter"])._asJQuery())._css_("left"));
-return self}, function($ctx1) {$ctx1.fill(self,"resize",{},smalltalk.HLVerticalSplitter)})},
+return self}, function($ctx1) {$ctx1.fill(self,"resize",{},globals.HLVerticalSplitter)})},
 args: [],
 source: "resize\x0a\x09self resize: (splitter asJQuery css: 'left')",
 messageSends: ["resize:", "css:", "asJQuery"],
 referencedClasses: []
 }),
-smalltalk.HLVerticalSplitter);
+globals.HLVerticalSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -536,13 +536,13 @@ $ctx1.sendIdx[","]=2;
 _st($11)._css_put_("left",$12);
 $ctx1.sendIdx["css:put:"]=2;
 _st(_st(self["@secondPane"])._asJQuery())._css_put_("left",_st(_st((100).__minus(percentage))._asString()).__comma("%"));
-return self}, function($ctx1) {$ctx1.fill(self,"resize:",{anInteger:anInteger,container:container,size:size,offset:offset,percentage:percentage},smalltalk.HLVerticalSplitter)})},
+return self}, function($ctx1) {$ctx1.fill(self,"resize:",{anInteger:anInteger,container:container,size:size,offset:offset,percentage:percentage},globals.HLVerticalSplitter)})},
 args: ["anInteger"],
 source: "resize: anInteger\x0a\x09| container size offset percentage |\x0a    \x0a    container := firstPane asJQuery parent.\x0a\x09offset := firstPane asJQuery offset left.\x0a    size := container width.\x0a\x09\x0a\x09percentage := (size - (anInteger - offset)) / size * 100.\x0a\x09percentage := 80 min: (percentage max: 20).\x0a\x09\x0a    firstPane asJQuery css: 'right' put: percentage asString, '%'.\x0a\x09\x0a\x09splitter asJQuery css: 'left' put: (100 - percentage) asString, '%'.\x0a\x09secondPane asJQuery css: 'left' put: (100 - percentage) asString, '%'",
 messageSends: ["parent", "asJQuery", "left", "offset", "width", "*", "/", "-", "min:", "max:", "css:put:", ",", "asString"],
 referencedClasses: []
 }),
-smalltalk.HLVerticalSplitter);
+globals.HLVerticalSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -570,13 +570,13 @@ return smalltalk.withContext(function($ctx2) {
 return self._resize_(_st(_st(ui)._offset())._left());
 }, function($ctx2) {$ctx2.fillBlock({e:e,ui:ui},$ctx1,2)})}))]);
 _st($1)._draggable_($2);
-return self}, function($ctx1) {$ctx1.fill(self,"setupSplitter",{},smalltalk.HLVerticalSplitter)})},
+return self}, function($ctx1) {$ctx1.fill(self,"setupSplitter",{},globals.HLVerticalSplitter)})},
 args: [],
 source: "setupSplitter\x0a\x09splitter asJQuery draggable: #{ \x0a    \x09'axis' -> 'x'. \x0a        'containment' -> splitter asJQuery parent.\x0a        'helper' -> 'clone'.\x0a        'start' -> [ :e :ui | self startResizing: ui helper ].\x0a        'drag' -> [ :e :ui | self resize: (ui offset left) ] }",
 messageSends: ["draggable:", "asJQuery", "->", "parent", "startResizing:", "helper", "resize:", "left", "offset"],
 referencedClasses: []
 }),
-smalltalk.HLVerticalSplitter);
+globals.HLVerticalSplitter);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -586,13 +586,13 @@ fn: function (aSplitter){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(aSplitter)._height_(_st(_st(self["@splitter"])._asJQuery())._height());
-return self}, function($ctx1) {$ctx1.fill(self,"startResizing:",{aSplitter:aSplitter},smalltalk.HLVerticalSplitter)})},
+return self}, function($ctx1) {$ctx1.fill(self,"startResizing:",{aSplitter:aSplitter},globals.HLVerticalSplitter)})},
 args: ["aSplitter"],
 source: "startResizing: aSplitter\x0a\x09aSplitter height: splitter asJQuery height",
 messageSends: ["height:", "height", "asJQuery"],
 referencedClasses: []
 }),
-smalltalk.HLVerticalSplitter);
+globals.HLVerticalSplitter);
 
 
 smalltalk.addMethod(
@@ -608,6 +608,6 @@ source: "isHeliosSplitter\x0a\x09^ false",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Object);
+globals.Object);
 
 });

js/Helios-References.js

@@ -1,8 +1,8 @@
-define("amber_core/Helios-References", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Objects", "amber_core/Helios-Core"], function(smalltalk,nil,_st){
+define("amber_core/Helios-References", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects", "amber_core/Helios-Core"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Helios-References');
 smalltalk.packages["Helios-References"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('HLMethodReference', smalltalk.Object, ['selector', 'methodClass'], 'Helios-References');
+smalltalk.addClass('HLMethodReference', globals.Object, ['selector', 'methodClass'], 'Helios-References');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "initializeFromMethod:",
@@ -13,13 +13,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 self._selector_(_st(aCompiledMethod)._selector());
 $1=self._methodClass_(_st(aCompiledMethod)._methodClass());
-return self}, function($ctx1) {$ctx1.fill(self,"initializeFromMethod:",{aCompiledMethod:aCompiledMethod},smalltalk.HLMethodReference)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initializeFromMethod:",{aCompiledMethod:aCompiledMethod},globals.HLMethodReference)})},
 args: ["aCompiledMethod"],
 source: "initializeFromMethod: aCompiledMethod\x0a\x09self\x0a\x09\x09selector: aCompiledMethod selector;\x0a\x09\x09methodClass: aCompiledMethod methodClass",
 messageSends: ["selector:", "selector", "methodClass:", "methodClass"],
 referencedClasses: []
 }),
-smalltalk.HLMethodReference);
+globals.HLMethodReference);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -31,13 +31,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self._methodClass())._methodAt_(self._selector());
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"method",{},smalltalk.HLMethodReference)})},
+}, function($ctx1) {$ctx1.fill(self,"method",{},globals.HLMethodReference)})},
 args: [],
 source: "method\x0a\x09^ self methodClass methodAt: self selector",
 messageSends: ["methodAt:", "methodClass", "selector"],
 referencedClasses: []
 }),
-smalltalk.HLMethodReference);
+globals.HLMethodReference);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -54,7 +54,7 @@ source: "methodClass\x0a\x09^ methodClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLMethodReference);
+globals.HLMethodReference);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -69,7 +69,7 @@ source: "methodClass: aClass\x0a\x09methodClass := aClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLMethodReference);
+globals.HLMethodReference);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -86,7 +86,7 @@ source: "selector\x0a\x09^ selector",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLMethodReference);
+globals.HLMethodReference);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -101,7 +101,7 @@ source: "selector: aString\x0a\x09selector := aString",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLMethodReference);
+globals.HLMethodReference);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -113,13 +113,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self._method())._source();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"source",{},smalltalk.HLMethodReference)})},
+}, function($ctx1) {$ctx1.fill(self,"source",{},globals.HLMethodReference)})},
 args: [],
 source: "source\x0a\x09^ self method source",
 messageSends: ["source", "method"],
 referencedClasses: []
 }),
-smalltalk.HLMethodReference);
+globals.HLMethodReference);
 
 
 smalltalk.addMethod(
@@ -135,23 +135,23 @@ _st($2)._initializeFromMethod_(aCompiledMethod);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"on:",{aCompiledMethod:aCompiledMethod},smalltalk.HLMethodReference.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"on:",{aCompiledMethod:aCompiledMethod},globals.HLMethodReference.klass)})},
 args: ["aCompiledMethod"],
 source: "on: aCompiledMethod\x0a\x09^ self new\x0a\x09\x09initializeFromMethod: aCompiledMethod;\x0a\x09\x09yourself",
 messageSends: ["initializeFromMethod:", "new", "yourself"],
 referencedClasses: []
 }),
-smalltalk.HLMethodReference.klass);
+globals.HLMethodReference.klass);
 
 
-smalltalk.addClass('HLReferences', smalltalk.HLWidget, ['model', 'sendersListWidget', 'implementorsListWidget', 'classReferencesListWidget', 'regexpListWidget', 'sourceCodeWidget'], 'Helios-References');
+smalltalk.addClass('HLReferences', globals.HLWidget, ['model', 'sendersListWidget', 'implementorsListWidget', 'classReferencesListWidget', 'regexpListWidget', 'sourceCodeWidget'], 'Helios-References');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "classReferencesListWidget",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-function $HLClassReferencesListWidget(){return smalltalk.HLClassReferencesListWidget||(typeof HLClassReferencesListWidget=="undefined"?nil:HLClassReferencesListWidget)}
+function $HLClassReferencesListWidget(){return globals.HLClassReferencesListWidget||(typeof HLClassReferencesListWidget=="undefined"?nil:HLClassReferencesListWidget)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$1;
 $2=self["@classReferencesListWidget"];
@@ -163,13 +163,13 @@ $1=_st(self["@classReferencesListWidget"])._next_(self._regexpListWidget());
 $1=$2;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"classReferencesListWidget",{},smalltalk.HLReferences)})},
+}, function($ctx1) {$ctx1.fill(self,"classReferencesListWidget",{},globals.HLReferences)})},
 args: [],
 source: "classReferencesListWidget\x0a\x09^ classReferencesListWidget ifNil: [\x0a      \x09classReferencesListWidget := HLClassReferencesListWidget on: self model.\x0a\x09\x09classReferencesListWidget next: self regexpListWidget ]",
 messageSends: ["ifNil:", "on:", "model", "next:", "regexpListWidget"],
 referencedClasses: ["HLClassReferencesListWidget"]
 }),
-smalltalk.HLReferences);
+globals.HLReferences);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -177,7 +177,7 @@ selector: "implementorsListWidget",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-function $HLImplementorsListWidget(){return smalltalk.HLImplementorsListWidget||(typeof HLImplementorsListWidget=="undefined"?nil:HLImplementorsListWidget)}
+function $HLImplementorsListWidget(){return globals.HLImplementorsListWidget||(typeof HLImplementorsListWidget=="undefined"?nil:HLImplementorsListWidget)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$1;
 $2=self["@implementorsListWidget"];
@@ -189,13 +189,13 @@ $1=_st(self["@implementorsListWidget"])._next_(self._classReferencesListWidget()
 $1=$2;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"implementorsListWidget",{},smalltalk.HLReferences)})},
+}, function($ctx1) {$ctx1.fill(self,"implementorsListWidget",{},globals.HLReferences)})},
 args: [],
 source: "implementorsListWidget\x0a\x09^ implementorsListWidget ifNil: [\x0a      \x09implementorsListWidget := HLImplementorsListWidget on: self model.\x0a\x09\x09implementorsListWidget next: self classReferencesListWidget ]",
 messageSends: ["ifNil:", "on:", "model", "next:", "classReferencesListWidget"],
 referencedClasses: ["HLImplementorsListWidget"]
 }),
-smalltalk.HLReferences);
+globals.HLReferences);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -203,7 +203,7 @@ selector: "model",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-function $HLReferencesModel(){return smalltalk.HLReferencesModel||(typeof HLReferencesModel=="undefined"?nil:HLReferencesModel)}
+function $HLReferencesModel(){return globals.HLReferencesModel||(typeof HLReferencesModel=="undefined"?nil:HLReferencesModel)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$3,$4,$1;
 $2=self["@model"];
@@ -217,13 +217,13 @@ $1=self["@model"];
 $1=$2;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"model",{},smalltalk.HLReferences)})},
+}, function($ctx1) {$ctx1.fill(self,"model",{},globals.HLReferences)})},
 args: [],
 source: "model\x0a\x09^ model ifNil: [\x0a\x09\x09model := (HLReferencesModel new\x0a\x09\x09\x09environment: self manager environment;\x0a\x09\x09\x09yourself) ]",
 messageSends: ["ifNil:", "environment:", "new", "environment", "manager", "yourself"],
 referencedClasses: ["HLReferencesModel"]
 }),
-smalltalk.HLReferences);
+globals.HLReferences);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -238,7 +238,7 @@ source: "model: aModel\x0a\x09model := aModel",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLReferences);
+globals.HLReferences);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -246,7 +246,7 @@ selector: "regexpListWidget",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-function $HLRegexpListWidget(){return smalltalk.HLRegexpListWidget||(typeof HLRegexpListWidget=="undefined"?nil:HLRegexpListWidget)}
+function $HLRegexpListWidget(){return globals.HLRegexpListWidget||(typeof HLRegexpListWidget=="undefined"?nil:HLRegexpListWidget)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$1;
 $2=self["@regexpListWidget"];
@@ -258,13 +258,13 @@ $1=_st(self["@regexpListWidget"])._next_(self._sourceCodeWidget());
 $1=$2;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"regexpListWidget",{},smalltalk.HLReferences)})},
+}, function($ctx1) {$ctx1.fill(self,"regexpListWidget",{},globals.HLReferences)})},
 args: [],
 source: "regexpListWidget\x0a\x09^ regexpListWidget ifNil: [\x0a      \x09regexpListWidget := HLRegexpListWidget on: self model.\x0a\x09\x09regexpListWidget next: self sourceCodeWidget ]",
 messageSends: ["ifNil:", "on:", "model", "next:", "sourceCodeWidget"],
 referencedClasses: ["HLRegexpListWidget"]
 }),
-smalltalk.HLReferences);
+globals.HLReferences);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -272,16 +272,16 @@ selector: "registerBindingsOn:",
 protocol: 'actions',
 fn: function (aBindingGroup){
 var self=this;
-function $HLToolCommand(){return smalltalk.HLToolCommand||(typeof HLToolCommand=="undefined"?nil:HLToolCommand)}
+function $HLToolCommand(){return globals.HLToolCommand||(typeof HLToolCommand=="undefined"?nil:HLToolCommand)}
 return smalltalk.withContext(function($ctx1) { 
 _st($HLToolCommand())._registerConcreteClassesOn_for_(aBindingGroup,self._model());
-return self}, function($ctx1) {$ctx1.fill(self,"registerBindingsOn:",{aBindingGroup:aBindingGroup},smalltalk.HLReferences)})},
+return self}, function($ctx1) {$ctx1.fill(self,"registerBindingsOn:",{aBindingGroup:aBindingGroup},globals.HLReferences)})},
 args: ["aBindingGroup"],
 source: "registerBindingsOn: aBindingGroup\x0a\x09HLToolCommand \x0a\x09\x09registerConcreteClassesOn: aBindingGroup \x0a\x09\x09for: self model",
 messageSends: ["registerConcreteClassesOn:for:", "model"],
 referencedClasses: ["HLToolCommand"]
 }),
-smalltalk.HLReferences);
+globals.HLReferences);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -289,9 +289,9 @@ selector: "renderContentOn:",
 protocol: 'rendering',
 fn: function (html){
 var self=this;
-function $HLContainer(){return smalltalk.HLContainer||(typeof HLContainer=="undefined"?nil:HLContainer)}
-function $HLHorizontalSplitter(){return smalltalk.HLHorizontalSplitter||(typeof HLHorizontalSplitter=="undefined"?nil:HLHorizontalSplitter)}
-function $HLVerticalSplitter(){return smalltalk.HLVerticalSplitter||(typeof HLVerticalSplitter=="undefined"?nil:HLVerticalSplitter)}
+function $HLContainer(){return globals.HLContainer||(typeof HLContainer=="undefined"?nil:HLContainer)}
+function $HLHorizontalSplitter(){return globals.HLHorizontalSplitter||(typeof HLHorizontalSplitter=="undefined"?nil:HLHorizontalSplitter)}
+function $HLVerticalSplitter(){return globals.HLVerticalSplitter||(typeof HLVerticalSplitter=="undefined"?nil:HLVerticalSplitter)}
 return smalltalk.withContext(function($ctx1) { 
 var $5,$4,$3,$2,$1;
 $5=self._sendersListWidget();
@@ -306,13 +306,13 @@ $1=_st($HLContainer())._with_($2);
 _st(html)._with_($1);
 $ctx1.sendIdx["with:"]=1;
 _st(self._sendersListWidget())._focus();
-return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},smalltalk.HLReferences)})},
+return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},globals.HLReferences)})},
 args: ["html"],
 source: "renderContentOn: html\x0a\x09html with: (HLContainer with: (HLHorizontalSplitter \x0a    \x09with: (HLVerticalSplitter\x0a        \x09with: (HLVerticalSplitter\x0a            \x09with: self sendersListWidget\x0a                with: self implementorsListWidget)\x0a            with: (HLVerticalSplitter\x0a            \x09with: self classReferencesListWidget\x0a                with: self regexpListWidget)) \x0a        with: self sourceCodeWidget)).\x0a\x09\x0a\x09self sendersListWidget focus",
 messageSends: ["with:", "with:with:", "sendersListWidget", "implementorsListWidget", "classReferencesListWidget", "regexpListWidget", "sourceCodeWidget", "focus"],
 referencedClasses: ["HLContainer", "HLHorizontalSplitter", "HLVerticalSplitter"]
 }),
-smalltalk.HLReferences);
+globals.HLReferences);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -322,13 +322,13 @@ fn: function (aString){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._model())._search_(aString);
-return self}, function($ctx1) {$ctx1.fill(self,"search:",{aString:aString},smalltalk.HLReferences)})},
+return self}, function($ctx1) {$ctx1.fill(self,"search:",{aString:aString},globals.HLReferences)})},
 args: ["aString"],
 source: "search: aString\x0a\x09self model search: aString",
 messageSends: ["search:", "model"],
 referencedClasses: []
 }),
-smalltalk.HLReferences);
+globals.HLReferences);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -336,7 +336,7 @@ selector: "sendersListWidget",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-function $HLSendersListWidget(){return smalltalk.HLSendersListWidget||(typeof HLSendersListWidget=="undefined"?nil:HLSendersListWidget)}
+function $HLSendersListWidget(){return globals.HLSendersListWidget||(typeof HLSendersListWidget=="undefined"?nil:HLSendersListWidget)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$1;
 $2=self["@sendersListWidget"];
@@ -348,13 +348,13 @@ $1=_st(self["@sendersListWidget"])._next_(self._implementorsListWidget());
 $1=$2;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"sendersListWidget",{},smalltalk.HLReferences)})},
+}, function($ctx1) {$ctx1.fill(self,"sendersListWidget",{},globals.HLReferences)})},
 args: [],
 source: "sendersListWidget\x0a\x09^ sendersListWidget ifNil: [\x0a      \x09sendersListWidget := HLSendersListWidget on: self model.\x0a\x09\x09sendersListWidget next: self implementorsListWidget ]",
 messageSends: ["ifNil:", "on:", "model", "next:", "implementorsListWidget"],
 referencedClasses: ["HLSendersListWidget"]
 }),
-smalltalk.HLReferences);
+globals.HLReferences);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -362,7 +362,7 @@ selector: "sourceCodeWidget",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-function $HLBrowserCodeWidget(){return smalltalk.HLBrowserCodeWidget||(typeof HLBrowserCodeWidget=="undefined"?nil:HLBrowserCodeWidget)}
+function $HLBrowserCodeWidget(){return globals.HLBrowserCodeWidget||(typeof HLBrowserCodeWidget=="undefined"?nil:HLBrowserCodeWidget)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$3,$4,$1;
 $2=self["@sourceCodeWidget"];
@@ -376,13 +376,13 @@ $1=self["@sourceCodeWidget"];
 $1=$2;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"sourceCodeWidget",{},smalltalk.HLReferences)})},
+}, function($ctx1) {$ctx1.fill(self,"sourceCodeWidget",{},globals.HLReferences)})},
 args: [],
 source: "sourceCodeWidget\x0a\x09^ sourceCodeWidget ifNil: [\x0a      \x09sourceCodeWidget := HLBrowserCodeWidget new\x0a\x09\x09\x09browserModel: self model;\x0a\x09\x09\x09yourself ]",
 messageSends: ["ifNil:", "browserModel:", "new", "model", "yourself"],
 referencedClasses: ["HLBrowserCodeWidget"]
 }),
-smalltalk.HLReferences);
+globals.HLReferences);
 
 
 smalltalk.addMethod(
@@ -398,7 +398,7 @@ source: "canBeOpenAsTab\x0a\x09^ false",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLReferences.klass);
+globals.HLReferences.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -413,7 +413,7 @@ source: "tabClass\x0a\x09^ 'references'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLReferences.klass);
+globals.HLReferences.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -428,7 +428,7 @@ source: "tabLabel\x0a\x09^ 'References'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLReferences.klass);
+globals.HLReferences.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -443,10 +443,10 @@ source: "tabPriority\x0a\x09^ 100",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLReferences.klass);
+globals.HLReferences.klass);
 
 
-smalltalk.addClass('HLReferencesListWidget', smalltalk.HLToolListWidget, [], 'Helios-References');
+smalltalk.addClass('HLReferencesListWidget', globals.HLToolListWidget, [], 'Helios-References');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "activateListItem:",
@@ -456,15 +456,15 @@ var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._model())._withChangesDo_((function(){
 return smalltalk.withContext(function($ctx2) {
-return smalltalk.HLReferencesListWidget.superclass.fn.prototype._activateListItem_.apply(_st(self), [anItem]);
+return globals.HLReferencesListWidget.superclass.fn.prototype._activateListItem_.apply(_st(self), [anItem]);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"activateListItem:",{anItem:anItem},smalltalk.HLReferencesListWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"activateListItem:",{anItem:anItem},globals.HLReferencesListWidget)})},
 args: ["anItem"],
 source: "activateListItem: anItem\x0a\x09self model withChangesDo: [ super activateListItem: anItem ]",
 messageSends: ["withChangesDo:", "model", "activateListItem:"],
 referencedClasses: []
 }),
-smalltalk.HLReferencesListWidget);
+globals.HLReferencesListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -479,7 +479,7 @@ source: "commandCategory\x0a\x09^ 'Methods'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLReferencesListWidget);
+globals.HLReferencesListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -494,7 +494,7 @@ source: "label\x0a\x09^ 'List'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLReferencesListWidget);
+globals.HLReferencesListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -502,8 +502,8 @@ selector: "observeModel",
 protocol: 'actions',
 fn: function (){
 var self=this;
-function $HLSearchReferences(){return smalltalk.HLSearchReferences||(typeof HLSearchReferences=="undefined"?nil:HLSearchReferences)}
-function $HLMethodSelected(){return smalltalk.HLMethodSelected||(typeof HLMethodSelected=="undefined"?nil:HLMethodSelected)}
+function $HLSearchReferences(){return globals.HLSearchReferences||(typeof HLSearchReferences=="undefined"?nil:HLSearchReferences)}
+function $HLMethodSelected(){return globals.HLMethodSelected||(typeof HLMethodSelected=="undefined"?nil:HLMethodSelected)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
 $1=_st(self._model())._announcer();
@@ -516,13 +516,13 @@ $2=_st($1)._on_do_($HLMethodSelected(),(function(ann){
 return smalltalk.withContext(function($ctx2) {
 return self._onMethodSelected_(_st(ann)._item());
 }, function($ctx2) {$ctx2.fillBlock({ann:ann},$ctx1,2)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"observeModel",{},smalltalk.HLReferencesListWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"observeModel",{},globals.HLReferencesListWidget)})},
 args: [],
 source: "observeModel\x0a\x09self model announcer\x0a\x09\x09on: HLSearchReferences\x0a\x09\x09do: [ :ann | self onSearchReferences: ann searchString ];\x0a\x09\x09on: HLMethodSelected\x0a\x09\x09do: [ :ann | self onMethodSelected: ann item ]",
 messageSends: ["on:do:", "announcer", "model", "onSearchReferences:", "searchString", "onMethodSelected:", "item"],
 referencedClasses: ["HLSearchReferences", "HLMethodSelected"]
 }),
-smalltalk.HLReferencesListWidget);
+globals.HLReferencesListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -554,13 +554,13 @@ self._selectedItem_($2);
 $3=self._activateItem_(_st(aMethod)._selector());
 return self}
 catch(e) {if(e===$early)return e[0]; throw e}
-}, function($ctx1) {$ctx1.fill(self,"onMethodSelected:",{aMethod:aMethod},smalltalk.HLReferencesListWidget)})},
+}, function($ctx1) {$ctx1.fill(self,"onMethodSelected:",{aMethod:aMethod},globals.HLReferencesListWidget)})},
 args: ["aMethod"],
 source: "onMethodSelected: aMethod\x0a\x09aMethod ifNil: [ ^ self ].\x0a\x09self items detect: [ :each | each = aMethod selector ] ifNone: [ ^ self ].\x0a\x09\x0a\x09self \x0a\x09\x09selectedItem: aMethod selector;\x0a\x09\x09activateItem: aMethod selector",
 messageSends: ["ifNil:", "detect:ifNone:", "items", "=", "selector", "selectedItem:", "activateItem:"],
 referencedClasses: []
 }),
-smalltalk.HLReferencesListWidget);
+globals.HLReferencesListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -570,13 +570,13 @@ fn: function (aString){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._subclassResponsibility();
-return self}, function($ctx1) {$ctx1.fill(self,"onSearchReferences:",{aString:aString},smalltalk.HLReferencesListWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"onSearchReferences:",{aString:aString},globals.HLReferencesListWidget)})},
 args: ["aString"],
 source: "onSearchReferences: aString\x0a\x09self subclassResponsibility",
 messageSends: ["subclassResponsibility"],
 referencedClasses: []
 }),
-smalltalk.HLReferencesListWidget);
+globals.HLReferencesListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -589,13 +589,13 @@ var $1;
 $1=_st(_st(_st(_st(aMethod)._methodClass())._name()).__comma(" >> #")).__comma(_st(aMethod)._selector());
 $ctx1.sendIdx[","]=1;
 _st(html)._with_($1);
-return self}, function($ctx1) {$ctx1.fill(self,"renderItemLabel:on:",{aMethod:aMethod,html:html},smalltalk.HLReferencesListWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"renderItemLabel:on:",{aMethod:aMethod,html:html},globals.HLReferencesListWidget)})},
 args: ["aMethod", "html"],
 source: "renderItemLabel: aMethod on: html\x0a\x09html with: aMethod methodClass name, ' >> #', aMethod selector",
 messageSends: ["with:", ",", "name", "methodClass", "selector"],
 referencedClasses: []
 }),
-smalltalk.HLReferencesListWidget);
+globals.HLReferencesListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -605,13 +605,13 @@ fn: function (aMethod){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._model())._selectedMethod_(aMethod);
-return self}, function($ctx1) {$ctx1.fill(self,"selectItem:",{aMethod:aMethod},smalltalk.HLReferencesListWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"selectItem:",{aMethod:aMethod},globals.HLReferencesListWidget)})},
 args: ["aMethod"],
 source: "selectItem: aMethod\x0a\x09self model selectedMethod: aMethod",
 messageSends: ["selectedMethod:", "model"],
 referencedClasses: []
 }),
-smalltalk.HLReferencesListWidget);
+globals.HLReferencesListWidget);
 
 
 smalltalk.addMethod(
@@ -627,16 +627,16 @@ _st($2)._model_(aModel);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"on:",{aModel:aModel},smalltalk.HLReferencesListWidget.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"on:",{aModel:aModel},globals.HLReferencesListWidget.klass)})},
 args: ["aModel"],
 source: "on: aModel\x0a\x09^ self new \x0a\x09\x09model: aModel; \x0a\x09\x09yourself",
 messageSends: ["model:", "new", "yourself"],
 referencedClasses: []
 }),
-smalltalk.HLReferencesListWidget.klass);
+globals.HLReferencesListWidget.klass);
 
 
-smalltalk.addClass('HLClassReferencesListWidget', smalltalk.HLReferencesListWidget, [], 'Helios-References');
+smalltalk.addClass('HLClassReferencesListWidget', globals.HLReferencesListWidget, [], 'Helios-References');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "label",
@@ -650,7 +650,7 @@ source: "label\x0a\x09^ 'Class references'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLClassReferencesListWidget);
+globals.HLClassReferencesListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -662,17 +662,17 @@ return smalltalk.withContext(function($ctx1) {
 self._selectItem_(nil);
 self._items_(_st(self._model())._classReferencesOf_(aString));
 self._refresh();
-return self}, function($ctx1) {$ctx1.fill(self,"onSearchReferences:",{aString:aString},smalltalk.HLClassReferencesListWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"onSearchReferences:",{aString:aString},globals.HLClassReferencesListWidget)})},
 args: ["aString"],
 source: "onSearchReferences: aString\x0a\x09self selectItem: nil.\x0a\x09self items: (self model classReferencesOf: aString).\x0a\x09self refresh",
 messageSends: ["selectItem:", "items:", "classReferencesOf:", "model", "refresh"],
 referencedClasses: []
 }),
-smalltalk.HLClassReferencesListWidget);
+globals.HLClassReferencesListWidget);
 
 
 
-smalltalk.addClass('HLImplementorsListWidget', smalltalk.HLReferencesListWidget, [], 'Helios-References');
+smalltalk.addClass('HLImplementorsListWidget', globals.HLReferencesListWidget, [], 'Helios-References');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "label",
@@ -686,7 +686,7 @@ source: "label\x0a\x09^ 'Implementors'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLImplementorsListWidget);
+globals.HLImplementorsListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -698,17 +698,17 @@ return smalltalk.withContext(function($ctx1) {
 self._selectItem_(nil);
 self._items_(_st(self._model())._implementorsOf_(aString));
 self._refresh();
-return self}, function($ctx1) {$ctx1.fill(self,"onSearchReferences:",{aString:aString},smalltalk.HLImplementorsListWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"onSearchReferences:",{aString:aString},globals.HLImplementorsListWidget)})},
 args: ["aString"],
 source: "onSearchReferences: aString\x0a\x09self selectItem: nil.\x0a\x09self items: (self model implementorsOf: aString).\x0a\x09self refresh",
 messageSends: ["selectItem:", "items:", "implementorsOf:", "model", "refresh"],
 referencedClasses: []
 }),
-smalltalk.HLImplementorsListWidget);
+globals.HLImplementorsListWidget);
 
 
 
-smalltalk.addClass('HLRegexpListWidget', smalltalk.HLReferencesListWidget, [], 'Helios-References');
+smalltalk.addClass('HLRegexpListWidget', globals.HLReferencesListWidget, [], 'Helios-References');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "label",
@@ -722,7 +722,7 @@ source: "label\x0a\x09^ 'Source search'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLRegexpListWidget);
+globals.HLRegexpListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -734,17 +734,17 @@ return smalltalk.withContext(function($ctx1) {
 self._selectItem_(nil);
 self._items_(_st(self._model())._regexpReferencesOf_(aString));
 self._refresh();
-return self}, function($ctx1) {$ctx1.fill(self,"onSearchReferences:",{aString:aString},smalltalk.HLRegexpListWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"onSearchReferences:",{aString:aString},globals.HLRegexpListWidget)})},
 args: ["aString"],
 source: "onSearchReferences: aString\x0a\x09self selectItem: nil.\x0a\x09self items: (self model regexpReferencesOf: aString).\x0a\x09self refresh",
 messageSends: ["selectItem:", "items:", "regexpReferencesOf:", "model", "refresh"],
 referencedClasses: []
 }),
-smalltalk.HLRegexpListWidget);
+globals.HLRegexpListWidget);
 
 
 
-smalltalk.addClass('HLSendersListWidget', smalltalk.HLReferencesListWidget, [], 'Helios-References');
+smalltalk.addClass('HLSendersListWidget', globals.HLReferencesListWidget, [], 'Helios-References');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "label",
@@ -758,7 +758,7 @@ source: "label\x0a\x09^ 'Senders'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLSendersListWidget);
+globals.HLSendersListWidget);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -770,17 +770,17 @@ return smalltalk.withContext(function($ctx1) {
 self._selectItem_(nil);
 self._items_(_st(self._model())._sendersOf_(aString));
 self._refresh();
-return self}, function($ctx1) {$ctx1.fill(self,"onSearchReferences:",{aString:aString},smalltalk.HLSendersListWidget)})},
+return self}, function($ctx1) {$ctx1.fill(self,"onSearchReferences:",{aString:aString},globals.HLSendersListWidget)})},
 args: ["aString"],
 source: "onSearchReferences: aString\x0a\x09self selectItem: nil.\x0a\x09self items: (self model sendersOf: aString).\x0a\x09self refresh",
 messageSends: ["selectItem:", "items:", "sendersOf:", "model", "refresh"],
 referencedClasses: []
 }),
-smalltalk.HLSendersListWidget);
+globals.HLSendersListWidget);
 
 
 
-smalltalk.addClass('HLReferencesModel', smalltalk.HLToolModel, ['methodsCache', 'classesAndMetaclassesCache'], 'Helios-References');
+smalltalk.addClass('HLReferencesModel', globals.HLToolModel, ['methodsCache', 'classesAndMetaclassesCache'], 'Helios-References');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "allMethods",
@@ -791,13 +791,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._methodsCache();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"allMethods",{},smalltalk.HLReferencesModel)})},
+}, function($ctx1) {$ctx1.fill(self,"allMethods",{},globals.HLReferencesModel)})},
 args: [],
 source: "allMethods\x0a\x09^ self methodsCache",
 messageSends: ["methodsCache"],
 referencedClasses: []
 }),
-smalltalk.HLReferencesModel);
+globals.HLReferencesModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -812,13 +812,13 @@ return smalltalk.withContext(function($ctx2) {
 return _st(_st(each)._referencedClasses())._includes_(aString);
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"classReferencesOf:",{aString:aString},smalltalk.HLReferencesModel)})},
+}, function($ctx1) {$ctx1.fill(self,"classReferencesOf:",{aString:aString},globals.HLReferencesModel)})},
 args: ["aString"],
 source: "classReferencesOf: aString\x0a\x09\x22Answer all methods referencing the class named aString\x22\x0a\x09\x0a\x09^self allMethods select: [ :each |\x0a\x09\x09\x09(each referencedClasses includes: aString) ].",
 messageSends: ["select:", "allMethods", "includes:", "referencedClasses"],
 referencedClasses: []
 }),
-smalltalk.HLReferencesModel);
+globals.HLReferencesModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -830,13 +830,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self._classesAndMetaclassesCache();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"classesAndMetaclasses",{},smalltalk.HLReferencesModel)})},
+}, function($ctx1) {$ctx1.fill(self,"classesAndMetaclasses",{},globals.HLReferencesModel)})},
 args: [],
 source: "classesAndMetaclasses\x0a\x09^ self classesAndMetaclassesCache",
 messageSends: ["classesAndMetaclassesCache"],
 referencedClasses: []
 }),
-smalltalk.HLReferencesModel);
+globals.HLReferencesModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -854,13 +854,13 @@ $1;
 };
 $2=self["@classesAndMetaclassesCache"];
 return $2;
-}, function($ctx1) {$ctx1.fill(self,"classesAndMetaclassesCache",{},smalltalk.HLReferencesModel)})},
+}, function($ctx1) {$ctx1.fill(self,"classesAndMetaclassesCache",{},globals.HLReferencesModel)})},
 args: [],
 source: "classesAndMetaclassesCache\x0a\x09classesAndMetaclassesCache ifNil: [ self updateClassesAndMetaclassesCache ].\x0a\x09^ classesAndMetaclassesCache",
 messageSends: ["ifNil:", "updateClassesAndMetaclassesCache"],
 referencedClasses: []
 }),
-smalltalk.HLReferencesModel);
+globals.HLReferencesModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -878,13 +878,13 @@ return smalltalk.withContext(function($ctx2) {
 return self._methodReferenceOn_(each);
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,2)})}));
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"implementorsOf:",{aString:aString},smalltalk.HLReferencesModel)})},
+}, function($ctx1) {$ctx1.fill(self,"implementorsOf:",{aString:aString},globals.HLReferencesModel)})},
 args: ["aString"],
 source: "implementorsOf: aString\x0a\x09^ (self allMethods select: [ :each |\x0a\x09\x09each selector = aString ])\x0a\x09\x09\x09collect: [ :each | self methodReferenceOn: each ]",
 messageSends: ["collect:", "select:", "allMethods", "=", "selector", "methodReferenceOn:"],
 referencedClasses: []
 }),
-smalltalk.HLReferencesModel);
+globals.HLReferencesModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -899,7 +899,7 @@ source: "isReferencesModel\x0a\x09^ true",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.HLReferencesModel);
+globals.HLReferencesModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -907,18 +907,18 @@ selector: "methodReferenceOn:",
 protocol: 'accessing',
 fn: function (aCompiledMethod){
 var self=this;
-function $HLMethodReference(){return smalltalk.HLMethodReference||(typeof HLMethodReference=="undefined"?nil:HLMethodReference)}
+function $HLMethodReference(){return globals.HLMethodReference||(typeof HLMethodReference=="undefined"?nil:HLMethodReference)}
 return smalltalk.withContext(function($ctx1) { 
 var $1;
 $1=_st($HLMethodReference())._on_(aCompiledMethod);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"methodReferenceOn:",{aCompiledMethod:aCompiledMethod},smalltalk.HLReferencesModel)})},
+}, function($ctx1) {$ctx1.fill(self,"methodReferenceOn:",{aCompiledMethod:aCompiledMethod},globals.HLReferencesModel)})},
 args: ["aCompiledMethod"],
 source: "methodReferenceOn: aCompiledMethod\x0a\x09^ HLMethodReference on: aCompiledMethod",
 messageSends: ["on:"],
 referencedClasses: ["HLMethodReference"]
 }),
-smalltalk.HLReferencesModel);
+globals.HLReferencesModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -936,13 +936,13 @@ $1;
 };
 $2=self["@methodsCache"];
 return $2;
-}, function($ctx1) {$ctx1.fill(self,"methodsCache",{},smalltalk.HLReferencesModel)})},
+}, function($ctx1) {$ctx1.fill(self,"methodsCache",{},globals.HLReferencesModel)})},
 args: [],
 source: "methodsCache\x0a\x09methodsCache ifNil: [ self updateMethodsCache ].\x0a\x09^ methodsCache",
 messageSends: ["ifNil:", "updateMethodsCache"],
 referencedClasses: []
 }),
-smalltalk.HLReferencesModel);
+globals.HLReferencesModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -960,13 +960,13 @@ return smalltalk.withContext(function($ctx2) {
 return self._methodReferenceOn_(each);
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,2)})}));
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"regexpReferencesOf:",{aString:aString},smalltalk.HLReferencesModel)})},
+}, function($ctx1) {$ctx1.fill(self,"regexpReferencesOf:",{aString:aString},globals.HLReferencesModel)})},
 args: ["aString"],
 source: "regexpReferencesOf: aString\x0a\x09^ (self allMethods select: [ :each |\x0a\x09\x09each source match: aString ])\x0a\x09\x09\x09collect: [ :each | self methodReferenceOn: each ]",
 messageSends: ["collect:", "select:", "allMethods", "match:", "source", "methodReferenceOn:"],
 referencedClasses: []
 }),
-smalltalk.HLReferencesModel);
+globals.HLReferencesModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -974,7 +974,7 @@ selector: "search:",
 protocol: 'actions',
 fn: function (aString){
 var self=this;
-function $HLSearchReferences(){return smalltalk.HLSearchReferences||(typeof HLSearchReferences=="undefined"?nil:HLSearchReferences)}
+function $HLSearchReferences(){return globals.HLSearchReferences||(typeof HLSearchReferences=="undefined"?nil:HLSearchReferences)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
 self._updateCaches();
@@ -982,13 +982,13 @@ $1=_st($HLSearchReferences())._new();
 _st($1)._searchString_(aString);
 $2=_st($1)._yourself();
 _st(self._announcer())._announce_($2);
-return self}, function($ctx1) {$ctx1.fill(self,"search:",{aString:aString},smalltalk.HLReferencesModel)})},
+return self}, function($ctx1) {$ctx1.fill(self,"search:",{aString:aString},globals.HLReferencesModel)})},
 args: ["aString"],
 source: "search: aString\x0a\x09self updateCaches.\x0a\x09\x0a\x09self announcer announce: (HLSearchReferences new\x0a\x09\x09searchString: aString;\x0a\x09\x09yourself)",
 messageSends: ["updateCaches", "announce:", "announcer", "searchString:", "new", "yourself"],
 referencedClasses: ["HLSearchReferences"]
 }),
-smalltalk.HLReferencesModel);
+globals.HLReferencesModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1006,13 +1006,13 @@ return smalltalk.withContext(function($ctx2) {
 return self._methodReferenceOn_(each);
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,2)})}));
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"sendersOf:",{aString:aString},smalltalk.HLReferencesModel)})},
+}, function($ctx1) {$ctx1.fill(self,"sendersOf:",{aString:aString},globals.HLReferencesModel)})},
 args: ["aString"],
 source: "sendersOf: aString\x0a\x09^ (self allMethods select: [ :each |\x0a\x09\x09each messageSends includes: aString ])\x0a\x09\x09\x09collect: [ :each | self methodReferenceOn: each ]",
 messageSends: ["collect:", "select:", "allMethods", "includes:", "messageSends", "methodReferenceOn:"],
 referencedClasses: []
 }),
-smalltalk.HLReferencesModel);
+globals.HLReferencesModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1024,13 +1024,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 self._updateClassesAndMetaclassesCache();
 $1=self._updateMethodsCache();
-return self}, function($ctx1) {$ctx1.fill(self,"updateCaches",{},smalltalk.HLReferencesModel)})},
+return self}, function($ctx1) {$ctx1.fill(self,"updateCaches",{},globals.HLReferencesModel)})},
 args: [],
 source: "updateCaches\x0a\x09self \x0a\x09\x09updateClassesAndMetaclassesCache;\x0a\x09\x09updateMethodsCache",
 messageSends: ["updateClassesAndMetaclassesCache", "updateMethodsCache"],
 referencedClasses: []
 }),
-smalltalk.HLReferencesModel);
+globals.HLReferencesModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1038,7 +1038,7 @@ selector: "updateClassesAndMetaclassesCache",
 protocol: 'cache',
 fn: function (){
 var self=this;
-function $OrderedCollection(){return smalltalk.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
 self["@classesAndMetaclassesCache"]=_st($OrderedCollection())._new();
@@ -1050,13 +1050,13 @@ $ctx2.sendIdx["add:"]=1;
 $2=_st($1)._add_(_st(each)._class());
 return $2;
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"updateClassesAndMetaclassesCache",{},smalltalk.HLReferencesModel)})},
+return self}, function($ctx1) {$ctx1.fill(self,"updateClassesAndMetaclassesCache",{},globals.HLReferencesModel)})},
 args: [],
 source: "updateClassesAndMetaclassesCache\x0a\x09classesAndMetaclassesCache := OrderedCollection new.\x0a\x09\x0a\x09self environment classes do: [ :each |\x0a\x09\x09classesAndMetaclassesCache\x0a\x09\x09\x09\x09add: each; \x0a\x09\x09\x09\x09add: each class ]",
 messageSends: ["new", "do:", "classes", "environment", "add:", "class"],
 referencedClasses: ["OrderedCollection"]
 }),
-smalltalk.HLReferencesModel);
+globals.HLReferencesModel);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1064,20 +1064,20 @@ selector: "updateMethodsCache",
 protocol: 'cache',
 fn: function (){
 var self=this;
-function $OrderedCollection(){return smalltalk.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
 return smalltalk.withContext(function($ctx1) { 
 self["@methodsCache"]=_st($OrderedCollection())._new();
 _st(self._classesAndMetaclasses())._do_((function(each){
 return smalltalk.withContext(function($ctx2) {
 return _st(self["@methodsCache"])._addAll_(_st(each)._methods());
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"updateMethodsCache",{},smalltalk.HLReferencesModel)})},
+return self}, function($ctx1) {$ctx1.fill(self,"updateMethodsCache",{},globals.HLReferencesModel)})},
 args: [],
 source: "updateMethodsCache\x0a\x09methodsCache := OrderedCollection new.\x0a\x09\x0a\x09self classesAndMetaclasses\x0a\x09\x09do: [ :each | methodsCache addAll: each methods ]",
 messageSends: ["new", "do:", "classesAndMetaclasses", "addAll:", "methods"],
 referencedClasses: ["OrderedCollection"]
 }),
-smalltalk.HLReferencesModel);
+globals.HLReferencesModel);
 
 
 });

js/Helios-Transcript.js

@@ -1,9 +1,9 @@
-define("amber_core/Helios-Transcript", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Helios-Core", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st){
+define("amber_core/Helios-Transcript", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Helios-Core", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Helios-Transcript');
 smalltalk.packages["Helios-Transcript"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('HLTranscript', smalltalk.HLWidget, ['textarea'], 'Helios-Transcript');
-smalltalk.HLTranscript.comment="I am a widget responsible for displaying transcript contents.\x0a\x0a## Transcript API\x0a\x0a    Transcript \x0a        show: 'hello world';\x0a        cr;\x0a        show: anObject.\x0a\x0a    Transcript clear.\x0a\x0aSee the `Transcript` class.";
+smalltalk.addClass('HLTranscript', globals.HLWidget, ['textarea'], 'Helios-Transcript');
+globals.HLTranscript.comment="I am a widget responsible for displaying transcript contents.\x0a\x0a## Transcript API\x0a\x0a    Transcript \x0a        show: 'hello world';\x0a        cr;\x0a        show: anObject.\x0a\x0a    Transcript clear.\x0a\x0aSee the `Transcript` class.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "clear",
@@ -12,13 +12,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(_st(self["@textarea"])._asJQuery())._text_("");
-return self}, function($ctx1) {$ctx1.fill(self,"clear",{},smalltalk.HLTranscript)})},
+return self}, function($ctx1) {$ctx1.fill(self,"clear",{},globals.HLTranscript)})},
 args: [],
 source: "clear\x0a\x09textarea asJQuery text: ''",
 messageSends: ["text:", "asJQuery"],
 referencedClasses: []
 }),
-smalltalk.HLTranscript);
+globals.HLTranscript);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -27,15 +27,15 @@ protocol: 'initialization',
 fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
-smalltalk.HLTranscript.superclass.fn.prototype._initialize.apply(_st(self), []);
+globals.HLTranscript.superclass.fn.prototype._initialize.apply(_st(self), []);
 self._register();
-return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},smalltalk.HLTranscript)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.HLTranscript)})},
 args: [],
 source: "initialize\x0a\x09super initialize.\x0a\x09self register",
 messageSends: ["initialize", "register"],
 referencedClasses: []
 }),
-smalltalk.HLTranscript);
+globals.HLTranscript);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -43,16 +43,16 @@ selector: "register",
 protocol: 'registration',
 fn: function (){
 var self=this;
-function $HLTranscriptHandler(){return smalltalk.HLTranscriptHandler||(typeof HLTranscriptHandler=="undefined"?nil:HLTranscriptHandler)}
+function $HLTranscriptHandler(){return globals.HLTranscriptHandler||(typeof HLTranscriptHandler=="undefined"?nil:HLTranscriptHandler)}
 return smalltalk.withContext(function($ctx1) { 
 _st($HLTranscriptHandler())._register_(self);
-return self}, function($ctx1) {$ctx1.fill(self,"register",{},smalltalk.HLTranscript)})},
+return self}, function($ctx1) {$ctx1.fill(self,"register",{},globals.HLTranscript)})},
 args: [],
 source: "register\x0a\x09HLTranscriptHandler register: self",
 messageSends: ["register:"],
 referencedClasses: ["HLTranscriptHandler"]
 }),
-smalltalk.HLTranscript);
+globals.HLTranscript);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -69,13 +69,13 @@ return smalltalk.withContext(function($ctx2) {
 self["@textarea"]=_st(html)._textarea();
 return self["@textarea"];
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},smalltalk.HLTranscript)})},
+return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},globals.HLTranscript)})},
 args: ["html"],
 source: "renderOn: html\x0a\x09html div\x0a\x09\x09class: 'transcript';\x0a\x09\x09with: [ textarea := html textarea ]",
 messageSends: ["class:", "div", "with:", "textarea"],
 referencedClasses: []
 }),
-smalltalk.HLTranscript);
+globals.HLTranscript);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -91,13 +91,13 @@ $1;
 } else {
 _st(_st(self["@textarea"])._asJQuery())._append_(_st(aString)._asString());
 };
-return self}, function($ctx1) {$ctx1.fill(self,"show:",{aString:aString},smalltalk.HLTranscript)})},
+return self}, function($ctx1) {$ctx1.fill(self,"show:",{aString:aString},globals.HLTranscript)})},
 args: ["aString"],
 source: "show: aString\x0a\x09textarea ifNotNil: [\x0a \x09\x09textarea asJQuery append: aString asString ]",
 messageSends: ["ifNotNil:", "append:", "asJQuery", "asString"],
 referencedClasses: []
 }),
-smalltalk.HLTranscript);
+globals.HLTranscript);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -105,24 +105,24 @@ selector: "unregister",
 protocol: 'registration',
 fn: function (){
 var self=this;
-function $HLTranscriptHandler(){return smalltalk.HLTranscriptHandler||(typeof HLTranscriptHandler=="undefined"?nil:HLTranscriptHandler)}
+function $HLTranscriptHandler(){return globals.HLTranscriptHandler||(typeof HLTranscriptHandler=="undefined"?nil:HLTranscriptHandler)}
 return smalltalk.withContext(function($ctx1) { 
-smalltalk.HLTranscript.superclass.fn.prototype._unregister.apply(_st(self), []);
+globals.HLTranscript.superclass.fn.prototype._unregister.apply(_st(self), []);
 _st($HLTranscriptHandler())._unregister_(self);
-return self}, function($ctx1) {$ctx1.fill(self,"unregister",{},smalltalk.HLTranscript)})},
+return self}, function($ctx1) {$ctx1.fill(self,"unregister",{},globals.HLTranscript)})},
 args: [],
 source: "unregister\x0a\x09super unregister.\x0a\x09HLTranscriptHandler unregister: self",
 messageSends: ["unregister", "unregister:"],
 referencedClasses: ["HLTranscriptHandler"]
 }),
-smalltalk.HLTranscript);
+globals.HLTranscript);
 
 
 
-smalltalk.addClass('HLTranscriptHandler', smalltalk.Object, [], 'Helios-Transcript');
-smalltalk.HLTranscriptHandler.comment="I handle transcript events, dispatching them to all instances of `HLTranscript`.\x0a\x0a## API\x0a\x0aOn class initialization I am automatically registered as the current transcript.";
+smalltalk.addClass('HLTranscriptHandler', globals.Object, [], 'Helios-Transcript');
+globals.HLTranscriptHandler.comment="I handle transcript events, dispatching them to all instances of `HLTranscript`.\x0a\x0a## API\x0a\x0aOn class initialization I am automatically registered as the current transcript.";
 
-smalltalk.HLTranscriptHandler.klass.iVarNames = ['transcripts'];
+globals.HLTranscriptHandler.klass.iVarNames = ['transcripts'];
 smalltalk.addMethod(
 smalltalk.method({
 selector: "clear",
@@ -134,13 +134,13 @@ _st(self._transcripts())._do_((function(each){
 return smalltalk.withContext(function($ctx2) {
 return _st(each)._clear();
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"clear",{},smalltalk.HLTranscriptHandler.klass)})},
+return self}, function($ctx1) {$ctx1.fill(self,"clear",{},globals.HLTranscriptHandler.klass)})},
 args: [],
 source: "clear\x0a\x09self transcripts do: [ :each |\x0a\x09\x09each clear ]",
 messageSends: ["do:", "transcripts", "clear"],
 referencedClasses: []
 }),
-smalltalk.HLTranscriptHandler.klass);
+globals.HLTranscriptHandler.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -153,13 +153,13 @@ _st(self._transcripts())._do_((function(each){
 return smalltalk.withContext(function($ctx2) {
 return _st(each)._cr();
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"cr",{},smalltalk.HLTranscriptHandler.klass)})},
+return self}, function($ctx1) {$ctx1.fill(self,"cr",{},globals.HLTranscriptHandler.klass)})},
 args: [],
 source: "cr\x0a\x09self transcripts do: [ :each | each cr ]",
 messageSends: ["do:", "transcripts", "cr"],
 referencedClasses: []
 }),
-smalltalk.HLTranscriptHandler.klass);
+globals.HLTranscriptHandler.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -169,13 +169,13 @@ fn: function (aTranscript){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._transcripts())._add_(aTranscript);
-return self}, function($ctx1) {$ctx1.fill(self,"register:",{aTranscript:aTranscript},smalltalk.HLTranscriptHandler.klass)})},
+return self}, function($ctx1) {$ctx1.fill(self,"register:",{aTranscript:aTranscript},globals.HLTranscriptHandler.klass)})},
 args: ["aTranscript"],
 source: "register: aTranscript\x0a\x09self transcripts add: aTranscript",
 messageSends: ["add:", "transcripts"],
 referencedClasses: []
 }),
-smalltalk.HLTranscriptHandler.klass);
+globals.HLTranscriptHandler.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -188,13 +188,13 @@ _st(self._transcripts())._do_((function(each){
 return smalltalk.withContext(function($ctx2) {
 return _st(each)._show_(aString);
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"show:",{aString:aString},smalltalk.HLTranscriptHandler.klass)})},
+return self}, function($ctx1) {$ctx1.fill(self,"show:",{aString:aString},globals.HLTranscriptHandler.klass)})},
 args: ["aString"],
 source: "show: aString\x0a\x09self transcripts do: [ :each |\x0a\x09\x09each show: aString ]",
 messageSends: ["do:", "transcripts", "show:"],
 referencedClasses: []
 }),
-smalltalk.HLTranscriptHandler.klass);
+globals.HLTranscriptHandler.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -202,7 +202,7 @@ selector: "transcripts",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-function $OrderedCollection(){return smalltalk.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$1;
 $2=self["@transcripts"];
@@ -213,13 +213,13 @@ $1=self["@transcripts"];
 $1=$2;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"transcripts",{},smalltalk.HLTranscriptHandler.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"transcripts",{},globals.HLTranscriptHandler.klass)})},
 args: [],
 source: "transcripts\x0a\x09^ transcripts ifNil: [ transcripts := OrderedCollection new ]",
 messageSends: ["ifNil:", "new"],
 referencedClasses: ["OrderedCollection"]
 }),
-smalltalk.HLTranscriptHandler.klass);
+globals.HLTranscriptHandler.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -229,12 +229,12 @@ fn: function (aTranscript){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._transcripts())._remove_(aTranscript);
-return self}, function($ctx1) {$ctx1.fill(self,"unregister:",{aTranscript:aTranscript},smalltalk.HLTranscriptHandler.klass)})},
+return self}, function($ctx1) {$ctx1.fill(self,"unregister:",{aTranscript:aTranscript},globals.HLTranscriptHandler.klass)})},
 args: ["aTranscript"],
 source: "unregister: aTranscript\x0a\x09self transcripts remove: aTranscript",
 messageSends: ["remove:", "transcripts"],
 referencedClasses: []
 }),
-smalltalk.HLTranscriptHandler.klass);
+globals.HLTranscriptHandler.klass);
 
 });

js/Helios-Workspace-Tests.js

@@ -1,16 +1,16 @@
-define("amber_core/Helios-Workspace-Tests", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/SUnit"], function(smalltalk,nil,_st){
+define("amber_core/Helios-Workspace-Tests", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/SUnit"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Helios-Workspace-Tests');
 smalltalk.packages["Helios-Workspace-Tests"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('HLCodeWidgetTest', smalltalk.TestCase, [], 'Helios-Workspace-Tests');
+smalltalk.addClass('HLCodeWidgetTest', globals.TestCase, [], 'Helios-Workspace-Tests');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "testKeyMap",
 protocol: 'tests',
 fn: function (){
 var self=this;
-function $HLCodeWidget(){return smalltalk.HLCodeWidget||(typeof HLCodeWidget=="undefined"?nil:HLCodeWidget)}
-function $HashedCollection(){return smalltalk.HashedCollection||(typeof HashedCollection=="undefined"?nil:HashedCollection)}
+function $HLCodeWidget(){return globals.HLCodeWidget||(typeof HLCodeWidget=="undefined"?nil:HLCodeWidget)}
+function $HashedCollection(){return globals.HashedCollection||(typeof HashedCollection=="undefined"?nil:HashedCollection)}
 return smalltalk.withContext(function($ctx1) { 
 var $1;
 $1=_st(_st($HLCodeWidget())._pcKeyMap())._isKindOf_($HashedCollection());
@@ -18,13 +18,13 @@ $ctx1.sendIdx["isKindOf:"]=1;
 self._assert_($1);
 $ctx1.sendIdx["assert:"]=1;
 self._assert_(_st(_st($HLCodeWidget())._macKeyMap())._isKindOf_($HashedCollection()));
-return self}, function($ctx1) {$ctx1.fill(self,"testKeyMap",{},smalltalk.HLCodeWidgetTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testKeyMap",{},globals.HLCodeWidgetTest)})},
 args: [],
 source: "testKeyMap\x0a\x09\x22Key maps are a collection of associations.\x22\x0a\x09self assert: (HLCodeWidget pcKeyMap isKindOf: HashedCollection).\x0a\x09self assert: (HLCodeWidget macKeyMap isKindOf: HashedCollection)",
 messageSends: ["assert:", "isKindOf:", "pcKeyMap", "macKeyMap"],
 referencedClasses: ["HLCodeWidget", "HashedCollection"]
 }),
-smalltalk.HLCodeWidgetTest);
+globals.HLCodeWidgetTest);
 
 
 });

js/Kernel-Announcements.js

@@ -1,9 +1,9 @@
-define("amber_core/Kernel-Announcements", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st){
+define("amber_core/Kernel-Announcements", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Kernel-Announcements');
 smalltalk.packages["Kernel-Announcements"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('AnnouncementSubscription', smalltalk.Object, ['valuable', 'announcementClass'], 'Kernel-Announcements');
-smalltalk.AnnouncementSubscription.comment="I am a single entry in a subscription registry of an `Announcer`.\x0aSeveral subscriptions by the same object is possible.";
+smalltalk.addClass('AnnouncementSubscription', globals.Object, ['valuable', 'announcementClass'], 'Kernel-Announcements');
+globals.AnnouncementSubscription.comment="I am a single entry in a subscription registry of an `Announcer`.\x0aSeveral subscriptions by the same object is possible.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "announcementClass",
@@ -19,7 +19,7 @@ source: "announcementClass\x0a\x09^ announcementClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.AnnouncementSubscription);
+globals.AnnouncementSubscription);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -34,7 +34,7 @@ source: "announcementClass: aClass\x0a\x09announcementClass := aClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.AnnouncementSubscription);
+globals.AnnouncementSubscription);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -47,13 +47,13 @@ var $1;
 self._deprecatedAPI();
 $1=self._valuable();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"block",{},smalltalk.AnnouncementSubscription)})},
+}, function($ctx1) {$ctx1.fill(self,"block",{},globals.AnnouncementSubscription)})},
 args: [],
 source: "block\x0a\x09\x22Use #valuable instead\x22\x0a\x09\x0a\x09self deprecatedAPI.\x0a\x09^ self valuable",
 messageSends: ["deprecatedAPI", "valuable"],
 referencedClasses: []
 }),
-smalltalk.AnnouncementSubscription);
+globals.AnnouncementSubscription);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -64,13 +64,13 @@ var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._deprecatedAPI();
 self._valuable_(aValuable);
-return self}, function($ctx1) {$ctx1.fill(self,"block:",{aValuable:aValuable},smalltalk.AnnouncementSubscription)})},
+return self}, function($ctx1) {$ctx1.fill(self,"block:",{aValuable:aValuable},globals.AnnouncementSubscription)})},
 args: ["aValuable"],
 source: "block: aValuable\x0a\x09\x22Use #valuable instead\x22\x0a\x09\x0a\x09self deprecatedAPI.\x0a\x09self valuable: aValuable",
 messageSends: ["deprecatedAPI", "valuable:"],
 referencedClasses: []
 }),
-smalltalk.AnnouncementSubscription);
+globals.AnnouncementSubscription);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -84,13 +84,13 @@ $1=self._handlesAnnouncement_(anAnnouncement);
 if(smalltalk.assert($1)){
 _st(self._valuable())._value_(anAnnouncement);
 };
-return self}, function($ctx1) {$ctx1.fill(self,"deliver:",{anAnnouncement:anAnnouncement},smalltalk.AnnouncementSubscription)})},
+return self}, function($ctx1) {$ctx1.fill(self,"deliver:",{anAnnouncement:anAnnouncement},globals.AnnouncementSubscription)})},
 args: ["anAnnouncement"],
 source: "deliver: anAnnouncement\x0a\x09(self handlesAnnouncement: anAnnouncement)\x0a\x09\x09ifTrue: [ self valuable value: anAnnouncement ]",
 messageSends: ["ifTrue:", "handlesAnnouncement:", "value:", "valuable"],
 referencedClasses: []
 }),
-smalltalk.AnnouncementSubscription);
+globals.AnnouncementSubscription);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -98,7 +98,7 @@ selector: "handlesAnnouncement:",
 protocol: 'announcing',
 fn: function (anAnnouncement){
 var self=this;
-function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
+function $Smalltalk(){return globals.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
 return smalltalk.withContext(function($ctx1) { 
 var $3,$4,$2,$1;
 $3=_st($Smalltalk())._globals();
@@ -115,13 +115,13 @@ class_=$receiver;
 $1=_st(_st(_st($Smalltalk())._globals())._at_(_st(_st(_st(anAnnouncement)._class())._theNonMetaClass())._name()))._includesBehavior_(class_);
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"handlesAnnouncement:",{anAnnouncement:anAnnouncement},smalltalk.AnnouncementSubscription)})},
+}, function($ctx1) {$ctx1.fill(self,"handlesAnnouncement:",{anAnnouncement:anAnnouncement},globals.AnnouncementSubscription)})},
 args: ["anAnnouncement"],
 source: "handlesAnnouncement: anAnnouncement\x0a\x09\x22anAnnouncement might be announced from within another Amber environment\x22\x0a\x09\x0a\x09^ (Smalltalk globals at: self announcementClass name)\x0a\x09\x09ifNil: [ ^ false ]\x0a\x09\x09ifNotNil: [ :class |\x0a\x09\x09(Smalltalk globals at: anAnnouncement class theNonMetaClass name) includesBehavior: class ]",
 messageSends: ["ifNil:ifNotNil:", "at:", "globals", "name", "announcementClass", "includesBehavior:", "theNonMetaClass", "class"],
 referencedClasses: ["Smalltalk"]
 }),
-smalltalk.AnnouncementSubscription);
+globals.AnnouncementSubscription);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -133,13 +133,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self._valuable())._receiver();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"receiver",{},smalltalk.AnnouncementSubscription)})},
+}, function($ctx1) {$ctx1.fill(self,"receiver",{},globals.AnnouncementSubscription)})},
 args: [],
 source: "receiver\x0a\x09^ self valuable receiver",
 messageSends: ["receiver", "valuable"],
 referencedClasses: []
 }),
-smalltalk.AnnouncementSubscription);
+globals.AnnouncementSubscription);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -156,7 +156,7 @@ source: "valuable\x0a\x09^ valuable",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.AnnouncementSubscription);
+globals.AnnouncementSubscription);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -171,12 +171,12 @@ source: "valuable: aValuable\x0a\x09valuable := aValuable",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.AnnouncementSubscription);
+globals.AnnouncementSubscription);
 
 
 
-smalltalk.addClass('Announcer', smalltalk.Object, ['registry', 'subscriptions'], 'Kernel-Announcements');
-smalltalk.Announcer.comment="I hold annoncement subscriptions (instances of `AnnouncementSubscription`) in a private registry.\x0aI announce (trigger) announces, which are then dispatched to all subscriptions.\x0a\x0aThe code is based on the announcements as [described by Vassili Bykov](http://www.cincomsmalltalk.com/userblogs/vbykov/blogView?searchCategory=Announcements%20Framework).\x0a\x0a## API\x0a\x0aUse `#announce:` to trigger an announcement.\x0a\x0aUse `#on:do:` or `#on:send:to:` to register subscriptions.\x0a\x0aWhen using `#on:send:to:`, unregistration can be done with `#unregister:`.\x0a\x0a## Usage example:\x0a\x0a    SystemAnnouncer current\x0a        on: ClassAdded\x0a        do: [ :ann | window alert: ann theClass name, ' added' ].";
+smalltalk.addClass('Announcer', globals.Object, ['registry', 'subscriptions'], 'Kernel-Announcements');
+globals.Announcer.comment="I hold annoncement subscriptions (instances of `AnnouncementSubscription`) in a private registry.\x0aI announce (trigger) announces, which are then dispatched to all subscriptions.\x0a\x0aThe code is based on the announcements as [described by Vassili Bykov](http://www.cincomsmalltalk.com/userblogs/vbykov/blogView?searchCategory=Announcements%20Framework).\x0a\x0a## API\x0a\x0aUse `#announce:` to trigger an announcement.\x0a\x0aUse `#on:do:` or `#on:send:to:` to register subscriptions.\x0a\x0aWhen using `#on:send:to:`, unregistration can be done with `#unregister:`.\x0a\x0a## Usage example:\x0a\x0a    SystemAnnouncer current\x0a        on: ClassAdded\x0a        do: [ :ann | window alert: ann theClass name, ' added' ].";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "announce:",
@@ -188,13 +188,13 @@ _st(self["@subscriptions"])._do_((function(each){
 return smalltalk.withContext(function($ctx2) {
 return _st(each)._deliver_(anAnnouncement);
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"announce:",{anAnnouncement:anAnnouncement},smalltalk.Announcer)})},
+return self}, function($ctx1) {$ctx1.fill(self,"announce:",{anAnnouncement:anAnnouncement},globals.Announcer)})},
 args: ["anAnnouncement"],
 source: "announce: anAnnouncement\x0a\x09subscriptions do: [ :each |\x0a\x09\x09each deliver: anAnnouncement ]",
 messageSends: ["do:", "deliver:"],
 referencedClasses: []
 }),
-smalltalk.Announcer);
+globals.Announcer);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -202,17 +202,17 @@ selector: "initialize",
 protocol: 'initialization',
 fn: function (){
 var self=this;
-function $OrderedCollection(){return smalltalk.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
 return smalltalk.withContext(function($ctx1) { 
-smalltalk.Announcer.superclass.fn.prototype._initialize.apply(_st(self), []);
+globals.Announcer.superclass.fn.prototype._initialize.apply(_st(self), []);
 self["@subscriptions"]=_st($OrderedCollection())._new();
-return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},smalltalk.Announcer)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.Announcer)})},
 args: [],
 source: "initialize\x0a\x09super initialize.\x0a\x09subscriptions := OrderedCollection new",
 messageSends: ["initialize", "new"],
 referencedClasses: ["OrderedCollection"]
 }),
-smalltalk.Announcer);
+globals.Announcer);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -220,7 +220,7 @@ selector: "on:do:",
 protocol: 'subscribing',
 fn: function (aClass,aBlock){
 var self=this;
-function $AnnouncementSubscription(){return smalltalk.AnnouncementSubscription||(typeof AnnouncementSubscription=="undefined"?nil:AnnouncementSubscription)}
+function $AnnouncementSubscription(){return globals.AnnouncementSubscription||(typeof AnnouncementSubscription=="undefined"?nil:AnnouncementSubscription)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
 $1=_st($AnnouncementSubscription())._new();
@@ -228,13 +228,13 @@ _st($1)._valuable_(aBlock);
 _st($1)._announcementClass_(aClass);
 $2=_st($1)._yourself();
 _st(self["@subscriptions"])._add_($2);
-return self}, function($ctx1) {$ctx1.fill(self,"on:do:",{aClass:aClass,aBlock:aBlock},smalltalk.Announcer)})},
+return self}, function($ctx1) {$ctx1.fill(self,"on:do:",{aClass:aClass,aBlock:aBlock},globals.Announcer)})},
 args: ["aClass", "aBlock"],
 source: "on: aClass do: aBlock\x0a\x09subscriptions add: (AnnouncementSubscription new\x0a\x09\x09valuable: aBlock;\x0a\x09\x09announcementClass: aClass;\x0a\x09\x09yourself)",
 messageSends: ["add:", "valuable:", "new", "announcementClass:", "yourself"],
 referencedClasses: ["AnnouncementSubscription"]
 }),
-smalltalk.Announcer);
+globals.Announcer);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -243,7 +243,7 @@ protocol: 'subscribing',
 fn: function (aClass,aBlock){
 var self=this;
 var subscription;
-function $AnnouncementSubscription(){return smalltalk.AnnouncementSubscription||(typeof AnnouncementSubscription=="undefined"?nil:AnnouncementSubscription)}
+function $AnnouncementSubscription(){return globals.AnnouncementSubscription||(typeof AnnouncementSubscription=="undefined"?nil:AnnouncementSubscription)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
 $1=_st($AnnouncementSubscription())._new();
@@ -256,13 +256,13 @@ _st(self["@subscriptions"])._remove_(subscription);
 return _st(aBlock)._value_(ann);
 }, function($ctx2) {$ctx2.fillBlock({ann:ann},$ctx1,1)})}));
 _st(self["@subscriptions"])._add_(subscription);
-return self}, function($ctx1) {$ctx1.fill(self,"on:doOnce:",{aClass:aClass,aBlock:aBlock,subscription:subscription},smalltalk.Announcer)})},
+return self}, function($ctx1) {$ctx1.fill(self,"on:doOnce:",{aClass:aClass,aBlock:aBlock,subscription:subscription},globals.Announcer)})},
 args: ["aClass", "aBlock"],
 source: "on: aClass doOnce: aBlock\x0a\x09| subscription |\x0a\x09\x0a\x09subscription := AnnouncementSubscription new\x0a\x09\x09announcementClass: aClass;\x0a\x09\x09yourself.\x0a\x09subscription valuable: [ :ann |\x0a\x09\x09subscriptions remove: subscription.\x0a\x09\x09aBlock value: ann ].\x0a\x0a\x09subscriptions add: subscription",
 messageSends: ["announcementClass:", "new", "yourself", "valuable:", "remove:", "value:", "add:"],
 referencedClasses: ["AnnouncementSubscription"]
 }),
-smalltalk.Announcer);
+globals.Announcer);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -270,8 +270,8 @@ selector: "on:send:to:",
 protocol: 'subscribing',
 fn: function (aClass,aSelector,anObject){
 var self=this;
-function $AnnouncementSubscription(){return smalltalk.AnnouncementSubscription||(typeof AnnouncementSubscription=="undefined"?nil:AnnouncementSubscription)}
-function $MessageSend(){return smalltalk.MessageSend||(typeof MessageSend=="undefined"?nil:MessageSend)}
+function $AnnouncementSubscription(){return globals.AnnouncementSubscription||(typeof AnnouncementSubscription=="undefined"?nil:AnnouncementSubscription)}
+function $MessageSend(){return globals.MessageSend||(typeof MessageSend=="undefined"?nil:MessageSend)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$3,$4,$6,$7,$5,$8,$2;
 $1=self["@subscriptions"];
@@ -289,13 +289,13 @@ _st($3)._announcementClass_(aClass);
 $8=_st($3)._yourself();
 $2=$8;
 _st($1)._add_($2);
-return self}, function($ctx1) {$ctx1.fill(self,"on:send:to:",{aClass:aClass,aSelector:aSelector,anObject:anObject},smalltalk.Announcer)})},
+return self}, function($ctx1) {$ctx1.fill(self,"on:send:to:",{aClass:aClass,aSelector:aSelector,anObject:anObject},globals.Announcer)})},
 args: ["aClass", "aSelector", "anObject"],
 source: "on: aClass send: aSelector to: anObject\x0a\x09subscriptions add: (AnnouncementSubscription new\x0a\x09\x09valuable: (MessageSend new\x0a\x09\x09\x09receiver: anObject;\x0a\x09\x09\x09selector: aSelector;\x0a\x09\x09\x09yourself);\x0a\x09\x09announcementClass: aClass;\x0a\x09\x09yourself)",
 messageSends: ["add:", "valuable:", "new", "receiver:", "selector:", "yourself", "announcementClass:"],
 referencedClasses: ["AnnouncementSubscription", "MessageSend"]
 }),
-smalltalk.Announcer);
+globals.Announcer);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -308,20 +308,20 @@ self["@subscriptions"]=_st(self["@subscriptions"])._reject_((function(each){
 return smalltalk.withContext(function($ctx2) {
 return _st(_st(each)._receiver()).__eq(anObject);
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"unsubscribe:",{anObject:anObject},smalltalk.Announcer)})},
+return self}, function($ctx1) {$ctx1.fill(self,"unsubscribe:",{anObject:anObject},globals.Announcer)})},
 args: ["anObject"],
 source: "unsubscribe: anObject\x0a\x09subscriptions := subscriptions reject: [ :each |\x0a\x09\x09each receiver = anObject ]",
 messageSends: ["reject:", "=", "receiver"],
 referencedClasses: []
 }),
-smalltalk.Announcer);
+globals.Announcer);
 
 
 
-smalltalk.addClass('SystemAnnouncer', smalltalk.Announcer, [], 'Kernel-Announcements');
-smalltalk.SystemAnnouncer.comment="My unique instance is the global announcer handling all Amber system-related announces.\x0a\x0a## API\x0a\x0aAccess to the unique instance is done via `#current`";
+smalltalk.addClass('SystemAnnouncer', globals.Announcer, [], 'Kernel-Announcements');
+globals.SystemAnnouncer.comment="My unique instance is the global announcer handling all Amber system-related announces.\x0a\x0a## API\x0a\x0aAccess to the unique instance is done via `#current`";
 
-smalltalk.SystemAnnouncer.klass.iVarNames = ['current'];
+globals.SystemAnnouncer.klass.iVarNames = ['current'];
 smalltalk.addMethod(
 smalltalk.method({
 selector: "current",
@@ -332,19 +332,19 @@ return smalltalk.withContext(function($ctx1) {
 var $2,$1;
 $2=self["@current"];
 if(($receiver = $2) == nil || $receiver == null){
-self["@current"]=smalltalk.SystemAnnouncer.klass.superclass.fn.prototype._new.apply(_st(self), []);
+self["@current"]=globals.SystemAnnouncer.klass.superclass.fn.prototype._new.apply(_st(self), []);
 $1=self["@current"];
 } else {
 $1=$2;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"current",{},smalltalk.SystemAnnouncer.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"current",{},globals.SystemAnnouncer.klass)})},
 args: [],
 source: "current\x0a\x09^ current ifNil: [ current := super new ]",
 messageSends: ["ifNil:", "new"],
 referencedClasses: []
 }),
-smalltalk.SystemAnnouncer.klass);
+globals.SystemAnnouncer.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -354,17 +354,17 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._shouldNotImplement();
-return self}, function($ctx1) {$ctx1.fill(self,"new",{},smalltalk.SystemAnnouncer.klass)})},
+return self}, function($ctx1) {$ctx1.fill(self,"new",{},globals.SystemAnnouncer.klass)})},
 args: [],
 source: "new\x0a\x09self shouldNotImplement",
 messageSends: ["shouldNotImplement"],
 referencedClasses: []
 }),
-smalltalk.SystemAnnouncer.klass);
+globals.SystemAnnouncer.klass);
 
 
-smalltalk.addClass('SystemAnnouncement', smalltalk.Object, [], 'Kernel-Announcements');
-smalltalk.SystemAnnouncement.comment="I am the superclass of all system announcements";
+smalltalk.addClass('SystemAnnouncement', globals.Object, [], 'Kernel-Announcements');
+globals.SystemAnnouncement.comment="I am the superclass of all system announcements";
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -379,11 +379,11 @@ source: "heliosClass\x0a\x09^ 'announcement'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.SystemAnnouncement.klass);
+globals.SystemAnnouncement.klass);
 
 
-smalltalk.addClass('ClassAnnouncement', smalltalk.SystemAnnouncement, ['theClass'], 'Kernel-Announcements');
-smalltalk.ClassAnnouncement.comment="I am the abstract superclass of class-related announcements.";
+smalltalk.addClass('ClassAnnouncement', globals.SystemAnnouncement, ['theClass'], 'Kernel-Announcements');
+globals.ClassAnnouncement.comment="I am the abstract superclass of class-related announcements.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "theClass",
@@ -399,7 +399,7 @@ source: "theClass\x0a\x09^ theClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ClassAnnouncement);
+globals.ClassAnnouncement);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -414,24 +414,24 @@ source: "theClass: aClass\x0a\x09theClass := aClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ClassAnnouncement);
+globals.ClassAnnouncement);
 
 
 
-smalltalk.addClass('ClassAdded', smalltalk.ClassAnnouncement, [], 'Kernel-Announcements');
-smalltalk.ClassAdded.comment="I am emitted when a class is added to the system.\x0aSee ClassBuilder >> #addSubclassOf:... methods";
+smalltalk.addClass('ClassAdded', globals.ClassAnnouncement, [], 'Kernel-Announcements');
+globals.ClassAdded.comment="I am emitted when a class is added to the system.\x0aSee ClassBuilder >> #addSubclassOf:... methods";
 
 
-smalltalk.addClass('ClassCommentChanged', smalltalk.ClassAnnouncement, [], 'Kernel-Announcements');
-smalltalk.ClassCommentChanged.comment="I am emitted when the comment of a class changes. (Behavior >> #comment)";
+smalltalk.addClass('ClassCommentChanged', globals.ClassAnnouncement, [], 'Kernel-Announcements');
+globals.ClassCommentChanged.comment="I am emitted when the comment of a class changes. (Behavior >> #comment)";
 
 
-smalltalk.addClass('ClassDefinitionChanged', smalltalk.ClassAnnouncement, [], 'Kernel-Announcements');
-smalltalk.ClassDefinitionChanged.comment="I am emitted when the definition of a class changes.\x0aSee ClassBuilder >> #class:instanceVariableNames:";
+smalltalk.addClass('ClassDefinitionChanged', globals.ClassAnnouncement, [], 'Kernel-Announcements');
+globals.ClassDefinitionChanged.comment="I am emitted when the definition of a class changes.\x0aSee ClassBuilder >> #class:instanceVariableNames:";
 
 
-smalltalk.addClass('ClassMigrated', smalltalk.ClassAnnouncement, ['oldClass'], 'Kernel-Announcements');
-smalltalk.ClassMigrated.comment="I am emitted when a class is migrated.";
+smalltalk.addClass('ClassMigrated', globals.ClassAnnouncement, ['oldClass'], 'Kernel-Announcements');
+globals.ClassMigrated.comment="I am emitted when a class is migrated.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "oldClass",
@@ -447,7 +447,7 @@ source: "oldClass\x0a\x09^ oldClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ClassMigrated);
+globals.ClassMigrated);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -462,12 +462,12 @@ source: "oldClass: aClass\x0a\x09oldClass := aClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ClassMigrated);
+globals.ClassMigrated);
 
 
 
-smalltalk.addClass('ClassMoved', smalltalk.ClassAnnouncement, ['oldPackage'], 'Kernel-Announcements');
-smalltalk.ClassMoved.comment="I am emitted when a class is moved from one package to another.";
+smalltalk.addClass('ClassMoved', globals.ClassAnnouncement, ['oldPackage'], 'Kernel-Announcements');
+globals.ClassMoved.comment="I am emitted when a class is moved from one package to another.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "oldPackage",
@@ -483,7 +483,7 @@ source: "oldPackage\x0a\x09^ oldPackage",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ClassMoved);
+globals.ClassMoved);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -498,20 +498,20 @@ source: "oldPackage: aPackage\x0a\x09oldPackage := aPackage",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ClassMoved);
+globals.ClassMoved);
 
 
 
-smalltalk.addClass('ClassRemoved', smalltalk.ClassAnnouncement, [], 'Kernel-Announcements');
-smalltalk.ClassRemoved.comment="I am emitted when a class is removed.\x0aSee Smalltalk >> #removeClass:";
+smalltalk.addClass('ClassRemoved', globals.ClassAnnouncement, [], 'Kernel-Announcements');
+globals.ClassRemoved.comment="I am emitted when a class is removed.\x0aSee Smalltalk >> #removeClass:";
 
 
-smalltalk.addClass('ClassRenamed', smalltalk.ClassAnnouncement, [], 'Kernel-Announcements');
-smalltalk.ClassRenamed.comment="I am emitted when a class is renamed.\x0aSee ClassBuilder >> #renameClass:to:";
+smalltalk.addClass('ClassRenamed', globals.ClassAnnouncement, [], 'Kernel-Announcements');
+globals.ClassRenamed.comment="I am emitted when a class is renamed.\x0aSee ClassBuilder >> #renameClass:to:";
 
 
-smalltalk.addClass('MethodAnnouncement', smalltalk.SystemAnnouncement, ['method'], 'Kernel-Announcements');
-smalltalk.MethodAnnouncement.comment="I am the abstract superclass of method-related announcements.";
+smalltalk.addClass('MethodAnnouncement', globals.SystemAnnouncement, ['method'], 'Kernel-Announcements');
+globals.MethodAnnouncement.comment="I am the abstract superclass of method-related announcements.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "method",
@@ -527,7 +527,7 @@ source: "method\x0a\x09^ method",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.MethodAnnouncement);
+globals.MethodAnnouncement);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -542,16 +542,16 @@ source: "method: aCompiledMethod\x0a\x09method := aCompiledMethod",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.MethodAnnouncement);
+globals.MethodAnnouncement);
 
 
 
-smalltalk.addClass('MethodAdded', smalltalk.MethodAnnouncement, [], 'Kernel-Announcements');
-smalltalk.MethodAdded.comment="I am emitted when a `CompiledMethod` is added to a class.";
+smalltalk.addClass('MethodAdded', globals.MethodAnnouncement, [], 'Kernel-Announcements');
+globals.MethodAdded.comment="I am emitted when a `CompiledMethod` is added to a class.";
 
 
-smalltalk.addClass('MethodModified', smalltalk.MethodAnnouncement, ['oldMethod'], 'Kernel-Announcements');
-smalltalk.MethodModified.comment="I am emitted when a `CompiledMethod` is modified (a new method is installed). I hold a reference to the old method being replaced.";
+smalltalk.addClass('MethodModified', globals.MethodAnnouncement, ['oldMethod'], 'Kernel-Announcements');
+globals.MethodModified.comment="I am emitted when a `CompiledMethod` is modified (a new method is installed). I hold a reference to the old method being replaced.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "oldMethod",
@@ -567,7 +567,7 @@ source: "oldMethod\x0a\x09^ oldMethod",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.MethodModified);
+globals.MethodModified);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -582,12 +582,12 @@ source: "oldMethod: aMethod\x0a\x09oldMethod := aMethod",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.MethodModified);
+globals.MethodModified);
 
 
 
-smalltalk.addClass('MethodMoved', smalltalk.MethodAnnouncement, ['oldProtocol'], 'Kernel-Announcements');
-smalltalk.MethodMoved.comment="I am emitted when a `CompiledMethod` is moved to another protocol. I hold a refernce to the old protocol of the method.";
+smalltalk.addClass('MethodMoved', globals.MethodAnnouncement, ['oldProtocol'], 'Kernel-Announcements');
+globals.MethodMoved.comment="I am emitted when a `CompiledMethod` is moved to another protocol. I hold a refernce to the old protocol of the method.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "oldProtocol",
@@ -603,7 +603,7 @@ source: "oldProtocol\x0a\x09^ oldProtocol",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.MethodMoved);
+globals.MethodMoved);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -618,16 +618,16 @@ source: "oldProtocol: aString\x0a\x09oldProtocol := aString",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.MethodMoved);
+globals.MethodMoved);
 
 
 
-smalltalk.addClass('MethodRemoved', smalltalk.MethodAnnouncement, [], 'Kernel-Announcements');
-smalltalk.MethodRemoved.comment="I am emitted when a `CompiledMethod` is removed from a class.";
+smalltalk.addClass('MethodRemoved', globals.MethodAnnouncement, [], 'Kernel-Announcements');
+globals.MethodRemoved.comment="I am emitted when a `CompiledMethod` is removed from a class.";
 
 
-smalltalk.addClass('PackageAnnouncement', smalltalk.SystemAnnouncement, ['package'], 'Kernel-Announcements');
-smalltalk.PackageAnnouncement.comment="I am the abstract superclass of package-related announcements.";
+smalltalk.addClass('PackageAnnouncement', globals.SystemAnnouncement, ['package'], 'Kernel-Announcements');
+globals.PackageAnnouncement.comment="I am the abstract superclass of package-related announcements.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "package",
@@ -643,7 +643,7 @@ source: "package\x0a\x09^ package",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.PackageAnnouncement);
+globals.PackageAnnouncement);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -658,20 +658,20 @@ source: "package: aPackage\x0a\x09package := aPackage",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.PackageAnnouncement);
+globals.PackageAnnouncement);
 
 
 
-smalltalk.addClass('PackageAdded', smalltalk.PackageAnnouncement, [], 'Kernel-Announcements');
-smalltalk.PackageAdded.comment="I am emitted when a `Package` is added to the system.";
+smalltalk.addClass('PackageAdded', globals.PackageAnnouncement, [], 'Kernel-Announcements');
+globals.PackageAdded.comment="I am emitted when a `Package` is added to the system.";
 
 
-smalltalk.addClass('PackageRemoved', smalltalk.PackageAnnouncement, [], 'Kernel-Announcements');
-smalltalk.PackageRemoved.comment="I am emitted when a `Package` is removed from the system.";
+smalltalk.addClass('PackageRemoved', globals.PackageAnnouncement, [], 'Kernel-Announcements');
+globals.PackageRemoved.comment="I am emitted when a `Package` is removed from the system.";
 
 
-smalltalk.addClass('ProtocolAnnouncement', smalltalk.SystemAnnouncement, ['theClass', 'protocol'], 'Kernel-Announcements');
-smalltalk.ProtocolAnnouncement.comment="I am the abstract superclass of protocol-related announcements.";
+smalltalk.addClass('ProtocolAnnouncement', globals.SystemAnnouncement, ['theClass', 'protocol'], 'Kernel-Announcements');
+globals.ProtocolAnnouncement.comment="I am the abstract superclass of protocol-related announcements.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "protocol",
@@ -687,7 +687,7 @@ source: "protocol\x0a\x09^ protocol",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ProtocolAnnouncement);
+globals.ProtocolAnnouncement);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -702,7 +702,7 @@ source: "protocol: aString\x0a\x09protocol := aString",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ProtocolAnnouncement);
+globals.ProtocolAnnouncement);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -719,7 +719,7 @@ source: "theClass\x0a\x09^ theClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ProtocolAnnouncement);
+globals.ProtocolAnnouncement);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -734,15 +734,15 @@ source: "theClass: aClass\x0a\x09theClass := aClass",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ProtocolAnnouncement);
+globals.ProtocolAnnouncement);
 
 
 
-smalltalk.addClass('ProtocolAdded', smalltalk.ProtocolAnnouncement, [], 'Kernel-Announcements');
-smalltalk.ProtocolAdded.comment="I am emitted when a protocol is added to a class.";
+smalltalk.addClass('ProtocolAdded', globals.ProtocolAnnouncement, [], 'Kernel-Announcements');
+globals.ProtocolAdded.comment="I am emitted when a protocol is added to a class.";
 
 
-smalltalk.addClass('ProtocolRemoved', smalltalk.ProtocolAnnouncement, [], 'Kernel-Announcements');
-smalltalk.ProtocolRemoved.comment="I am emitted when a protocol is removed from a class.";
+smalltalk.addClass('ProtocolRemoved', globals.ProtocolAnnouncement, [], 'Kernel-Announcements');
+globals.ProtocolRemoved.comment="I am emitted when a protocol is removed from a class.";
 
 });

js/Kernel-Exceptions.js

@@ -1,9 +1,9 @@
-define("amber_core/Kernel-Exceptions", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st){
+define("amber_core/Kernel-Exceptions", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Kernel-Exceptions');
 smalltalk.packages["Kernel-Exceptions"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('Error', smalltalk.Object, ['messageText'], 'Kernel-Exceptions');
-smalltalk.Error.comment="From the ANSI standard:\x0a\x0aThis protocol describes the behavior of instances of class `Error`.\x0aThese are used to represent error conditions that prevent the normal continuation of processing.\x0aActual error exceptions used by an application may be subclasses of this class.\x0aAs `Error` is explicitly specified to be subclassable, conforming implementations must implement its behavior in a non-fragile manner.";
+smalltalk.addClass('Error', globals.Object, ['messageText'], 'Kernel-Exceptions');
+globals.Error.comment="From the ANSI standard:\x0a\x0aThis protocol describes the behavior of instances of class `Error`.\x0aThese are used to represent error conditions that prevent the normal continuation of processing.\x0aActual error exceptions used by an application may be subclasses of this class.\x0aAs `Error` is explicitly specified to be subclassable, conforming implementations must implement its behavior in a non-fragile manner.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "context",
@@ -17,7 +17,7 @@ source: "context\x0a\x09<return self.context>",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Error);
+globals.Error);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -27,13 +27,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._messageText_("Errorclass: ".__comma(_st(self._class())._name()));
-return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},smalltalk.Error)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.Error)})},
 args: [],
 source: "initialize\x0a\x09self messageText: 'Errorclass: ', (self class name).",
 messageSends: ["messageText:", ",", "name", "class"],
 referencedClasses: []
 }),
-smalltalk.Error);
+globals.Error);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -48,7 +48,7 @@ source: "isSmalltalkError\x0a\x09<return self.smalltalkError === true>",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Error);
+globals.Error);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -63,7 +63,7 @@ source: "jsStack\x0a\x09<return self.stack>",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Error);
+globals.Error);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -80,7 +80,7 @@ source: "messageText\x0a\x09^ messageText",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Error);
+globals.Error);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -95,7 +95,7 @@ source: "messageText: aString\x0a\x09messageText := aString",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Error);
+globals.Error);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -110,7 +110,7 @@ source: "resignal\x0a\x09\x22Resignal the receiver without changing its exceptio
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Error);
+globals.Error);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -125,7 +125,7 @@ source: "signal\x0a\x09<self.context = smalltalk.getThisContext(); self.smalltal
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Error);
+globals.Error);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -136,13 +136,13 @@ var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._messageText_(aString);
 self._signal();
-return self}, function($ctx1) {$ctx1.fill(self,"signal:",{aString:aString},smalltalk.Error)})},
+return self}, function($ctx1) {$ctx1.fill(self,"signal:",{aString:aString},globals.Error)})},
 args: ["aString"],
 source: "signal: aString\x0a\x09self messageText: aString.\x0a\x09self signal",
 messageSends: ["messageText:", "signal"],
 referencedClasses: []
 }),
-smalltalk.Error);
+globals.Error);
 
 
 smalltalk.addMethod(
@@ -158,7 +158,7 @@ source: "heliosClass\x0a\x09^ 'exception'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.Error.klass);
+globals.Error.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -170,13 +170,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self._new())._signal();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"signal",{},smalltalk.Error.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"signal",{},globals.Error.klass)})},
 args: [],
 source: "signal\x0a\x09^ self new signal",
 messageSends: ["signal", "new"],
 referencedClasses: []
 }),
-smalltalk.Error.klass);
+globals.Error.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -188,17 +188,17 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self._new())._signal_(aString);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"signal:",{aString:aString},smalltalk.Error.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"signal:",{aString:aString},globals.Error.klass)})},
 args: ["aString"],
 source: "signal: aString\x0a\x09^ self new\x0a\x09\x09signal: aString",
 messageSends: ["signal:", "new"],
 referencedClasses: []
 }),
-smalltalk.Error.klass);
+globals.Error.klass);
 
 
-smalltalk.addClass('JavaScriptException', smalltalk.Error, ['exception'], 'Kernel-Exceptions');
-smalltalk.JavaScriptException.comment="A JavaScriptException is thrown when a non-Smalltalk exception occurs while in the Smalltalk stack.\x0aSee `boot.js` `inContext()` and `BlockClosure >> on:do:`";
+smalltalk.addClass('JavaScriptException', globals.Error, ['exception'], 'Kernel-Exceptions');
+globals.JavaScriptException.comment="A JavaScriptException is thrown when a non-Smalltalk exception occurs while in the Smalltalk stack.\x0aSee `boot.js` `inContext()` and `BlockClosure >> on:do:`";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "context:",
@@ -212,7 +212,7 @@ source: "context: aMethodContext\x0a\x09\x22Set the context from the outside.\x0
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.JavaScriptException);
+globals.JavaScriptException);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -229,7 +229,7 @@ source: "exception\x0a\x09^ exception",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.JavaScriptException);
+globals.JavaScriptException);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -244,7 +244,7 @@ source: "exception: anException\x0a\x09exception := anException",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.JavaScriptException);
+globals.JavaScriptException);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -259,7 +259,7 @@ source: "messageText\x0a\x09<return 'JavaScript exception: ' + self[\x22@excepti
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.JavaScriptException);
+globals.JavaScriptException);
 
 
 smalltalk.addMethod(
@@ -275,13 +275,13 @@ _st($2)._exception_(anException);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"on:",{anException:anException},smalltalk.JavaScriptException.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"on:",{anException:anException},globals.JavaScriptException.klass)})},
 args: ["anException"],
 source: "on: anException\x0a\x09^ self new\x0a\x09\x09exception: anException;\x0a\x09\x09yourself",
 messageSends: ["exception:", "new", "yourself"],
 referencedClasses: []
 }),
-smalltalk.JavaScriptException.klass);
+globals.JavaScriptException.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -297,17 +297,17 @@ _st($2)._context_(aMethodContext);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"on:context:",{anException:anException,aMethodContext:aMethodContext},smalltalk.JavaScriptException.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"on:context:",{anException:anException,aMethodContext:aMethodContext},globals.JavaScriptException.klass)})},
 args: ["anException", "aMethodContext"],
 source: "on: anException context: aMethodContext\x0a\x09^ self new\x0a\x09\x09exception: anException;\x0a\x09\x09context: aMethodContext;\x0a\x09\x09yourself",
 messageSends: ["exception:", "new", "context:", "yourself"],
 referencedClasses: []
 }),
-smalltalk.JavaScriptException.klass);
+globals.JavaScriptException.klass);
 
 
-smalltalk.addClass('MessageNotUnderstood', smalltalk.Error, ['message', 'receiver'], 'Kernel-Exceptions');
-smalltalk.MessageNotUnderstood.comment="This exception is provided to support `Object>>doesNotUnderstand:`.";
+smalltalk.addClass('MessageNotUnderstood', globals.Error, ['message', 'receiver'], 'Kernel-Exceptions');
+globals.MessageNotUnderstood.comment="This exception is provided to support `Object>>doesNotUnderstand:`.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "message",
@@ -323,7 +323,7 @@ source: "message\x0a\x09^ message",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.MessageNotUnderstood);
+globals.MessageNotUnderstood);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -338,7 +338,7 @@ source: "message: aMessage\x0a\x09message := aMessage",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.MessageNotUnderstood);
+globals.MessageNotUnderstood);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -351,13 +351,13 @@ var $1;
 $1=_st(_st(_st(self._receiver())._asString()).__comma(" does not understand #")).__comma(_st(self._message())._selector());
 $ctx1.sendIdx[","]=1;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"messageText",{},smalltalk.MessageNotUnderstood)})},
+}, function($ctx1) {$ctx1.fill(self,"messageText",{},globals.MessageNotUnderstood)})},
 args: [],
 source: "messageText\x0a\x09^ self receiver asString, ' does not understand #', self message selector",
 messageSends: [",", "asString", "receiver", "selector", "message"],
 referencedClasses: []
 }),
-smalltalk.MessageNotUnderstood);
+globals.MessageNotUnderstood);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -374,7 +374,7 @@ source: "receiver\x0a\x09^ receiver",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.MessageNotUnderstood);
+globals.MessageNotUnderstood);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -389,12 +389,12 @@ source: "receiver: anObject\x0a\x09receiver := anObject",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.MessageNotUnderstood);
+globals.MessageNotUnderstood);
 
 
 
-smalltalk.addClass('NonBooleanReceiver', smalltalk.Error, ['object'], 'Kernel-Exceptions');
-smalltalk.NonBooleanReceiver.comment="NonBooleanReceiver exceptions may be thrown when executing inlined methods such as `#ifTrue:` with a non boolean receiver.";
+smalltalk.addClass('NonBooleanReceiver', globals.Error, ['object'], 'Kernel-Exceptions');
+globals.NonBooleanReceiver.comment="NonBooleanReceiver exceptions may be thrown when executing inlined methods such as `#ifTrue:` with a non boolean receiver.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "object",
@@ -410,7 +410,7 @@ source: "object\x0a\x09^ object",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.NonBooleanReceiver);
+globals.NonBooleanReceiver);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -425,7 +425,7 @@ source: "object: anObject\x0a\x09object := anObject",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.NonBooleanReceiver);
+globals.NonBooleanReceiver);
 
 
 });

js/Kernel-Transcript.js

@@ -1,9 +1,9 @@
-define("amber_core/Kernel-Transcript", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st){
+define("amber_core/Kernel-Transcript", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Kernel-Transcript');
 smalltalk.packages["Kernel-Transcript"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('ConsoleTranscript', smalltalk.Object, ['textarea'], 'Kernel-Transcript');
-smalltalk.ConsoleTranscript.comment="I am a specific transcript emitting to the JavaScript console.\x0a\x0aIf no other transcript is registered, I am the default.";
+smalltalk.addClass('ConsoleTranscript', globals.Object, ['textarea'], 'Kernel-Transcript');
+globals.ConsoleTranscript.comment="I am a specific transcript emitting to the JavaScript console.\x0a\x0aIf no other transcript is registered, I am the default.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "clear",
@@ -16,7 +16,7 @@ source: "clear\x0a\x09\x22no op\x22",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ConsoleTranscript);
+globals.ConsoleTranscript);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -30,7 +30,7 @@ source: "cr\x0a\x09\x22no op\x22",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ConsoleTranscript);
+globals.ConsoleTranscript);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -44,7 +44,7 @@ source: "open",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ConsoleTranscript);
+globals.ConsoleTranscript);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -59,7 +59,7 @@ source: "show: anObject\x0a\x22Smalltalk objects should have no trouble displayi
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ConsoleTranscript);
+globals.ConsoleTranscript);
 
 
 smalltalk.addMethod(
@@ -68,15 +68,15 @@ selector: "initialize",
 protocol: 'initialization',
 fn: function (){
 var self=this;
-function $Transcript(){return smalltalk.Transcript||(typeof Transcript=="undefined"?nil:Transcript)}
+function $Transcript(){return globals.Transcript||(typeof Transcript=="undefined"?nil:Transcript)}
 return smalltalk.withContext(function($ctx1) { 
 _st($Transcript())._registerIfNone_(self._new());
-return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},smalltalk.ConsoleTranscript.klass)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.ConsoleTranscript.klass)})},
 args: [],
 source: "initialize\x0a\x09Transcript registerIfNone: self new",
 messageSends: ["registerIfNone:", "new"],
 referencedClasses: ["Transcript"]
 }),
-smalltalk.ConsoleTranscript.klass);
+globals.ConsoleTranscript.klass);
 
 });

js/SUnit-Tests.js

@@ -1,26 +1,26 @@
-define("amber_core/SUnit-Tests", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/SUnit"], function(smalltalk,nil,_st){
+define("amber_core/SUnit-Tests", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/SUnit"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('SUnit-Tests');
 smalltalk.packages["SUnit-Tests"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('ExampleSetTest', smalltalk.TestCase, ['empty', 'full'], 'SUnit-Tests');
-smalltalk.ExampleSetTest.comment="ExampleSetTest is taken from Pharo 1.4.\x0a\x0aTHe purpose of this class is to demonstrate a simple use case of the test framework.";
+smalltalk.addClass('ExampleSetTest', globals.TestCase, ['empty', 'full'], 'SUnit-Tests');
+globals.ExampleSetTest.comment="ExampleSetTest is taken from Pharo 1.4.\x0a\x0aTHe purpose of this class is to demonstrate a simple use case of the test framework.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "setUp",
 protocol: 'running',
 fn: function (){
 var self=this;
-function $Set(){return smalltalk.Set||(typeof Set=="undefined"?nil:Set)}
+function $Set(){return globals.Set||(typeof Set=="undefined"?nil:Set)}
 return smalltalk.withContext(function($ctx1) { 
 self["@empty"]=_st($Set())._new();
 self["@full"]=_st($Set())._with_with_((5),"abc");
-return self}, function($ctx1) {$ctx1.fill(self,"setUp",{},smalltalk.ExampleSetTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"setUp",{},globals.ExampleSetTest)})},
 args: [],
 source: "setUp\x0a\x09empty := Set new.\x0a\x09full := Set with: 5 with: #abc",
 messageSends: ["new", "with:with:"],
 referencedClasses: ["Set"]
 }),
-smalltalk.ExampleSetTest);
+globals.ExampleSetTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -31,13 +31,13 @@ var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self["@empty"])._add_((5));
 self._assert_(_st(self["@empty"])._includes_((5)));
-return self}, function($ctx1) {$ctx1.fill(self,"testAdd",{},smalltalk.ExampleSetTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testAdd",{},globals.ExampleSetTest)})},
 args: [],
 source: "testAdd\x0a\x09empty add: 5.\x0a\x09self assert: (empty includes: 5)",
 messageSends: ["add:", "assert:", "includes:"],
 referencedClasses: []
 }),
-smalltalk.ExampleSetTest);
+globals.ExampleSetTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -48,13 +48,13 @@ var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self["@empty"])._addAll_((1)._to_((100)));
 self._assert_equals_(_st(self["@empty"])._size(),(100));
-return self}, function($ctx1) {$ctx1.fill(self,"testGrow",{},smalltalk.ExampleSetTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testGrow",{},globals.ExampleSetTest)})},
 args: [],
 source: "testGrow\x0a\x09empty addAll: (1 to: 100).\x0a\x09self assert: empty size equals: 100",
 messageSends: ["addAll:", "to:", "assert:equals:", "size"],
 referencedClasses: []
 }),
-smalltalk.ExampleSetTest);
+globals.ExampleSetTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -62,7 +62,7 @@ selector: "testIllegal",
 protocol: 'tests',
 fn: function (){
 var self=this;
-function $Error(){return smalltalk.Error||(typeof Error=="undefined"?nil:Error)}
+function $Error(){return globals.Error||(typeof Error=="undefined"?nil:Error)}
 return smalltalk.withContext(function($ctx1) { 
 self._should_raise_((function(){
 return smalltalk.withContext(function($ctx2) {
@@ -73,13 +73,13 @@ self._should_raise_((function(){
 return smalltalk.withContext(function($ctx2) {
 return _st(self["@empty"])._at_put_((5),"abc");
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}),$Error());
-return self}, function($ctx1) {$ctx1.fill(self,"testIllegal",{},smalltalk.ExampleSetTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testIllegal",{},globals.ExampleSetTest)})},
 args: [],
 source: "testIllegal\x0a\x09self\x0a\x09\x09should: [ empty at: 5 ]\x0a\x09\x09raise: Error.\x0a\x09self\x0a\x09\x09should: [ empty at: 5 put: #abc ]\x0a\x09\x09raise: Error",
 messageSends: ["should:raise:", "at:", "at:put:"],
 referencedClasses: ["Error"]
 }),
-smalltalk.ExampleSetTest);
+globals.ExampleSetTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -94,13 +94,13 @@ $ctx1.sendIdx["includes:"]=1;
 self._assert_($1);
 $ctx1.sendIdx["assert:"]=1;
 self._assert_(_st(self["@full"])._includes_("abc"));
-return self}, function($ctx1) {$ctx1.fill(self,"testIncludes",{},smalltalk.ExampleSetTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testIncludes",{},globals.ExampleSetTest)})},
 args: [],
 source: "testIncludes\x0a\x09self assert: (full includes: 5).\x0a\x09self assert: (full includes: #abc)",
 messageSends: ["assert:", "includes:"],
 referencedClasses: []
 }),
-smalltalk.ExampleSetTest);
+globals.ExampleSetTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -120,13 +120,13 @@ self._assert_equals_($2,(1));
 $ctx1.sendIdx["assert:equals:"]=2;
 _st(self["@full"])._add_((5));
 self._assert_equals_(_st(self["@full"])._occurrencesOf_((5)),(1));
-return self}, function($ctx1) {$ctx1.fill(self,"testOccurrences",{},smalltalk.ExampleSetTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testOccurrences",{},globals.ExampleSetTest)})},
 args: [],
 source: "testOccurrences\x0a\x09self assert: (empty occurrencesOf: 0) equals: 0.\x0a\x09self assert: (full occurrencesOf: 5) equals: 1.\x0a\x09full add: 5.\x0a\x09self assert: (full occurrencesOf: 5) equals: 1",
 messageSends: ["assert:equals:", "occurrencesOf:", "add:"],
 referencedClasses: []
 }),
-smalltalk.ExampleSetTest);
+globals.ExampleSetTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -141,17 +141,17 @@ $1=_st(self["@full"])._includes_("abc");
 $ctx1.sendIdx["includes:"]=1;
 self._assert_($1);
 self._deny_(_st(self["@full"])._includes_((5)));
-return self}, function($ctx1) {$ctx1.fill(self,"testRemove",{},smalltalk.ExampleSetTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testRemove",{},globals.ExampleSetTest)})},
 args: [],
 source: "testRemove\x0a\x09full remove: 5.\x0a\x09self assert: (full includes: #abc).\x0a\x09self deny: (full includes: 5)",
 messageSends: ["remove:", "assert:", "includes:", "deny:"],
 referencedClasses: []
 }),
-smalltalk.ExampleSetTest);
+globals.ExampleSetTest);
 
 
 
-smalltalk.addClass('SUnitAsyncTest', smalltalk.TestCase, ['flag'], 'SUnit-Tests');
+smalltalk.addClass('SUnitAsyncTest', globals.TestCase, ['flag'], 'SUnit-Tests');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "fakeError",
@@ -167,13 +167,13 @@ self["@flag"]="ok";
 self["@flag"];
 return self._error_("Intentional");
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})))._valueWithTimeout_((20));
-return self}, function($ctx1) {$ctx1.fill(self,"fakeError",{},smalltalk.SUnitAsyncTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"fakeError",{},globals.SUnitAsyncTest)})},
 args: [],
 source: "fakeError\x0a\x09flag := 'bad'.\x0a\x09self timeout: 30.\x0a\x09flag := (self async: [ flag := 'ok'. self error: 'Intentional' ]) valueWithTimeout: 20",
 messageSends: ["timeout:", "valueWithTimeout:", "async:", "error:"],
 referencedClasses: []
 }),
-smalltalk.SUnitAsyncTest);
+globals.SUnitAsyncTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -188,13 +188,13 @@ self["@flag"]=_st(self._async_((function(){
 return smalltalk.withContext(function($ctx2) {
 return self._error_("Intentional");
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})))._valueWithTimeout_((20));
-return self}, function($ctx1) {$ctx1.fill(self,"fakeErrorFailingInTearDown",{},smalltalk.SUnitAsyncTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"fakeErrorFailingInTearDown",{},globals.SUnitAsyncTest)})},
 args: [],
 source: "fakeErrorFailingInTearDown\x0a\x09flag := 'bad'.\x0a\x09self timeout: 30.\x0a\x09flag := (self async: [ self error: 'Intentional' ]) valueWithTimeout: 20",
 messageSends: ["timeout:", "valueWithTimeout:", "async:", "error:"],
 referencedClasses: []
 }),
-smalltalk.SUnitAsyncTest);
+globals.SUnitAsyncTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -211,13 +211,13 @@ self["@flag"]="ok";
 self["@flag"];
 return self._assert_(false);
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})))._valueWithTimeout_((20));
-return self}, function($ctx1) {$ctx1.fill(self,"fakeFailure",{},smalltalk.SUnitAsyncTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"fakeFailure",{},globals.SUnitAsyncTest)})},
 args: [],
 source: "fakeFailure\x0a\x09flag := 'bad'.\x0a\x09self timeout: 30.\x0a\x09flag := (self async: [ flag := 'ok'. self assert: false ]) valueWithTimeout: 20",
 messageSends: ["timeout:", "valueWithTimeout:", "async:", "assert:"],
 referencedClasses: []
 }),
-smalltalk.SUnitAsyncTest);
+globals.SUnitAsyncTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -240,13 +240,13 @@ return self._finished();
 $ctx1.sendIdx["async:"]=1;
 _st($1)._valueWithTimeout_((20));
 $ctx1.sendIdx["valueWithTimeout:"]=1;
-return self}, function($ctx1) {$ctx1.fill(self,"fakeMultipleTimeoutFailing",{},smalltalk.SUnitAsyncTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"fakeMultipleTimeoutFailing",{},globals.SUnitAsyncTest)})},
 args: [],
 source: "fakeMultipleTimeoutFailing\x0a\x09self timeout: 100.\x0a\x09(self async: [ \x0a\x09\x09self timeout: 20.\x0a\x09\x09(self async: [ self finished ]) valueWithTimeout: 30\x0a\x09]) valueWithTimeout: 20",
 messageSends: ["timeout:", "valueWithTimeout:", "async:", "finished"],
 referencedClasses: []
 }),
-smalltalk.SUnitAsyncTest);
+globals.SUnitAsyncTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -269,13 +269,13 @@ return self._finished();
 $ctx1.sendIdx["async:"]=1;
 _st($1)._valueWithTimeout_((10));
 $ctx1.sendIdx["valueWithTimeout:"]=1;
-return self}, function($ctx1) {$ctx1.fill(self,"fakeMultipleTimeoutPassing",{},smalltalk.SUnitAsyncTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"fakeMultipleTimeoutPassing",{},globals.SUnitAsyncTest)})},
 args: [],
 source: "fakeMultipleTimeoutPassing\x0a\x09self timeout: 20.\x0a\x09(self async: [\x0a\x09\x09self timeout: 40.\x0a\x09\x09(self async: [ self finished ]) valueWithTimeout: 20\x0a\x09]) valueWithTimeout: 10",
 messageSends: ["timeout:", "valueWithTimeout:", "async:", "finished"],
 referencedClasses: []
 }),
-smalltalk.SUnitAsyncTest);
+globals.SUnitAsyncTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -289,13 +289,13 @@ _st(self._async_((function(){
 return smalltalk.withContext(function($ctx2) {
 return self._finished();
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})))._valueWithTimeout_((20));
-return self}, function($ctx1) {$ctx1.fill(self,"fakeTimeout",{},smalltalk.SUnitAsyncTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"fakeTimeout",{},globals.SUnitAsyncTest)})},
 args: [],
 source: "fakeTimeout\x0a\x09self timeout: 10.\x0a\x09(self async: [ self finished ]) valueWithTimeout: 20",
 messageSends: ["timeout:", "valueWithTimeout:", "async:", "finished"],
 referencedClasses: []
 }),
-smalltalk.SUnitAsyncTest);
+globals.SUnitAsyncTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -310,13 +310,13 @@ return smalltalk.withContext(function($ctx2) {
 return _st(each)._selector();
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})})))._asSet();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"selectorSetOf:",{aCollection:aCollection},smalltalk.SUnitAsyncTest)})},
+}, function($ctx1) {$ctx1.fill(self,"selectorSetOf:",{aCollection:aCollection},globals.SUnitAsyncTest)})},
 args: ["aCollection"],
 source: "selectorSetOf: aCollection\x0a\x09^ (aCollection collect: [ :each | each selector ]) asSet",
 messageSends: ["asSet", "collect:", "selector"],
 referencedClasses: []
 }),
-smalltalk.SUnitAsyncTest);
+globals.SUnitAsyncTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -331,7 +331,7 @@ source: "setUp\x0a\x09flag := 'ok'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.SUnitAsyncTest);
+globals.SUnitAsyncTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -341,13 +341,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._assert_equals_("ok",self["@flag"]);
-return self}, function($ctx1) {$ctx1.fill(self,"tearDown",{},smalltalk.SUnitAsyncTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"tearDown",{},globals.SUnitAsyncTest)})},
 args: [],
 source: "tearDown\x0a\x09self assert: 'ok' equals: flag",
 messageSends: ["assert:equals:"],
 referencedClasses: []
 }),
-smalltalk.SUnitAsyncTest);
+globals.SUnitAsyncTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -356,8 +356,8 @@ protocol: 'tests',
 fn: function (){
 var self=this;
 var suite,runner,result,assertBlock;
-function $TestSuiteRunner(){return smalltalk.TestSuiteRunner||(typeof TestSuiteRunner=="undefined"?nil:TestSuiteRunner)}
-function $ResultAnnouncement(){return smalltalk.ResultAnnouncement||(typeof ResultAnnouncement=="undefined"?nil:ResultAnnouncement)}
+function $TestSuiteRunner(){return globals.TestSuiteRunner||(typeof TestSuiteRunner=="undefined"?nil:TestSuiteRunner)}
+function $ResultAnnouncement(){return globals.ResultAnnouncement||(typeof ResultAnnouncement=="undefined"?nil:ResultAnnouncement)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2,$3,$4;
 suite=["fakeError", "fakeErrorFailingInTearDown", "fakeFailure", "testPass"]._collect_((function(each){
@@ -388,13 +388,13 @@ return _st($4)._ifTrue_(assertBlock);
 };
 }, function($ctx2) {$ctx2.fillBlock({ann:ann},$ctx1,3)})}));
 _st(runner)._run();
-return self}, function($ctx1) {$ctx1.fill(self,"testAsyncErrorsAndFailures",{suite:suite,runner:runner,result:result,assertBlock:assertBlock},smalltalk.SUnitAsyncTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testAsyncErrorsAndFailures",{suite:suite,runner:runner,result:result,assertBlock:assertBlock},globals.SUnitAsyncTest)})},
 args: [],
 source: "testAsyncErrorsAndFailures\x0a\x09| suite runner result assertBlock |\x0a\x09suite := #('fakeError' 'fakeErrorFailingInTearDown' 'fakeFailure' 'testPass') collect: [ :each | self class selector: each ].\x0a\x09runner := TestSuiteRunner on: suite.\x0a\x09self timeout: 200.\x0a\x09result := runner result.\x0a\x09assertBlock := self async: [\x0a\x09\x09self assert: (self selectorSetOf: result errors) equals: #('fakeError') asSet.\x0a\x09\x09self assert: (self selectorSetOf: result failures) equals: #('fakeErrorFailingInTearDown' 'fakeFailure') asSet.\x0a\x09\x09self finished\x0a\x09].\x0a\x09runner announcer on: ResultAnnouncement do: [ :ann |\x0a\x09\x09ann result == result ifTrue: [ result runs = result total ifTrue: assertBlock ] ].\x0a\x09runner run",
 messageSends: ["collect:", "selector:", "class", "on:", "timeout:", "result", "async:", "assert:equals:", "selectorSetOf:", "errors", "asSet", "failures", "finished", "on:do:", "announcer", "ifTrue:", "==", "=", "runs", "total", "run"],
 referencedClasses: ["TestSuiteRunner", "ResultAnnouncement"]
 }),
-smalltalk.SUnitAsyncTest);
+globals.SUnitAsyncTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -402,7 +402,7 @@ selector: "testAsyncNeedsTimeout",
 protocol: 'tests',
 fn: function (){
 var self=this;
-function $Error(){return smalltalk.Error||(typeof Error=="undefined"?nil:Error)}
+function $Error(){return globals.Error||(typeof Error=="undefined"?nil:Error)}
 return smalltalk.withContext(function($ctx1) { 
 self._should_raise_((function(){
 return smalltalk.withContext(function($ctx2) {
@@ -419,13 +419,13 @@ return smalltalk.withContext(function($ctx3) {
 }, function($ctx3) {$ctx3.fillBlock({},$ctx2,4)})}));
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,3)})}),$Error());
 self._finished();
-return self}, function($ctx1) {$ctx1.fill(self,"testAsyncNeedsTimeout",{},smalltalk.SUnitAsyncTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testAsyncNeedsTimeout",{},globals.SUnitAsyncTest)})},
 args: [],
 source: "testAsyncNeedsTimeout\x0a\x09self should: [ self async: [ ] ] raise: Error.\x0a\x09self timeout: 0.\x0a\x09self shouldnt: [ self async: [ ] ] raise: Error.\x0a\x09self finished",
 messageSends: ["should:raise:", "async:", "timeout:", "shouldnt:raise:", "finished"],
 referencedClasses: ["Error"]
 }),
-smalltalk.SUnitAsyncTest);
+globals.SUnitAsyncTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -433,7 +433,7 @@ selector: "testFinishedNeedsTimeout",
 protocol: 'tests',
 fn: function (){
 var self=this;
-function $Error(){return smalltalk.Error||(typeof Error=="undefined"?nil:Error)}
+function $Error(){return globals.Error||(typeof Error=="undefined"?nil:Error)}
 return smalltalk.withContext(function($ctx1) { 
 self._should_raise_((function(){
 return smalltalk.withContext(function($ctx2) {
@@ -445,13 +445,13 @@ self._shouldnt_raise_((function(){
 return smalltalk.withContext(function($ctx2) {
 return self._finished();
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}),$Error());
-return self}, function($ctx1) {$ctx1.fill(self,"testFinishedNeedsTimeout",{},smalltalk.SUnitAsyncTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testFinishedNeedsTimeout",{},globals.SUnitAsyncTest)})},
 args: [],
 source: "testFinishedNeedsTimeout\x0a\x09self should: [ self finished ] raise: Error.\x0a\x09self timeout: 0.\x0a\x09self shouldnt: [ self finished ] raise: Error.",
 messageSends: ["should:raise:", "finished", "timeout:", "shouldnt:raise:"],
 referencedClasses: ["Error"]
 }),
-smalltalk.SUnitAsyncTest);
+globals.SUnitAsyncTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -471,13 +471,13 @@ $ctx1.sendIdx["isAsync"]=2;
 self._assert_($2);
 self._finished();
 self._deny_(self._isAsync());
-return self}, function($ctx1) {$ctx1.fill(self,"testIsAsyncReturnsCorrectValues",{},smalltalk.SUnitAsyncTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testIsAsyncReturnsCorrectValues",{},globals.SUnitAsyncTest)})},
 args: [],
 source: "testIsAsyncReturnsCorrectValues\x0a\x09self deny: self isAsync.\x0a\x09self timeout: 0.\x0a\x09self assert: self isAsync.\x0a\x09self finished.\x0a\x09self deny: self isAsync",
 messageSends: ["deny:", "isAsync", "timeout:", "assert:", "finished"],
 referencedClasses: []
 }),
-smalltalk.SUnitAsyncTest);
+globals.SUnitAsyncTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -495,13 +495,13 @@ self._finished();
 self["@flag"]="ok";
 return self["@flag"];
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})))._valueWithTimeout_((5));
-return self}, function($ctx1) {$ctx1.fill(self,"testPass",{},smalltalk.SUnitAsyncTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testPass",{},globals.SUnitAsyncTest)})},
 args: [],
 source: "testPass\x0a\x09flag := 'bad'.\x0a\x09self timeout: 10.\x0a\x09flag := (self async: [ self assert: true. self finished. flag := 'ok' ]) valueWithTimeout: 5",
 messageSends: ["timeout:", "valueWithTimeout:", "async:", "assert:", "finished"],
 referencedClasses: []
 }),
-smalltalk.SUnitAsyncTest);
+globals.SUnitAsyncTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -510,9 +510,9 @@ protocol: 'tests',
 fn: function (){
 var self=this;
 var suite,runner,result,assertBlock;
-function $TestSuiteRunner(){return smalltalk.TestSuiteRunner||(typeof TestSuiteRunner=="undefined"?nil:TestSuiteRunner)}
-function $Set(){return smalltalk.Set||(typeof Set=="undefined"?nil:Set)}
-function $ResultAnnouncement(){return smalltalk.ResultAnnouncement||(typeof ResultAnnouncement=="undefined"?nil:ResultAnnouncement)}
+function $TestSuiteRunner(){return globals.TestSuiteRunner||(typeof TestSuiteRunner=="undefined"?nil:TestSuiteRunner)}
+function $Set(){return globals.Set||(typeof Set=="undefined"?nil:Set)}
+function $ResultAnnouncement(){return globals.ResultAnnouncement||(typeof ResultAnnouncement=="undefined"?nil:ResultAnnouncement)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2,$3;
 suite=["fakeTimeout", "fakeMultipleTimeoutFailing", "fakeMultipleTimeoutPassing", "testPass"]._collect_((function(each){
@@ -541,13 +541,13 @@ return _st($3)._ifTrue_(assertBlock);
 };
 }, function($ctx2) {$ctx2.fillBlock({ann:ann},$ctx1,3)})}));
 _st(runner)._run();
-return self}, function($ctx1) {$ctx1.fill(self,"testTimeouts",{suite:suite,runner:runner,result:result,assertBlock:assertBlock},smalltalk.SUnitAsyncTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testTimeouts",{suite:suite,runner:runner,result:result,assertBlock:assertBlock},globals.SUnitAsyncTest)})},
 args: [],
 source: "testTimeouts\x0a\x09| suite runner result assertBlock |\x0a\x09suite := #('fakeTimeout' 'fakeMultipleTimeoutFailing' 'fakeMultipleTimeoutPassing' 'testPass') collect: [ :each | self class selector: each ].\x0a\x09runner := TestSuiteRunner on: suite.\x0a\x09self timeout: 200.\x0a\x09result := runner result.\x0a\x09assertBlock := self async: [\x0a\x09\x09self assert: (self selectorSetOf: result errors) equals: Set new.\x0a\x09\x09self assert: (self selectorSetOf: result failures) equals: #('fakeMultipleTimeoutFailing' 'fakeTimeout') asSet.\x0a\x09\x09self finished\x0a\x09].\x0a\x09runner announcer on: ResultAnnouncement do: [ :ann |\x0a\x09\x09ann result == result ifTrue: [ result runs = result total ifTrue: assertBlock ] ].\x0a\x09runner run",
 messageSends: ["collect:", "selector:", "class", "on:", "timeout:", "result", "async:", "assert:equals:", "selectorSetOf:", "errors", "new", "failures", "asSet", "finished", "on:do:", "announcer", "ifTrue:", "==", "=", "runs", "total", "run"],
 referencedClasses: ["TestSuiteRunner", "Set", "ResultAnnouncement"]
 }),
-smalltalk.SUnitAsyncTest);
+globals.SUnitAsyncTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -585,13 +585,13 @@ x=_st(x).__plus((1));
 x;
 return self._assert_equals_(x,(1));
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})})))._valueWithTimeout_((0));
-return self}, function($ctx1) {$ctx1.fill(self,"testTwoAsyncPassesWithFinishedOnlyOneIsRun",{x:x},smalltalk.SUnitAsyncTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testTwoAsyncPassesWithFinishedOnlyOneIsRun",{x:x},globals.SUnitAsyncTest)})},
 args: [],
 source: "testTwoAsyncPassesWithFinishedOnlyOneIsRun\x0a\x09| x |\x0a\x09flag := 'bad'.\x0a\x09self timeout: 10.\x0a\x09x := 0.\x0a\x09flag := (self async: [ self finished. flag := 'ok'. x := x+1. self assert: x equals: 1 ]) valueWithTimeout: 0.\x0a\x09flag := (self async: [ self finished. flag := 'ok'. x := x+1. self assert: x equals: 1 ]) valueWithTimeout: 0.",
 messageSends: ["timeout:", "valueWithTimeout:", "async:", "finished", "+", "assert:equals:"],
 referencedClasses: []
 }),
-smalltalk.SUnitAsyncTest);
+globals.SUnitAsyncTest);
 
 
 });

js/SUnit.js

@@ -1,9 +1,9 @@
-define("amber_core/SUnit", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Objects", "amber_core/Kernel-Exceptions"], function(smalltalk,nil,_st){
+define("amber_core/SUnit", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects", "amber_core/Kernel-Exceptions"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('SUnit');
 smalltalk.packages["SUnit"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('ResultAnnouncement', smalltalk.Object, ['result'], 'SUnit');
-smalltalk.ResultAnnouncement.comment="I get signaled when a `TestCase` has been run.\x0a\x0aMy instances hold the result (instance of `TestResult`) of the test run.";
+smalltalk.addClass('ResultAnnouncement', globals.Object, ['result'], 'SUnit');
+globals.ResultAnnouncement.comment="I get signaled when a `TestCase` has been run.\x0a\x0aMy instances hold the result (instance of `TestResult`) of the test run.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "result",
@@ -19,7 +19,7 @@ source: "result\x0a\x09^ result",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ResultAnnouncement);
+globals.ResultAnnouncement);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -34,12 +34,12 @@ source: "result: aTestResult\x0a\x09result := aTestResult",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ResultAnnouncement);
+globals.ResultAnnouncement);
 
 
 
-smalltalk.addClass('TestCase', smalltalk.Object, ['testSelector', 'asyncTimeout', 'context'], 'SUnit');
-smalltalk.TestCase.comment="I am an implementation of the command pattern to run a test.\x0a\x0a## API\x0a\x0aMy instances are created with the class method `#selector:`,\x0apassing the symbol that names the method to be executed when the test case runs.\x0a\x0aWhen you discover a new fixture, subclass `TestCase` and create a `#test...` method for the first test.\x0aAs that method develops and more `#test...` methods are added, you will find yourself refactoring temps\x0ainto instance variables for the objects in the fixture and overriding `#setUp` to initialize these variables.\x0aAs required, override `#tearDown` to nil references, release objects and deallocate.";
+smalltalk.addClass('TestCase', globals.Object, ['testSelector', 'asyncTimeout', 'context'], 'SUnit');
+globals.TestCase.comment="I am an implementation of the command pattern to run a test.\x0a\x0a## API\x0a\x0aMy instances are created with the class method `#selector:`,\x0apassing the symbol that names the method to be executed when the test case runs.\x0a\x0aWhen you discover a new fixture, subclass `TestCase` and create a `#test...` method for the first test.\x0aAs that method develops and more `#test...` methods are added, you will find yourself refactoring temps\x0ainto instance variables for the objects in the fixture and overriding `#setUp` to initialize these variables.\x0aAs required, override `#tearDown` to nil references, release objects and deallocate.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "assert:",
@@ -48,13 +48,13 @@ fn: function (aBoolean){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._assert_description_(aBoolean,"Assertion failed");
-return self}, function($ctx1) {$ctx1.fill(self,"assert:",{aBoolean:aBoolean},smalltalk.TestCase)})},
+return self}, function($ctx1) {$ctx1.fill(self,"assert:",{aBoolean:aBoolean},globals.TestCase)})},
 args: ["aBoolean"],
 source: "assert: aBoolean\x0a\x09self assert: aBoolean description: 'Assertion failed'",
 messageSends: ["assert:description:"],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -66,13 +66,13 @@ return smalltalk.withContext(function($ctx1) {
 if(! smalltalk.assert(aBoolean)){
 self._signalFailure_(aString);
 };
-return self}, function($ctx1) {$ctx1.fill(self,"assert:description:",{aBoolean:aBoolean,aString:aString},smalltalk.TestCase)})},
+return self}, function($ctx1) {$ctx1.fill(self,"assert:description:",{aBoolean:aBoolean,aString:aString},globals.TestCase)})},
 args: ["aBoolean", "aString"],
 source: "assert: aBoolean description: aString\x0a\x09aBoolean ifFalse: [ self signalFailure: aString ]",
 messageSends: ["ifFalse:", "signalFailure:"],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -92,13 +92,13 @@ $3=_st($4).__comma(_st(actual)._printString());
 $ctx1.sendIdx[","]=1;
 $1=self._assert_description_($2,$3);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"assert:equals:",{actual:actual,expected:expected},smalltalk.TestCase)})},
+}, function($ctx1) {$ctx1.fill(self,"assert:equals:",{actual:actual,expected:expected},globals.TestCase)})},
 args: ["actual", "expected"],
 source: "assert: actual equals: expected\x0a\x09^ self assert: (actual = expected) description: 'Expected: ', expected printString, ' but was: ', actual printString",
 messageSends: ["assert:description:", "=", ",", "printString"],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -119,13 +119,13 @@ return _st(c)._execute_(aBlock);
 };
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})});
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"async:",{aBlock:aBlock,c:c},smalltalk.TestCase)})},
+}, function($ctx1) {$ctx1.fill(self,"async:",{aBlock:aBlock,c:c},globals.TestCase)})},
 args: ["aBlock"],
 source: "async: aBlock\x0a\x09| c |\x0a\x09self errorIfNotAsync: '#async'.\x0a\x09c := context.\x0a\x09^ [ self isAsync ifTrue: [ c execute: aBlock ] ]",
 messageSends: ["errorIfNotAsync:", "ifTrue:", "isAsync", "execute:"],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -140,7 +140,7 @@ source: "context: aRunningTestContext\x0a\x09context := aRunningTestContext",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -150,13 +150,13 @@ fn: function (aBoolean){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._assert_(_st(aBoolean)._not());
-return self}, function($ctx1) {$ctx1.fill(self,"deny:",{aBoolean:aBoolean},smalltalk.TestCase)})},
+return self}, function($ctx1) {$ctx1.fill(self,"deny:",{aBoolean:aBoolean},globals.TestCase)})},
 args: ["aBoolean"],
 source: "deny: aBoolean\x0a\x09self assert: aBoolean not",
 messageSends: ["assert:", "not"],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -170,13 +170,13 @@ $1=self._isAsync();
 if(! smalltalk.assert($1)){
 self._error_(_st(aString).__comma(" used without prior #timeout:"));
 };
-return self}, function($ctx1) {$ctx1.fill(self,"errorIfNotAsync:",{aString:aString},smalltalk.TestCase)})},
+return self}, function($ctx1) {$ctx1.fill(self,"errorIfNotAsync:",{aString:aString},globals.TestCase)})},
 args: ["aString"],
 source: "errorIfNotAsync: aString\x0a\x09self isAsync ifFalse: [\x0a\x09\x09self error: aString, ' used without prior #timeout:' ]",
 messageSends: ["ifFalse:", "isAsync", "error:", ","],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -187,13 +187,13 @@ var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._errorIfNotAsync_("#finished");
 self["@asyncTimeout"]=nil;
-return self}, function($ctx1) {$ctx1.fill(self,"finished",{},smalltalk.TestCase)})},
+return self}, function($ctx1) {$ctx1.fill(self,"finished",{},globals.TestCase)})},
 args: [],
 source: "finished\x0a\x09self errorIfNotAsync: '#finished'.\x0a\x09asyncTimeout := nil",
 messageSends: ["errorIfNotAsync:"],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -205,13 +205,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self["@asyncTimeout"])._notNil();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isAsync",{},smalltalk.TestCase)})},
+}, function($ctx1) {$ctx1.fill(self,"isAsync",{},globals.TestCase)})},
 args: [],
 source: "isAsync\x0a\x09^ asyncTimeout notNil",
 messageSends: ["notNil"],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -222,13 +222,13 @@ var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self["@asyncTimeout"]=nil;
 self._perform_(self._selector());
-return self}, function($ctx1) {$ctx1.fill(self,"performTest",{},smalltalk.TestCase)})},
+return self}, function($ctx1) {$ctx1.fill(self,"performTest",{},globals.TestCase)})},
 args: [],
 source: "performTest\x0a\x09asyncTimeout := nil.\x0a\x09self perform: self selector",
 messageSends: ["perform:", "selector"],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -236,16 +236,16 @@ selector: "runCase",
 protocol: 'running',
 fn: function (){
 var self=this;
-function $TestContext(){return smalltalk.TestContext||(typeof TestContext=="undefined"?nil:TestContext)}
+function $TestContext(){return globals.TestContext||(typeof TestContext=="undefined"?nil:TestContext)}
 return smalltalk.withContext(function($ctx1) { 
 _st(_st($TestContext())._testCase_(self))._start();
-return self}, function($ctx1) {$ctx1.fill(self,"runCase",{},smalltalk.TestCase)})},
+return self}, function($ctx1) {$ctx1.fill(self,"runCase",{},globals.TestCase)})},
 args: [],
 source: "runCase\x0a\x09\x22Runs a test case in isolated context, leaking all errors.\x22\x0a\x0a\x09(TestContext testCase: self) start",
 messageSends: ["start", "testCase:"],
 referencedClasses: ["TestContext"]
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -262,7 +262,7 @@ source: "selector\x0a\x09^ testSelector",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -277,7 +277,7 @@ source: "setTestSelector: aSelector\x0a\x09testSelector := aSelector",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -291,7 +291,7 @@ source: "setUp",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -301,13 +301,13 @@ fn: function (aBlock){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._assert_(_st(aBlock)._value());
-return self}, function($ctx1) {$ctx1.fill(self,"should:",{aBlock:aBlock},smalltalk.TestCase)})},
+return self}, function($ctx1) {$ctx1.fill(self,"should:",{aBlock:aBlock},globals.TestCase)})},
 args: ["aBlock"],
 source: "should: aBlock\x0a\x09self assert: aBlock value",
 messageSends: ["assert:", "value"],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -324,13 +324,13 @@ return false;
 return smalltalk.withContext(function($ctx2) {
 return true;
 }, function($ctx2) {$ctx2.fillBlock({ex:ex},$ctx1,2)})})));
-return self}, function($ctx1) {$ctx1.fill(self,"should:raise:",{aBlock:aBlock,anExceptionClass:anExceptionClass},smalltalk.TestCase)})},
+return self}, function($ctx1) {$ctx1.fill(self,"should:raise:",{aBlock:aBlock,anExceptionClass:anExceptionClass},globals.TestCase)})},
 args: ["aBlock", "anExceptionClass"],
 source: "should: aBlock raise: anExceptionClass\x0a\x09self assert: ([ aBlock value. false ]\x0a\x09\x09on: anExceptionClass\x0a\x09\x09do: [ :ex | true ])",
 messageSends: ["assert:", "on:do:", "value"],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -347,13 +347,13 @@ return true;
 return smalltalk.withContext(function($ctx2) {
 return false;
 }, function($ctx2) {$ctx2.fillBlock({ex:ex},$ctx1,2)})})));
-return self}, function($ctx1) {$ctx1.fill(self,"shouldnt:raise:",{aBlock:aBlock,anExceptionClass:anExceptionClass},smalltalk.TestCase)})},
+return self}, function($ctx1) {$ctx1.fill(self,"shouldnt:raise:",{aBlock:aBlock,anExceptionClass:anExceptionClass},globals.TestCase)})},
 args: ["aBlock", "anExceptionClass"],
 source: "shouldnt: aBlock raise: anExceptionClass\x0a\x09self assert: ([ aBlock value. true ]\x0a\x09\x09on: anExceptionClass\x0a\x09\x09do: [ :ex | false ])",
 messageSends: ["assert:", "on:do:", "value"],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -361,19 +361,19 @@ selector: "signalFailure:",
 protocol: 'private',
 fn: function (aString){
 var self=this;
-function $TestFailure(){return smalltalk.TestFailure||(typeof TestFailure=="undefined"?nil:TestFailure)}
+function $TestFailure(){return globals.TestFailure||(typeof TestFailure=="undefined"?nil:TestFailure)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2;
 $1=_st($TestFailure())._new();
 _st($1)._messageText_(aString);
 $2=_st($1)._signal();
-return self}, function($ctx1) {$ctx1.fill(self,"signalFailure:",{aString:aString},smalltalk.TestCase)})},
+return self}, function($ctx1) {$ctx1.fill(self,"signalFailure:",{aString:aString},globals.TestCase)})},
 args: ["aString"],
 source: "signalFailure: aString\x0a\x09TestFailure new\x0a\x09\x09messageText: aString;\x0a\x09\x09signal",
 messageSends: ["messageText:", "new", "signal"],
 referencedClasses: ["TestFailure"]
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -387,7 +387,7 @@ source: "tearDown",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -408,13 +408,13 @@ self["@asyncTimeout"]=_st(self._async_((function(){
 return smalltalk.withContext(function($ctx2) {
 return self._assert_description_(false,"SUnit grace time exhausted");
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})})))._valueWithTimeout_(aNumber);
-return self}, function($ctx1) {$ctx1.fill(self,"timeout:",{aNumber:aNumber},smalltalk.TestCase)})},
+return self}, function($ctx1) {$ctx1.fill(self,"timeout:",{aNumber:aNumber},globals.TestCase)})},
 args: ["aNumber"],
 source: "timeout: aNumber\x0a\x09\x22Set a grace time timeout in milliseconds to run the test asynchronously\x22\x0a\x09\x0a\x09asyncTimeout ifNotNil: [ asyncTimeout clearTimeout ].\x0a\x09\x0a\x09\x22to allow #async: message send without throwing an error\x22\x0a\x09asyncTimeout := 0.\x0a\x09\x0a\x09asyncTimeout := (self async: [\x0a\x09\x09self assert: false description: 'SUnit grace time exhausted' ])\x0a\x09\x09\x09valueWithTimeout: aNumber",
 messageSends: ["ifNotNil:", "clearTimeout", "valueWithTimeout:", "async:", "assert:description:"],
 referencedClasses: []
 }),
-smalltalk.TestCase);
+globals.TestCase);
 
 
 smalltalk.addMethod(
@@ -433,13 +433,13 @@ _st(selectors)._addAll_(_st(self._superclass())._allTestSelectors());
 };
 $2=selectors;
 return $2;
-}, function($ctx1) {$ctx1.fill(self,"allTestSelectors",{selectors:selectors},smalltalk.TestCase.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"allTestSelectors",{selectors:selectors},globals.TestCase.klass)})},
 args: [],
 source: "allTestSelectors\x0a\x09| selectors |\x0a\x09selectors := self testSelectors.\x0a\x09self shouldInheritSelectors ifTrue: [\x0a\x09\x09selectors addAll: self superclass allTestSelectors ].\x0a\x09^ selectors",
 messageSends: ["testSelectors", "ifTrue:", "shouldInheritSelectors", "addAll:", "allTestSelectors", "superclass"],
 referencedClasses: []
 }),
-smalltalk.TestCase.klass);
+globals.TestCase.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -454,13 +454,13 @@ return smalltalk.withContext(function($ctx2) {
 return self._selector_(each);
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"buildSuite",{},smalltalk.TestCase.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"buildSuite",{},globals.TestCase.klass)})},
 args: [],
 source: "buildSuite\x0a\x09^ self allTestSelectors collect: [ :each | self selector: each ]",
 messageSends: ["collect:", "allTestSelectors", "selector:"],
 referencedClasses: []
 }),
-smalltalk.TestCase.klass);
+globals.TestCase.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -475,7 +475,7 @@ source: "heliosClass\x0a\x09^ 'test'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.TestCase.klass);
+globals.TestCase.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -487,13 +487,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self._name()).__eq("TestCase");
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isAbstract",{},smalltalk.TestCase.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"isAbstract",{},globals.TestCase.klass)})},
 args: [],
 source: "isAbstract\x0a\x09^ self name = 'TestCase'",
 messageSends: ["=", "name"],
 referencedClasses: []
 }),
-smalltalk.TestCase.klass);
+globals.TestCase.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -501,7 +501,7 @@ selector: "lookupHierarchyRoot",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-function $TestCase(){return smalltalk.TestCase||(typeof TestCase=="undefined"?nil:TestCase)}
+function $TestCase(){return globals.TestCase||(typeof TestCase=="undefined"?nil:TestCase)}
 return $TestCase();
 },
 args: [],
@@ -509,7 +509,7 @@ source: "lookupHierarchyRoot\x0a\x09^ TestCase",
 messageSends: [],
 referencedClasses: ["TestCase"]
 }),
-smalltalk.TestCase.klass);
+globals.TestCase.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -524,13 +524,13 @@ _st($2)._setTestSelector_(aSelector);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"selector:",{aSelector:aSelector},smalltalk.TestCase.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"selector:",{aSelector:aSelector},globals.TestCase.klass)})},
 args: ["aSelector"],
 source: "selector: aSelector\x0a\x09^ self new\x0a\x09\x09setTestSelector: aSelector;\x0a\x09\x09yourself",
 messageSends: ["setTestSelector:", "new", "yourself"],
 referencedClasses: []
 }),
-smalltalk.TestCase.klass);
+globals.TestCase.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -542,13 +542,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=self.__tild_eq(self._lookupHierarchyRoot());
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"shouldInheritSelectors",{},smalltalk.TestCase.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"shouldInheritSelectors",{},globals.TestCase.klass)})},
 args: [],
 source: "shouldInheritSelectors\x0a\x09^ self ~= self lookupHierarchyRoot",
 messageSends: ["~=", "lookupHierarchyRoot"],
 referencedClasses: []
 }),
-smalltalk.TestCase.klass);
+globals.TestCase.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -563,17 +563,17 @@ return smalltalk.withContext(function($ctx2) {
 return _st(each)._match_("^test");
 }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"testSelectors",{},smalltalk.TestCase.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"testSelectors",{},globals.TestCase.klass)})},
 args: [],
 source: "testSelectors\x0a\x09^ self methodDictionary keys select: [ :each | each match: '^test' ]",
 messageSends: ["select:", "keys", "methodDictionary", "match:"],
 referencedClasses: []
 }),
-smalltalk.TestCase.klass);
+globals.TestCase.klass);
 
 
-smalltalk.addClass('TestContext', smalltalk.Object, ['testCase'], 'SUnit');
-smalltalk.TestContext.comment="I govern running a particular test case.\x0a\x0aMy main added value is `#execute:` method which runs a block as a part of test case (restores context, nilling it afterwards, cleaning/calling `#tearDown` as appropriate for sync/async scenario).";
+smalltalk.addClass('TestContext', globals.Object, ['testCase'], 'SUnit');
+globals.TestContext.comment="I govern running a particular test case.\x0a\x0aMy main added value is `#execute:` method which runs a block as a part of test case (restores context, nilling it afterwards, cleaning/calling `#tearDown` as appropriate for sync/async scenario).";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute:",
@@ -608,13 +608,13 @@ if(! smalltalk.assert($2)){
 return _st(self["@testCase"])._tearDown();
 };
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"execute:",{aBlock:aBlock,failed:failed},smalltalk.TestContext)})},
+return self}, function($ctx1) {$ctx1.fill(self,"execute:",{aBlock:aBlock,failed:failed},globals.TestContext)})},
 args: ["aBlock"],
 source: "execute: aBlock\x0a\x09| failed |\x0a\x09\x0a\x09testCase context: self.\x0a\x09[\x0a\x09\x09failed := true.\x0a\x09\x09aBlock value.\x0a\x09\x09failed := false\x0a\x09]\x0a\x09\x09ensure: [\x0a\x09\x09\x09testCase context: nil.\x0a\x09\x09\x09\x0a\x09\x09\x09(failed and: [ testCase isAsync ]) ifTrue: [\x0a\x09\x09\x09\x09testCase finished ].\x0a\x09\x09\x09testCase isAsync ifFalse: [\x0a\x09\x09\x09\x09testCase tearDown ] ]",
 messageSends: ["context:", "ensure:", "value", "ifTrue:", "and:", "isAsync", "finished", "ifFalse:", "tearDown"],
 referencedClasses: []
 }),
-smalltalk.TestContext);
+globals.TestContext);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -628,13 +628,13 @@ return smalltalk.withContext(function($ctx2) {
 _st(self["@testCase"])._setUp();
 return _st(self["@testCase"])._performTest();
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"start",{},smalltalk.TestContext)})},
+return self}, function($ctx1) {$ctx1.fill(self,"start",{},globals.TestContext)})},
 args: [],
 source: "start\x0a\x09self execute: [\x0a\x09\x09testCase setUp.\x0a\x09\x09testCase performTest ]",
 messageSends: ["execute:", "setUp", "performTest"],
 referencedClasses: []
 }),
-smalltalk.TestContext);
+globals.TestContext);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -649,7 +649,7 @@ source: "testCase: aTestCase\x0a\x09testCase := aTestCase",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.TestContext);
+globals.TestContext);
 
 
 smalltalk.addMethod(
@@ -665,17 +665,17 @@ _st($2)._testCase_(aTestCase);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"testCase:",{aTestCase:aTestCase},smalltalk.TestContext.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"testCase:",{aTestCase:aTestCase},globals.TestContext.klass)})},
 args: ["aTestCase"],
 source: "testCase: aTestCase\x0a\x09^ self new\x0a\x09\x09testCase: aTestCase;\x0a\x09\x09yourself",
 messageSends: ["testCase:", "new", "yourself"],
 referencedClasses: []
 }),
-smalltalk.TestContext.klass);
+globals.TestContext.klass);
 
 
-smalltalk.addClass('ReportingTestContext', smalltalk.TestContext, ['finished', 'result'], 'SUnit');
-smalltalk.ReportingTestContext.comment="I add `TestResult` reporting to `TestContext`.\x0a\x0aErrors are caught and save into a `TestResult`,\x0aWhen test case is finished (which can be later for async tests), a callback block is executed; this is used by a `TestSuiteRunner`.";
+smalltalk.addClass('ReportingTestContext', globals.TestContext, ['finished', 'result'], 'SUnit');
+globals.ReportingTestContext.comment="I add `TestResult` reporting to `TestContext`.\x0a\x0aErrors are caught and save into a `TestResult`,\x0aWhen test case is finished (which can be later for async tests), a callback block is executed; this is used by a `TestSuiteRunner`.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "execute:",
@@ -688,7 +688,7 @@ _st((function(){
 return smalltalk.withContext(function($ctx2) {
 return self._withErrorReporting_((function(){
 return smalltalk.withContext(function($ctx3) {
-return smalltalk.ReportingTestContext.superclass.fn.prototype._execute_.apply(_st(self), [aBlock]);
+return globals.ReportingTestContext.superclass.fn.prototype._execute_.apply(_st(self), [aBlock]);
 }, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))._ensure_((function(){
 return smalltalk.withContext(function($ctx2) {
@@ -698,13 +698,13 @@ _st(self["@result"])._increaseRuns();
 return _st(self["@finished"])._value();
 };
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,3)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"execute:",{aBlock:aBlock},smalltalk.ReportingTestContext)})},
+return self}, function($ctx1) {$ctx1.fill(self,"execute:",{aBlock:aBlock},globals.ReportingTestContext)})},
 args: ["aBlock"],
 source: "execute: aBlock\x0a\x09[\x0a\x09\x09self withErrorReporting: [ super execute: aBlock ]\x0a\x09]\x0a\x09\x09ensure: [\x0a\x09\x09\x09testCase isAsync ifFalse: [\x0a\x09\x09\x09\x09result increaseRuns. finished value ] ]",
 messageSends: ["ensure:", "withErrorReporting:", "execute:", "ifFalse:", "isAsync", "increaseRuns", "value"],
 referencedClasses: []
 }),
-smalltalk.ReportingTestContext);
+globals.ReportingTestContext);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -719,7 +719,7 @@ source: "finished: aBlock\x0a\x09finished := aBlock",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ReportingTestContext);
+globals.ReportingTestContext);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -734,7 +734,7 @@ source: "result: aTestResult\x0a\x09result := aTestResult",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ReportingTestContext);
+globals.ReportingTestContext);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -742,8 +742,8 @@ selector: "withErrorReporting:",
 protocol: 'private',
 fn: function (aBlock){
 var self=this;
-function $TestFailure(){return smalltalk.TestFailure||(typeof TestFailure=="undefined"?nil:TestFailure)}
-function $Error(){return smalltalk.Error||(typeof Error=="undefined"?nil:Error)}
+function $TestFailure(){return globals.TestFailure||(typeof TestFailure=="undefined"?nil:TestFailure)}
+function $Error(){return globals.Error||(typeof Error=="undefined"?nil:Error)}
 return smalltalk.withContext(function($ctx1) { 
 _st((function(){
 return smalltalk.withContext(function($ctx2) {
@@ -756,13 +756,13 @@ return smalltalk.withContext(function($ctx2) {
 return _st(self["@result"])._addError_(self["@testCase"]);
 }, function($ctx2) {$ctx2.fillBlock({ex:ex},$ctx1,3)})}));
 $ctx1.sendIdx["on:do:"]=1;
-return self}, function($ctx1) {$ctx1.fill(self,"withErrorReporting:",{aBlock:aBlock},smalltalk.ReportingTestContext)})},
+return self}, function($ctx1) {$ctx1.fill(self,"withErrorReporting:",{aBlock:aBlock},globals.ReportingTestContext)})},
 args: ["aBlock"],
 source: "withErrorReporting: aBlock\x0a\x09[ aBlock\x0a\x09\x09on: TestFailure\x0a\x09\x09do: [ :ex | result addFailure: testCase ]\x0a\x09]\x0a\x09\x09on: Error\x0a\x09\x09do: [ :ex | result addError: testCase ]",
 messageSends: ["on:do:", "addFailure:", "addError:"],
 referencedClasses: ["TestFailure", "Error"]
 }),
-smalltalk.ReportingTestContext);
+globals.ReportingTestContext);
 
 
 smalltalk.addMethod(
@@ -773,27 +773,27 @@ fn: function (aTestCase,aTestResult,aBlock){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 var $2,$3,$1;
-$2=smalltalk.ReportingTestContext.klass.superclass.fn.prototype._testCase_.apply(_st(self), [aTestCase]);
+$2=globals.ReportingTestContext.klass.superclass.fn.prototype._testCase_.apply(_st(self), [aTestCase]);
 _st($2)._result_(aTestResult);
 _st($2)._finished_(aBlock);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"testCase:result:finished:",{aTestCase:aTestCase,aTestResult:aTestResult,aBlock:aBlock},smalltalk.ReportingTestContext.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"testCase:result:finished:",{aTestCase:aTestCase,aTestResult:aTestResult,aBlock:aBlock},globals.ReportingTestContext.klass)})},
 args: ["aTestCase", "aTestResult", "aBlock"],
 source: "testCase: aTestCase result: aTestResult finished: aBlock\x0a\x09^ (super testCase: aTestCase)\x0a\x09\x09result: aTestResult;\x0a\x09\x09finished: aBlock;\x0a\x09\x09yourself",
 messageSends: ["result:", "testCase:", "finished:", "yourself"],
 referencedClasses: []
 }),
-smalltalk.ReportingTestContext.klass);
+globals.ReportingTestContext.klass);
 
 
-smalltalk.addClass('TestFailure', smalltalk.Error, [], 'SUnit');
-smalltalk.TestFailure.comment="I am raised when the boolean parameter of an #`assert:` or `#deny:` call is the opposite of what the assertion claims.\x0a\x0aThe test framework distinguishes between failures and errors.\x0aA failure is an event whose possibiity is explicitly anticipated and checked for in an assertion,\x0awhereas an error is an unanticipated problem like a division by 0 or an index out of bounds.";
+smalltalk.addClass('TestFailure', globals.Error, [], 'SUnit');
+globals.TestFailure.comment="I am raised when the boolean parameter of an #`assert:` or `#deny:` call is the opposite of what the assertion claims.\x0a\x0aThe test framework distinguishes between failures and errors.\x0aA failure is an event whose possibiity is explicitly anticipated and checked for in an assertion,\x0awhereas an error is an unanticipated problem like a division by 0 or an index out of bounds.";
 
 
-smalltalk.addClass('TestResult', smalltalk.Object, ['timestamp', 'runs', 'errors', 'failures', 'total'], 'SUnit');
-smalltalk.TestResult.comment="I implement the collecting parameter pattern for running a bunch of tests.\x0a\x0aMy instances hold tests that have run, sorted into the result categories of passed, failures and errors.\x0a\x0a`TestResult` is an interesting object to subclass or substitute. `#runCase:` is the external protocol you need to reproduce";
+smalltalk.addClass('TestResult', globals.Object, ['timestamp', 'runs', 'errors', 'failures', 'total'], 'SUnit');
+globals.TestResult.comment="I implement the collecting parameter pattern for running a bunch of tests.\x0a\x0aMy instances hold tests that have run, sorted into the result categories of passed, failures and errors.\x0a\x0a`TestResult` is an interesting object to subclass or substitute. `#runCase:` is the external protocol you need to reproduce";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "addError:",
@@ -802,13 +802,13 @@ fn: function (anError){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._errors())._add_(anError);
-return self}, function($ctx1) {$ctx1.fill(self,"addError:",{anError:anError},smalltalk.TestResult)})},
+return self}, function($ctx1) {$ctx1.fill(self,"addError:",{anError:anError},globals.TestResult)})},
 args: ["anError"],
 source: "addError: anError\x0a\x09self errors add: anError",
 messageSends: ["add:", "errors"],
 referencedClasses: []
 }),
-smalltalk.TestResult);
+globals.TestResult);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -818,13 +818,13 @@ fn: function (aFailure){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self._failures())._add_(aFailure);
-return self}, function($ctx1) {$ctx1.fill(self,"addFailure:",{aFailure:aFailure},smalltalk.TestResult)})},
+return self}, function($ctx1) {$ctx1.fill(self,"addFailure:",{aFailure:aFailure},globals.TestResult)})},
 args: ["aFailure"],
 source: "addFailure: aFailure\x0a\x09self failures add: aFailure",
 messageSends: ["add:", "failures"],
 referencedClasses: []
 }),
-smalltalk.TestResult);
+globals.TestResult);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -841,7 +841,7 @@ source: "errors\x0a\x09^ errors",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.TestResult);
+globals.TestResult);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -858,7 +858,7 @@ source: "failures\x0a\x09^ failures",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.TestResult);
+globals.TestResult);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -868,13 +868,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self["@runs"]=_st(self["@runs"]).__plus((1));
-return self}, function($ctx1) {$ctx1.fill(self,"increaseRuns",{},smalltalk.TestResult)})},
+return self}, function($ctx1) {$ctx1.fill(self,"increaseRuns",{},globals.TestResult)})},
 args: [],
 source: "increaseRuns\x0a\x09runs := runs + 1",
 messageSends: ["+"],
 referencedClasses: []
 }),
-smalltalk.TestResult);
+globals.TestResult);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -882,23 +882,23 @@ selector: "initialize",
 protocol: 'initialization',
 fn: function (){
 var self=this;
-function $Date(){return smalltalk.Date||(typeof Date=="undefined"?nil:Date)}
-function $Array(){return smalltalk.Array||(typeof Array=="undefined"?nil:Array)}
+function $Date(){return globals.Date||(typeof Date=="undefined"?nil:Date)}
+function $Array(){return globals.Array||(typeof Array=="undefined"?nil:Array)}
 return smalltalk.withContext(function($ctx1) { 
-smalltalk.TestResult.superclass.fn.prototype._initialize.apply(_st(self), []);
+globals.TestResult.superclass.fn.prototype._initialize.apply(_st(self), []);
 self["@timestamp"]=_st($Date())._now();
 self["@runs"]=(0);
 self["@errors"]=_st($Array())._new();
 $ctx1.sendIdx["new"]=1;
 self["@failures"]=_st($Array())._new();
 self["@total"]=(0);
-return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},smalltalk.TestResult)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.TestResult)})},
 args: [],
 source: "initialize\x0a\x09super initialize.\x0a\x09timestamp := Date now.\x0a\x09runs := 0.\x0a\x09errors := Array new.\x0a\x09failures := Array new.\x0a\x09total := 0",
 messageSends: ["initialize", "now", "new"],
 referencedClasses: ["Date", "Array"]
 }),
-smalltalk.TestResult);
+globals.TestResult);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -915,13 +915,13 @@ if(! smalltalk.assert($2)){
 $1=_st(aBlock)._value_(_st(self._runs()).__plus((1)));
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"nextRunDo:",{aBlock:aBlock},smalltalk.TestResult)})},
+}, function($ctx1) {$ctx1.fill(self,"nextRunDo:",{aBlock:aBlock},globals.TestResult)})},
 args: ["aBlock"],
 source: "nextRunDo: aBlock\x0a\x09\x22Runs aBlock with index of next run or does nothing if no more runs\x22\x0a\x09^ self runs == self total\x0a\x09\x09ifFalse: [ aBlock value: self runs + 1 ]",
 messageSends: ["ifFalse:", "==", "runs", "total", "value:", "+"],
 referencedClasses: []
 }),
-smalltalk.TestResult);
+globals.TestResult);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -929,8 +929,8 @@ selector: "runCase:",
 protocol: 'running',
 fn: function (aTestCase){
 var self=this;
-function $TestFailure(){return smalltalk.TestFailure||(typeof TestFailure=="undefined"?nil:TestFailure)}
-function $Error(){return smalltalk.Error||(typeof Error=="undefined"?nil:Error)}
+function $TestFailure(){return globals.TestFailure||(typeof TestFailure=="undefined"?nil:TestFailure)}
+function $Error(){return globals.Error||(typeof Error=="undefined"?nil:Error)}
 return smalltalk.withContext(function($ctx1) { 
 _st((function(){
 return smalltalk.withContext(function($ctx2) {
@@ -947,13 +947,13 @@ return smalltalk.withContext(function($ctx2) {
 return self._addError_(aTestCase);
 }, function($ctx2) {$ctx2.fillBlock({ex:ex},$ctx1,4)})}));
 $ctx1.sendIdx["on:do:"]=1;
-return self}, function($ctx1) {$ctx1.fill(self,"runCase:",{aTestCase:aTestCase},smalltalk.TestResult)})},
+return self}, function($ctx1) {$ctx1.fill(self,"runCase:",{aTestCase:aTestCase},globals.TestResult)})},
 args: ["aTestCase"],
 source: "runCase: aTestCase\x0a\x09[ [ self increaseRuns.\x0a\x09\x09aTestCase runCase ]\x0a\x09on: TestFailure do: [ :ex | self addFailure: aTestCase ]]\x0a\x09on: Error do: [ :ex | self addError: aTestCase ]",
 messageSends: ["on:do:", "increaseRuns", "runCase", "addFailure:", "addError:"],
 referencedClasses: ["TestFailure", "Error"]
 }),
-smalltalk.TestResult);
+globals.TestResult);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -970,7 +970,7 @@ source: "runs\x0a\x09^ runs",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.TestResult);
+globals.TestResult);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -993,13 +993,13 @@ $1="failure";
 $1="error";
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"status",{},smalltalk.TestResult)})},
+}, function($ctx1) {$ctx1.fill(self,"status",{},globals.TestResult)})},
 args: [],
 source: "status\x0a\x09^ self errors isEmpty\x0a\x09\x09ifTrue: [\x0a\x09\x09\x09self failures isEmpty\x0a\x09\x09\x09\x09ifTrue: [ 'success' ]\x0a\x09\x09\x09\x09ifFalse: [ 'failure' ]]\x0a\x09\x09ifFalse: [ 'error' ]",
 messageSends: ["ifTrue:ifFalse:", "isEmpty", "errors", "failures"],
 referencedClasses: []
 }),
-smalltalk.TestResult);
+globals.TestResult);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1016,7 +1016,7 @@ source: "timestamp\x0a\x09^ timestamp",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.TestResult);
+globals.TestResult);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1033,7 +1033,7 @@ source: "total\x0a\x09^ total",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.TestResult);
+globals.TestResult);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1048,12 +1048,12 @@ source: "total: aNumber\x0a\x09total := aNumber",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.TestResult);
+globals.TestResult);
 
 
 
-smalltalk.addClass('TestSuiteRunner', smalltalk.Object, ['suite', 'result', 'announcer', 'runNextTest'], 'SUnit');
-smalltalk.TestSuiteRunner.comment="I am responsible for running a collection (`suite`) of tests.\x0a\x0a## API\x0a\x0aInstances should be created using the class-side `#on:` method, taking a collection of tests to run as parameter.\x0aTo run the test suite, use `#run`.";
+smalltalk.addClass('TestSuiteRunner', globals.Object, ['suite', 'result', 'announcer', 'runNextTest'], 'SUnit');
+globals.TestSuiteRunner.comment="I am responsible for running a collection (`suite`) of tests.\x0a\x0a## API\x0a\x0aInstances should be created using the class-side `#on:` method, taking a collection of tests to run as parameter.\x0aTo run the test suite, use `#run`.";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "announcer",
@@ -1069,7 +1069,7 @@ source: "announcer\x0a\x09^ announcer",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.TestSuiteRunner);
+globals.TestSuiteRunner);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1077,7 +1077,7 @@ selector: "contextOf:",
 protocol: 'private',
 fn: function (anInteger){
 var self=this;
-function $ReportingTestContext(){return smalltalk.ReportingTestContext||(typeof ReportingTestContext=="undefined"?nil:ReportingTestContext)}
+function $ReportingTestContext(){return globals.ReportingTestContext||(typeof ReportingTestContext=="undefined"?nil:ReportingTestContext)}
 return smalltalk.withContext(function($ctx1) { 
 var $1;
 $1=_st($ReportingTestContext())._testCase_result_finished_(_st(self["@suite"])._at_(anInteger),self["@result"],(function(){
@@ -1085,13 +1085,13 @@ return smalltalk.withContext(function($ctx2) {
 return self._resume();
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"contextOf:",{anInteger:anInteger},smalltalk.TestSuiteRunner)})},
+}, function($ctx1) {$ctx1.fill(self,"contextOf:",{anInteger:anInteger},globals.TestSuiteRunner)})},
 args: ["anInteger"],
 source: "contextOf: anInteger\x0a\x09^ ReportingTestContext testCase: (suite at: anInteger) result: result finished: [ self resume ]",
 messageSends: ["testCase:result:finished:", "at:", "resume"],
 referencedClasses: ["ReportingTestContext"]
 }),
-smalltalk.TestSuiteRunner);
+globals.TestSuiteRunner);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1099,11 +1099,11 @@ selector: "initialize",
 protocol: 'initialization',
 fn: function (){
 var self=this;
-function $Announcer(){return smalltalk.Announcer||(typeof Announcer=="undefined"?nil:Announcer)}
-function $TestResult(){return smalltalk.TestResult||(typeof TestResult=="undefined"?nil:TestResult)}
+function $Announcer(){return globals.Announcer||(typeof Announcer=="undefined"?nil:Announcer)}
+function $TestResult(){return globals.TestResult||(typeof TestResult=="undefined"?nil:TestResult)}
 return smalltalk.withContext(function($ctx1) { 
 var $1;
-smalltalk.TestSuiteRunner.superclass.fn.prototype._initialize.apply(_st(self), []);
+globals.TestSuiteRunner.superclass.fn.prototype._initialize.apply(_st(self), []);
 self["@announcer"]=_st($Announcer())._new();
 $ctx1.sendIdx["new"]=1;
 self["@result"]=_st($TestResult())._new();
@@ -1117,13 +1117,13 @@ if(smalltalk.assert($1)){
 return _st(self._contextOf_(_st(runs).__plus((1))))._start();
 };
 }, function($ctx2) {$ctx2.fillBlock({runs:runs},$ctx1,1)})});
-return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},smalltalk.TestSuiteRunner)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.TestSuiteRunner)})},
 args: [],
 source: "initialize\x0a\x09super initialize.\x0a\x09announcer := Announcer new.\x0a\x09result := TestResult new.\x0a\x09runNextTest := [ | runs | runs := result runs. runs < result total ifTrue: [ (self contextOf: runs + 1) start ] ].",
 messageSends: ["initialize", "new", "runs", "ifTrue:", "<", "total", "start", "contextOf:", "+"],
 referencedClasses: ["Announcer", "TestResult"]
 }),
-smalltalk.TestSuiteRunner);
+globals.TestSuiteRunner);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1140,7 +1140,7 @@ source: "result\x0a\x09^ result",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.TestSuiteRunner);
+globals.TestSuiteRunner);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1148,17 +1148,17 @@ selector: "resume",
 protocol: 'actions',
 fn: function (){
 var self=this;
-function $ResultAnnouncement(){return smalltalk.ResultAnnouncement||(typeof ResultAnnouncement=="undefined"?nil:ResultAnnouncement)}
+function $ResultAnnouncement(){return globals.ResultAnnouncement||(typeof ResultAnnouncement=="undefined"?nil:ResultAnnouncement)}
 return smalltalk.withContext(function($ctx1) { 
 _st(self["@runNextTest"])._fork();
 _st(self["@announcer"])._announce_(_st(_st($ResultAnnouncement())._new())._result_(self["@result"]));
-return self}, function($ctx1) {$ctx1.fill(self,"resume",{},smalltalk.TestSuiteRunner)})},
+return self}, function($ctx1) {$ctx1.fill(self,"resume",{},globals.TestSuiteRunner)})},
 args: [],
 source: "resume\x0a\x09runNextTest fork.\x0a\x09announcer announce: (ResultAnnouncement new result: result)",
 messageSends: ["fork", "announce:", "result:", "new"],
 referencedClasses: ["ResultAnnouncement"]
 }),
-smalltalk.TestSuiteRunner);
+globals.TestSuiteRunner);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1169,13 +1169,13 @@ var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self["@result"])._total_(_st(self["@suite"])._size());
 self._resume();
-return self}, function($ctx1) {$ctx1.fill(self,"run",{},smalltalk.TestSuiteRunner)})},
+return self}, function($ctx1) {$ctx1.fill(self,"run",{},globals.TestSuiteRunner)})},
 args: [],
 source: "run\x0a\x09result total: suite size.\x0a\x09self resume",
 messageSends: ["total:", "size", "resume"],
 referencedClasses: []
 }),
-smalltalk.TestSuiteRunner);
+globals.TestSuiteRunner);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1190,7 +1190,7 @@ source: "suite: aCollection\x0a\x09suite := aCollection",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.TestSuiteRunner);
+globals.TestSuiteRunner);
 
 
 smalltalk.addMethod(
@@ -1201,13 +1201,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._shouldNotImplement();
-return self}, function($ctx1) {$ctx1.fill(self,"new",{},smalltalk.TestSuiteRunner.klass)})},
+return self}, function($ctx1) {$ctx1.fill(self,"new",{},globals.TestSuiteRunner.klass)})},
 args: [],
 source: "new\x0a\x09self shouldNotImplement",
 messageSends: ["shouldNotImplement"],
 referencedClasses: []
 }),
-smalltalk.TestSuiteRunner.klass);
+globals.TestSuiteRunner.klass);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -1217,14 +1217,14 @@ fn: function (aCollection){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 var $1;
-$1=_st(smalltalk.TestSuiteRunner.klass.superclass.fn.prototype._new.apply(_st(self), []))._suite_(aCollection);
+$1=_st(globals.TestSuiteRunner.klass.superclass.fn.prototype._new.apply(_st(self), []))._suite_(aCollection);
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"on:",{aCollection:aCollection},smalltalk.TestSuiteRunner.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"on:",{aCollection:aCollection},globals.TestSuiteRunner.klass)})},
 args: ["aCollection"],
 source: "on: aCollection\x0a\x09^ super new suite: aCollection",
 messageSends: ["suite:", "new"],
 referencedClasses: []
 }),
-smalltalk.TestSuiteRunner.klass);
+globals.TestSuiteRunner.klass);
 
 });

js/Spaces.js

@@ -1,9 +1,9 @@
-define("amber_core/Spaces", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Objects", "amber_core/Kernel-Exceptions", "amber_core/SUnit"], function(smalltalk,nil,_st){
+define("amber_core/Spaces", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/Kernel-Objects", "amber_core/Kernel-Exceptions", "amber_core/SUnit"], function(smalltalk,nil,_st, globals){
 smalltalk.addPackage('Spaces');
 smalltalk.packages["Spaces"].transport = {"type":"amd","amdNamespace":"amber_core"};
 
-smalltalk.addClass('ObjectSpace', smalltalk.Object, ['frame'], 'Spaces');
-smalltalk.ObjectSpace.comment="I am a connection to another Smalltalk environment.\x0aThe implementation creates an iframe on the same location as the window, and connect to the Amber environment.\x0a\x0a\x0a\x0a## Usage example:\x0a\x0a\x09| space |\x0a\x09\x0a\x09space := ObjectSpace new.\x0a\x09space do: [ smalltalk ] \x22Answers aSmalltalk\x22\x0a\x09(space do: [ smalltalk ]) == smalltalk \x22Answers false\x22\x0a\x09\x0a\x09space release \x22Remove the object space environment\x22";
+smalltalk.addClass('ObjectSpace', globals.Object, ['frame'], 'Spaces');
+globals.ObjectSpace.comment="I am a connection to another Smalltalk environment.\x0aThe implementation creates an iframe on the same location as the window, and connect to the Amber environment.\x0a\x0a\x0a\x0a## Usage example:\x0a\x0a\x09| space |\x0a\x09\x0a\x09space := ObjectSpace new.\x0a\x09space do: [ smalltalk ] \x22Answers aSmalltalk\x22\x0a\x09(space do: [ smalltalk ]) == smalltalk \x22Answers false\x22\x0a\x09\x0a\x09space release \x22Remove the object space environment\x22";
 smalltalk.addMethod(
 smalltalk.method({
 selector: "connectTo:",
@@ -13,13 +13,13 @@ var self=this;
 return smalltalk.withContext(function($ctx1) { 
 self._release();
 self["@frame"]=aFrame;
-return self}, function($ctx1) {$ctx1.fill(self,"connectTo:",{aFrame:aFrame},smalltalk.ObjectSpace)})},
+return self}, function($ctx1) {$ctx1.fill(self,"connectTo:",{aFrame:aFrame},globals.ObjectSpace)})},
 args: ["aFrame"],
 source: "connectTo: aFrame\x0a\x09self release.\x0a\x09frame := aFrame",
 messageSends: ["release"],
 referencedClasses: []
 }),
-smalltalk.ObjectSpace);
+globals.ObjectSpace);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -34,13 +34,13 @@ $ctx1.sendIdx["asJQuery"]=1;
 _st($1)._append_("<iframe style=\x22display: none;\x22></iframe>");
 self["@frame"]=_st(_st("iframe"._asJQuery())._get())._last();
 _st(_st(self["@frame"])._contentWindow())._location_(_st(window)._location());
-return self}, function($ctx1) {$ctx1.fill(self,"create",{},smalltalk.ObjectSpace)})},
+return self}, function($ctx1) {$ctx1.fill(self,"create",{},globals.ObjectSpace)})},
 args: [],
 source: "create\x0a\x09'body' asJQuery append: '<iframe style=\x22display: none;\x22></iframe>'.\x0a\x09frame := 'iframe' asJQuery get last.\x0a\x09frame contentWindow location: window location",
 messageSends: ["append:", "asJQuery", "last", "get", "location:", "contentWindow", "location"],
 referencedClasses: []
 }),
-smalltalk.ObjectSpace);
+globals.ObjectSpace);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -58,13 +58,13 @@ $1;
 };
 _st(_st(self["@frame"])._asJQuery())._remove();
 self._release();
-return self}, function($ctx1) {$ctx1.fill(self,"destroy",{},smalltalk.ObjectSpace)})},
+return self}, function($ctx1) {$ctx1.fill(self,"destroy",{},globals.ObjectSpace)})},
 args: [],
 source: "destroy\x0a\x09frame ifNil: [ ^ self ].\x0a\x09frame asJQuery remove.\x0a\x0a\x09self release",
 messageSends: ["ifNil:", "remove", "asJQuery", "release"],
 referencedClasses: []
 }),
-smalltalk.ObjectSpace);
+globals.ObjectSpace);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -72,7 +72,7 @@ selector: "do:",
 protocol: 'evaluating',
 fn: function (aBlock){
 var self=this;
-function $ObjectSpaceConnectionError(){return smalltalk.ObjectSpaceConnectionError||(typeof ObjectSpaceConnectionError=="undefined"?nil:ObjectSpaceConnectionError)}
+function $ObjectSpaceConnectionError(){return globals.ObjectSpaceConnectionError||(typeof ObjectSpaceConnectionError=="undefined"?nil:ObjectSpaceConnectionError)}
 return smalltalk.withContext(function($ctx1) { 
 var $1,$2,$4,$5,$3;
 $1=self._isConnected();
@@ -85,13 +85,13 @@ $5=_st("(".__comma(_st(aBlock)._compiledSource())).__comma(")()");
 $ctx1.sendIdx[","]=1;
 $3=_st($4)._eval_($5);
 return $3;
-}, function($ctx1) {$ctx1.fill(self,"do:",{aBlock:aBlock},smalltalk.ObjectSpace)})},
+}, function($ctx1) {$ctx1.fill(self,"do:",{aBlock:aBlock},globals.ObjectSpace)})},
 args: ["aBlock"],
 source: "do: aBlock\x0a\x09self isConnected ifFalse: [ ^ ObjectSpaceConnectionError signal ].\x0a\x09^ frame contentWindow eval: '(', aBlock compiledSource, ')()'",
 messageSends: ["ifFalse:", "isConnected", "signal", "eval:", "contentWindow", ",", "compiledSource"],
 referencedClasses: ["ObjectSpaceConnectionError"]
 }),
-smalltalk.ObjectSpace);
+globals.ObjectSpace);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -108,7 +108,7 @@ source: "frame\x0a\x09^ frame",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ObjectSpace);
+globals.ObjectSpace);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -117,15 +117,15 @@ protocol: 'initialization',
 fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
-smalltalk.ObjectSpace.superclass.fn.prototype._initialize.apply(_st(self), []);
+globals.ObjectSpace.superclass.fn.prototype._initialize.apply(_st(self), []);
 self._create();
-return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},smalltalk.ObjectSpace)})},
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.ObjectSpace)})},
 args: [],
 source: "initialize\x0a\x09super initialize.\x0a\x09self create",
 messageSends: ["initialize", "create"],
 referencedClasses: []
 }),
-smalltalk.ObjectSpace);
+globals.ObjectSpace);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -137,13 +137,13 @@ return smalltalk.withContext(function($ctx1) {
 var $1;
 $1=_st(self._frame())._notNil();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isConnected",{},smalltalk.ObjectSpace)})},
+}, function($ctx1) {$ctx1.fill(self,"isConnected",{},globals.ObjectSpace)})},
 args: [],
 source: "isConnected\x0a\x09^ self frame notNil",
 messageSends: ["notNil", "frame"],
 referencedClasses: []
 }),
-smalltalk.ObjectSpace);
+globals.ObjectSpace);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -158,7 +158,7 @@ source: "release\x0a\x09frame := nil",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ObjectSpace);
+globals.ObjectSpace);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -168,13 +168,13 @@ fn: function (aBlock){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(_st(self["@frame"])._asJQuery())._bind_do_("load",aBlock);
-return self}, function($ctx1) {$ctx1.fill(self,"whenReadyDo:",{aBlock:aBlock},smalltalk.ObjectSpace)})},
+return self}, function($ctx1) {$ctx1.fill(self,"whenReadyDo:",{aBlock:aBlock},globals.ObjectSpace)})},
 args: ["aBlock"],
 source: "whenReadyDo: aBlock\x0a\x09frame asJQuery\x0a\x09\x09bind: 'load'\x0a\x09\x09do: aBlock",
 messageSends: ["bind:do:", "asJQuery"],
 referencedClasses: []
 }),
-smalltalk.ObjectSpace);
+globals.ObjectSpace);
 
 
 smalltalk.addMethod(
@@ -190,16 +190,16 @@ _st($2)._connectTo_(aFrame);
 $3=_st($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"on:",{aFrame:aFrame},smalltalk.ObjectSpace.klass)})},
+}, function($ctx1) {$ctx1.fill(self,"on:",{aFrame:aFrame},globals.ObjectSpace.klass)})},
 args: ["aFrame"],
 source: "on: aFrame\x0a\x09^ self basicNew\x0a\x09\x09connectTo: aFrame;\x0a\x09\x09yourself",
 messageSends: ["connectTo:", "basicNew", "yourself"],
 referencedClasses: []
 }),
-smalltalk.ObjectSpace.klass);
+globals.ObjectSpace.klass);
 
 
-smalltalk.addClass('ObjectSpaceConnectionError', smalltalk.Error, [], 'Spaces');
+smalltalk.addClass('ObjectSpaceConnectionError', globals.Error, [], 'Spaces');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "messageText",
@@ -213,27 +213,27 @@ source: "messageText\x0a\x09^ 'The ObjectSpace is not connected'",
 messageSends: [],
 referencedClasses: []
 }),
-smalltalk.ObjectSpaceConnectionError);
+globals.ObjectSpaceConnectionError);
 
 
 
-smalltalk.addClass('ObjectSpaceTest', smalltalk.TestCase, ['space'], 'Spaces');
+smalltalk.addClass('ObjectSpaceTest', globals.TestCase, ['space'], 'Spaces');
 smalltalk.addMethod(
 smalltalk.method({
 selector: "setUp",
 protocol: 'initialization',
 fn: function (){
 var self=this;
-function $ObjectSpace(){return smalltalk.ObjectSpace||(typeof ObjectSpace=="undefined"?nil:ObjectSpace)}
+function $ObjectSpace(){return globals.ObjectSpace||(typeof ObjectSpace=="undefined"?nil:ObjectSpace)}
 return smalltalk.withContext(function($ctx1) { 
 self["@space"]=_st($ObjectSpace())._new();
-return self}, function($ctx1) {$ctx1.fill(self,"setUp",{},smalltalk.ObjectSpaceTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"setUp",{},globals.ObjectSpaceTest)})},
 args: [],
 source: "setUp\x0a\x09space := ObjectSpace new",
 messageSends: ["new"],
 referencedClasses: ["ObjectSpace"]
 }),
-smalltalk.ObjectSpaceTest);
+globals.ObjectSpaceTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -243,13 +243,13 @@ fn: function (){
 var self=this;
 return smalltalk.withContext(function($ctx1) { 
 _st(self["@space"])._destroy();
-return self}, function($ctx1) {$ctx1.fill(self,"tearDown",{},smalltalk.ObjectSpaceTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"tearDown",{},globals.ObjectSpaceTest)})},
 args: [],
 source: "tearDown\x0a\x09space destroy",
 messageSends: ["destroy"],
 referencedClasses: []
 }),
-smalltalk.ObjectSpaceTest);
+globals.ObjectSpaceTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -257,7 +257,7 @@ selector: "testConnection",
 protocol: 'tests',
 fn: function (){
 var self=this;
-function $ObjectSpaceConnectionError(){return smalltalk.ObjectSpaceConnectionError||(typeof ObjectSpaceConnectionError=="undefined"?nil:ObjectSpaceConnectionError)}
+function $ObjectSpaceConnectionError(){return globals.ObjectSpaceConnectionError||(typeof ObjectSpaceConnectionError=="undefined"?nil:ObjectSpaceConnectionError)}
 return smalltalk.withContext(function($ctx1) { 
 _st(self["@space"])._destroy();
 self._deny_(_st(self["@space"])._isConnected());
@@ -267,13 +267,13 @@ return _st(self["@space"])._do_((function(){
 return smalltalk.withContext(function($ctx3) {
 }, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}),$ObjectSpaceConnectionError());
-return self}, function($ctx1) {$ctx1.fill(self,"testConnection",{},smalltalk.ObjectSpaceTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testConnection",{},globals.ObjectSpaceTest)})},
 args: [],
 source: "testConnection\x0a\x09space destroy.\x0a\x09self deny: space isConnected.\x0a\x09self should: [ space do: [] ] raise: ObjectSpaceConnectionError",
 messageSends: ["destroy", "deny:", "isConnected", "should:raise:", "do:"],
 referencedClasses: ["ObjectSpaceConnectionError"]
 }),
-smalltalk.ObjectSpaceTest);
+globals.ObjectSpaceTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -285,13 +285,13 @@ return smalltalk.withContext(function($ctx1) {
 self._assert_(_st(_st(self["@space"])._frame())._notNil());
 $ctx1.sendIdx["assert:"]=1;
 self._assert_(_st(self["@space"])._isConnected());
-return self}, function($ctx1) {$ctx1.fill(self,"testCreate",{},smalltalk.ObjectSpaceTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testCreate",{},globals.ObjectSpaceTest)})},
 args: [],
 source: "testCreate\x0a\x0a\x09self assert: space frame notNil.\x0a\x09self assert: space isConnected",
 messageSends: ["assert:", "notNil", "frame", "isConnected"],
 referencedClasses: []
 }),
-smalltalk.ObjectSpaceTest);
+globals.ObjectSpaceTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -300,7 +300,7 @@ protocol: 'tests',
 fn: function (){
 var self=this;
 var result;
-function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
+function $Smalltalk(){return globals.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
 return smalltalk.withContext(function($ctx1) { 
 var $2,$1;
 _st(self["@space"])._whenReadyDo_((function(){
@@ -318,13 +318,13 @@ self._deny_(_st(_st(result)._class()).__eq($Smalltalk()));
 $ctx2.sendIdx["deny:"]=1;
 return self._deny_(_st(result).__eq_eq(smalltalk));
 }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"testEvaluation",{result:result},smalltalk.ObjectSpaceTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testEvaluation",{result:result},globals.ObjectSpaceTest)})},
 args: [],
 source: "testEvaluation\x0a\x09| result |\x0a\x0a\x09space whenReadyDo: [\x0a\x09\x09result := space do: [ smalltalk ].\x0a\x0a\x09\x09self assert: result class name equals: 'Smalltalk'.\x0a\x09\x09self deny: result class = Smalltalk.\x0a\x09\x09self deny: result == smalltalk ]",
 messageSends: ["whenReadyDo:", "do:", "assert:equals:", "name", "class", "deny:", "=", "=="],
 referencedClasses: ["Smalltalk"]
 }),
-smalltalk.ObjectSpaceTest);
+globals.ObjectSpaceTest);
 
 smalltalk.addMethod(
 smalltalk.method({
@@ -341,13 +341,13 @@ $ctx1.sendIdx["isNil"]=1;
 self._deny_($1);
 _st(self["@space"])._release();
 self._assert_(_st(_st(self["@space"])._frame())._isNil());
-return self}, function($ctx1) {$ctx1.fill(self,"testRelease",{},smalltalk.ObjectSpaceTest)})},
+return self}, function($ctx1) {$ctx1.fill(self,"testRelease",{},globals.ObjectSpaceTest)})},
 args: [],
 source: "testRelease\x0a\x0a\x09self deny: space frame isNil.\x0a\x0a\x09space release.\x0a\x09\x0a\x09self assert: space frame isNil",
 messageSends: ["deny:", "isNil", "frame", "release", "assert:"],
 referencedClasses: []
 }),
-smalltalk.ObjectSpaceTest);
+globals.ObjectSpaceTest);
 
 
 });

st/Compiler-Core.st

@@ -223,6 +223,11 @@ Object subclass: #DoIt
 !DoIt commentStamp!
 `DoIt` is the class used to compile and evaluate expressions. See `Compiler >> evaluateExpression:`.!
 
+!DoIt methodsFor: 'tests'!
+
+foo ^ Array new add: 3; add: 4; yourself
+! !
+
 Object subclass: #NodeVisitor
 	instanceVariableNames: ''
 	package: 'Compiler-Core'!

st/Compiler-IR.st

@@ -1135,7 +1135,7 @@ nextPutClassRefFunction: aString
 	stream
 		nextPutAll: 'function $';
 		nextPutAll: aString;
-		nextPutAll: '(){return smalltalk.';
+		nextPutAll: '(){return globals.';
 		nextPutAll: aString;
 		nextPutAll: '||(typeof ';
 		nextPutAll: aString;

st/IDE.st

@@ -2342,6 +2342,23 @@ inspectOn: anInspector
 	anInspector setLabel: label
 ! !
 
+!MethodContext methodsFor: '*IDE'!
+
+inspectOn: anInspector
+	| variables |
+	variables := Dictionary new.
+	variables at: '#self' put: self.
+	variables at: '#home' put: self home.
+	variables at: '#receiver' put: self receiver.
+	variables at: '#selector' put: self selector.
+	variables at: '#temps' put: self temps.
+	self class instanceVariableNames do: [ :each |
+		variables at: each put: (self instVarAt: each) ].
+	anInspector
+		setLabel: self printString;
+		setVariables: variables
+! !
+
 !AssociativeCollection methodsFor: '*IDE'!
 
 inspectOn: anInspector
@@ -2371,20 +2388,3 @@ inspectOn: anInspector
 		setVariables: variables
 ! !
 
-!MethodContext methodsFor: '*IDE'!
-
-inspectOn: anInspector
-	| variables |
-	variables := Dictionary new.
-	variables at: '#self' put: self.
-	variables at: '#home' put: self home.
-	variables at: '#receiver' put: self receiver.
-	variables at: '#selector' put: self selector.
-	variables at: '#temps' put: self temps.
-	self class instanceVariableNames do: [ :each |
-		variables at: each put: (self instVarAt: each) ].
-	anInspector
-		setLabel: self printString;
-		setVariables: variables
-! !
-

st/Kernel-Classes.st

@@ -426,7 +426,7 @@ subclass: aString instanceVariableNames: aString2 package: aString3
 !Class methodsFor: 'converting'!
 
 asJavascript
-	^ 'smalltalk.', self name
+	^ 'globals.', self name
 ! !
 
 !Class methodsFor: 'printing'!
@@ -488,7 +488,7 @@ theNonMetaClass
 !Metaclass methodsFor: 'converting'!
 
 asJavascript
-	^ 'smalltalk.', self instanceClass name, '.klass'
+	^ 'globals.', self instanceClass name, '.klass'
 ! !
 
 !Metaclass methodsFor: 'printing'!

st/Kernel-ImportExport.st

@@ -261,7 +261,7 @@ exportDefinitionOf: aClass on: aStream
 		lf;
 		nextPutAll: 'smalltalk.addClass(';
 		nextPutAll: '''', (self classNameFor: aClass), ''', ';
-		nextPutAll: 'smalltalk.', (self classNameFor: aClass superclass);
+		nextPutAll: 'globals.', (self classNameFor: aClass superclass);
 		nextPutAll: ', ['.
 	aClass instanceVariableNames
 		do: [ :each | aStream nextPutAll: '''', each, '''' ]
@@ -273,7 +273,7 @@ exportDefinitionOf: aClass on: aStream
 	aClass comment notEmpty ifTrue: [
 		aStream
 			lf;
-		nextPutAll: 'smalltalk.';
+		nextPutAll: 'globals.';
 		nextPutAll: (self classNameFor: aClass);
 		nextPutAll: '.comment=';
 		nextPutAll: aClass comment asJavascript;
@@ -285,7 +285,7 @@ exportMetaDefinitionOf: aClass on: aStream
 	aStream lf.
 	aClass class instanceVariableNames isEmpty ifFalse: [
 		aStream
-		nextPutAll: 'smalltalk.', (self classNameFor: aClass class);
+		nextPutAll: 'globals.', (self classNameFor: aClass class);
 		nextPutAll: '.iVarNames = ['.
 		aClass class instanceVariableNames
 		do: [ :each | aStream nextPutAll: '''', each, '''' ]
@@ -308,7 +308,7 @@ exportMethod: aMethod on: aStream
 	aStream
 		lf;
 		nextPutAll: '}),';lf;
-		nextPutAll: 'smalltalk.', (self classNameFor: aMethod methodClass);
+		nextPutAll: 'globals.', (self classNameFor: aMethod methodClass);
 		nextPutAll: ');';lf;lf
 !
 
@@ -384,8 +384,8 @@ exportPackagePrologueOf: aPackage on: aStream
 		nextPutAll: '/';
 		nextPutAll: aPackage name;
 		nextPutAll: '", ';
-		nextPutAll: (#('amber_vm/smalltalk' 'amber_vm/nil' 'amber_vm/_st'), (self amdNamesOfPackages: aPackage loadDependencies)) asJavascript;
-		nextPutAll: ', function(smalltalk,nil,_st){';
+		nextPutAll: (#('amber_vm/smalltalk' 'amber_vm/nil' 'amber_vm/_st' 'amber_vm/globals'), (self amdNamesOfPackages: aPackage loadDependencies)) asJavascript;
+		nextPutAll: ', function(smalltalk,nil,_st, globals){';
 		lf
 ! !