Recompile 0.13 way.

src/Helios-Commands-Browser.js

@@ -1,800 +1,1036 @@
 define("helios/Helios-Commands-Browser", ["amber/boot", "helios/Helios-Commands-Tools"], function($boot){
-var smalltalk=$boot.vm,nil=$boot.nil,_st=$boot.asReceiver,globals=$boot.globals;
-smalltalk.addPackage('Helios-Commands-Browser');
-smalltalk.packages["Helios-Commands-Browser"].transport = {"type":"amd","amdNamespace":"helios"};
+var $core=$boot.api,nil=$boot.nil,$recv=$boot.asReceiver,$globals=$boot.globals;
+var smalltalk=$core,_st=$recv,globals=$globals;
+$core.addPackage('Helios-Commands-Browser');
+$core.packages["Helios-Commands-Browser"].transport = {"type":"amd","amdNamespace":"helios"};
 
-smalltalk.addClass('HLBrowserCommand', globals.HLToolCommand, [], 'Helios-Commands-Browser');
+$core.addClass('HLBrowserCommand', $globals.HLToolCommand, [], 'Helios-Commands-Browser');
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isValidFor:",
 protocol: 'testing',
 fn: function (aModel){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(aModel)._isBrowserModel();
+$1=$recv(aModel)._isBrowserModel();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},globals.HLBrowserCommand.klass)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},$globals.HLBrowserCommand.klass)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aModel"],
 source: "isValidFor: aModel\x0a\x09^ aModel isBrowserModel",
-messageSends: ["isBrowserModel"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["isBrowserModel"]
 }),
-globals.HLBrowserCommand.klass);
+$globals.HLBrowserCommand.klass);
 
 
-smalltalk.addClass('HLBrowserGoToCommand', globals.HLBrowserCommand, [], 'Helios-Commands-Browser');
+$core.addClass('HLBrowserGoToCommand', $globals.HLBrowserCommand, [], 'Helios-Commands-Browser');
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isValidFor:",
 protocol: 'testing',
 fn: function (aModel){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(aModel)._isBrowserModel();
+$1=$recv(aModel)._isBrowserModel();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},globals.HLBrowserGoToCommand.klass)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},$globals.HLBrowserGoToCommand.klass)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aModel"],
 source: "isValidFor: aModel\x0a\x09^ aModel isBrowserModel",
-messageSends: ["isBrowserModel"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["isBrowserModel"]
 }),
-globals.HLBrowserGoToCommand.klass);
+$globals.HLBrowserGoToCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "g";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'g'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLBrowserGoToCommand.klass);
+$globals.HLBrowserGoToCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Go to";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Go to'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLBrowserGoToCommand.klass);
+$globals.HLBrowserGoToCommand.klass);
 
 
-smalltalk.addClass('HLGoToClassesCommand', globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLGoToClassesCommand', $globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._focusOnClasses();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLGoToClassesCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._focusOnClasses();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLGoToClassesCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model focusOnClasses",
-messageSends: ["focusOnClasses", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["focusOnClasses", "model"]
 }),
-globals.HLGoToClassesCommand);
+$globals.HLGoToClassesCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "c";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'c'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGoToClassesCommand.klass);
+$globals.HLGoToClassesCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Classes";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Classes'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGoToClassesCommand.klass);
+$globals.HLGoToClassesCommand.klass);
 
 
-smalltalk.addClass('HLGoToDocumentationCommand', globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLGoToDocumentationCommand', $globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._focusOnDocumentation();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLGoToDocumentationCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._focusOnDocumentation();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLGoToDocumentationCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model focusOnDocumentation",
-messageSends: ["focusOnDocumentation", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["focusOnDocumentation", "model"]
 }),
-globals.HLGoToDocumentationCommand);
+$globals.HLGoToDocumentationCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "d";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'd'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGoToDocumentationCommand.klass);
+$globals.HLGoToDocumentationCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Documentation";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Documentation'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGoToDocumentationCommand.klass);
+$globals.HLGoToDocumentationCommand.klass);
 
 
-smalltalk.addClass('HLGoToMethodsCommand', globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLGoToMethodsCommand', $globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._focusOnMethods();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLGoToMethodsCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._focusOnMethods();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLGoToMethodsCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model focusOnMethods",
-messageSends: ["focusOnMethods", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["focusOnMethods", "model"]
 }),
-globals.HLGoToMethodsCommand);
+$globals.HLGoToMethodsCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "m";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'm'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGoToMethodsCommand.klass);
+$globals.HLGoToMethodsCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Methods";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Methods'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGoToMethodsCommand.klass);
+$globals.HLGoToMethodsCommand.klass);
 
 
-smalltalk.addClass('HLGoToPackagesCommand', globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLGoToPackagesCommand', $globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._focusOnPackages();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLGoToPackagesCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._focusOnPackages();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLGoToPackagesCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model focusOnPackages",
-messageSends: ["focusOnPackages", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["focusOnPackages", "model"]
 }),
-globals.HLGoToPackagesCommand);
+$globals.HLGoToPackagesCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "p";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'p'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGoToPackagesCommand.klass);
+$globals.HLGoToPackagesCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Packages";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Packages'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGoToPackagesCommand.klass);
+$globals.HLGoToPackagesCommand.klass);
 
 
-smalltalk.addClass('HLGoToProtocolsCommand', globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLGoToProtocolsCommand', $globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._focusOnProtocols();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLGoToProtocolsCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._focusOnProtocols();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLGoToProtocolsCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model focusOnProtocols",
-messageSends: ["focusOnProtocols", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["focusOnProtocols", "model"]
 }),
-globals.HLGoToProtocolsCommand);
+$globals.HLGoToProtocolsCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "t";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 't'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGoToProtocolsCommand.klass);
+$globals.HLGoToProtocolsCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Protocols";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Protocols'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGoToProtocolsCommand.klass);
+$globals.HLGoToProtocolsCommand.klass);
 
 
-smalltalk.addClass('HLGoToSourceCodeCommand', globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLGoToSourceCodeCommand', $globals.HLBrowserGoToCommand, [], 'Helios-Commands-Browser');
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._focusOnSourceCode();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLGoToSourceCodeCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._focusOnSourceCode();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLGoToSourceCodeCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model focusOnSourceCode",
-messageSends: ["focusOnSourceCode", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["focusOnSourceCode", "model"]
 }),
-globals.HLGoToSourceCodeCommand);
+$globals.HLGoToSourceCodeCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "s";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 's'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGoToSourceCodeCommand.klass);
+$globals.HLGoToSourceCodeCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Source code";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Source code'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGoToSourceCodeCommand.klass);
+$globals.HLGoToSourceCodeCommand.klass);
 
 
-smalltalk.addClass('HLEditCommentCommand', globals.HLBrowserCommand, [], 'Helios-Commands-Browser');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLEditCommentCommand', $globals.HLBrowserCommand, [], 'Helios-Commands-Browser');
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._editComment();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLEditCommentCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._editComment();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLEditCommentCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model editComment",
-messageSends: ["editComment", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["editComment", "model"]
 }),
-globals.HLEditCommentCommand);
+$globals.HLEditCommentCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isActive",
 protocol: 'testing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $3,$2,$1;
 $3=self._model();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["model"]=1;
-$2=_st($3)._showComment();
-$1=_st($2)._and_((function(){
-return smalltalk.withContext(function($ctx2) {
-return _st(_st(self._model())._selectedClass())._notNil();
-}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+//>>excludeEnd("ctx");
+$2=$recv($3)._showComment();
+$1=$recv($2)._and_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
+return $recv($recv(self._model())._selectedClass())._notNil();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
+}));
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLEditCommentCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLEditCommentCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isActive\x0a\x09^ self model showComment and: [ self model selectedClass notNil ]",
-messageSends: ["and:", "showComment", "model", "notNil", "selectedClass"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["and:", "showComment", "model", "notNil", "selectedClass"]
 }),
-globals.HLEditCommentCommand);
+$globals.HLEditCommentCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "d";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'd'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLEditCommentCommand.klass);
+$globals.HLEditCommentCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Edit documentation";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Edit documentation'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLEditCommentCommand.klass);
+$globals.HLEditCommentCommand.klass);
 
 
-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)";
+$core.addClass('HLGenerateCommand', $globals.HLBrowserCommand, [], 'Helios-Commands-Browser');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$globals.HLGenerateCommand.comment="I am a group command used to gather all the commands generating code (`accessors`, `initialize`, etc)";
+//>>excludeEnd("ide");
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "h";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'h'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGenerateCommand.klass);
+$globals.HLGenerateCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Generate";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Generate'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGenerateCommand.klass);
+$globals.HLGenerateCommand.klass);
 
 
-smalltalk.addClass('HLCategorizeUnclassifiedCommand', globals.HLGenerateCommand, [], 'Helios-Commands-Browser');
-globals.HLCategorizeUnclassifiedCommand.comment="I am the command used to categorize unclassified methods";
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLCategorizeUnclassifiedCommand', $globals.HLGenerateCommand, [], 'Helios-Commands-Browser');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$globals.HLCategorizeUnclassifiedCommand.comment="I am the command used to categorize unclassified methods";
+//>>excludeEnd("ide");
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
 var targetClass,unclassified;
-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){
-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},globals.HLCategorizeUnclassifiedCommand)})},
+function $HLMethodClassifier(){return $globals.HLMethodClassifier||(typeof HLMethodClassifier=="undefined"?nil:HLMethodClassifier)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+targetClass=$recv(self._model())._selectedClass();
+unclassified=$recv($recv(targetClass)._methods())._select_((function(e){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
+return $recv($recv(e)._protocol()).__eq("as yet unclassified");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({e:e},$ctx1,1)});
+//>>excludeEnd("ctx");
+}));
+$recv($recv($HLMethodClassifier())._new())._classifyAll_(unclassified);
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{targetClass:targetClass,unclassified:unclassified},$globals.HLCategorizeUnclassifiedCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 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"]
+referencedClasses: ["HLMethodClassifier"],
+//>>excludeEnd("ide");
+messageSends: ["selectedClass", "model", "select:", "methods", "=", "protocol", "classifyAll:", "new"]
 }),
-globals.HLCategorizeUnclassifiedCommand);
+$globals.HLCategorizeUnclassifiedCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "c";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'c'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLCategorizeUnclassifiedCommand.klass);
+$globals.HLCategorizeUnclassifiedCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Categorize";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Categorize'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLCategorizeUnclassifiedCommand.klass);
+$globals.HLCategorizeUnclassifiedCommand.klass);
 
 
-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({
+$core.addClass('HLGenerateAccessorsCommand', $globals.HLGenerateCommand, [], 'Helios-Commands-Browser');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$globals.HLGenerateAccessorsCommand.comment="I am the command used to generate the `getter` and the `setter` methods depending of the selected class";
+//>>excludeEnd("ide");
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
 var targetClass,output,first;
-function $HLInitializeGenerator(){return globals.HLInitializeGenerator||(typeof HLInitializeGenerator=="undefined"?nil:HLInitializeGenerator)}
-return smalltalk.withContext(function($ctx1) { 
+function $HLInitializeGenerator(){return $globals.HLInitializeGenerator||(typeof HLInitializeGenerator=="undefined"?nil:HLInitializeGenerator)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$2,$3,$4,$5;
 $1=self._model();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["model"]=1;
-targetClass=_st($1)._selectedClass();
-$2=_st($HLInitializeGenerator())._new();
-_st($2)._class_(targetClass);
-_st($2)._generate();
-$3=_st($2)._output();
+//>>excludeEnd("ctx");
+targetClass=$recv($1)._selectedClass();
+$2=$recv($HLInitializeGenerator())._new();
+$recv($2)._class_(targetClass);
+$recv($2)._generate();
+$3=$recv($2)._output();
 output=$3;
-_st(output)._compile();
-first=_st(_st(output)._sourceCodes())._first();
+$recv(output)._compile();
+first=$recv($recv(output)._sourceCodes())._first();
 $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},globals.HLGenerateAccessorsCommand)})},
+$recv($4)._selectedProtocol_($recv(output)._protocol());
+$recv($4)._selectedMethod_($recv(targetClass).__gt_gt($recv(first)._selector()));
+$5=$recv($4)._focusOnSourceCode();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{targetClass:targetClass,output:output,first:first},$globals.HLGenerateAccessorsCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 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"]
+referencedClasses: ["HLInitializeGenerator"],
+//>>excludeEnd("ide");
+messageSends: ["selectedClass", "model", "class:", "new", "generate", "output", "compile", "first", "sourceCodes", "selectedProtocol:", "protocol", "selectedMethod:", ">>", "selector", "focusOnSourceCode"]
 }),
-globals.HLGenerateAccessorsCommand);
+$globals.HLGenerateAccessorsCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "i";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'i'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGenerateAccessorsCommand.klass);
+$globals.HLGenerateAccessorsCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Initialize";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Initialize'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGenerateAccessorsCommand.klass);
+$globals.HLGenerateAccessorsCommand.klass);
 
 
-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({
+$core.addClass('HLGenerateInitializeCommand', $globals.HLGenerateCommand, [], 'Helios-Commands-Browser');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$globals.HLGenerateInitializeCommand.comment="I am the command used to generate the `initialize` method depending of the selected class";
+//>>excludeEnd("ide");
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
 var targetClass,output;
-function $HLAccessorsGenerator(){return globals.HLAccessorsGenerator||(typeof HLAccessorsGenerator=="undefined"?nil:HLAccessorsGenerator)}
-return smalltalk.withContext(function($ctx1) { 
+function $HLAccessorsGenerator(){return $globals.HLAccessorsGenerator||(typeof HLAccessorsGenerator=="undefined"?nil:HLAccessorsGenerator)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$2,$3;
 $1=self._model();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["model"]=1;
-targetClass=_st($1)._selectedClass();
-$2=_st($HLAccessorsGenerator())._new();
-_st($2)._class_(targetClass);
-_st($2)._generate();
-$3=_st($2)._output();
+//>>excludeEnd("ctx");
+targetClass=$recv($1)._selectedClass();
+$2=$recv($HLAccessorsGenerator())._new();
+$recv($2)._class_(targetClass);
+$recv($2)._generate();
+$3=$recv($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},globals.HLGenerateInitializeCommand)})},
+$recv(output)._compile();
+$recv(self._model())._selectedProtocol_($recv(output)._protocol());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{targetClass:targetClass,output:output},$globals.HLGenerateInitializeCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 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"]
+referencedClasses: ["HLAccessorsGenerator"],
+//>>excludeEnd("ide");
+messageSends: ["selectedClass", "model", "class:", "new", "generate", "output", "compile", "selectedProtocol:", "protocol"]
 }),
-globals.HLGenerateInitializeCommand);
+$globals.HLGenerateInitializeCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "a";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'a'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGenerateInitializeCommand.klass);
+$globals.HLGenerateInitializeCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Accessors";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Accessors'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLGenerateInitializeCommand.klass);
+$globals.HLGenerateInitializeCommand.klass);
 
 
-smalltalk.addClass('HLToggleCommand', globals.HLBrowserCommand, [], 'Helios-Commands-Browser');
+$core.addClass('HLToggleCommand', $globals.HLBrowserCommand, [], 'Helios-Commands-Browser');
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "t";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 't'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLToggleCommand.klass);
+$globals.HLToggleCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Toggle";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Toggle'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLToggleCommand.klass);
+$globals.HLToggleCommand.klass);
 
 
-smalltalk.addClass('HLToggleClassCommentCommand', globals.HLToggleCommand, [], 'Helios-Commands-Browser');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLToggleClassCommentCommand', $globals.HLToggleCommand, [], 'Helios-Commands-Browser');
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
 $1=self._model();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["model"]=1;
-_st($1)._showComment_(_st(_st(self._model())._showComment())._not());
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLToggleClassCommentCommand)})},
+//>>excludeEnd("ctx");
+$recv($1)._showComment_($recv($recv(self._model())._showComment())._not());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLToggleClassCommentCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model showComment: self model showComment not",
-messageSends: ["showComment:", "model", "not", "showComment"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["showComment:", "model", "not", "showComment"]
 }),
-globals.HLToggleClassCommentCommand);
+$globals.HLToggleClassCommentCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "d";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'd'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLToggleClassCommentCommand.klass);
+$globals.HLToggleClassCommentCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Documentation";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Documentation'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLToggleClassCommentCommand.klass);
+$globals.HLToggleClassCommentCommand.klass);
 
 
-smalltalk.addClass('HLToggleClassSideCommand', globals.HLToggleCommand, [], 'Helios-Commands-Browser');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLToggleClassSideCommand', $globals.HLToggleCommand, [], 'Helios-Commands-Browser');
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
 $1=self._model();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["model"]=1;
-_st($1)._showInstance_(_st(_st(self._model())._showInstance())._not());
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLToggleClassSideCommand)})},
+//>>excludeEnd("ctx");
+$recv($1)._showInstance_($recv($recv(self._model())._showInstance())._not());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLToggleClassSideCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model showInstance: self model showInstance not",
-messageSends: ["showInstance:", "model", "not", "showInstance"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["showInstance:", "model", "not", "showInstance"]
 }),
-globals.HLToggleClassSideCommand);
+$globals.HLToggleClassSideCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "c";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'c'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLToggleClassSideCommand.klass);
+$globals.HLToggleClassSideCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Class side";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Class side'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLToggleClassSideCommand.klass);
+$globals.HLToggleClassSideCommand.klass);
 
 });

src/Helios-Commands-SUnit.js

@@ -1,487 +1,628 @@
 define("helios/Helios-Commands-SUnit", ["amber/boot", "helios/Helios-Commands-Tools"], function($boot){
-var smalltalk=$boot.vm,nil=$boot.nil,_st=$boot.asReceiver,globals=$boot.globals;
-smalltalk.addPackage('Helios-Commands-SUnit');
-smalltalk.packages["Helios-Commands-SUnit"].transport = {"type":"amd","amdNamespace":"helios"};
-
-smalltalk.addClass('HLSUnitCommand', globals.HLToolCommand, [], 'Helios-Commands-SUnit');
-globals.HLSUnitCommand.comment="I group the commands pertaining to Helios-SUnit (`HLSUnitModel`)";
-
-smalltalk.addMethod(
-smalltalk.method({
+var $core=$boot.api,nil=$boot.nil,$recv=$boot.asReceiver,$globals=$boot.globals;
+var smalltalk=$core,_st=$recv,globals=$globals;
+$core.addPackage('Helios-Commands-SUnit');
+$core.packages["Helios-Commands-SUnit"].transport = {"type":"amd","amdNamespace":"helios"};
+
+$core.addClass('HLSUnitCommand', $globals.HLToolCommand, [], 'Helios-Commands-SUnit');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$globals.HLSUnitCommand.comment="I group the commands pertaining to Helios-SUnit (`HLSUnitModel`)";
+//>>excludeEnd("ide");
+
+$core.addMethod(
+$core.method({
 selector: "isValidFor:",
 protocol: 'testing',
 fn: function (aModel){
 var self=this;
-function $HLSUnitModel(){return globals.HLSUnitModel||(typeof HLSUnitModel=="undefined"?nil:HLSUnitModel)}
-return smalltalk.withContext(function($ctx1) { 
+function $HLSUnitModel(){return $globals.HLSUnitModel||(typeof HLSUnitModel=="undefined"?nil:HLSUnitModel)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(aModel)._isKindOf_($HLSUnitModel());
+$1=$recv(aModel)._isKindOf_($HLSUnitModel());
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},globals.HLSUnitCommand.klass)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},$globals.HLSUnitCommand.klass)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aModel"],
 source: "isValidFor: aModel\x0a\x09^ aModel isKindOf: HLSUnitModel",
-messageSends: ["isKindOf:"],
-referencedClasses: ["HLSUnitModel"]
+referencedClasses: ["HLSUnitModel"],
+//>>excludeEnd("ide");
+messageSends: ["isKindOf:"]
 }),
-globals.HLSUnitCommand.klass);
+$globals.HLSUnitCommand.klass);
 
 
-smalltalk.addClass('HLSUnitInvertSelectedCommand', globals.HLSUnitCommand, [], 'Helios-Commands-SUnit');
-globals.HLSUnitInvertSelectedCommand.comment="I group the commands that invert selections";
+$core.addClass('HLSUnitInvertSelectedCommand', $globals.HLSUnitCommand, [], 'Helios-Commands-SUnit');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$globals.HLSUnitInvertSelectedCommand.comment="I group the commands that invert selections";
+//>>excludeEnd("ide");
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "i";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'i'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitInvertSelectedCommand.klass);
+$globals.HLSUnitInvertSelectedCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Invert selection";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^'Invert selection'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitInvertSelectedCommand.klass);
+$globals.HLSUnitInvertSelectedCommand.klass);
 
 
-smalltalk.addClass('HLSUnitInvertSelectedClassesCommand', globals.HLSUnitInvertSelectedCommand, [], 'Helios-Commands-SUnit');
-globals.HLSUnitInvertSelectedClassesCommand.comment="Invert the currently selected classes on a `HLSUnitModel`";
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLSUnitInvertSelectedClassesCommand', $globals.HLSUnitInvertSelectedCommand, [], 'Helios-Commands-SUnit');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$globals.HLSUnitInvertSelectedClassesCommand.comment="Invert the currently selected classes on a `HLSUnitModel`";
+//>>excludeEnd("ide");
+$core.addMethod(
+$core.method({
 selector: "category",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Classes";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "category\x0a\x09^'Classes'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitInvertSelectedClassesCommand);
+$globals.HLSUnitInvertSelectedClassesCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._invertSelectedClasses();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLSUnitInvertSelectedClassesCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._invertSelectedClasses();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLSUnitInvertSelectedClassesCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model invertSelectedClasses",
-messageSends: ["invertSelectedClasses", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["invertSelectedClasses", "model"]
 }),
-globals.HLSUnitInvertSelectedClassesCommand);
+$globals.HLSUnitInvertSelectedClassesCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isActive",
 protocol: 'testing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(_st(self["@model"])._selectedPackages())._notEmpty();
+$1=$recv($recv(self["@model"])._selectedPackages())._notEmpty();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLSUnitInvertSelectedClassesCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLSUnitInvertSelectedClassesCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isActive\x0a\x09^model selectedPackages notEmpty",
-messageSends: ["notEmpty", "selectedPackages"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["notEmpty", "selectedPackages"]
 }),
-globals.HLSUnitInvertSelectedClassesCommand);
+$globals.HLSUnitInvertSelectedClassesCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "c";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'c'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitInvertSelectedClassesCommand.klass);
+$globals.HLSUnitInvertSelectedClassesCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Invert selected classes";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Invert selected classes'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitInvertSelectedClassesCommand.klass);
+$globals.HLSUnitInvertSelectedClassesCommand.klass);
 
 
-smalltalk.addClass('HLSUnitInvertSelectedPackagesCommand', globals.HLSUnitInvertSelectedCommand, [], 'Helios-Commands-SUnit');
-globals.HLSUnitInvertSelectedPackagesCommand.comment="Invert the currently selected packages on a `HLSUnitModel`";
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLSUnitInvertSelectedPackagesCommand', $globals.HLSUnitInvertSelectedCommand, [], 'Helios-Commands-SUnit');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$globals.HLSUnitInvertSelectedPackagesCommand.comment="Invert the currently selected packages on a `HLSUnitModel`";
+//>>excludeEnd("ide");
+$core.addMethod(
+$core.method({
 selector: "category",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Packages";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "category\x0a\x09^'Packages'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitInvertSelectedPackagesCommand);
+$globals.HLSUnitInvertSelectedPackagesCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._invertSelectedPackages();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLSUnitInvertSelectedPackagesCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._invertSelectedPackages();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLSUnitInvertSelectedPackagesCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model invertSelectedPackages",
-messageSends: ["invertSelectedPackages", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["invertSelectedPackages", "model"]
 }),
-globals.HLSUnitInvertSelectedPackagesCommand);
+$globals.HLSUnitInvertSelectedPackagesCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isActive",
 protocol: 'testing',
 fn: function (){
 var self=this;
 return true;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isActive\x0a\x09^true",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitInvertSelectedPackagesCommand);
+$globals.HLSUnitInvertSelectedPackagesCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "p";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'p'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitInvertSelectedPackagesCommand.klass);
+$globals.HLSUnitInvertSelectedPackagesCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Invert selected packages";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Invert selected packages'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitInvertSelectedPackagesCommand.klass);
+$globals.HLSUnitInvertSelectedPackagesCommand.klass);
 
 
-smalltalk.addClass('HLSUnitRunTests', globals.HLSUnitCommand, [], 'Helios-Commands-SUnit');
-globals.HLSUnitRunTests.comment="Run the test cases in the currently selected classes on a `HLSUnitModel`";
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLSUnitRunTests', $globals.HLSUnitCommand, [], 'Helios-Commands-SUnit');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$globals.HLSUnitRunTests.comment="Run the test cases in the currently selected classes on a `HLSUnitModel`";
+//>>excludeEnd("ide");
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._runTests();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLSUnitRunTests)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._runTests();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLSUnitRunTests)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model runTests",
-messageSends: ["runTests", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["runTests", "model"]
 }),
-globals.HLSUnitRunTests);
+$globals.HLSUnitRunTests);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isActive",
 protocol: 'testing',
 fn: function (){
 var self=this;
 return true;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isActive\x0a\x09^true",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitRunTests);
+$globals.HLSUnitRunTests);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "r";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^'r'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitRunTests.klass);
+$globals.HLSUnitRunTests.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Run Tests";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^'Run Tests'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitRunTests.klass);
+$globals.HLSUnitRunTests.klass);
 
 
-smalltalk.addClass('HLSUnitSelectAllCommand', globals.HLSUnitCommand, [], 'Helios-Commands-SUnit');
-globals.HLSUnitSelectAllCommand.comment="I group the select all commands";
+$core.addClass('HLSUnitSelectAllCommand', $globals.HLSUnitCommand, [], 'Helios-Commands-SUnit');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$globals.HLSUnitSelectAllCommand.comment="I group the select all commands";
+//>>excludeEnd("ide");
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "a";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'a'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitSelectAllCommand.klass);
+$globals.HLSUnitSelectAllCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Select all";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Select all'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitSelectAllCommand.klass);
+$globals.HLSUnitSelectAllCommand.klass);
 
 
-smalltalk.addClass('HLSUnitSelectAllClassesCommand', globals.HLSUnitSelectAllCommand, [], 'Helios-Commands-SUnit');
-globals.HLSUnitSelectAllClassesCommand.comment="Select all available test classes based on what packages are selected on a `HLSUnitModel`";
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLSUnitSelectAllClassesCommand', $globals.HLSUnitSelectAllCommand, [], 'Helios-Commands-SUnit');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$globals.HLSUnitSelectAllClassesCommand.comment="Select all available test classes based on what packages are selected on a `HLSUnitModel`";
+//>>excludeEnd("ide");
+$core.addMethod(
+$core.method({
 selector: "category",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Classes";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "category\x0a\x09^'Classes'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitSelectAllClassesCommand);
+$globals.HLSUnitSelectAllClassesCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._selectAllClasses();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLSUnitSelectAllClassesCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._selectAllClasses();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLSUnitSelectAllClassesCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model selectAllClasses",
-messageSends: ["selectAllClasses", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["selectAllClasses", "model"]
 }),
-globals.HLSUnitSelectAllClassesCommand);
+$globals.HLSUnitSelectAllClassesCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isActive",
 protocol: 'testing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(_st(self["@model"])._selectedPackages())._notEmpty();
+$1=$recv($recv(self["@model"])._selectedPackages())._notEmpty();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLSUnitSelectAllClassesCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLSUnitSelectAllClassesCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isActive\x0a\x09^model selectedPackages notEmpty",
-messageSends: ["notEmpty", "selectedPackages"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["notEmpty", "selectedPackages"]
 }),
-globals.HLSUnitSelectAllClassesCommand);
+$globals.HLSUnitSelectAllClassesCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "c";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'c'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitSelectAllClassesCommand.klass);
+$globals.HLSUnitSelectAllClassesCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Select all classes";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Select all classes'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitSelectAllClassesCommand.klass);
+$globals.HLSUnitSelectAllClassesCommand.klass);
 
 
-smalltalk.addClass('HLSUnitSelectAllPackagesCommand', globals.HLSUnitSelectAllCommand, [], 'Helios-Commands-SUnit');
-globals.HLSUnitSelectAllPackagesCommand.comment="Select all packages with test cases on a `HLSUnitModel`";
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLSUnitSelectAllPackagesCommand', $globals.HLSUnitSelectAllCommand, [], 'Helios-Commands-SUnit');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$globals.HLSUnitSelectAllPackagesCommand.comment="Select all packages with test cases on a `HLSUnitModel`";
+//>>excludeEnd("ide");
+$core.addMethod(
+$core.method({
 selector: "category",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Packages";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "category\x0a\x09^'Packages'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitSelectAllPackagesCommand);
+$globals.HLSUnitSelectAllPackagesCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._selectAllPackages();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLSUnitSelectAllPackagesCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._selectAllPackages();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLSUnitSelectAllPackagesCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model selectAllPackages",
-messageSends: ["selectAllPackages", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["selectAllPackages", "model"]
 }),
-globals.HLSUnitSelectAllPackagesCommand);
+$globals.HLSUnitSelectAllPackagesCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isActive",
 protocol: 'testing',
 fn: function (){
 var self=this;
 return true;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isActive\x0a\x09^true",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitSelectAllPackagesCommand);
+$globals.HLSUnitSelectAllPackagesCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "p";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'p'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitSelectAllPackagesCommand.klass);
+$globals.HLSUnitSelectAllPackagesCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Select all packages";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Select all packages'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSUnitSelectAllPackagesCommand.klass);
+$globals.HLSUnitSelectAllPackagesCommand.klass);
 
 });

src/Helios-Commands-Tools.js

@@ -1,1951 +1,2480 @@
 define("helios/Helios-Commands-Tools", ["amber/boot", "helios/Helios-Commands-Core"], function($boot){
-var smalltalk=$boot.vm,nil=$boot.nil,_st=$boot.asReceiver,globals=$boot.globals;
-smalltalk.addPackage('Helios-Commands-Tools');
-smalltalk.packages["Helios-Commands-Tools"].transport = {"type":"amd","amdNamespace":"helios"};
-
-smalltalk.addClass('HLToolCommand', globals.HLModelCommand, [], 'Helios-Commands-Tools');
-smalltalk.addMethod(
-smalltalk.method({
+var $core=$boot.api,nil=$boot.nil,$recv=$boot.asReceiver,$globals=$boot.globals;
+var smalltalk=$core,_st=$recv,globals=$globals;
+$core.addPackage('Helios-Commands-Tools');
+$core.packages["Helios-Commands-Tools"].transport = {"type":"amd","amdNamespace":"helios"};
+
+$core.addClass('HLToolCommand', $globals.HLModelCommand, [], 'Helios-Commands-Tools');
+$core.addMethod(
+$core.method({
 selector: "category",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return nil;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "category\x0a\x09^ nil",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLToolCommand);
+$globals.HLToolCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "for:",
 protocol: 'instance creation',
 fn: function (aToolModel){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $2,$3,$1;
 $2=self._new();
-_st($2)._model_(aToolModel);
-$3=_st($2)._yourself();
+$recv($2)._model_(aToolModel);
+$3=$recv($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"for:",{aToolModel:aToolModel},globals.HLToolCommand.klass)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"for:",{aToolModel:aToolModel},$globals.HLToolCommand.klass)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aToolModel"],
 source: "for: aToolModel\x0a\x09^ self new\x0a    \x09model: aToolModel;\x0a        yourself",
-messageSends: ["model:", "new", "yourself"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["model:", "new", "yourself"]
 }),
-globals.HLToolCommand.klass);
+$globals.HLToolCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isValidFor:",
 protocol: 'testing',
 fn: function (aModel){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(aModel)._isToolModel();
+$1=$recv(aModel)._isToolModel();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},globals.HLToolCommand.klass)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},$globals.HLToolCommand.klass)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aModel"],
 source: "isValidFor: aModel\x0a\x09^ aModel isToolModel",
-messageSends: ["isToolModel"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["isToolModel"]
 }),
-globals.HLToolCommand.klass);
+$globals.HLToolCommand.klass);
 
 
-smalltalk.addClass('HLBrowseMethodCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLBrowseMethodCommand', $globals.HLToolCommand, [], 'Helios-Commands-Tools');
+$core.addMethod(
+$core.method({
 selector: "displayLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "browse method";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "displayLabel\x0a\x09^ 'browse method'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLBrowseMethodCommand);
+$globals.HLBrowseMethodCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._openMethod();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLBrowseMethodCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._openMethod();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLBrowseMethodCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model openMethod",
-messageSends: ["openMethod", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["openMethod", "model"]
 }),
-globals.HLBrowseMethodCommand);
+$globals.HLBrowseMethodCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isValidFor:",
 protocol: 'testing',
 fn: function (aModel){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(aModel)._isReferencesModel();
+$1=$recv(aModel)._isReferencesModel();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},globals.HLBrowseMethodCommand.klass)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},$globals.HLBrowseMethodCommand.klass)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aModel"],
 source: "isValidFor: aModel\x0a\x09^ aModel isReferencesModel",
-messageSends: ["isReferencesModel"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["isReferencesModel"]
 }),
-globals.HLBrowseMethodCommand.klass);
+$globals.HLBrowseMethodCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "b";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'b'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLBrowseMethodCommand.klass);
+$globals.HLBrowseMethodCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "browse method";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'browse method'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLBrowseMethodCommand.klass);
+$globals.HLBrowseMethodCommand.klass);
 
 
-smalltalk.addClass('HLCommitPackageCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLCommitPackageCommand', $globals.HLToolCommand, [], 'Helios-Commands-Tools');
+$core.addMethod(
+$core.method({
 selector: "category",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Packages";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "category\x0a\x09^ 'Packages'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLCommitPackageCommand);
+$globals.HLCommitPackageCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "commitPackage",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._commitPackageOnSuccess_onError_((function(){
-return smalltalk.withContext(function($ctx2) {
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._commitPackageOnSuccess_onError_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 return self._informSuccess();
-}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}),(function(error){
-return smalltalk.withContext(function($ctx2) {
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
+}),(function(error){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
 return self._onPackageCommitError_(error);
-}, function($ctx2) {$ctx2.fillBlock({error:error},$ctx1,2)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"commitPackage",{},globals.HLCommitPackageCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({error:error},$ctx1,2)});
+//>>excludeEnd("ctx");
+}));
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"commitPackage",{},$globals.HLCommitPackageCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "commitPackage\x0a\x09self model \x0a\x09\x09commitPackageOnSuccess: [ self informSuccess ]\x0a\x09\x09onError: [ :error | self onPackageCommitError: error ]",
-messageSends: ["commitPackageOnSuccess:onError:", "model", "informSuccess", "onPackageCommitError:"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["commitPackageOnSuccess:onError:", "model", "informSuccess", "onPackageCommitError:"]
 }),
-globals.HLCommitPackageCommand);
+$globals.HLCommitPackageCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 self._commitPackage();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLCommitPackageCommand)})},
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLCommitPackageCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self commitPackage",
-messageSends: ["commitPackage"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["commitPackage"]
 }),
-globals.HLCommitPackageCommand);
+$globals.HLCommitPackageCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "informSuccess",
 protocol: 'executing',
 fn: function (){
 var self=this;
-function $HLInformationWidget(){return globals.HLInformationWidget||(typeof HLInformationWidget=="undefined"?nil:HLInformationWidget)}
-return smalltalk.withContext(function($ctx1) { 
+function $HLInformationWidget(){return $globals.HLInformationWidget||(typeof HLInformationWidget=="undefined"?nil:HLInformationWidget)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$2;
-$1=_st($HLInformationWidget())._new();
-_st($1)._informationString_("Commit successful!");
-$2=_st($1)._show();
-return self}, function($ctx1) {$ctx1.fill(self,"informSuccess",{},globals.HLCommitPackageCommand)})},
+$1=$recv($HLInformationWidget())._new();
+$recv($1)._informationString_("Commit successful!");
+$2=$recv($1)._show();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"informSuccess",{},$globals.HLCommitPackageCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "informSuccess\x0a\x09HLInformationWidget new\x0a\x09\x09informationString: 'Commit successful!';\x0a\x09\x09show",
-messageSends: ["informationString:", "new", "show"],
-referencedClasses: ["HLInformationWidget"]
+referencedClasses: ["HLInformationWidget"],
+//>>excludeEnd("ide");
+messageSends: ["informationString:", "new", "show"]
 }),
-globals.HLCommitPackageCommand);
+$globals.HLCommitPackageCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isActive",
 protocol: 'testing',
 fn: function (){
 var self=this;
 return true;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isActive\x0a\x09^ true\x0a\x09\x22self model isPackageDirty\x22",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLCommitPackageCommand);
+$globals.HLCommitPackageCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "onPackageCommitError:",
 protocol: 'error handling',
 fn: function (anError){
 var self=this;
-function $HLPackageCommitErrorHelper(){return globals.HLPackageCommitErrorHelper||(typeof HLPackageCommitErrorHelper=="undefined"?nil:HLPackageCommitErrorHelper)}
-return smalltalk.withContext(function($ctx1) { 
-_st(_st($HLPackageCommitErrorHelper())._on_(self._model()))._showHelp();
-return self}, function($ctx1) {$ctx1.fill(self,"onPackageCommitError:",{anError:anError},globals.HLCommitPackageCommand)})},
+function $HLPackageCommitErrorHelper(){return $globals.HLPackageCommitErrorHelper||(typeof HLPackageCommitErrorHelper=="undefined"?nil:HLPackageCommitErrorHelper)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv($recv($HLPackageCommitErrorHelper())._on_(self._model()))._showHelp();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"onPackageCommitError:",{anError:anError},$globals.HLCommitPackageCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["anError"],
 source: "onPackageCommitError: anError\x0a\x09(HLPackageCommitErrorHelper on: self model)\x0a\x09\x09showHelp",
-messageSends: ["showHelp", "on:", "model"],
-referencedClasses: ["HLPackageCommitErrorHelper"]
+referencedClasses: ["HLPackageCommitErrorHelper"],
+//>>excludeEnd("ide");
+messageSends: ["showHelp", "on:", "model"]
 }),
-globals.HLCommitPackageCommand);
+$globals.HLCommitPackageCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "k";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'k'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLCommitPackageCommand.klass);
+$globals.HLCommitPackageCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Commit package";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Commit package'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLCommitPackageCommand.klass);
+$globals.HLCommitPackageCommand.klass);
 
 
-smalltalk.addClass('HLCopyCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
+$core.addClass('HLCopyCommand', $globals.HLToolCommand, [], 'Helios-Commands-Tools');
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "c";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'c'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLCopyCommand.klass);
+$globals.HLCopyCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Copy";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Copy'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLCopyCommand.klass);
+$globals.HLCopyCommand.klass);
 
 
-smalltalk.addClass('HLCopyClassCommand', globals.HLCopyCommand, [], 'Helios-Commands-Tools');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLCopyClassCommand', $globals.HLCopyCommand, [], 'Helios-Commands-Tools');
+$core.addMethod(
+$core.method({
 selector: "category",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Classes";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "category\x0a\x09^ 'Classes'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLCopyClassCommand);
+$globals.HLCopyClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "defaultInput",
 protocol: 'defaults',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(_st(_st(self._model())._selectedClass())._theNonMetaClass())._name();
+$1=$recv($recv($recv(self._model())._selectedClass())._theNonMetaClass())._name();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"defaultInput",{},globals.HLCopyClassCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"defaultInput",{},$globals.HLCopyClassCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "defaultInput\x0a\x09^ self model selectedClass theNonMetaClass name",
-messageSends: ["name", "theNonMetaClass", "selectedClass", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["name", "theNonMetaClass", "selectedClass", "model"]
 }),
-globals.HLCopyClassCommand);
+$globals.HLCopyClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "displayLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "New class name:";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "displayLabel\x0a\x09^ 'New class name:'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLCopyClassCommand);
+$globals.HLCopyClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._copyClassTo_(self._input());
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLCopyClassCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._copyClassTo_(self._input());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLCopyClassCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model copyClassTo: self input",
-messageSends: ["copyClassTo:", "model", "input"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["copyClassTo:", "model", "input"]
 }),
-globals.HLCopyClassCommand);
+$globals.HLCopyClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isActive",
 protocol: 'testing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(_st(self._model())._selectedClass())._notNil();
+$1=$recv($recv(self._model())._selectedClass())._notNil();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLCopyClassCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLCopyClassCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isActive\x0a\x09^ self model selectedClass notNil",
-messageSends: ["notNil", "selectedClass", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["notNil", "selectedClass", "model"]
 }),
-globals.HLCopyClassCommand);
+$globals.HLCopyClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isInputRequired",
 protocol: 'testing',
 fn: function (){
 var self=this;
 return true;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isInputRequired\x0a\x09^ true",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLCopyClassCommand);
+$globals.HLCopyClassCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "c";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'c'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLCopyClassCommand.klass);
+$globals.HLCopyClassCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Copy class";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Copy class'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLCopyClassCommand.klass);
+$globals.HLCopyClassCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "menuLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Copy class...";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "menuLabel\x0a\x09^ 'Copy class...'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLCopyClassCommand.klass);
+$globals.HLCopyClassCommand.klass);
 
 
-smalltalk.addClass('HLFindCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
+$core.addClass('HLFindCommand', $globals.HLToolCommand, [], 'Helios-Commands-Tools');
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "f";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'f'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLFindCommand.klass);
+$globals.HLFindCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Find";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Find'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLFindCommand.klass);
+$globals.HLFindCommand.klass);
 
 
-smalltalk.addClass('HLFindClassCommand', globals.HLFindCommand, [], 'Helios-Commands-Tools');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLFindClassCommand', $globals.HLFindCommand, [], 'Helios-Commands-Tools');
+$core.addMethod(
+$core.method({
 selector: "displayLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "select a class";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "displayLabel\x0a\x09^ 'select a class'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLFindClassCommand);
+$globals.HLFindClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._openClassNamed_(self._input());
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLFindClassCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._openClassNamed_(self._input());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLFindClassCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model openClassNamed: self input",
-messageSends: ["openClassNamed:", "model", "input"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["openClassNamed:", "model", "input"]
 }),
-globals.HLFindClassCommand);
+$globals.HLFindClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "inputCompletion",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(self._model())._availableClassNames();
+$1=$recv(self._model())._availableClassNames();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},globals.HLFindClassCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},$globals.HLFindClassCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "inputCompletion\x0a\x09^ self model availableClassNames",
-messageSends: ["availableClassNames", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["availableClassNames", "model"]
 }),
-globals.HLFindClassCommand);
+$globals.HLFindClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "inputLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Find a class";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "inputLabel\x0a\x09^ 'Find a class'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLFindClassCommand);
+$globals.HLFindClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isInputRequired",
 protocol: 'testing',
 fn: function (){
 var self=this;
 return true;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isInputRequired\x0a\x09^ true",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLFindClassCommand);
+$globals.HLFindClassCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "c";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'c'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLFindClassCommand.klass);
+$globals.HLFindClassCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Find class";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Find class'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLFindClassCommand.klass);
+$globals.HLFindClassCommand.klass);
 
 
-smalltalk.addClass('HLFindReferencesCommand', globals.HLFindCommand, [], 'Helios-Commands-Tools');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLFindReferencesCommand', $globals.HLFindCommand, [], 'Helios-Commands-Tools');
+$core.addMethod(
+$core.method({
 selector: "defaultInput",
 protocol: 'defaults',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $3,$2,$4,$1,$receiver;
 $3=self._model();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["model"]=1;
-$2=_st($3)._selectedMethod();
+//>>excludeEnd("ctx");
+$2=$recv($3)._selectedMethod();
 if(($receiver = $2) == null || $receiver.isNil){
-$4=_st(self._model())._selectedClass();
+$4=$recv(self._model())._selectedClass();
 if(($receiver = $4) == null || $receiver.isNil){
 $1="";
 } else {
 var class_;
 class_=$receiver;
-$1=_st(_st(class_)._theNonMetaClass())._name();
+$1=$recv($recv(class_)._theNonMetaClass())._name();
 };
 } else {
 var method;
 method=$receiver;
-$1=_st(method)._selector();
+$1=$recv(method)._selector();
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"defaultInput",{},globals.HLFindReferencesCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"defaultInput",{},$globals.HLFindReferencesCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "defaultInput\x0a\x09^ self model selectedMethod \x0a\x09\x09ifNil: [\x0a\x09\x09\x09self model selectedClass\x0a\x09\x09\x09\x09ifNil: [ '' ]\x0a\x09\x09\x09\x09ifNotNil: [ :class | class theNonMetaClass name ] ]\x0a\x09\x09ifNotNil: [ :method | method selector ]",
-messageSends: ["ifNil:ifNotNil:", "selectedMethod", "model", "selectedClass", "name", "theNonMetaClass", "selector"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["ifNil:ifNotNil:", "selectedMethod", "model", "selectedClass", "name", "theNonMetaClass", "selector"]
 }),
-globals.HLFindReferencesCommand);
+$globals.HLFindReferencesCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "displayLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "find references";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "displayLabel\x0a\x09^ 'find references'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLFindReferencesCommand);
+$globals.HLFindReferencesCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-function $HLReferences(){return globals.HLReferences||(typeof HLReferences=="undefined"?nil:HLReferences)}
-return smalltalk.withContext(function($ctx1) { 
+function $HLReferences(){return $globals.HLReferences||(typeof HLReferences=="undefined"?nil:HLReferences)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$2;
-$1=_st($HLReferences())._new();
-_st($1)._openAsTab();
-$2=_st($1)._search_(self._input());
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLFindReferencesCommand)})},
+$1=$recv($HLReferences())._new();
+$recv($1)._openAsTab();
+$2=$recv($1)._search_(self._input());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLFindReferencesCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09HLReferences new \x0a\x09\x09openAsTab;\x0a\x09\x09search: self input",
-messageSends: ["openAsTab", "new", "search:", "input"],
-referencedClasses: ["HLReferences"]
+referencedClasses: ["HLReferences"],
+//>>excludeEnd("ide");
+messageSends: ["openAsTab", "new", "search:", "input"]
 }),
-globals.HLFindReferencesCommand);
+$globals.HLFindReferencesCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "inputCompletion",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $3,$2,$1;
 $3=self._model();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["model"]=1;
-$2=_st($3)._availableClassNames();
-$1=_st($2).__comma(_st(self._model())._allSelectors());
+//>>excludeEnd("ctx");
+$2=$recv($3)._availableClassNames();
+$1=$recv($2).__comma($recv(self._model())._allSelectors());
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},globals.HLFindReferencesCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},$globals.HLFindReferencesCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "inputCompletion\x0a\x09^ self model availableClassNames, self model allSelectors",
-messageSends: [",", "availableClassNames", "model", "allSelectors"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: [",", "availableClassNames", "model", "allSelectors"]
 }),
-globals.HLFindReferencesCommand);
+$globals.HLFindReferencesCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "inputLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Find references of";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "inputLabel\x0a\x09^ 'Find references of'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLFindReferencesCommand);
+$globals.HLFindReferencesCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isInputRequired",
 protocol: 'testing',
 fn: function (){
 var self=this;
 return true;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isInputRequired\x0a\x09^ true",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLFindReferencesCommand);
+$globals.HLFindReferencesCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "r";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'r'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLFindReferencesCommand.klass);
+$globals.HLFindReferencesCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Find references";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Find references'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLFindReferencesCommand.klass);
+$globals.HLFindReferencesCommand.klass);
 
 
-smalltalk.addClass('HLMoveToCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
+$core.addClass('HLMoveToCommand', $globals.HLToolCommand, [], 'Helios-Commands-Tools');
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "m";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'm'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveToCommand.klass);
+$globals.HLMoveToCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Move";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Move'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveToCommand.klass);
+$globals.HLMoveToCommand.klass);
 
 
-smalltalk.addClass('HLMoveClassToCommand', globals.HLMoveToCommand, [], 'Helios-Commands-Tools');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLMoveClassToCommand', $globals.HLMoveToCommand, [], 'Helios-Commands-Tools');
+$core.addMethod(
+$core.method({
 selector: "isActive",
 protocol: 'testing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(_st(self._model())._selectedClass())._notNil();
+$1=$recv($recv(self._model())._selectedClass())._notNil();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLMoveClassToCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLMoveClassToCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isActive\x0a\x09^ self model selectedClass notNil",
-messageSends: ["notNil", "selectedClass", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["notNil", "selectedClass", "model"]
 }),
-globals.HLMoveClassToCommand);
+$globals.HLMoveClassToCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "c";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'c'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveClassToCommand.klass);
+$globals.HLMoveClassToCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Move class";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Move class'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveClassToCommand.klass);
+$globals.HLMoveClassToCommand.klass);
 
 
-smalltalk.addClass('HLMoveClassToPackageCommand', globals.HLMoveClassToCommand, [], 'Helios-Commands-Tools');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLMoveClassToPackageCommand', $globals.HLMoveClassToCommand, [], 'Helios-Commands-Tools');
+$core.addMethod(
+$core.method({
 selector: "category",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Classes";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "category\x0a\x09^ 'Classes'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveClassToPackageCommand);
+$globals.HLMoveClassToPackageCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "displayLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "select a package";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "displayLabel\x0a\x09^ 'select a package'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveClassToPackageCommand);
+$globals.HLMoveClassToPackageCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._moveClassToPackage_(self._input());
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLMoveClassToPackageCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._moveClassToPackage_(self._input());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLMoveClassToPackageCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model moveClassToPackage: self input",
-messageSends: ["moveClassToPackage:", "model", "input"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["moveClassToPackage:", "model", "input"]
 }),
-globals.HLMoveClassToPackageCommand);
+$globals.HLMoveClassToPackageCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "inputCompletion",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(self._model())._availablePackageNames();
+$1=$recv(self._model())._availablePackageNames();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},globals.HLMoveClassToPackageCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},$globals.HLMoveClassToPackageCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "inputCompletion\x0a\x09^ self model availablePackageNames",
-messageSends: ["availablePackageNames", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["availablePackageNames", "model"]
 }),
-globals.HLMoveClassToPackageCommand);
+$globals.HLMoveClassToPackageCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "inputLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Move class to package:";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "inputLabel\x0a\x09^ 'Move class to package:'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveClassToPackageCommand);
+$globals.HLMoveClassToPackageCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isInputRequired",
 protocol: 'testing',
 fn: function (){
 var self=this;
 return true;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isInputRequired\x0a\x09^ true",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveClassToPackageCommand);
+$globals.HLMoveClassToPackageCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "p";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'p'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveClassToPackageCommand.klass);
+$globals.HLMoveClassToPackageCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Move class to package";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Move class to package'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveClassToPackageCommand.klass);
+$globals.HLMoveClassToPackageCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "menuLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Move to package...";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "menuLabel\x09\x0a\x09^ 'Move to package...'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveClassToPackageCommand.klass);
+$globals.HLMoveClassToPackageCommand.klass);
 
 
-smalltalk.addClass('HLMoveMethodToCommand', globals.HLMoveToCommand, [], 'Helios-Commands-Tools');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLMoveMethodToCommand', $globals.HLMoveToCommand, [], 'Helios-Commands-Tools');
+$core.addMethod(
+$core.method({
 selector: "category",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Methods";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "category\x0a\x09^ 'Methods'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveMethodToCommand);
+$globals.HLMoveMethodToCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isActive",
 protocol: 'testing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(_st(self._model())._selectedMethod())._notNil();
+$1=$recv($recv(self._model())._selectedMethod())._notNil();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLMoveMethodToCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLMoveMethodToCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isActive\x0a\x09^ self model selectedMethod notNil",
-messageSends: ["notNil", "selectedMethod", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["notNil", "selectedMethod", "model"]
 }),
-globals.HLMoveMethodToCommand);
+$globals.HLMoveMethodToCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "m";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'm'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveMethodToCommand.klass);
+$globals.HLMoveMethodToCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Move method";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Move method'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveMethodToCommand.klass);
+$globals.HLMoveMethodToCommand.klass);
 
 
-smalltalk.addClass('HLMoveMethodToClassCommand', globals.HLMoveMethodToCommand, [], 'Helios-Commands-Tools');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLMoveMethodToClassCommand', $globals.HLMoveMethodToCommand, [], 'Helios-Commands-Tools');
+$core.addMethod(
+$core.method({
 selector: "displayLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "select a class";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "displayLabel\x0a\x09^ 'select a class'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveMethodToClassCommand);
+$globals.HLMoveMethodToClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._moveMethodToClass_(self._input());
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLMoveMethodToClassCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._moveMethodToClass_(self._input());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLMoveMethodToClassCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model moveMethodToClass: self input",
-messageSends: ["moveMethodToClass:", "model", "input"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["moveMethodToClass:", "model", "input"]
 }),
-globals.HLMoveMethodToClassCommand);
+$globals.HLMoveMethodToClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "inputCompletion",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(self._model())._availableClassNames();
+$1=$recv(self._model())._availableClassNames();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},globals.HLMoveMethodToClassCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},$globals.HLMoveMethodToClassCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "inputCompletion\x0a\x09^ self model availableClassNames",
-messageSends: ["availableClassNames", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["availableClassNames", "model"]
 }),
-globals.HLMoveMethodToClassCommand);
+$globals.HLMoveMethodToClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "inputLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Move method to class:";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "inputLabel\x0a\x09^ 'Move method to class:'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveMethodToClassCommand);
+$globals.HLMoveMethodToClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isInputRequired",
 protocol: 'testing',
 fn: function (){
 var self=this;
 return true;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isInputRequired\x0a\x09^ true",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveMethodToClassCommand);
+$globals.HLMoveMethodToClassCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "c";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'c'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveMethodToClassCommand.klass);
+$globals.HLMoveMethodToClassCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Move method to class";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x09\x0a\x09^ 'Move method to class'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveMethodToClassCommand.klass);
+$globals.HLMoveMethodToClassCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "menuLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Move to class...";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "menuLabel\x09\x0a\x09^ 'Move to class...'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveMethodToClassCommand.klass);
+$globals.HLMoveMethodToClassCommand.klass);
 
 
-smalltalk.addClass('HLMoveMethodToProtocolCommand', globals.HLMoveMethodToCommand, [], 'Helios-Commands-Tools');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLMoveMethodToProtocolCommand', $globals.HLMoveMethodToCommand, [], 'Helios-Commands-Tools');
+$core.addMethod(
+$core.method({
 selector: "displayLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "select a protocol";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "displayLabel\x0a\x09^ 'select a protocol'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveMethodToProtocolCommand);
+$globals.HLMoveMethodToProtocolCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._moveMethodToProtocol_(self._input());
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLMoveMethodToProtocolCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._moveMethodToProtocol_(self._input());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLMoveMethodToProtocolCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model moveMethodToProtocol: self input",
-messageSends: ["moveMethodToProtocol:", "model", "input"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["moveMethodToProtocol:", "model", "input"]
 }),
-globals.HLMoveMethodToProtocolCommand);
+$globals.HLMoveMethodToProtocolCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "inputCompletion",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(self._model())._availableProtocols();
+$1=$recv(self._model())._availableProtocols();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},globals.HLMoveMethodToProtocolCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"inputCompletion",{},$globals.HLMoveMethodToProtocolCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "inputCompletion\x0a\x09^ self model availableProtocols",
-messageSends: ["availableProtocols", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["availableProtocols", "model"]
 }),
-globals.HLMoveMethodToProtocolCommand);
+$globals.HLMoveMethodToProtocolCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "inputLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Move method to a protocol:";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "inputLabel\x0a\x09^ 'Move method to a protocol:'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveMethodToProtocolCommand);
+$globals.HLMoveMethodToProtocolCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isInputRequired",
 protocol: 'testing',
 fn: function (){
 var self=this;
 return true;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isInputRequired\x0a\x09^ true",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveMethodToProtocolCommand);
+$globals.HLMoveMethodToProtocolCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "t";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 't'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveMethodToProtocolCommand.klass);
+$globals.HLMoveMethodToProtocolCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Move method to protocol";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Move method to protocol'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveMethodToProtocolCommand.klass);
+$globals.HLMoveMethodToProtocolCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "menuLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Move to protocol...";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "menuLabel\x0a\x09^ 'Move to protocol...'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLMoveMethodToProtocolCommand.klass);
+$globals.HLMoveMethodToProtocolCommand.klass);
 
 
-smalltalk.addClass('HLRemoveCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
+$core.addClass('HLRemoveCommand', $globals.HLToolCommand, [], 'Helios-Commands-Tools');
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "x";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'x'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRemoveCommand.klass);
+$globals.HLRemoveCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Remove";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Remove'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRemoveCommand.klass);
+$globals.HLRemoveCommand.klass);
 
 
-smalltalk.addClass('HLRemoveClassCommand', globals.HLRemoveCommand, [], 'Helios-Commands-Tools');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLRemoveClassCommand', $globals.HLRemoveCommand, [], 'Helios-Commands-Tools');
+$core.addMethod(
+$core.method({
 selector: "category",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Classes";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "category\x0a\x09^ 'Classes'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRemoveClassCommand);
+$globals.HLRemoveClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._removeClass();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLRemoveClassCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._removeClass();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLRemoveClassCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model removeClass",
-messageSends: ["removeClass", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["removeClass", "model"]
 }),
-globals.HLRemoveClassCommand);
+$globals.HLRemoveClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isActive",
 protocol: 'testing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(_st(self._model())._selectedClass())._notNil();
+$1=$recv($recv(self._model())._selectedClass())._notNil();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLRemoveClassCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLRemoveClassCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isActive\x0a\x09^ self model selectedClass notNil",
-messageSends: ["notNil", "selectedClass", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["notNil", "selectedClass", "model"]
 }),
-globals.HLRemoveClassCommand);
+$globals.HLRemoveClassCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "c";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'c'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRemoveClassCommand.klass);
+$globals.HLRemoveClassCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Remove class";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Remove class'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRemoveClassCommand.klass);
+$globals.HLRemoveClassCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "menuLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Remove class";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "menuLabel\x0a\x09^ 'Remove class'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRemoveClassCommand.klass);
+$globals.HLRemoveClassCommand.klass);
 
 
-smalltalk.addClass('HLRemoveMethodCommand', globals.HLRemoveCommand, [], 'Helios-Commands-Tools');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLRemoveMethodCommand', $globals.HLRemoveCommand, [], 'Helios-Commands-Tools');
+$core.addMethod(
+$core.method({
 selector: "category",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Methods";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "category\x0a\x09^ 'Methods'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRemoveMethodCommand);
+$globals.HLRemoveMethodCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._removeMethod();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLRemoveMethodCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._removeMethod();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLRemoveMethodCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model removeMethod",
-messageSends: ["removeMethod", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["removeMethod", "model"]
 }),
-globals.HLRemoveMethodCommand);
+$globals.HLRemoveMethodCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isActive",
 protocol: 'testing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(_st(self._model())._selectedMethod())._notNil();
+$1=$recv($recv(self._model())._selectedMethod())._notNil();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLRemoveMethodCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLRemoveMethodCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isActive\x0a\x09^ self model selectedMethod notNil",
-messageSends: ["notNil", "selectedMethod", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["notNil", "selectedMethod", "model"]
 }),
-globals.HLRemoveMethodCommand);
+$globals.HLRemoveMethodCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "m";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'm'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRemoveMethodCommand.klass);
+$globals.HLRemoveMethodCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Remove method";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Remove method'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRemoveMethodCommand.klass);
+$globals.HLRemoveMethodCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "menuLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Remove method";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "menuLabel\x0a\x09^ 'Remove method'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRemoveMethodCommand.klass);
+$globals.HLRemoveMethodCommand.klass);
 
 
-smalltalk.addClass('HLRemoveProtocolCommand', globals.HLRemoveCommand, [], 'Helios-Commands-Tools');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLRemoveProtocolCommand', $globals.HLRemoveCommand, [], 'Helios-Commands-Tools');
+$core.addMethod(
+$core.method({
 selector: "category",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Protocols";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "category\x0a\x09^ 'Protocols'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRemoveProtocolCommand);
+$globals.HLRemoveProtocolCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._removeProtocol();
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLRemoveProtocolCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._removeProtocol();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLRemoveProtocolCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model removeProtocol",
-messageSends: ["removeProtocol", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["removeProtocol", "model"]
 }),
-globals.HLRemoveProtocolCommand);
+$globals.HLRemoveProtocolCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isActive",
 protocol: 'testing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(_st(self._model())._selectedProtocol())._notNil();
+$1=$recv($recv(self._model())._selectedProtocol())._notNil();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLRemoveProtocolCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLRemoveProtocolCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isActive\x0a\x09^ self model selectedProtocol notNil",
-messageSends: ["notNil", "selectedProtocol", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["notNil", "selectedProtocol", "model"]
 }),
-globals.HLRemoveProtocolCommand);
+$globals.HLRemoveProtocolCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "t";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 't'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRemoveProtocolCommand.klass);
+$globals.HLRemoveProtocolCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Remove protocol";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Remove protocol'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRemoveProtocolCommand.klass);
+$globals.HLRemoveProtocolCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "menuLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Remove protocol";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "menuLabel\x0a\x09^ 'Remove protocol'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRemoveProtocolCommand.klass);
+$globals.HLRemoveProtocolCommand.klass);
 
 
-smalltalk.addClass('HLRenameCommand', globals.HLToolCommand, [], 'Helios-Commands-Tools');
+$core.addClass('HLRenameCommand', $globals.HLToolCommand, [], 'Helios-Commands-Tools');
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "r";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'r'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRenameCommand.klass);
+$globals.HLRenameCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Rename";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Rename'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRenameCommand.klass);
+$globals.HLRenameCommand.klass);
 
 
-smalltalk.addClass('HLRenameClassCommand', globals.HLRenameCommand, [], 'Helios-Commands-Tools');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLRenameClassCommand', $globals.HLRenameCommand, [], 'Helios-Commands-Tools');
+$core.addMethod(
+$core.method({
 selector: "category",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Classes";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "category\x0a\x09^ 'Classes'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRenameClassCommand);
+$globals.HLRenameClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "defaultInput",
 protocol: 'defaults',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(_st(_st(self._model())._selectedClass())._theNonMetaClass())._name();
+$1=$recv($recv($recv(self._model())._selectedClass())._theNonMetaClass())._name();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"defaultInput",{},globals.HLRenameClassCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"defaultInput",{},$globals.HLRenameClassCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "defaultInput\x0a\x09^ self model selectedClass theNonMetaClass name",
-messageSends: ["name", "theNonMetaClass", "selectedClass", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["name", "theNonMetaClass", "selectedClass", "model"]
 }),
-globals.HLRenameClassCommand);
+$globals.HLRenameClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "displayLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Rename class to:";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "displayLabel\x0a\x09^ 'Rename class to:'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRenameClassCommand);
+$globals.HLRenameClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._renameClassTo_(self._input());
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLRenameClassCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._renameClassTo_(self._input());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLRenameClassCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model renameClassTo: self input",
-messageSends: ["renameClassTo:", "model", "input"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["renameClassTo:", "model", "input"]
 }),
-globals.HLRenameClassCommand);
+$globals.HLRenameClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isActive",
 protocol: 'testing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(_st(self._model())._selectedClass())._notNil();
+$1=$recv($recv(self._model())._selectedClass())._notNil();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLRenameClassCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLRenameClassCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isActive\x0a\x09^ self model selectedClass notNil",
-messageSends: ["notNil", "selectedClass", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["notNil", "selectedClass", "model"]
 }),
-globals.HLRenameClassCommand);
+$globals.HLRenameClassCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isInputRequired",
 protocol: 'testing',
 fn: function (){
 var self=this;
 return true;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isInputRequired\x0a\x09^ true",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRenameClassCommand);
+$globals.HLRenameClassCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "c";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 'c'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRenameClassCommand.klass);
+$globals.HLRenameClassCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Rename class";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Rename class'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRenameClassCommand.klass);
+$globals.HLRenameClassCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "menuLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Rename class...";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "menuLabel\x0a\x09^ 'Rename class...'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRenameClassCommand.klass);
+$globals.HLRenameClassCommand.klass);
 
 
-smalltalk.addClass('HLRenameProtocolCommand', globals.HLRenameCommand, [], 'Helios-Commands-Tools');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLRenameProtocolCommand', $globals.HLRenameCommand, [], 'Helios-Commands-Tools');
+$core.addMethod(
+$core.method({
 selector: "category",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Protocols";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "category\x0a\x09^ 'Protocols'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRenameProtocolCommand);
+$globals.HLRenameProtocolCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "defaultInput",
 protocol: 'defaults',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(self._model())._selectedProtocol();
+$1=$recv(self._model())._selectedProtocol();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"defaultInput",{},globals.HLRenameProtocolCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"defaultInput",{},$globals.HLRenameProtocolCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "defaultInput\x0a\x09^ self model selectedProtocol",
-messageSends: ["selectedProtocol", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["selectedProtocol", "model"]
 }),
-globals.HLRenameProtocolCommand);
+$globals.HLRenameProtocolCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "displayLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Rename protocol to:";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "displayLabel\x0a\x09^ 'Rename protocol to:'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRenameProtocolCommand);
+$globals.HLRenameProtocolCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "execute",
 protocol: 'executing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(self._model())._renameProtocolTo_(self._input());
-return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLRenameProtocolCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._model())._renameProtocolTo_(self._input());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"execute",{},$globals.HLRenameProtocolCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "execute\x0a\x09self model renameProtocolTo: self input",
-messageSends: ["renameProtocolTo:", "model", "input"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["renameProtocolTo:", "model", "input"]
 }),
-globals.HLRenameProtocolCommand);
+$globals.HLRenameProtocolCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isActive",
 protocol: 'testing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(_st(self._model())._selectedProtocol())._notNil();
+$1=$recv($recv(self._model())._selectedProtocol())._notNil();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLRenameProtocolCommand)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},$globals.HLRenameProtocolCommand)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isActive\x0a\x09^ self model selectedProtocol notNil",
-messageSends: ["notNil", "selectedProtocol", "model"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["notNil", "selectedProtocol", "model"]
 }),
-globals.HLRenameProtocolCommand);
+$globals.HLRenameProtocolCommand);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isInputRequired",
 protocol: 'testing',
 fn: function (){
 var self=this;
 return true;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isInputRequired\x0a\x09^ true",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRenameProtocolCommand);
+$globals.HLRenameProtocolCommand);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "key",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "t";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "key\x0a\x09^ 't'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRenameProtocolCommand.klass);
+$globals.HLRenameProtocolCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "label",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Rename protocol";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "label\x0a\x09^ 'Rename protocol'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRenameProtocolCommand.klass);
+$globals.HLRenameProtocolCommand.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "menuLabel",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "Rename protocol...";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "menuLabel\x0a\x09^ 'Rename protocol...'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLRenameProtocolCommand.klass);
+$globals.HLRenameProtocolCommand.klass);
 
 });

src/Helios-Exceptions.js

@@ -1,17 +1,24 @@
 define("helios/Helios-Exceptions", ["amber/boot", "amber_core/Kernel-Exceptions"], function($boot){
-var smalltalk=$boot.vm,nil=$boot.nil,_st=$boot.asReceiver,globals=$boot.globals;
-smalltalk.addPackage('Helios-Exceptions');
-smalltalk.packages["Helios-Exceptions"].transport = {"type":"amd","amdNamespace":"helios"};
+var $core=$boot.api,nil=$boot.nil,$recv=$boot.asReceiver,$globals=$boot.globals;
+var smalltalk=$core,_st=$recv,globals=$globals;
+$core.addPackage('Helios-Exceptions');
+$core.packages["Helios-Exceptions"].transport = {"type":"amd","amdNamespace":"helios"};
 
-smalltalk.addClass('HLError', globals.Error, [], 'Helios-Exceptions');
-globals.HLError.comment="I am the abstract superclass of all Helios-specific errors.";
+$core.addClass('HLError', $globals.Error, [], 'Helios-Exceptions');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$globals.HLError.comment="I am the abstract superclass of all Helios-specific errors.";
+//>>excludeEnd("ide");
 
 
-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:`.";
+$core.addClass('HLChangeForbidden', $globals.HLError, [], 'Helios-Exceptions');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$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:`.";
+//>>excludeEnd("ide");
 
 
-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.";
+$core.addClass('HLListItemNotFound', $globals.HLError, [], 'Helios-Exceptions');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$globals.HLListItemNotFound.comment="I get signaled by a `HLListWidget` when a non-existing item in the list is activated.";
+//>>excludeEnd("ide");
 
 });

src/Helios-Layout.js

@@ -1,30 +1,39 @@
 define("helios/Helios-Layout", ["amber/boot", "helios/Helios-Core", "amber_core/Web", "amber_core/Kernel-Objects"], function($boot){
-var smalltalk=$boot.vm,nil=$boot.nil,_st=$boot.asReceiver,globals=$boot.globals;
-smalltalk.addPackage('Helios-Layout');
-smalltalk.packages["Helios-Layout"].transport = {"type":"amd","amdNamespace":"helios"};
-
-smalltalk.addClass('HLContainer', globals.HLWidget, ['splitter'], 'Helios-Layout');
-smalltalk.addMethod(
-smalltalk.method({
+var $core=$boot.api,nil=$boot.nil,$recv=$boot.asReceiver,$globals=$boot.globals;
+var smalltalk=$core,_st=$recv,globals=$globals;
+$core.addPackage('Helios-Layout');
+$core.packages["Helios-Layout"].transport = {"type":"amd","amdNamespace":"helios"};
+
+$core.addClass('HLContainer', $globals.HLWidget, ['splitter'], 'Helios-Layout');
+$core.addMethod(
+$core.method({
 selector: "renderOn:",
 protocol: 'rendering',
 fn: function (html){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 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},globals.HLContainer)})},
+$1=$recv(html)._div();
+$recv($1)._class_("tool_container");
+$2=$recv($1)._with_(self._splitter());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},$globals.HLContainer)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["html"],
 source: "renderOn: html\x0a\x09html div \x0a    \x09class: 'tool_container'; \x0a        with: self splitter",
-messageSends: ["class:", "div", "with:", "splitter"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["class:", "div", "with:", "splitter"]
 }),
-globals.HLContainer);
+$globals.HLContainer);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "splitter",
 protocol: 'accessing',
 fn: function (){
@@ -32,70 +41,87 @@ var self=this;
 var $1;
 $1=self["@splitter"];
 return $1;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "splitter\x0a\x09^ splitter",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLContainer);
+$globals.HLContainer);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "splitter:",
 protocol: 'accessing',
 fn: function (aSplitter){
 var self=this;
 self["@splitter"]=aSplitter;
-return self},
+return self;
+
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aSplitter"],
 source: "splitter: aSplitter\x0a\x09splitter := aSplitter",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLContainer);
+$globals.HLContainer);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "with:",
 protocol: 'instance creation',
 fn: function (aSplitter){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $2,$3,$1;
 $2=self._new();
-_st($2)._splitter_(aSplitter);
-$3=_st($2)._yourself();
+$recv($2)._splitter_(aSplitter);
+$3=$recv($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"with:",{aSplitter:aSplitter},globals.HLContainer.klass)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"with:",{aSplitter:aSplitter},$globals.HLContainer.klass)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aSplitter"],
 source: "with: aSplitter\x0a\x09^ self new \x0a    \x09splitter: aSplitter; \x0a        yourself",
-messageSends: ["splitter:", "new", "yourself"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["splitter:", "new", "yourself"]
 }),
-globals.HLContainer.klass);
+$globals.HLContainer.klass);
 
 
-smalltalk.addClass('HLSplitter', globals.Widget, ['firstWidget', 'secondWidget', 'firstPane', 'secondPane', 'splitter'], 'Helios-Layout');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLSplitter', $globals.Widget, ['firstWidget', 'secondWidget', 'firstPane', 'secondPane', 'splitter'], 'Helios-Layout');
+$core.addMethod(
+$core.method({
 selector: "cssClass",
 protocol: 'accessing',
 fn: function (){
 var self=this;
 return "splitter";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "cssClass\x0a\x09^ 'splitter'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSplitter);
+$globals.HLSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "firstWidget",
 protocol: 'accessing',
 fn: function (){
@@ -103,118 +129,164 @@ var self=this;
 var $1;
 $1=self["@firstWidget"];
 return $1;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "firstWidget\x0a\x09^ firstWidget",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSplitter);
+$globals.HLSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "firstWidget:",
 protocol: 'accessing',
 fn: function (aWidget){
 var self=this;
 self["@firstWidget"]=aWidget;
-return self},
+return self;
+
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aWidget"],
 source: "firstWidget: aWidget\x0a\x09firstWidget := aWidget",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSplitter);
+$globals.HLSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isHeliosSplitter",
 protocol: 'testing',
 fn: function (){
 var self=this;
 return true;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isHeliosSplitter\x0a\x09^ true",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSplitter);
+$globals.HLSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "panesCssClass",
 protocol: 'rendering',
 fn: function (){
 var self=this;
 return "panes";
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "panesCssClass\x0a\x09^ 'panes'",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSplitter);
+$globals.HLSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "renderOn:",
 protocol: 'rendering',
 fn: function (html){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$3,$4,$5,$6,$7,$2;
-$1=_st(html)._div();
+$1=$recv(html)._div();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["div"]=1;
-_st($1)._class_(self._panesCssClass());
+//>>excludeEnd("ctx");
+$recv($1)._class_(self._panesCssClass());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["class:"]=1;
-$2=_st($1)._with_((function(){
-return smalltalk.withContext(function($ctx2) {
-$3=_st(html)._div();
+//>>excludeEnd("ctx");
+$2=$recv($1)._with_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
+$3=$recv(html)._div();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["div"]=2;
-_st($3)._class_("pane");
+//>>excludeEnd("ctx");
+$recv($3)._class_("pane");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["class:"]=2;
-$4=_st($3)._with_(self._firstWidget());
+//>>excludeEnd("ctx");
+$4=$recv($3)._with_(self._firstWidget());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["with:"]=2;
+//>>excludeEnd("ctx");
 self["@firstPane"]=$4;
 self["@firstPane"];
-$5=_st(html)._div();
+$5=$recv(html)._div();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["div"]=3;
-self["@splitter"]=_st($5)._class_(self._cssClass());
+//>>excludeEnd("ctx");
+self["@splitter"]=$recv($5)._class_(self._cssClass());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx2.sendIdx["class:"]=3;
+//>>excludeEnd("ctx");
 self["@splitter"];
-$6=_st(html)._div();
-_st($6)._class_("pane");
-$7=_st($6)._with_(self._secondWidget());
+$6=$recv(html)._div();
+$recv($6)._class_("pane");
+$7=$recv($6)._with_(self._secondWidget());
 self["@secondPane"]=$7;
 return self["@secondPane"];
-}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
+}));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["with:"]=1;
+//>>excludeEnd("ctx");
 self._setupSplitter();
-return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},globals.HLSplitter)})},
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},$globals.HLSplitter)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 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: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["class:", "div", "panesCssClass", "with:", "firstWidget", "cssClass", "secondWidget", "setupSplitter"]
 }),
-globals.HLSplitter);
+$globals.HLSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "resize",
 protocol: 'rendering',
 fn: function (){
 var self=this;
-return self},
+return self;
+
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "resize",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSplitter);
+$globals.HLSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "secondWidget",
 protocol: 'accessing',
 fn: function (){
@@ -222,383 +294,596 @@ var self=this;
 var $1;
 $1=self["@secondWidget"];
 return $1;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "secondWidget\x0a\x09^ secondWidget",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSplitter);
+$globals.HLSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "secondWidget:",
 protocol: 'accessing',
 fn: function (aWidget){
 var self=this;
 self["@secondWidget"]=aWidget;
-return self},
+return self;
+
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aWidget"],
 source: "secondWidget: aWidget\x0a\x09secondWidget := aWidget",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSplitter);
+$globals.HLSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "setupSplitter",
 protocol: 'rendering',
 fn: function (){
 var self=this;
-return self},
+return self;
+
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "setupSplitter",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.HLSplitter);
+$globals.HLSplitter);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "with:with:",
 protocol: 'instance creation',
 fn: function (aWidget,anotherWidget){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $2,$3,$1;
 $2=self._new();
-_st($2)._firstWidget_(aWidget);
-_st($2)._secondWidget_(anotherWidget);
-$3=_st($2)._yourself();
+$recv($2)._firstWidget_(aWidget);
+$recv($2)._secondWidget_(anotherWidget);
+$3=$recv($2)._yourself();
 $1=$3;
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"with:with:",{aWidget:aWidget,anotherWidget:anotherWidget},globals.HLSplitter.klass)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"with:with:",{aWidget:aWidget,anotherWidget:anotherWidget},$globals.HLSplitter.klass)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 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: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["firstWidget:", "new", "secondWidget:", "yourself"]
 }),
-globals.HLSplitter.klass);
+$globals.HLSplitter.klass);
 
 
-smalltalk.addClass('HLHorizontalSplitter', globals.HLSplitter, [], 'Helios-Layout');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLHorizontalSplitter', $globals.HLSplitter, [], 'Helios-Layout');
+$core.addMethod(
+$core.method({
 selector: "cssClass",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $2,$1;
-$2=($ctx1.supercall = true, globals.HLHorizontalSplitter.superclass.fn.prototype._cssClass.apply(_st(self), []));
+$2=(
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+$ctx1.supercall = true, 
+//>>excludeEnd("ctx");
+$globals.HLHorizontalSplitter.superclass.fn.prototype._cssClass.apply($recv(self), []));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.supercall = false;
-$1=_st($2).__comma(" horizontal");
+//>>excludeEnd("ctx");;
+$1=$recv($2).__comma(" horizontal");
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"cssClass",{},globals.HLHorizontalSplitter)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"cssClass",{},$globals.HLHorizontalSplitter)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "cssClass\x0a\x09^ super cssClass, ' horizontal'",
-messageSends: [",", "cssClass"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: [",", "cssClass"]
 }),
-globals.HLHorizontalSplitter);
+$globals.HLHorizontalSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "panesCssClass",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $2,$1;
-$2=($ctx1.supercall = true, globals.HLHorizontalSplitter.superclass.fn.prototype._panesCssClass.apply(_st(self), []));
+$2=(
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+$ctx1.supercall = true, 
+//>>excludeEnd("ctx");
+$globals.HLHorizontalSplitter.superclass.fn.prototype._panesCssClass.apply($recv(self), []));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.supercall = false;
-$1=_st($2).__comma(" horizontal");
+//>>excludeEnd("ctx");;
+$1=$recv($2).__comma(" horizontal");
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"panesCssClass",{},globals.HLHorizontalSplitter)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"panesCssClass",{},$globals.HLHorizontalSplitter)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "panesCssClass\x0a\x09^ super panesCssClass, ' horizontal'",
-messageSends: [",", "panesCssClass"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: [",", "panesCssClass"]
 }),
-globals.HLHorizontalSplitter);
+$globals.HLHorizontalSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "resize",
 protocol: 'actions',
 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",{},globals.HLHorizontalSplitter)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+self._resize_($recv($recv(self["@splitter"])._asJQuery())._css_("top"));
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"resize",{},$globals.HLHorizontalSplitter)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "resize\x0a\x09self resize: (splitter asJQuery css: 'top')",
-messageSends: ["resize:", "css:", "asJQuery"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["resize:", "css:", "asJQuery"]
 }),
-globals.HLHorizontalSplitter);
+$globals.HLHorizontalSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "resize:",
 protocol: 'actions',
 fn: function (anInteger){
 var self=this;
 var container,size,offset,percentage;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$3,$2,$6,$7,$5,$4,$8,$10,$9,$11,$14,$13,$12;
-$1=_st(self["@firstPane"])._asJQuery();
+$1=$recv(self["@firstPane"])._asJQuery();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["asJQuery"]=1;
-container=_st($1)._parent();
-$3=_st(self["@firstPane"])._asJQuery();
+//>>excludeEnd("ctx");
+container=$recv($1)._parent();
+$3=$recv(self["@firstPane"])._asJQuery();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["asJQuery"]=2;
-$2=_st($3)._offset();
-offset=_st($2)._top();
-size=_st(container)._height();
+//>>excludeEnd("ctx");
+$2=$recv($3)._offset();
+offset=$recv($2)._top();
+size=$recv(container)._height();
 $6=size;
-$7=_st(anInteger).__minus(offset);
+$7=$recv(anInteger).__minus(offset);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["-"]=2;
-$5=_st($6).__minus($7);
+//>>excludeEnd("ctx");
+$5=$recv($6).__minus($7);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["-"]=1;
-$4=_st($5).__slash(size);
-percentage=_st($4).__star((100));
-percentage=(80)._min_(_st(percentage)._max_((20)));
-$8=_st(self["@firstPane"])._asJQuery();
+//>>excludeEnd("ctx");
+$4=$recv($5).__slash(size);
+percentage=$recv($4).__star((100));
+percentage=(80)._min_($recv(percentage)._max_((20)));
+$8=$recv(self["@firstPane"])._asJQuery();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["asJQuery"]=3;
-$10=_st(percentage)._asString();
+//>>excludeEnd("ctx");
+$10=$recv(percentage)._asString();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["asString"]=1;
-$9=_st($10).__comma("%");
+//>>excludeEnd("ctx");
+$9=$recv($10).__comma("%");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx[","]=1;
-_st($8)._css_put_("bottom",$9);
+//>>excludeEnd("ctx");
+$recv($8)._css_put_("bottom",$9);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["css:put:"]=1;
-$11=_st(self["@splitter"])._asJQuery();
+//>>excludeEnd("ctx");
+$11=$recv(self["@splitter"])._asJQuery();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["asJQuery"]=4;
+//>>excludeEnd("ctx");
 $14=(100).__minus(percentage);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["-"]=3;
-$13=_st($14)._asString();
+//>>excludeEnd("ctx");
+$13=$recv($14)._asString();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["asString"]=2;
-$12=_st($13).__comma("%");
+//>>excludeEnd("ctx");
+$12=$recv($13).__comma("%");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx[","]=2;
-_st($11)._css_put_("top",$12);
+//>>excludeEnd("ctx");
+$recv($11)._css_put_("top",$12);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $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},globals.HLHorizontalSplitter)})},
+//>>excludeEnd("ctx");
+$recv($recv(self["@secondPane"])._asJQuery())._css_put_("top",$recv($recv((100).__minus(percentage))._asString()).__comma("%"));
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"resize:",{anInteger:anInteger,container:container,size:size,offset:offset,percentage:percentage},$globals.HLHorizontalSplitter)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 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: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["parent", "asJQuery", "top", "offset", "height", "*", "/", "-", "min:", "max:", "css:put:", ",", "asString"]
 }),
-globals.HLHorizontalSplitter);
+$globals.HLHorizontalSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "setupSplitter",
 protocol: 'rendering',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(self["@splitter"])._asJQuery();
+$1=$recv(self["@splitter"])._asJQuery();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["asJQuery"]=1;
-_st($1)._draggable_(globals.HashedCollection._newFromPairs_(["axis","y","containment",_st(_st(self["@splitter"])._asJQuery())._parent(),"helper","clone","start",(function(e,ui){
-return smalltalk.withContext(function($ctx2) {
-return self._startResizing_(_st(ui)._helper());
-}, function($ctx2) {$ctx2.fillBlock({e:e,ui:ui},$ctx1,1)})}),"drag",(function(e,ui){
-return smalltalk.withContext(function($ctx2) {
-return self._resize_(_st(_st(ui)._offset())._top());
-}, function($ctx2) {$ctx2.fillBlock({e:e,ui:ui},$ctx1,2)})})]));
-return self}, function($ctx1) {$ctx1.fill(self,"setupSplitter",{},globals.HLHorizontalSplitter)})},
+//>>excludeEnd("ctx");
+$recv($1)._draggable_($globals.HashedCollection._newFromPairs_(["axis","y","containment",$recv($recv(self["@splitter"])._asJQuery())._parent(),"helper","clone","start",(function(e,ui){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
+return self._startResizing_($recv(ui)._helper());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({e:e,ui:ui},$ctx1,1)});
+//>>excludeEnd("ctx");
+}),"drag",(function(e,ui){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
+return self._resize_($recv($recv(ui)._offset())._top());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({e:e,ui:ui},$ctx1,2)});
+//>>excludeEnd("ctx");
+})]));
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"setupSplitter",{},$globals.HLHorizontalSplitter)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 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: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["draggable:", "asJQuery", "parent", "startResizing:", "helper", "resize:", "top", "offset"]
 }),
-globals.HLHorizontalSplitter);
+$globals.HLHorizontalSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "startResizing:",
 protocol: 'actions',
 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},globals.HLHorizontalSplitter)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(aSplitter)._width_($recv($recv(self["@splitter"])._asJQuery())._width());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"startResizing:",{aSplitter:aSplitter},$globals.HLHorizontalSplitter)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aSplitter"],
 source: "startResizing: aSplitter\x0a\x09aSplitter width: splitter asJQuery width",
-messageSends: ["width:", "width", "asJQuery"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["width:", "width", "asJQuery"]
 }),
-globals.HLHorizontalSplitter);
+$globals.HLHorizontalSplitter);
 
 
 
-smalltalk.addClass('HLVerticalSplitter', globals.HLSplitter, [], 'Helios-Layout');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLVerticalSplitter', $globals.HLSplitter, [], 'Helios-Layout');
+$core.addMethod(
+$core.method({
 selector: "cssClass",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $2,$1;
-$2=($ctx1.supercall = true, globals.HLVerticalSplitter.superclass.fn.prototype._cssClass.apply(_st(self), []));
+$2=(
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+$ctx1.supercall = true, 
+//>>excludeEnd("ctx");
+$globals.HLVerticalSplitter.superclass.fn.prototype._cssClass.apply($recv(self), []));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.supercall = false;
-$1=_st($2).__comma(" vertical");
+//>>excludeEnd("ctx");;
+$1=$recv($2).__comma(" vertical");
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"cssClass",{},globals.HLVerticalSplitter)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"cssClass",{},$globals.HLVerticalSplitter)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "cssClass\x0a\x09^ super cssClass, ' vertical'",
-messageSends: [",", "cssClass"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: [",", "cssClass"]
 }),
-globals.HLVerticalSplitter);
+$globals.HLVerticalSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "panesCssClass",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $2,$1;
-$2=($ctx1.supercall = true, globals.HLVerticalSplitter.superclass.fn.prototype._panesCssClass.apply(_st(self), []));
+$2=(
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+$ctx1.supercall = true, 
+//>>excludeEnd("ctx");
+$globals.HLVerticalSplitter.superclass.fn.prototype._panesCssClass.apply($recv(self), []));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.supercall = false;
-$1=_st($2).__comma(" vertical");
+//>>excludeEnd("ctx");;
+$1=$recv($2).__comma(" vertical");
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"panesCssClass",{},globals.HLVerticalSplitter)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"panesCssClass",{},$globals.HLVerticalSplitter)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "panesCssClass\x0a\x09^ super panesCssClass, ' vertical'",
-messageSends: [",", "panesCssClass"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: [",", "panesCssClass"]
 }),
-globals.HLVerticalSplitter);
+$globals.HLVerticalSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "resize",
 protocol: 'actions',
 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",{},globals.HLVerticalSplitter)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+self._resize_($recv($recv(self["@splitter"])._asJQuery())._css_("left"));
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"resize",{},$globals.HLVerticalSplitter)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "resize\x0a\x09self resize: (splitter asJQuery css: 'left')",
-messageSends: ["resize:", "css:", "asJQuery"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["resize:", "css:", "asJQuery"]
 }),
-globals.HLVerticalSplitter);
+$globals.HLVerticalSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "resize:",
 protocol: 'actions',
 fn: function (anInteger){
 var self=this;
 var container,size,offset,percentage;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$3,$2,$6,$7,$5,$4,$8,$10,$9,$11,$14,$13,$12;
-$1=_st(self["@firstPane"])._asJQuery();
+$1=$recv(self["@firstPane"])._asJQuery();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["asJQuery"]=1;
-container=_st($1)._parent();
-$3=_st(self["@firstPane"])._asJQuery();
+//>>excludeEnd("ctx");
+container=$recv($1)._parent();
+$3=$recv(self["@firstPane"])._asJQuery();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["asJQuery"]=2;
-$2=_st($3)._offset();
-offset=_st($2)._left();
-size=_st(container)._width();
+//>>excludeEnd("ctx");
+$2=$recv($3)._offset();
+offset=$recv($2)._left();
+size=$recv(container)._width();
 $6=size;
-$7=_st(anInteger).__minus(offset);
+$7=$recv(anInteger).__minus(offset);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["-"]=2;
-$5=_st($6).__minus($7);
+//>>excludeEnd("ctx");
+$5=$recv($6).__minus($7);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["-"]=1;
-$4=_st($5).__slash(size);
-percentage=_st($4).__star((100));
-percentage=(80)._min_(_st(percentage)._max_((20)));
-$8=_st(self["@firstPane"])._asJQuery();
+//>>excludeEnd("ctx");
+$4=$recv($5).__slash(size);
+percentage=$recv($4).__star((100));
+percentage=(80)._min_($recv(percentage)._max_((20)));
+$8=$recv(self["@firstPane"])._asJQuery();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["asJQuery"]=3;
-$10=_st(percentage)._asString();
+//>>excludeEnd("ctx");
+$10=$recv(percentage)._asString();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["asString"]=1;
-$9=_st($10).__comma("%");
+//>>excludeEnd("ctx");
+$9=$recv($10).__comma("%");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx[","]=1;
-_st($8)._css_put_("right",$9);
+//>>excludeEnd("ctx");
+$recv($8)._css_put_("right",$9);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["css:put:"]=1;
-$11=_st(self["@splitter"])._asJQuery();
+//>>excludeEnd("ctx");
+$11=$recv(self["@splitter"])._asJQuery();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["asJQuery"]=4;
+//>>excludeEnd("ctx");
 $14=(100).__minus(percentage);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["-"]=3;
-$13=_st($14)._asString();
+//>>excludeEnd("ctx");
+$13=$recv($14)._asString();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["asString"]=2;
-$12=_st($13).__comma("%");
+//>>excludeEnd("ctx");
+$12=$recv($13).__comma("%");
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx[","]=2;
-_st($11)._css_put_("left",$12);
+//>>excludeEnd("ctx");
+$recv($11)._css_put_("left",$12);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $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},globals.HLVerticalSplitter)})},
+//>>excludeEnd("ctx");
+$recv($recv(self["@secondPane"])._asJQuery())._css_put_("left",$recv($recv((100).__minus(percentage))._asString()).__comma("%"));
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"resize:",{anInteger:anInteger,container:container,size:size,offset:offset,percentage:percentage},$globals.HLVerticalSplitter)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 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: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["parent", "asJQuery", "left", "offset", "width", "*", "/", "-", "min:", "max:", "css:put:", ",", "asString"]
 }),
-globals.HLVerticalSplitter);
+$globals.HLVerticalSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "setupSplitter",
 protocol: 'rendering',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(self["@splitter"])._asJQuery();
+$1=$recv(self["@splitter"])._asJQuery();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["asJQuery"]=1;
-_st($1)._draggable_(globals.HashedCollection._newFromPairs_(["axis","x","containment",_st(_st(self["@splitter"])._asJQuery())._parent(),"helper","clone","start",(function(e,ui){
-return smalltalk.withContext(function($ctx2) {
-return self._startResizing_(_st(ui)._helper());
-}, function($ctx2) {$ctx2.fillBlock({e:e,ui:ui},$ctx1,1)})}),"drag",(function(e,ui){
-return smalltalk.withContext(function($ctx2) {
-return self._resize_(_st(_st(ui)._offset())._left());
-}, function($ctx2) {$ctx2.fillBlock({e:e,ui:ui},$ctx1,2)})})]));
-return self}, function($ctx1) {$ctx1.fill(self,"setupSplitter",{},globals.HLVerticalSplitter)})},
+//>>excludeEnd("ctx");
+$recv($1)._draggable_($globals.HashedCollection._newFromPairs_(["axis","x","containment",$recv($recv(self["@splitter"])._asJQuery())._parent(),"helper","clone","start",(function(e,ui){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
+return self._startResizing_($recv(ui)._helper());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({e:e,ui:ui},$ctx1,1)});
+//>>excludeEnd("ctx");
+}),"drag",(function(e,ui){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
+return self._resize_($recv($recv(ui)._offset())._left());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({e:e,ui:ui},$ctx1,2)});
+//>>excludeEnd("ctx");
+})]));
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"setupSplitter",{},$globals.HLVerticalSplitter)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 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: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["draggable:", "asJQuery", "parent", "startResizing:", "helper", "resize:", "left", "offset"]
 }),
-globals.HLVerticalSplitter);
+$globals.HLVerticalSplitter);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "startResizing:",
 protocol: 'actions',
 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},globals.HLVerticalSplitter)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(aSplitter)._height_($recv($recv(self["@splitter"])._asJQuery())._height());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"startResizing:",{aSplitter:aSplitter},$globals.HLVerticalSplitter)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aSplitter"],
 source: "startResizing: aSplitter\x0a\x09aSplitter height: splitter asJQuery height",
-messageSends: ["height:", "height", "asJQuery"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["height:", "height", "asJQuery"]
 }),
-globals.HLVerticalSplitter);
+$globals.HLVerticalSplitter);
 
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "isHeliosSplitter",
 protocol: '*Helios-Layout',
 fn: function (){
 var self=this;
 return false;
+
 },
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "isHeliosSplitter\x0a\x09^ false",
-messageSends: [],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: []
 }),
-globals.Object);
+$globals.Object);
 
 });

src/Helios-SUnit-Tests.js

@@ -1,423 +1,634 @@
 define("helios/Helios-SUnit-Tests", ["amber/boot", "amber_core/SUnit"], function($boot){
-var smalltalk=$boot.vm,nil=$boot.nil,_st=$boot.asReceiver,globals=$boot.globals;
-smalltalk.addPackage('Helios-SUnit-Tests');
-smalltalk.packages["Helios-SUnit-Tests"].transport = {"type":"amd","amdNamespace":"helios"};
+var $core=$boot.api,nil=$boot.nil,$recv=$boot.asReceiver,$globals=$boot.globals;
+var smalltalk=$core,_st=$recv,globals=$globals;
+$core.addPackage('Helios-SUnit-Tests');
+$core.packages["Helios-SUnit-Tests"].transport = {"type":"amd","amdNamespace":"helios"};
 
-smalltalk.addClass('HLSUnitModelTest', globals.TestCase, ['model'], 'Helios-SUnit-Tests');
-globals.HLSUnitModelTest.comment="Test cases for the functionality of  `HLSUnitModel`";
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLSUnitModelTest', $globals.TestCase, ['model'], 'Helios-SUnit-Tests');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$globals.HLSUnitModelTest.comment="Test cases for the functionality of  `HLSUnitModel`";
+//>>excludeEnd("ide");
+$core.addMethod(
+$core.method({
 selector: "setUp",
 protocol: 'initializing',
 fn: function (){
 var self=this;
-function $HLSUnitModel(){return globals.HLSUnitModel||(typeof HLSUnitModel=="undefined"?nil:HLSUnitModel)}
-return smalltalk.withContext(function($ctx1) { 
-($ctx1.supercall = true, globals.HLSUnitModelTest.superclass.fn.prototype._setUp.apply(_st(self), []));
+function $HLSUnitModel(){return $globals.HLSUnitModel||(typeof HLSUnitModel=="undefined"?nil:HLSUnitModel)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+(
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+$ctx1.supercall = true, 
+//>>excludeEnd("ctx");
+$globals.HLSUnitModelTest.superclass.fn.prototype._setUp.apply($recv(self), []));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.supercall = false;
-self["@model"]=_st($HLSUnitModel())._new();
-return self}, function($ctx1) {$ctx1.fill(self,"setUp",{},globals.HLSUnitModelTest)})},
+//>>excludeEnd("ctx");;
+self["@model"]=$recv($HLSUnitModel())._new();
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"setUp",{},$globals.HLSUnitModelTest)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "setUp\x0a\x09super setUp.\x0a\x09model := HLSUnitModel new",
-messageSends: ["setUp", "new"],
-referencedClasses: ["HLSUnitModel"]
+referencedClasses: ["HLSUnitModel"],
+//>>excludeEnd("ide");
+messageSends: ["setUp", "new"]
 }),
-globals.HLSUnitModelTest);
+$globals.HLSUnitModelTest);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "testClassBecomesAvailable",
 protocol: 'tests',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $2,$1;
-$2=_st(self["@model"])._testClasses();
+$2=$recv(self["@model"])._testClasses();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["testClasses"]=1;
-$1=_st($2)._isEmpty();
+//>>excludeEnd("ctx");
+$1=$recv($2)._isEmpty();
 self._assert_($1);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["assert:"]=1;
-_st(self["@model"])._selectPackage_(self._thisPackage());
-self._assert_(_st(_st(self["@model"])._testClasses())._includes_(self._class()));
-return self}, function($ctx1) {$ctx1.fill(self,"testClassBecomesAvailable",{},globals.HLSUnitModelTest)})},
+//>>excludeEnd("ctx");
+$recv(self["@model"])._selectPackage_(self._thisPackage());
+self._assert_($recv($recv(self["@model"])._testClasses())._includes_(self._class()));
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testClassBecomesAvailable",{},$globals.HLSUnitModelTest)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testClassBecomesAvailable\x0a\x09self assert: model testClasses isEmpty.\x0a\x09model selectPackage: self thisPackage.\x0a\x09self assert: (model testClasses includes: self class).",
-messageSends: ["assert:", "isEmpty", "testClasses", "selectPackage:", "thisPackage", "includes:", "class"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["assert:", "isEmpty", "testClasses", "selectPackage:", "thisPackage", "includes:", "class"]
 }),
-globals.HLSUnitModelTest);
+$globals.HLSUnitModelTest);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "testEmptyTestResults",
 protocol: 'tests',
 fn: function (){
 var self=this;
-function $TestResult(){return globals.TestResult||(typeof TestResult=="undefined"?nil:TestResult)}
-return smalltalk.withContext(function($ctx1) { 
-self._assert_(_st(_st(self["@model"])._testResult())._isKindOf_($TestResult()));
-return self}, function($ctx1) {$ctx1.fill(self,"testEmptyTestResults",{},globals.HLSUnitModelTest)})},
+function $TestResult(){return $globals.TestResult||(typeof TestResult=="undefined"?nil:TestResult)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+self._assert_($recv($recv(self["@model"])._testResult())._isKindOf_($TestResult()));
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testEmptyTestResults",{},$globals.HLSUnitModelTest)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testEmptyTestResults\x0a\x09self assert: (model testResult isKindOf: TestResult)",
-messageSends: ["assert:", "isKindOf:", "testResult"],
-referencedClasses: ["TestResult"]
+referencedClasses: ["TestResult"],
+//>>excludeEnd("ide");
+messageSends: ["assert:", "isKindOf:", "testResult"]
 }),
-globals.HLSUnitModelTest);
+$globals.HLSUnitModelTest);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "testInvertSelectedClasses",
 protocol: 'tests',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$2,$4,$3,$6,$5,$8,$7,$10,$9;
-_st(self["@model"])._selectAllPackages();
-_st(self["@model"])._selectAllClasses();
+$recv(self["@model"])._selectAllPackages();
+$recv(self["@model"])._selectAllClasses();
 $1=self["@model"];
 $2=self._class();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["class"]=1;
-_st($1)._unselectClass_($2);
-$4=_st(self["@model"])._selectedClasses();
+//>>excludeEnd("ctx");
+$recv($1)._unselectClass_($2);
+$4=$recv(self["@model"])._selectedClasses();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["selectedClasses"]=1;
-$3=_st($4)._notEmpty();
+//>>excludeEnd("ctx");
+$3=$recv($4)._notEmpty();
 self._assert_($3);
-$6=_st(self["@model"])._selectedClasses();
+$6=$recv(self["@model"])._selectedClasses();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["selectedClasses"]=2;
-$5=_st($6)._size();
+//>>excludeEnd("ctx");
+$5=$recv($6)._size();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["size"]=1;
-$8=_st(_st(self["@model"])._testClasses())._size();
+//>>excludeEnd("ctx");
+$8=$recv($recv(self["@model"])._testClasses())._size();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["size"]=2;
-$7=_st($8).__minus((1));
+//>>excludeEnd("ctx");
+$7=$recv($8).__minus((1));
 self._assert_equals_($5,$7);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["assert:equals:"]=1;
-_st(self["@model"])._invertSelectedClasses();
-$10=_st(self["@model"])._selectedClasses();
+//>>excludeEnd("ctx");
+$recv(self["@model"])._invertSelectedClasses();
+$10=$recv(self["@model"])._selectedClasses();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["selectedClasses"]=3;
-$9=_st($10)._size();
+//>>excludeEnd("ctx");
+$9=$recv($10)._size();
 self._assert_equals_($9,(1));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["assert:equals:"]=2;
-self._assert_equals_(_st(_st(self["@model"])._selectedClasses())._anyOne(),self._class());
-return self}, function($ctx1) {$ctx1.fill(self,"testInvertSelectedClasses",{},globals.HLSUnitModelTest)})},
+//>>excludeEnd("ctx");
+self._assert_equals_($recv($recv(self["@model"])._selectedClasses())._anyOne(),self._class());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testInvertSelectedClasses",{},$globals.HLSUnitModelTest)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testInvertSelectedClasses\x0a\x09model selectAllPackages.\x0a\x09model selectAllClasses.\x0a\x09model unselectClass: self class.\x0a\x09self assert: model selectedClasses notEmpty.\x0a\x09self assert: model selectedClasses size equals: model testClasses size - 1.\x0a\x09model invertSelectedClasses.\x0a\x09self assert: model selectedClasses size equals: 1.\x0a\x09self assert: model selectedClasses anyOne equals: self class.",
-messageSends: ["selectAllPackages", "selectAllClasses", "unselectClass:", "class", "assert:", "notEmpty", "selectedClasses", "assert:equals:", "size", "-", "testClasses", "invertSelectedClasses", "anyOne"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["selectAllPackages", "selectAllClasses", "unselectClass:", "class", "assert:", "notEmpty", "selectedClasses", "assert:equals:", "size", "-", "testClasses", "invertSelectedClasses", "anyOne"]
 }),
-globals.HLSUnitModelTest);
+$globals.HLSUnitModelTest);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "testInvertSelectedPackages",
 protocol: 'tests',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$2,$4,$3,$6,$5,$8,$7,$10,$9;
-_st(self["@model"])._selectAllPackages();
+$recv(self["@model"])._selectAllPackages();
 $1=self["@model"];
 $2=self._thisPackage();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["thisPackage"]=1;
-_st($1)._unselectPackage_($2);
-$4=_st(self["@model"])._selectedPackages();
+//>>excludeEnd("ctx");
+$recv($1)._unselectPackage_($2);
+$4=$recv(self["@model"])._selectedPackages();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["selectedPackages"]=1;
-$3=_st($4)._notEmpty();
+//>>excludeEnd("ctx");
+$3=$recv($4)._notEmpty();
 self._assert_($3);
-$6=_st(self["@model"])._selectedPackages();
+$6=$recv(self["@model"])._selectedPackages();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["selectedPackages"]=2;
-$5=_st($6)._size();
+//>>excludeEnd("ctx");
+$5=$recv($6)._size();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["size"]=1;
-$8=_st(_st(self["@model"])._testPackages())._size();
+//>>excludeEnd("ctx");
+$8=$recv($recv(self["@model"])._testPackages())._size();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["size"]=2;
-$7=_st($8).__minus((1));
+//>>excludeEnd("ctx");
+$7=$recv($8).__minus((1));
 self._assert_equals_($5,$7);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["assert:equals:"]=1;
-_st(self["@model"])._invertSelectedPackages();
-$10=_st(self["@model"])._selectedPackages();
+//>>excludeEnd("ctx");
+$recv(self["@model"])._invertSelectedPackages();
+$10=$recv(self["@model"])._selectedPackages();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["selectedPackages"]=3;
-$9=_st($10)._size();
+//>>excludeEnd("ctx");
+$9=$recv($10)._size();
 self._assert_equals_($9,(1));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["assert:equals:"]=2;
-self._assert_equals_(_st(_st(self["@model"])._selectedPackages())._anyOne(),self._thisPackage());
-return self}, function($ctx1) {$ctx1.fill(self,"testInvertSelectedPackages",{},globals.HLSUnitModelTest)})},
+//>>excludeEnd("ctx");
+self._assert_equals_($recv($recv(self["@model"])._selectedPackages())._anyOne(),self._thisPackage());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testInvertSelectedPackages",{},$globals.HLSUnitModelTest)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testInvertSelectedPackages\x0a\x09model selectAllPackages.\x0a\x09model unselectPackage: self thisPackage.\x0a\x09self assert: model selectedPackages notEmpty.\x0a\x09self assert: model selectedPackages size equals: model testPackages size - 1.\x0a\x09model invertSelectedPackages.\x0a\x09self assert: model selectedPackages size equals: 1.\x0a\x09self assert: model selectedPackages anyOne equals: self thisPackage.",
-messageSends: ["selectAllPackages", "unselectPackage:", "thisPackage", "assert:", "notEmpty", "selectedPackages", "assert:equals:", "size", "-", "testPackages", "invertSelectedPackages", "anyOne"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["selectAllPackages", "unselectPackage:", "thisPackage", "assert:", "notEmpty", "selectedPackages", "assert:equals:", "size", "-", "testPackages", "invertSelectedPackages", "anyOne"]
 }),
-globals.HLSUnitModelTest);
+$globals.HLSUnitModelTest);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "testSelectAllClasses",
 protocol: 'tests',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $2,$1,$3;
-_st(self["@model"])._selectAllPackages();
-$2=_st(self["@model"])._testClasses();
+$recv(self["@model"])._selectAllPackages();
+$2=$recv(self["@model"])._testClasses();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["testClasses"]=1;
-$1=_st($2)._notEmpty();
+//>>excludeEnd("ctx");
+$1=$recv($2)._notEmpty();
 self._assert_($1);
-_st(self["@model"])._selectAllClasses();
-$3=_st(_st(self["@model"])._selectedClasses())._size();
+$recv(self["@model"])._selectAllClasses();
+$3=$recv($recv(self["@model"])._selectedClasses())._size();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["size"]=1;
-self._assert_equals_($3,_st(_st(self["@model"])._testClasses())._size());
-return self}, function($ctx1) {$ctx1.fill(self,"testSelectAllClasses",{},globals.HLSUnitModelTest)})},
+//>>excludeEnd("ctx");
+self._assert_equals_($3,$recv($recv(self["@model"])._testClasses())._size());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testSelectAllClasses",{},$globals.HLSUnitModelTest)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testSelectAllClasses\x0a\x09model selectAllPackages.\x0a\x09self assert: model testClasses notEmpty.\x0a\x09model selectAllClasses.\x0a\x09self assert: model selectedClasses size equals: model testClasses size",
-messageSends: ["selectAllPackages", "assert:", "notEmpty", "testClasses", "selectAllClasses", "assert:equals:", "size", "selectedClasses"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["selectAllPackages", "assert:", "notEmpty", "testClasses", "selectAllClasses", "assert:equals:", "size", "selectedClasses"]
 }),
-globals.HLSUnitModelTest);
+$globals.HLSUnitModelTest);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "testSelectAllPackages",
 protocol: 'tests',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $2,$1,$3;
-$2=_st(self["@model"])._selectedPackages();
+$2=$recv(self["@model"])._selectedPackages();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["selectedPackages"]=1;
-$1=_st($2)._isEmpty();
+//>>excludeEnd("ctx");
+$1=$recv($2)._isEmpty();
 self._assert_($1);
-_st(self["@model"])._selectAllPackages();
-$3=_st(_st(self["@model"])._selectedPackages())._size();
+$recv(self["@model"])._selectAllPackages();
+$3=$recv($recv(self["@model"])._selectedPackages())._size();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["size"]=1;
-self._assert_equals_($3,_st(_st(self["@model"])._testPackages())._size());
-return self}, function($ctx1) {$ctx1.fill(self,"testSelectAllPackages",{},globals.HLSUnitModelTest)})},
+//>>excludeEnd("ctx");
+self._assert_equals_($3,$recv($recv(self["@model"])._testPackages())._size());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testSelectAllPackages",{},$globals.HLSUnitModelTest)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testSelectAllPackages\x0a\x09self assert: model selectedPackages isEmpty.\x0a\x09model selectAllPackages.\x0a\x09self assert: model selectedPackages size equals: model testPackages size",
-messageSends: ["assert:", "isEmpty", "selectedPackages", "selectAllPackages", "assert:equals:", "size", "testPackages"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["assert:", "isEmpty", "selectedPackages", "selectAllPackages", "assert:equals:", "size", "testPackages"]
 }),
-globals.HLSUnitModelTest);
+$globals.HLSUnitModelTest);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "testSelectClass",
 protocol: 'tests',
 fn: function (){
 var self=this;
 var announcementFired;
-function $HLClassSelected(){return globals.HLClassSelected||(typeof HLClassSelected=="undefined"?nil:HLClassSelected)}
-return smalltalk.withContext(function($ctx1) { 
+function $HLClassSelected(){return $globals.HLClassSelected||(typeof HLClassSelected=="undefined"?nil:HLClassSelected)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $2,$1,$3,$4;
-_st(self["@model"])._selectPackage_(self._thisPackage());
-$2=_st(self["@model"])._selectedClasses();
+$recv(self["@model"])._selectPackage_(self._thisPackage());
+$2=$recv(self["@model"])._selectedClasses();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["selectedClasses"]=1;
-$1=_st($2)._isEmpty();
+//>>excludeEnd("ctx");
+$1=$recv($2)._isEmpty();
 self._assert_($1);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["assert:"]=1;
-_st(_st(self["@model"])._announcer())._on_do_for_($HLClassSelected(),(function(){
+//>>excludeEnd("ctx");
+$recv($recv(self["@model"])._announcer())._on_do_for_($HLClassSelected(),(function(){
 announcementFired=true;
 return announcementFired;
+
 }),self);
 $3=self["@model"];
 $4=self._class();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["class"]=1;
-_st($3)._selectClass_($4);
-self._assert_equals_(_st(_st(self["@model"])._selectedClasses())._anyOne(),self._class());
+//>>excludeEnd("ctx");
+$recv($3)._selectClass_($4);
+self._assert_equals_($recv($recv(self["@model"])._selectedClasses())._anyOne(),self._class());
 self._assert_(announcementFired);
-return self}, function($ctx1) {$ctx1.fill(self,"testSelectClass",{announcementFired:announcementFired},globals.HLSUnitModelTest)})},
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testSelectClass",{announcementFired:announcementFired},$globals.HLSUnitModelTest)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testSelectClass\x0a\x09| announcementFired |\x0a\x09model selectPackage: self thisPackage.\x0a\x09self assert: model selectedClasses isEmpty.\x0a\x09model announcer on: HLClassSelected\x0a\x09\x09do: [ announcementFired := true ]\x0a\x09\x09for: self.\x0a\x09model selectClass: self class.\x0a\x09self assert: model selectedClasses anyOne equals: self class.\x0a\x09self assert: announcementFired.",
-messageSends: ["selectPackage:", "thisPackage", "assert:", "isEmpty", "selectedClasses", "on:do:for:", "announcer", "selectClass:", "class", "assert:equals:", "anyOne"],
-referencedClasses: ["HLClassSelected"]
+referencedClasses: ["HLClassSelected"],
+//>>excludeEnd("ide");
+messageSends: ["selectPackage:", "thisPackage", "assert:", "isEmpty", "selectedClasses", "on:do:for:", "announcer", "selectClass:", "class", "assert:equals:", "anyOne"]
 }),
-globals.HLSUnitModelTest);
+$globals.HLSUnitModelTest);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "testSelectPackage",
 protocol: 'tests',
 fn: function (){
 var self=this;
 var announcementFired;
-function $HLPackageSelected(){return globals.HLPackageSelected||(typeof HLPackageSelected=="undefined"?nil:HLPackageSelected)}
-return smalltalk.withContext(function($ctx1) { 
+function $HLPackageSelected(){return $globals.HLPackageSelected||(typeof HLPackageSelected=="undefined"?nil:HLPackageSelected)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $2,$1,$3,$4;
-$2=_st(self["@model"])._selectedPackages();
+$2=$recv(self["@model"])._selectedPackages();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["selectedPackages"]=1;
-$1=_st($2)._isEmpty();
+//>>excludeEnd("ctx");
+$1=$recv($2)._isEmpty();
 self._assert_($1);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["assert:"]=1;
-_st(_st(self["@model"])._announcer())._on_do_for_($HLPackageSelected(),(function(){
+//>>excludeEnd("ctx");
+$recv($recv(self["@model"])._announcer())._on_do_for_($HLPackageSelected(),(function(){
 announcementFired=true;
 return announcementFired;
+
 }),self);
 $3=self["@model"];
 $4=self._thisPackage();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["thisPackage"]=1;
-_st($3)._selectPackage_($4);
-self._assert_equals_(_st(_st(self["@model"])._selectedPackages())._anyOne(),self._thisPackage());
+//>>excludeEnd("ctx");
+$recv($3)._selectPackage_($4);
+self._assert_equals_($recv($recv(self["@model"])._selectedPackages())._anyOne(),self._thisPackage());
 self._assert_(announcementFired);
-return self}, function($ctx1) {$ctx1.fill(self,"testSelectPackage",{announcementFired:announcementFired},globals.HLSUnitModelTest)})},
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testSelectPackage",{announcementFired:announcementFired},$globals.HLSUnitModelTest)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testSelectPackage\x0a\x09| announcementFired |\x0a\x09self assert: model selectedPackages isEmpty.\x0a\x09model announcer on: HLPackageSelected\x0a\x09\x09do: [ announcementFired := true ]\x0a\x09\x09for: self.\x0a\x09model selectPackage: self thisPackage.\x0a\x09self assert: model selectedPackages anyOne equals: self thisPackage.\x0a\x09self assert: announcementFired",
-messageSends: ["assert:", "isEmpty", "selectedPackages", "on:do:for:", "announcer", "selectPackage:", "thisPackage", "assert:equals:", "anyOne"],
-referencedClasses: ["HLPackageSelected"]
+referencedClasses: ["HLPackageSelected"],
+//>>excludeEnd("ide");
+messageSends: ["assert:", "isEmpty", "selectedPackages", "on:do:for:", "announcer", "selectPackage:", "thisPackage", "assert:equals:", "anyOne"]
 }),
-globals.HLSUnitModelTest);
+$globals.HLSUnitModelTest);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "testSelectedClassNotListedIfPackageUnselected",
 protocol: 'tests',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$2,$3,$4,$6,$5;
 $1=self["@model"];
 $2=self._thisPackage();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["thisPackage"]=1;
-_st($1)._selectPackage_($2);
+//>>excludeEnd("ctx");
+$recv($1)._selectPackage_($2);
 $3=self["@model"];
 $4=self._class();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["class"]=1;
-_st($3)._selectClass_($4);
-$6=_st(self["@model"])._selectedClasses();
+//>>excludeEnd("ctx");
+$recv($3)._selectClass_($4);
+$6=$recv(self["@model"])._selectedClasses();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["selectedClasses"]=1;
-$5=_st($6)._anyOne();
+//>>excludeEnd("ctx");
+$5=$recv($6)._anyOne();
 self._assert_equals_($5,self._class());
-_st(self["@model"])._unselectPackage_(self._thisPackage());
-self._assert_(_st(_st(self["@model"])._selectedClasses())._isEmpty());
-return self}, function($ctx1) {$ctx1.fill(self,"testSelectedClassNotListedIfPackageUnselected",{},globals.HLSUnitModelTest)})},
+$recv(self["@model"])._unselectPackage_(self._thisPackage());
+self._assert_($recv($recv(self["@model"])._selectedClasses())._isEmpty());
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testSelectedClassNotListedIfPackageUnselected",{},$globals.HLSUnitModelTest)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testSelectedClassNotListedIfPackageUnselected\x0a\x09model selectPackage: self thisPackage.\x0a\x09model selectClass: self class.\x0a\x09self assert: model selectedClasses anyOne equals: self class.\x0a\x09model unselectPackage: self thisPackage.\x0a\x09self assert: model selectedClasses isEmpty.",
-messageSends: ["selectPackage:", "thisPackage", "selectClass:", "class", "assert:equals:", "anyOne", "selectedClasses", "unselectPackage:", "assert:", "isEmpty"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["selectPackage:", "thisPackage", "selectClass:", "class", "assert:equals:", "anyOne", "selectedClasses", "unselectPackage:", "assert:", "isEmpty"]
 }),
-globals.HLSUnitModelTest);
+$globals.HLSUnitModelTest);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "testTestClassHasOnlyTestClasses",
 protocol: 'tests',
 fn: function (){
 var self=this;
 var notATestClass;
-function $Object(){return globals.Object||(typeof Object=="undefined"?nil:Object)}
-function $Smalltalk(){return globals.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
-return smalltalk.withContext(function($ctx1) { 
-notATestClass=_st($Object())._subclass_instanceVariableNames_package_("HLNotATestClass","",_st(self._class())._category());
-_st(self["@model"])._selectPackage_(self._thisPackage());
-self._deny_(_st(_st(self["@model"])._testClasses())._includes_(notATestClass));
-_st($Smalltalk())._removeClass_(notATestClass);
-return self}, function($ctx1) {$ctx1.fill(self,"testTestClassHasOnlyTestClasses",{notATestClass:notATestClass},globals.HLSUnitModelTest)})},
+function $Object(){return $globals.Object||(typeof Object=="undefined"?nil:Object)}
+function $Smalltalk(){return $globals.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+notATestClass=$recv($Object())._subclass_instanceVariableNames_package_("HLNotATestClass","",$recv(self._class())._category());
+$recv(self["@model"])._selectPackage_(self._thisPackage());
+self._deny_($recv($recv(self["@model"])._testClasses())._includes_(notATestClass));
+$recv($Smalltalk())._removeClass_(notATestClass);
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testTestClassHasOnlyTestClasses",{notATestClass:notATestClass},$globals.HLSUnitModelTest)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testTestClassHasOnlyTestClasses\x0a\x09| notATestClass |\x0a\x09notATestClass := Object subclass: #HLNotATestClass\x0a\x09\x09instanceVariableNames: ''\x0a\x09\x09package: self class category.\x0a\x09model selectPackage: self thisPackage.\x0a\x09self deny: (model testClasses includes: notATestClass).\x0a\x09Smalltalk removeClass: notATestClass.",
-messageSends: ["subclass:instanceVariableNames:package:", "category", "class", "selectPackage:", "thisPackage", "deny:", "includes:", "testClasses", "removeClass:"],
-referencedClasses: ["Object", "Smalltalk"]
+referencedClasses: ["Object", "Smalltalk"],
+//>>excludeEnd("ide");
+messageSends: ["subclass:instanceVariableNames:package:", "category", "class", "selectPackage:", "thisPackage", "deny:", "includes:", "testClasses", "removeClass:"]
 }),
-globals.HLSUnitModelTest);
+$globals.HLSUnitModelTest);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "testTestPackages",
 protocol: 'tests',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $2,$1;
-$2=_st(self["@model"])._testPackages();
+$2=$recv(self["@model"])._testPackages();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["testPackages"]=1;
-$1=_st($2)._notEmpty();
+//>>excludeEnd("ctx");
+$1=$recv($2)._notEmpty();
 self._assert_($1);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["assert:"]=1;
-self._assert_(_st(_st(self["@model"])._testPackages())._anySatisfy_((function(each){
-return smalltalk.withContext(function($ctx2) {
-return _st(each).__eq(self._thisPackage());
-}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})})));
-return self}, function($ctx1) {$ctx1.fill(self,"testTestPackages",{},globals.HLSUnitModelTest)})},
+//>>excludeEnd("ctx");
+self._assert_($recv($recv(self["@model"])._testPackages())._anySatisfy_((function(each){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
+return $recv(each).__eq(self._thisPackage());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)});
+//>>excludeEnd("ctx");
+})));
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testTestPackages",{},$globals.HLSUnitModelTest)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testTestPackages\x0a\x09self assert: model testPackages notEmpty.\x0a\x09self assert: (model testPackages anySatisfy: [:each | each = self thisPackage]).",
-messageSends: ["assert:", "notEmpty", "testPackages", "anySatisfy:", "=", "thisPackage"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["assert:", "notEmpty", "testPackages", "anySatisfy:", "=", "thisPackage"]
 }),
-globals.HLSUnitModelTest);
+$globals.HLSUnitModelTest);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "testUnselectClass",
 protocol: 'tests',
 fn: function (){
 var self=this;
 var announcementFired;
-function $HLClassUnselected(){return globals.HLClassUnselected||(typeof HLClassUnselected=="undefined"?nil:HLClassUnselected)}
-return smalltalk.withContext(function($ctx1) { 
+function $HLClassUnselected(){return $globals.HLClassUnselected||(typeof HLClassUnselected=="undefined"?nil:HLClassUnselected)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$2;
-_st(self["@model"])._selectPackage_(self._thisPackage());
+$recv(self["@model"])._selectPackage_(self._thisPackage());
 $1=self["@model"];
 $2=self._class();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["class"]=1;
-_st($1)._selectClass_($2);
-_st(_st(self["@model"])._announcer())._on_do_for_($HLClassUnselected(),(function(){
+//>>excludeEnd("ctx");
+$recv($1)._selectClass_($2);
+$recv($recv(self["@model"])._announcer())._on_do_for_($HLClassUnselected(),(function(){
 announcementFired=true;
 return announcementFired;
+
 }),self);
-_st(self["@model"])._unselectClass_(self._class());
-self._assert_(_st(_st(self["@model"])._selectedClasses())._isEmpty());
+$recv(self["@model"])._unselectClass_(self._class());
+self._assert_($recv($recv(self["@model"])._selectedClasses())._isEmpty());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["assert:"]=1;
+//>>excludeEnd("ctx");
 self._assert_(announcementFired);
-return self}, function($ctx1) {$ctx1.fill(self,"testUnselectClass",{announcementFired:announcementFired},globals.HLSUnitModelTest)})},
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testUnselectClass",{announcementFired:announcementFired},$globals.HLSUnitModelTest)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testUnselectClass\x0a\x09| announcementFired |\x0a\x09model selectPackage: self thisPackage.\x0a\x09model selectClass: self class.\x0a\x09model announcer on: HLClassUnselected\x0a\x09\x09do: [ announcementFired := true ]\x0a\x09\x09for: self.\x0a\x09model unselectClass: self class.\x0a\x09self assert: model selectedClasses isEmpty.\x0a\x09self assert: announcementFired",
-messageSends: ["selectPackage:", "thisPackage", "selectClass:", "class", "on:do:for:", "announcer", "unselectClass:", "assert:", "isEmpty", "selectedClasses"],
-referencedClasses: ["HLClassUnselected"]
+referencedClasses: ["HLClassUnselected"],
+//>>excludeEnd("ide");
+messageSends: ["selectPackage:", "thisPackage", "selectClass:", "class", "on:do:for:", "announcer", "unselectClass:", "assert:", "isEmpty", "selectedClasses"]
 }),
-globals.HLSUnitModelTest);
+$globals.HLSUnitModelTest);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "testUnselectPackage",
 protocol: 'tests',
 fn: function (){
 var self=this;
 var announcementFired;
-function $HLPackageUnselected(){return globals.HLPackageUnselected||(typeof HLPackageUnselected=="undefined"?nil:HLPackageUnselected)}
-return smalltalk.withContext(function($ctx1) { 
+function $HLPackageUnselected(){return $globals.HLPackageUnselected||(typeof HLPackageUnselected=="undefined"?nil:HLPackageUnselected)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$2;
 $1=self["@model"];
 $2=self._thisPackage();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["thisPackage"]=1;
-_st($1)._selectPackage_($2);
-_st(_st(self["@model"])._announcer())._on_do_for_($HLPackageUnselected(),(function(){
+//>>excludeEnd("ctx");
+$recv($1)._selectPackage_($2);
+$recv($recv(self["@model"])._announcer())._on_do_for_($HLPackageUnselected(),(function(){
 announcementFired=true;
 return announcementFired;
+
 }),self);
-_st(self["@model"])._unselectPackage_(self._thisPackage());
-self._assert_(_st(_st(self["@model"])._selectedPackages())._isEmpty());
+$recv(self["@model"])._unselectPackage_(self._thisPackage());
+self._assert_($recv($recv(self["@model"])._selectedPackages())._isEmpty());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["assert:"]=1;
+//>>excludeEnd("ctx");
 self._assert_(announcementFired);
-return self}, function($ctx1) {$ctx1.fill(self,"testUnselectPackage",{announcementFired:announcementFired},globals.HLSUnitModelTest)})},
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testUnselectPackage",{announcementFired:announcementFired},$globals.HLSUnitModelTest)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "testUnselectPackage\x0a\x09| announcementFired |\x0a\x09model selectPackage: self thisPackage.\x0a\x09model announcer on: HLPackageUnselected\x0a\x09\x09do: [ announcementFired := true ]\x0a\x09\x09for: self.\x0a\x09model unselectPackage: self thisPackage.\x0a\x09self assert: model selectedPackages isEmpty.\x0a\x09self assert: announcementFired.",
-messageSends: ["selectPackage:", "thisPackage", "on:do:for:", "announcer", "unselectPackage:", "assert:", "isEmpty", "selectedPackages"],
-referencedClasses: ["HLPackageUnselected"]
+referencedClasses: ["HLPackageUnselected"],
+//>>excludeEnd("ide");
+messageSends: ["selectPackage:", "thisPackage", "on:do:for:", "announcer", "unselectPackage:", "assert:", "isEmpty", "selectedPackages"]
 }),
-globals.HLSUnitModelTest);
+$globals.HLSUnitModelTest);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "thisPackage",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(self._class())._package();
+$1=$recv(self._class())._package();
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"thisPackage",{},globals.HLSUnitModelTest)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"thisPackage",{},$globals.HLSUnitModelTest)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "thisPackage\x0a\x09^self class package",
-messageSends: ["package", "class"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["package", "class"]
 }),
-globals.HLSUnitModelTest);
+$globals.HLSUnitModelTest);
 
 
 });

src/Helios-Transcript.js

@@ -1,243 +1,375 @@
 define("helios/Helios-Transcript", ["amber/boot", "helios/Helios-Core", "amber_core/Kernel-Objects"], function($boot){
-var smalltalk=$boot.vm,nil=$boot.nil,_st=$boot.asReceiver,globals=$boot.globals;
-smalltalk.addPackage('Helios-Transcript');
-smalltalk.packages["Helios-Transcript"].transport = {"type":"amd","amdNamespace":"helios"};
-
-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` service class.";
-smalltalk.addMethod(
-smalltalk.method({
+var $core=$boot.api,nil=$boot.nil,$recv=$boot.asReceiver,$globals=$boot.globals;
+var smalltalk=$core,_st=$recv,globals=$globals;
+$core.addPackage('Helios-Transcript');
+$core.packages["Helios-Transcript"].transport = {"type":"amd","amdNamespace":"helios"};
+
+$core.addClass('HLTranscript', $globals.HLWidget, ['textarea'], 'Helios-Transcript');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$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` service class.";
+//>>excludeEnd("ide");
+$core.addMethod(
+$core.method({
 selector: "clear",
 protocol: 'actions',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_st(_st(self["@textarea"])._asJQuery())._text_("");
-return self}, function($ctx1) {$ctx1.fill(self,"clear",{},globals.HLTranscript)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv($recv(self["@textarea"])._asJQuery())._text_("");
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"clear",{},$globals.HLTranscript)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "clear\x0a\x09textarea asJQuery text: ''",
-messageSends: ["text:", "asJQuery"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["text:", "asJQuery"]
 }),
-globals.HLTranscript);
+$globals.HLTranscript);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "initialize",
 protocol: 'initialization',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-($ctx1.supercall = true, globals.HLTranscript.superclass.fn.prototype._initialize.apply(_st(self), []));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+(
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+$ctx1.supercall = true, 
+//>>excludeEnd("ctx");
+$globals.HLTranscript.superclass.fn.prototype._initialize.apply($recv(self), []));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.supercall = false;
+//>>excludeEnd("ctx");;
 self._register();
-return self}, function($ctx1) {$ctx1.fill(self,"initialize",{},globals.HLTranscript)})},
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"initialize",{},$globals.HLTranscript)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "initialize\x0a\x09super initialize.\x0a\x09self register",
-messageSends: ["initialize", "register"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["initialize", "register"]
 }),
-globals.HLTranscript);
+$globals.HLTranscript);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "register",
 protocol: 'registration',
 fn: function (){
 var self=this;
-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",{},globals.HLTranscript)})},
+function $HLTranscriptHandler(){return $globals.HLTranscriptHandler||(typeof HLTranscriptHandler=="undefined"?nil:HLTranscriptHandler)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv($HLTranscriptHandler())._register_(self);
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"register",{},$globals.HLTranscript)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "register\x0a\x09HLTranscriptHandler register: self",
-messageSends: ["register:"],
-referencedClasses: ["HLTranscriptHandler"]
+referencedClasses: ["HLTranscriptHandler"],
+//>>excludeEnd("ide");
+messageSends: ["register:"]
 }),
-globals.HLTranscript);
+$globals.HLTranscript);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "renderOn:",
 protocol: 'rendering',
 fn: function (html){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$2;
-$1=_st(html)._div();
-_st($1)._class_("transcript");
-$2=_st($1)._with_((function(){
-return smalltalk.withContext(function($ctx2) {
-self["@textarea"]=_st(html)._textarea();
+$1=$recv(html)._div();
+$recv($1)._class_("transcript");
+$2=$recv($1)._with_((function(){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
+self["@textarea"]=$recv(html)._textarea();
 return self["@textarea"];
-}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
-return self}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},globals.HLTranscript)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
+//>>excludeEnd("ctx");
+}));
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"renderOn:",{html:html},$globals.HLTranscript)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["html"],
 source: "renderOn: html\x0a\x09html div\x0a\x09\x09class: 'transcript';\x0a\x09\x09with: [ textarea := html textarea ]",
-messageSends: ["class:", "div", "with:", "textarea"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["class:", "div", "with:", "textarea"]
 }),
-globals.HLTranscript);
+$globals.HLTranscript);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "show:",
 protocol: 'actions',
 fn: function (aString){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1,$receiver;
 $1=self["@textarea"];
 if(($receiver = $1) == null || $receiver.isNil){
 $1;
 } else {
-_st(_st(self["@textarea"])._asJQuery())._append_(_st(aString)._asString());
+$recv($recv(self["@textarea"])._asJQuery())._append_($recv(aString)._asString());
 };
-return self}, function($ctx1) {$ctx1.fill(self,"show:",{aString:aString},globals.HLTranscript)})},
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"show:",{aString:aString},$globals.HLTranscript)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aString"],
 source: "show: aString\x0a\x09textarea ifNotNil: [\x0a \x09\x09textarea asJQuery append: aString asString ]",
-messageSends: ["ifNotNil:", "append:", "asJQuery", "asString"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["ifNotNil:", "append:", "asJQuery", "asString"]
 }),
-globals.HLTranscript);
+$globals.HLTranscript);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "unregister",
 protocol: 'registration',
 fn: function (){
 var self=this;
-function $HLTranscriptHandler(){return globals.HLTranscriptHandler||(typeof HLTranscriptHandler=="undefined"?nil:HLTranscriptHandler)}
-return smalltalk.withContext(function($ctx1) { 
-($ctx1.supercall = true, globals.HLTranscript.superclass.fn.prototype._unregister.apply(_st(self), []));
+function $HLTranscriptHandler(){return $globals.HLTranscriptHandler||(typeof HLTranscriptHandler=="undefined"?nil:HLTranscriptHandler)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+(
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+$ctx1.supercall = true, 
+//>>excludeEnd("ctx");
+$globals.HLTranscript.superclass.fn.prototype._unregister.apply($recv(self), []));
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.supercall = false;
-_st($HLTranscriptHandler())._unregister_(self);
-return self}, function($ctx1) {$ctx1.fill(self,"unregister",{},globals.HLTranscript)})},
+//>>excludeEnd("ctx");;
+$recv($HLTranscriptHandler())._unregister_(self);
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"unregister",{},$globals.HLTranscript)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "unregister\x0a\x09super unregister.\x0a\x09HLTranscriptHandler unregister: self",
-messageSends: ["unregister", "unregister:"],
-referencedClasses: ["HLTranscriptHandler"]
+referencedClasses: ["HLTranscriptHandler"],
+//>>excludeEnd("ide");
+messageSends: ["unregister", "unregister:"]
 }),
-globals.HLTranscript);
+$globals.HLTranscript);
 
 
 
-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\x0aUse the class-side method `#register:` to add transcript instances.";
+$core.addClass('HLTranscriptHandler', $globals.Object, [], 'Helios-Transcript');
+//>>excludeStart("ide", pragmas.excludeIdeData);
+$globals.HLTranscriptHandler.comment="I handle transcript events, dispatching them to all instances of `HLTranscript`.\x0a\x0a## API\x0a\x0aUse the class-side method `#register:` to add transcript instances.";
+//>>excludeEnd("ide");
 
-globals.HLTranscriptHandler.klass.iVarNames = ['transcripts'];
-smalltalk.addMethod(
-smalltalk.method({
+$globals.HLTranscriptHandler.klass.iVarNames = ['transcripts'];
+$core.addMethod(
+$core.method({
 selector: "clear",
 protocol: 'printing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_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",{},globals.HLTranscriptHandler.klass)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._transcripts())._do_((function(each){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
+return $recv(each)._clear();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)});
+//>>excludeEnd("ctx");
+}));
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"clear",{},$globals.HLTranscriptHandler.klass)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "clear\x0a\x09self transcripts do: [ :each |\x0a\x09\x09each clear ]",
-messageSends: ["do:", "transcripts", "clear"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["do:", "transcripts", "clear"]
 }),
-globals.HLTranscriptHandler.klass);
+$globals.HLTranscriptHandler.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "cr",
 protocol: 'printing',
 fn: function (){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_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",{},globals.HLTranscriptHandler.klass)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._transcripts())._do_((function(each){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
+return $recv(each)._cr();
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)});
+//>>excludeEnd("ctx");
+}));
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"cr",{},$globals.HLTranscriptHandler.klass)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "cr\x0a\x09self transcripts do: [ :each | each cr ]",
-messageSends: ["do:", "transcripts", "cr"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["do:", "transcripts", "cr"]
 }),
-globals.HLTranscriptHandler.klass);
+$globals.HLTranscriptHandler.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "register:",
 protocol: 'registration',
 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},globals.HLTranscriptHandler.klass)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._transcripts())._add_(aTranscript);
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"register:",{aTranscript:aTranscript},$globals.HLTranscriptHandler.klass)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aTranscript"],
 source: "register: aTranscript\x0a\x09self transcripts add: aTranscript",
-messageSends: ["add:", "transcripts"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["add:", "transcripts"]
 }),
-globals.HLTranscriptHandler.klass);
+$globals.HLTranscriptHandler.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "show:",
 protocol: 'printing',
 fn: function (aString){
 var self=this;
-return smalltalk.withContext(function($ctx1) { 
-_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},globals.HLTranscriptHandler.klass)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._transcripts())._do_((function(each){
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx2) {
+//>>excludeEnd("ctx");
+return $recv(each)._show_(aString);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)});
+//>>excludeEnd("ctx");
+}));
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"show:",{aString:aString},$globals.HLTranscriptHandler.klass)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aString"],
 source: "show: aString\x0a\x09self transcripts do: [ :each |\x0a\x09\x09each show: aString ]",
-messageSends: ["do:", "transcripts", "show:"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["do:", "transcripts", "show:"]
 }),
-globals.HLTranscriptHandler.klass);
+$globals.HLTranscriptHandler.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "transcripts",
 protocol: 'accessing',
 fn: function (){
 var self=this;
-function $OrderedCollection(){return globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
-return smalltalk.withContext(function($ctx1) { 
+function $OrderedCollection(){return $globals.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $2,$1,$receiver;
 $2=self["@transcripts"];
 if(($receiver = $2) == null || $receiver.isNil){
-self["@transcripts"]=_st($OrderedCollection())._new();
+self["@transcripts"]=$recv($OrderedCollection())._new();
 $1=self["@transcripts"];
 } else {
 $1=$2;
 };
 return $1;
-}, function($ctx1) {$ctx1.fill(self,"transcripts",{},globals.HLTranscriptHandler.klass)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"transcripts",{},$globals.HLTranscriptHandler.klass)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: [],
 source: "transcripts\x0a\x09^ transcripts ifNil: [ transcripts := OrderedCollection new ]",
-messageSends: ["ifNil:", "new"],
-referencedClasses: ["OrderedCollection"]
+referencedClasses: ["OrderedCollection"],
+//>>excludeEnd("ide");
+messageSends: ["ifNil:", "new"]
 }),
-globals.HLTranscriptHandler.klass);
+$globals.HLTranscriptHandler.klass);
 
-smalltalk.addMethod(
-smalltalk.method({
+$core.addMethod(
+$core.method({
 selector: "unregister:",
 protocol: 'registration',
 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},globals.HLTranscriptHandler.klass)})},
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
+$recv(self._transcripts())._remove_(aTranscript);
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"unregister:",{aTranscript:aTranscript},$globals.HLTranscriptHandler.klass)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 args: ["aTranscript"],
 source: "unregister: aTranscript\x0a\x09self transcripts remove: aTranscript",
-messageSends: ["remove:", "transcripts"],
-referencedClasses: []
+referencedClasses: [],
+//>>excludeEnd("ide");
+messageSends: ["remove:", "transcripts"]
 }),
-globals.HLTranscriptHandler.klass);
+$globals.HLTranscriptHandler.klass);
 
 });

src/Helios-Workspace-Tests.js

@@ -1,31 +1,44 @@
 define("helios/Helios-Workspace-Tests", ["amber/boot", "amber_core/SUnit"], function($boot){
-var smalltalk=$boot.vm,nil=$boot.nil,_st=$boot.asReceiver,globals=$boot.globals;
-smalltalk.addPackage('Helios-Workspace-Tests');
-smalltalk.packages["Helios-Workspace-Tests"].transport = {"type":"amd","amdNamespace":"helios"};
+var $core=$boot.api,nil=$boot.nil,$recv=$boot.asReceiver,$globals=$boot.globals;
+var smalltalk=$core,_st=$recv,globals=$globals;
+$core.addPackage('Helios-Workspace-Tests');
+$core.packages["Helios-Workspace-Tests"].transport = {"type":"amd","amdNamespace":"helios"};
 
-smalltalk.addClass('HLCodeWidgetTest', globals.TestCase, [], 'Helios-Workspace-Tests');
-smalltalk.addMethod(
-smalltalk.method({
+$core.addClass('HLCodeWidgetTest', $globals.TestCase, [], 'Helios-Workspace-Tests');
+$core.addMethod(
+$core.method({
 selector: "testKeyMap",
 protocol: 'tests',
 fn: function (){
 var self=this;
-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) { 
+function $HLCodeWidget(){return $globals.HLCodeWidget||(typeof HLCodeWidget=="undefined"?nil:HLCodeWidget)}
+function $HashedCollection(){return $globals.HashedCollection||(typeof HashedCollection=="undefined"?nil:HashedCollection)}
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) { 
+//>>excludeEnd("ctx");
 var $1;
-$1=_st(_st($HLCodeWidget())._pcKeyMap())._isKindOf_($HashedCollection());
+$1=$recv($recv($HLCodeWidget())._pcKeyMap())._isKindOf_($HashedCollection());
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["isKindOf:"]=1;
+//>>excludeEnd("ctx");
 self._assert_($1);
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
 $ctx1.sendIdx["assert:"]=1;
-self._assert_(_st(_st($HLCodeWidget())._macKeyMap())._isKindOf_($HashedCollection()));
-return self}, function($ctx1) {$ctx1.fill(self,"testKeyMap",{},globals.HLCodeWidgetTest)})},
+//>>excludeEnd("ctx");
+self._assert_($recv($recv($HLCodeWidget())._macKeyMap())._isKindOf_($HashedCollection()));
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"testKeyMap",{},$globals.HLCodeWidgetTest)});
+//>>excludeEnd("ctx");
+},
+//>>excludeStart("ide", pragmas.excludeIdeData);
 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"]
+referencedClasses: ["HLCodeWidget", "HashedCollection"],
+//>>excludeEnd("ide");
+messageSends: ["assert:", "isKindOf:", "pcKeyMap", "macKeyMap"]
 }),
-globals.HLCodeWidgetTest);
+$globals.HLCodeWidgetTest);
 
 
 });