resin 0.0.1 → 0.0.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/amber/images/amber.svg +706 -0
 - data/amber/js/Canvas.deploy.js +1311 -400
 - data/amber/js/Canvas.js +1750 -424
 - data/amber/js/Compiler.deploy.js +615 -615
 - data/amber/js/Compiler.js +1367 -1367
 - data/amber/js/IDE.deploy.js +1381 -1345
 - data/amber/js/IDE.js +1949 -1903
 - data/amber/js/Kernel-Announcements.deploy.js +37 -37
 - data/amber/js/Kernel-Announcements.js +52 -52
 - data/amber/js/Kernel-Collections.deploy.js +961 -950
 - data/amber/js/Kernel-Collections.js +2064 -2053
 - data/amber/js/Kernel-Methods.deploy.js +323 -260
 - data/amber/js/Kernel-Methods.js +395 -327
 - data/amber/js/Kernel-Objects.deploy.js +1846 -1104
 - data/amber/js/Kernel-Objects.js +2142 -1194
 - data/amber/js/boot.js +44 -29
 - data/amber/js/parser.js +234 -17
 - data/amber/js/parser.pegjs +9 -6
 - data/amber/st/Canvas.st +474 -146
 - data/amber/st/Compiler.st +418 -417
 - data/amber/st/IDE.st +803 -772
 - data/amber/st/Kernel-Announcements.st +27 -27
 - data/amber/st/Kernel-Collections.st +289 -268
 - data/amber/st/Kernel-Methods.st +104 -100
 - data/amber/st/Kernel-Objects.st +277 -80
 - metadata +18 -17
 
| 
         @@ -1,41 +1,4 @@ 
     | 
|
| 
       1 
1 
     | 
    
         
             
            smalltalk.addPackage('Kernel-Announcements', {});
         
     | 
| 
       2 
     | 
    
         
            -
            smalltalk.addClass('Announcer', smalltalk.Object, ['registry', 'subscriptions'], 'Kernel-Announcements');
         
     | 
| 
       3 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       4 
     | 
    
         
            -
            unescape('_announce_'),
         
     | 
| 
       5 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       6 
     | 
    
         
            -
            selector: unescape('announce%3A'),
         
     | 
| 
       7 
     | 
    
         
            -
            fn: function (anAnnouncement){
         
     | 
| 
       8 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       9 
     | 
    
         
            -
            smalltalk.send(self['@subscriptions'], "_do_", [(function(each){return smalltalk.send(each, "_deliver_", [anAnnouncement]);})]);
         
     | 
| 
       10 
     | 
    
         
            -
            return self;}
         
     | 
| 
       11 
     | 
    
         
            -
            }),
         
     | 
| 
       12 
     | 
    
         
            -
            smalltalk.Announcer);
         
     | 
| 
       13 
     | 
    
         
            -
             
     | 
| 
       14 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       15 
     | 
    
         
            -
            unescape('_initialize'),
         
     | 
| 
       16 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       17 
     | 
    
         
            -
            selector: unescape('initialize'),
         
     | 
| 
       18 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
       19 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       20 
     | 
    
         
            -
            smalltalk.send(self, "_initialize", [], smalltalk.Object);
         
     | 
| 
       21 
     | 
    
         
            -
            (self['@subscriptions']=smalltalk.send((smalltalk.OrderedCollection || OrderedCollection), "_new", []));
         
     | 
| 
       22 
     | 
    
         
            -
            return self;}
         
     | 
| 
       23 
     | 
    
         
            -
            }),
         
     | 
| 
       24 
     | 
    
         
            -
            smalltalk.Announcer);
         
     | 
| 
       25 
     | 
    
         
            -
             
     | 
| 
       26 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       27 
     | 
    
         
            -
            unescape('_on_do_'),
         
     | 
| 
       28 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       29 
     | 
    
         
            -
            selector: unescape('on%3Ado%3A'),
         
     | 
| 
       30 
     | 
    
         
            -
            fn: function (aClass, aBlock){
         
     | 
| 
       31 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       32 
     | 
    
         
            -
            smalltalk.send(self['@subscriptions'], "_add_", [(function($rec){smalltalk.send($rec, "_block_", [aBlock]);smalltalk.send($rec, "_announcementClass_", [aClass]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send((smalltalk.AnnouncementSubscription || AnnouncementSubscription), "_new", []))]);
         
     | 
| 
       33 
     | 
    
         
            -
            return self;}
         
     | 
| 
       34 
     | 
    
         
            -
            }),
         
     | 
| 
       35 
     | 
    
         
            -
            smalltalk.Announcer);
         
     | 
| 
       36 
     | 
    
         
            -
             
     | 
| 
       37 
     | 
    
         
            -
             
     | 
| 
       38 
     | 
    
         
            -
             
     | 
| 
       39 
2 
     | 
    
         
             
            smalltalk.addClass('AnnouncementSubscription', smalltalk.Object, ['block', 'announcementClass'], 'Kernel-Announcements');
         
     | 
| 
       40 
3 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       41 
4 
     | 
    
         
             
            unescape('_announcementClass'),
         
     | 
| 
         @@ -105,3 +68,40 @@ smalltalk.AnnouncementSubscription); 
     | 
|
| 
       105 
68 
     | 
    
         | 
| 
       106 
69 
     | 
    
         | 
| 
       107 
70 
     | 
    
         | 
| 
      
 71 
     | 
    
         
            +
            smalltalk.addClass('Announcer', smalltalk.Object, ['registry', 'subscriptions'], 'Kernel-Announcements');
         
     | 
| 
      
 72 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 73 
     | 
    
         
            +
            unescape('_announce_'),
         
     | 
| 
      
 74 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 75 
     | 
    
         
            +
            selector: unescape('announce%3A'),
         
     | 
| 
      
 76 
     | 
    
         
            +
            fn: function (anAnnouncement){
         
     | 
| 
      
 77 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 78 
     | 
    
         
            +
            smalltalk.send(self['@subscriptions'], "_do_", [(function(each){return smalltalk.send(each, "_deliver_", [anAnnouncement]);})]);
         
     | 
| 
      
 79 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 80 
     | 
    
         
            +
            }),
         
     | 
| 
      
 81 
     | 
    
         
            +
            smalltalk.Announcer);
         
     | 
| 
      
 82 
     | 
    
         
            +
             
     | 
| 
      
 83 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 84 
     | 
    
         
            +
            unescape('_initialize'),
         
     | 
| 
      
 85 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 86 
     | 
    
         
            +
            selector: unescape('initialize'),
         
     | 
| 
      
 87 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 88 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 89 
     | 
    
         
            +
            smalltalk.send(self, "_initialize", [], smalltalk.Object);
         
     | 
| 
      
 90 
     | 
    
         
            +
            (self['@subscriptions']=smalltalk.send((smalltalk.Array || Array), "_new", []));
         
     | 
| 
      
 91 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 92 
     | 
    
         
            +
            }),
         
     | 
| 
      
 93 
     | 
    
         
            +
            smalltalk.Announcer);
         
     | 
| 
      
 94 
     | 
    
         
            +
             
     | 
| 
      
 95 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 96 
     | 
    
         
            +
            unescape('_on_do_'),
         
     | 
| 
      
 97 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 98 
     | 
    
         
            +
            selector: unescape('on%3Ado%3A'),
         
     | 
| 
      
 99 
     | 
    
         
            +
            fn: function (aClass, aBlock){
         
     | 
| 
      
 100 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 101 
     | 
    
         
            +
            smalltalk.send(self['@subscriptions'], "_add_", [(function($rec){smalltalk.send($rec, "_block_", [aBlock]);smalltalk.send($rec, "_announcementClass_", [aClass]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send((smalltalk.AnnouncementSubscription || AnnouncementSubscription), "_new", []))]);
         
     | 
| 
      
 102 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 103 
     | 
    
         
            +
            }),
         
     | 
| 
      
 104 
     | 
    
         
            +
            smalltalk.Announcer);
         
     | 
| 
      
 105 
     | 
    
         
            +
             
     | 
| 
      
 106 
     | 
    
         
            +
             
     | 
| 
      
 107 
     | 
    
         
            +
             
     | 
| 
         @@ -1,56 +1,4 @@ 
     | 
|
| 
       1 
1 
     | 
    
         
             
            smalltalk.addPackage('Kernel-Announcements', {});
         
     | 
| 
       2 
     | 
    
         
            -
            smalltalk.addClass('Announcer', smalltalk.Object, ['registry', 'subscriptions'], 'Kernel-Announcements');
         
     | 
| 
       3 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       4 
     | 
    
         
            -
            unescape('_announce_'),
         
     | 
| 
       5 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       6 
     | 
    
         
            -
            selector: unescape('announce%3A'),
         
     | 
| 
       7 
     | 
    
         
            -
            category: 'announcing',
         
     | 
| 
       8 
     | 
    
         
            -
            fn: function (anAnnouncement){
         
     | 
| 
       9 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       10 
     | 
    
         
            -
            smalltalk.send(self['@subscriptions'], "_do_", [(function(each){return smalltalk.send(each, "_deliver_", [anAnnouncement]);})]);
         
     | 
| 
       11 
     | 
    
         
            -
            return self;},
         
     | 
| 
       12 
     | 
    
         
            -
            args: ["anAnnouncement"],
         
     | 
| 
       13 
     | 
    
         
            -
            source: unescape('announce%3A%20anAnnouncement%0A%09subscriptions%20do%3A%20%5B%3Aeach%20%7C%0A%09%09each%20deliver%3A%20anAnnouncement%5D'),
         
     | 
| 
       14 
     | 
    
         
            -
            messageSends: ["do:", "deliver:"],
         
     | 
| 
       15 
     | 
    
         
            -
            referencedClasses: []
         
     | 
| 
       16 
     | 
    
         
            -
            }),
         
     | 
| 
       17 
     | 
    
         
            -
            smalltalk.Announcer);
         
     | 
| 
       18 
     | 
    
         
            -
             
     | 
| 
       19 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       20 
     | 
    
         
            -
            unescape('_initialize'),
         
     | 
| 
       21 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       22 
     | 
    
         
            -
            selector: unescape('initialize'),
         
     | 
| 
       23 
     | 
    
         
            -
            category: 'initialization',
         
     | 
| 
       24 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
       25 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       26 
     | 
    
         
            -
            smalltalk.send(self, "_initialize", [], smalltalk.Object);
         
     | 
| 
       27 
     | 
    
         
            -
            (self['@subscriptions']=smalltalk.send((smalltalk.OrderedCollection || OrderedCollection), "_new", []));
         
     | 
| 
       28 
     | 
    
         
            -
            return self;},
         
     | 
| 
       29 
     | 
    
         
            -
            args: [],
         
     | 
| 
       30 
     | 
    
         
            -
            source: unescape('initialize%0A%09super%20initialize.%0A%09subscriptions%20%3A%3D%20OrderedCollection%20new'),
         
     | 
| 
       31 
     | 
    
         
            -
            messageSends: ["initialize", "new"],
         
     | 
| 
       32 
     | 
    
         
            -
            referencedClasses: ["OrderedCollection"]
         
     | 
| 
       33 
     | 
    
         
            -
            }),
         
     | 
| 
       34 
     | 
    
         
            -
            smalltalk.Announcer);
         
     | 
| 
       35 
     | 
    
         
            -
             
     | 
| 
       36 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       37 
     | 
    
         
            -
            unescape('_on_do_'),
         
     | 
| 
       38 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       39 
     | 
    
         
            -
            selector: unescape('on%3Ado%3A'),
         
     | 
| 
       40 
     | 
    
         
            -
            category: 'subscribing',
         
     | 
| 
       41 
     | 
    
         
            -
            fn: function (aClass, aBlock){
         
     | 
| 
       42 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       43 
     | 
    
         
            -
            smalltalk.send(self['@subscriptions'], "_add_", [(function($rec){smalltalk.send($rec, "_block_", [aBlock]);smalltalk.send($rec, "_announcementClass_", [aClass]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send((smalltalk.AnnouncementSubscription || AnnouncementSubscription), "_new", []))]);
         
     | 
| 
       44 
     | 
    
         
            -
            return self;},
         
     | 
| 
       45 
     | 
    
         
            -
            args: ["aClass", "aBlock"],
         
     | 
| 
       46 
     | 
    
         
            -
            source: unescape('on%3A%20aClass%20do%3A%20aBlock%0A%09subscriptions%20add%3A%20%28AnnouncementSubscription%20new%0A%09%09block%3A%20aBlock%3B%0A%09%09announcementClass%3A%20aClass%3B%0A%09%09yourself%29'),
         
     | 
| 
       47 
     | 
    
         
            -
            messageSends: ["add:", "block:", "announcementClass:", "yourself", "new"],
         
     | 
| 
       48 
     | 
    
         
            -
            referencedClasses: ["AnnouncementSubscription"]
         
     | 
| 
       49 
     | 
    
         
            -
            }),
         
     | 
| 
       50 
     | 
    
         
            -
            smalltalk.Announcer);
         
     | 
| 
       51 
     | 
    
         
            -
             
     | 
| 
       52 
     | 
    
         
            -
             
     | 
| 
       53 
     | 
    
         
            -
             
     | 
| 
       54 
2 
     | 
    
         
             
            smalltalk.addClass('AnnouncementSubscription', smalltalk.Object, ['block', 'announcementClass'], 'Kernel-Announcements');
         
     | 
| 
       55 
3 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       56 
4 
     | 
    
         
             
            unescape('_announcementClass'),
         
     | 
| 
         @@ -150,3 +98,55 @@ smalltalk.AnnouncementSubscription); 
     | 
|
| 
       150 
98 
     | 
    
         | 
| 
       151 
99 
     | 
    
         | 
| 
       152 
100 
     | 
    
         | 
| 
      
 101 
     | 
    
         
            +
            smalltalk.addClass('Announcer', smalltalk.Object, ['registry', 'subscriptions'], 'Kernel-Announcements');
         
     | 
| 
      
 102 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 103 
     | 
    
         
            +
            unescape('_announce_'),
         
     | 
| 
      
 104 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 105 
     | 
    
         
            +
            selector: unescape('announce%3A'),
         
     | 
| 
      
 106 
     | 
    
         
            +
            category: 'announcing',
         
     | 
| 
      
 107 
     | 
    
         
            +
            fn: function (anAnnouncement){
         
     | 
| 
      
 108 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 109 
     | 
    
         
            +
            smalltalk.send(self['@subscriptions'], "_do_", [(function(each){return smalltalk.send(each, "_deliver_", [anAnnouncement]);})]);
         
     | 
| 
      
 110 
     | 
    
         
            +
            return self;},
         
     | 
| 
      
 111 
     | 
    
         
            +
            args: ["anAnnouncement"],
         
     | 
| 
      
 112 
     | 
    
         
            +
            source: unescape('announce%3A%20anAnnouncement%0A%09subscriptions%20do%3A%20%5B%3Aeach%20%7C%0A%09%09each%20deliver%3A%20anAnnouncement%5D'),
         
     | 
| 
      
 113 
     | 
    
         
            +
            messageSends: ["do:", "deliver:"],
         
     | 
| 
      
 114 
     | 
    
         
            +
            referencedClasses: []
         
     | 
| 
      
 115 
     | 
    
         
            +
            }),
         
     | 
| 
      
 116 
     | 
    
         
            +
            smalltalk.Announcer);
         
     | 
| 
      
 117 
     | 
    
         
            +
             
     | 
| 
      
 118 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 119 
     | 
    
         
            +
            unescape('_initialize'),
         
     | 
| 
      
 120 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 121 
     | 
    
         
            +
            selector: unescape('initialize'),
         
     | 
| 
      
 122 
     | 
    
         
            +
            category: 'initialization',
         
     | 
| 
      
 123 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 124 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 125 
     | 
    
         
            +
            smalltalk.send(self, "_initialize", [], smalltalk.Object);
         
     | 
| 
      
 126 
     | 
    
         
            +
            (self['@subscriptions']=smalltalk.send((smalltalk.Array || Array), "_new", []));
         
     | 
| 
      
 127 
     | 
    
         
            +
            return self;},
         
     | 
| 
      
 128 
     | 
    
         
            +
            args: [],
         
     | 
| 
      
 129 
     | 
    
         
            +
            source: unescape('initialize%0A%09super%20initialize.%0A%09subscriptions%20%3A%3D%20Array%20new'),
         
     | 
| 
      
 130 
     | 
    
         
            +
            messageSends: ["initialize", "new"],
         
     | 
| 
      
 131 
     | 
    
         
            +
            referencedClasses: ["Array"]
         
     | 
| 
      
 132 
     | 
    
         
            +
            }),
         
     | 
| 
      
 133 
     | 
    
         
            +
            smalltalk.Announcer);
         
     | 
| 
      
 134 
     | 
    
         
            +
             
     | 
| 
      
 135 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 136 
     | 
    
         
            +
            unescape('_on_do_'),
         
     | 
| 
      
 137 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 138 
     | 
    
         
            +
            selector: unescape('on%3Ado%3A'),
         
     | 
| 
      
 139 
     | 
    
         
            +
            category: 'subscribing',
         
     | 
| 
      
 140 
     | 
    
         
            +
            fn: function (aClass, aBlock){
         
     | 
| 
      
 141 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 142 
     | 
    
         
            +
            smalltalk.send(self['@subscriptions'], "_add_", [(function($rec){smalltalk.send($rec, "_block_", [aBlock]);smalltalk.send($rec, "_announcementClass_", [aClass]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send((smalltalk.AnnouncementSubscription || AnnouncementSubscription), "_new", []))]);
         
     | 
| 
      
 143 
     | 
    
         
            +
            return self;},
         
     | 
| 
      
 144 
     | 
    
         
            +
            args: ["aClass", "aBlock"],
         
     | 
| 
      
 145 
     | 
    
         
            +
            source: unescape('on%3A%20aClass%20do%3A%20aBlock%0A%09subscriptions%20add%3A%20%28AnnouncementSubscription%20new%0A%09%09block%3A%20aBlock%3B%0A%09%09announcementClass%3A%20aClass%3B%0A%09%09yourself%29'),
         
     | 
| 
      
 146 
     | 
    
         
            +
            messageSends: ["add:", "block:", "announcementClass:", "yourself", "new"],
         
     | 
| 
      
 147 
     | 
    
         
            +
            referencedClasses: ["AnnouncementSubscription"]
         
     | 
| 
      
 148 
     | 
    
         
            +
            }),
         
     | 
| 
      
 149 
     | 
    
         
            +
            smalltalk.Announcer);
         
     | 
| 
      
 150 
     | 
    
         
            +
             
     | 
| 
      
 151 
     | 
    
         
            +
             
     | 
| 
      
 152 
     | 
    
         
            +
             
     | 
| 
         @@ -1,9 +1,422 @@ 
     | 
|
| 
       1 
1 
     | 
    
         
             
            smalltalk.addPackage('Kernel-Collections', {});
         
     | 
| 
      
 2 
     | 
    
         
            +
            smalltalk.addClass('Stream', smalltalk.Object, ['collection', 'position', 'streamSize'], 'Kernel-Collections');
         
     | 
| 
      
 3 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 4 
     | 
    
         
            +
            unescape('_collection'),
         
     | 
| 
      
 5 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 6 
     | 
    
         
            +
            selector: unescape('collection'),
         
     | 
| 
      
 7 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 8 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 9 
     | 
    
         
            +
            return self['@collection'];
         
     | 
| 
      
 10 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 11 
     | 
    
         
            +
            }),
         
     | 
| 
      
 12 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 13 
     | 
    
         
            +
             
     | 
| 
      
 14 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 15 
     | 
    
         
            +
            unescape('_setCollection_'),
         
     | 
| 
      
 16 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 17 
     | 
    
         
            +
            selector: unescape('setCollection%3A'),
         
     | 
| 
      
 18 
     | 
    
         
            +
            fn: function (aCollection){
         
     | 
| 
      
 19 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 20 
     | 
    
         
            +
            (self['@collection']=aCollection);
         
     | 
| 
      
 21 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 22 
     | 
    
         
            +
            }),
         
     | 
| 
      
 23 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 24 
     | 
    
         
            +
             
     | 
| 
      
 25 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 26 
     | 
    
         
            +
            unescape('_position'),
         
     | 
| 
      
 27 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 28 
     | 
    
         
            +
            selector: unescape('position'),
         
     | 
| 
      
 29 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 30 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 31 
     | 
    
         
            +
            return (($receiver = self['@position']) == nil || $receiver == undefined) ? (function(){return (self['@position']=(0));})() : $receiver;
         
     | 
| 
      
 32 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 33 
     | 
    
         
            +
            }),
         
     | 
| 
      
 34 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 35 
     | 
    
         
            +
             
     | 
| 
      
 36 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 37 
     | 
    
         
            +
            unescape('_position_'),
         
     | 
| 
      
 38 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 39 
     | 
    
         
            +
            selector: unescape('position%3A'),
         
     | 
| 
      
 40 
     | 
    
         
            +
            fn: function (anInteger){
         
     | 
| 
      
 41 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 42 
     | 
    
         
            +
            (self['@position']=anInteger);
         
     | 
| 
      
 43 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 44 
     | 
    
         
            +
            }),
         
     | 
| 
      
 45 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 46 
     | 
    
         
            +
             
     | 
| 
      
 47 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 48 
     | 
    
         
            +
            unescape('_streamSize'),
         
     | 
| 
      
 49 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 50 
     | 
    
         
            +
            selector: unescape('streamSize'),
         
     | 
| 
      
 51 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 52 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 53 
     | 
    
         
            +
            return self['@streamSize'];
         
     | 
| 
      
 54 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 55 
     | 
    
         
            +
            }),
         
     | 
| 
      
 56 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 57 
     | 
    
         
            +
             
     | 
| 
      
 58 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 59 
     | 
    
         
            +
            unescape('_setStreamSize_'),
         
     | 
| 
      
 60 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 61 
     | 
    
         
            +
            selector: unescape('setStreamSize%3A'),
         
     | 
| 
      
 62 
     | 
    
         
            +
            fn: function (anInteger){
         
     | 
| 
      
 63 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 64 
     | 
    
         
            +
            (self['@streamSize']=anInteger);
         
     | 
| 
      
 65 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 66 
     | 
    
         
            +
            }),
         
     | 
| 
      
 67 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 68 
     | 
    
         
            +
             
     | 
| 
      
 69 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 70 
     | 
    
         
            +
            unescape('_contents'),
         
     | 
| 
      
 71 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 72 
     | 
    
         
            +
            selector: unescape('contents'),
         
     | 
| 
      
 73 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 74 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 75 
     | 
    
         
            +
            return smalltalk.send(smalltalk.send(self, "_collection", []), "_copyFrom_to_", [(1), smalltalk.send(self, "_streamSize", [])]);
         
     | 
| 
      
 76 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 77 
     | 
    
         
            +
            }),
         
     | 
| 
      
 78 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 79 
     | 
    
         
            +
             
     | 
| 
      
 80 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 81 
     | 
    
         
            +
            unescape('_size'),
         
     | 
| 
      
 82 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 83 
     | 
    
         
            +
            selector: unescape('size'),
         
     | 
| 
      
 84 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 85 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 86 
     | 
    
         
            +
            return smalltalk.send(self, "_streamSize", []);
         
     | 
| 
      
 87 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 88 
     | 
    
         
            +
            }),
         
     | 
| 
      
 89 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 90 
     | 
    
         
            +
             
     | 
| 
      
 91 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 92 
     | 
    
         
            +
            unescape('_reset'),
         
     | 
| 
      
 93 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 94 
     | 
    
         
            +
            selector: unescape('reset'),
         
     | 
| 
      
 95 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 96 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 97 
     | 
    
         
            +
            smalltalk.send(self, "_position_", [(0)]);
         
     | 
| 
      
 98 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 99 
     | 
    
         
            +
            }),
         
     | 
| 
      
 100 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 101 
     | 
    
         
            +
             
     | 
| 
      
 102 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 103 
     | 
    
         
            +
            unescape('_close'),
         
     | 
| 
      
 104 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 105 
     | 
    
         
            +
            selector: unescape('close'),
         
     | 
| 
      
 106 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 107 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 108 
     | 
    
         
            +
             
     | 
| 
      
 109 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 110 
     | 
    
         
            +
            }),
         
     | 
| 
      
 111 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 112 
     | 
    
         
            +
             
     | 
| 
      
 113 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 114 
     | 
    
         
            +
            unescape('_flush'),
         
     | 
| 
      
 115 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 116 
     | 
    
         
            +
            selector: unescape('flush'),
         
     | 
| 
      
 117 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 118 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 119 
     | 
    
         
            +
             
     | 
| 
      
 120 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 121 
     | 
    
         
            +
            }),
         
     | 
| 
      
 122 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 123 
     | 
    
         
            +
             
     | 
| 
      
 124 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 125 
     | 
    
         
            +
            unescape('_resetContents'),
         
     | 
| 
      
 126 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 127 
     | 
    
         
            +
            selector: unescape('resetContents'),
         
     | 
| 
      
 128 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 129 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 130 
     | 
    
         
            +
            smalltalk.send(self, "_reset", []);
         
     | 
| 
      
 131 
     | 
    
         
            +
            smalltalk.send(self, "_setStreamSize_", [(0)]);
         
     | 
| 
      
 132 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 133 
     | 
    
         
            +
            }),
         
     | 
| 
      
 134 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 135 
     | 
    
         
            +
             
     | 
| 
      
 136 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 137 
     | 
    
         
            +
            unescape('_do_'),
         
     | 
| 
      
 138 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 139 
     | 
    
         
            +
            selector: unescape('do%3A'),
         
     | 
| 
      
 140 
     | 
    
         
            +
            fn: function (aBlock){
         
     | 
| 
      
 141 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 142 
     | 
    
         
            +
            (function(){while(!(function(){return smalltalk.send(self, "_atEnd", []);})()) {(function(){return smalltalk.send(aBlock, "_value_", [smalltalk.send(self, "_next", [])]);})()}})();
         
     | 
| 
      
 143 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 144 
     | 
    
         
            +
            }),
         
     | 
| 
      
 145 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 146 
     | 
    
         
            +
             
     | 
| 
      
 147 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 148 
     | 
    
         
            +
            unescape('_setToEnd'),
         
     | 
| 
      
 149 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 150 
     | 
    
         
            +
            selector: unescape('setToEnd'),
         
     | 
| 
      
 151 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 152 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 153 
     | 
    
         
            +
            smalltalk.send(self, "_position_", [smalltalk.send(self, "_size", [])]);
         
     | 
| 
      
 154 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 155 
     | 
    
         
            +
            }),
         
     | 
| 
      
 156 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 157 
     | 
    
         
            +
             
     | 
| 
      
 158 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 159 
     | 
    
         
            +
            unescape('_skip_'),
         
     | 
| 
      
 160 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 161 
     | 
    
         
            +
            selector: unescape('skip%3A'),
         
     | 
| 
      
 162 
     | 
    
         
            +
            fn: function (anInteger){
         
     | 
| 
      
 163 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 164 
     | 
    
         
            +
            smalltalk.send(self, "_position_", [smalltalk.send(((($receiver = smalltalk.send(self, "_position", [])).klass === smalltalk.Number) ? $receiver +anInteger : smalltalk.send($receiver, "__plus", [anInteger])), "_min_max_", [smalltalk.send(self, "_size", []), (0)])]);
         
     | 
| 
      
 165 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 166 
     | 
    
         
            +
            }),
         
     | 
| 
      
 167 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 168 
     | 
    
         
            +
             
     | 
| 
      
 169 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 170 
     | 
    
         
            +
            unescape('_next'),
         
     | 
| 
      
 171 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 172 
     | 
    
         
            +
            selector: unescape('next'),
         
     | 
| 
      
 173 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 174 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 175 
     | 
    
         
            +
            return ((($receiver = smalltalk.send(self, "_atEnd", [])).klass === smalltalk.Boolean) ? ($receiver ? (function(){return nil;})() : (function(){smalltalk.send(self, "_position_", [((($receiver = smalltalk.send(self, "_position", [])).klass === smalltalk.Number) ? $receiver +(1) : smalltalk.send($receiver, "__plus", [(1)]))]);return smalltalk.send(self['@collection'], "_at_", [smalltalk.send(self, "_position", [])]);})()) : smalltalk.send($receiver, "_ifTrue_ifFalse_", [(function(){return nil;}), (function(){smalltalk.send(self, "_position_", [((($receiver = smalltalk.send(self, "_position", [])).klass === smalltalk.Number) ? $receiver +(1) : smalltalk.send($receiver, "__plus", [(1)]))]);return smalltalk.send(self['@collection'], "_at_", [smalltalk.send(self, "_position", [])]);})]));
         
     | 
| 
      
 176 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 177 
     | 
    
         
            +
            }),
         
     | 
| 
      
 178 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 179 
     | 
    
         
            +
             
     | 
| 
      
 180 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 181 
     | 
    
         
            +
            unescape('_next_'),
         
     | 
| 
      
 182 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 183 
     | 
    
         
            +
            selector: unescape('next%3A'),
         
     | 
| 
      
 184 
     | 
    
         
            +
            fn: function (anInteger){
         
     | 
| 
      
 185 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 186 
     | 
    
         
            +
            var tempCollection=nil;
         
     | 
| 
      
 187 
     | 
    
         
            +
            (tempCollection=smalltalk.send(smalltalk.send(smalltalk.send(self, "_collection", []), "_class", []), "_new", []));
         
     | 
| 
      
 188 
     | 
    
         
            +
            smalltalk.send(anInteger, "_timesRepeat_", [(function(){return ((($receiver = smalltalk.send(self, "_atEnd", [])).klass === smalltalk.Boolean) ? (! $receiver ? (function(){return smalltalk.send(tempCollection, "_add_", [smalltalk.send(self, "_next", [])]);})() : nil) : smalltalk.send($receiver, "_ifFalse_", [(function(){return smalltalk.send(tempCollection, "_add_", [smalltalk.send(self, "_next", [])]);})]));})]);
         
     | 
| 
      
 189 
     | 
    
         
            +
            return tempCollection;
         
     | 
| 
      
 190 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 191 
     | 
    
         
            +
            }),
         
     | 
| 
      
 192 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 193 
     | 
    
         
            +
             
     | 
| 
      
 194 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 195 
     | 
    
         
            +
            unescape('_nextPut_'),
         
     | 
| 
      
 196 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 197 
     | 
    
         
            +
            selector: unescape('nextPut%3A'),
         
     | 
| 
      
 198 
     | 
    
         
            +
            fn: function (anObject){
         
     | 
| 
      
 199 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 200 
     | 
    
         
            +
            smalltalk.send(self, "_position_", [((($receiver = smalltalk.send(self, "_position", [])).klass === smalltalk.Number) ? $receiver +(1) : smalltalk.send($receiver, "__plus", [(1)]))]);
         
     | 
| 
      
 201 
     | 
    
         
            +
            smalltalk.send(smalltalk.send(self, "_collection", []), "_at_put_", [smalltalk.send(self, "_position", []), anObject]);
         
     | 
| 
      
 202 
     | 
    
         
            +
            smalltalk.send(self, "_setStreamSize_", [smalltalk.send(smalltalk.send(self, "_streamSize", []), "_max_", [smalltalk.send(self, "_position", [])])]);
         
     | 
| 
      
 203 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 204 
     | 
    
         
            +
            }),
         
     | 
| 
      
 205 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 206 
     | 
    
         
            +
             
     | 
| 
      
 207 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 208 
     | 
    
         
            +
            unescape('_nextPutAll_'),
         
     | 
| 
      
 209 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 210 
     | 
    
         
            +
            selector: unescape('nextPutAll%3A'),
         
     | 
| 
      
 211 
     | 
    
         
            +
            fn: function (aCollection){
         
     | 
| 
      
 212 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 213 
     | 
    
         
            +
            smalltalk.send(aCollection, "_do_", [(function(each){return smalltalk.send(self, "_nextPut_", [each]);})]);
         
     | 
| 
      
 214 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 215 
     | 
    
         
            +
            }),
         
     | 
| 
      
 216 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 217 
     | 
    
         
            +
             
     | 
| 
      
 218 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 219 
     | 
    
         
            +
            unescape('_peek'),
         
     | 
| 
      
 220 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 221 
     | 
    
         
            +
            selector: unescape('peek'),
         
     | 
| 
      
 222 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 223 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 224 
     | 
    
         
            +
            return ((($receiver = smalltalk.send(self, "_atEnd", [])).klass === smalltalk.Boolean) ? (! $receiver ? (function(){return smalltalk.send(smalltalk.send(self, "_collection", []), "_at_", [((($receiver = smalltalk.send(self, "_position", [])).klass === smalltalk.Number) ? $receiver +(1) : smalltalk.send($receiver, "__plus", [(1)]))]);})() : nil) : smalltalk.send($receiver, "_ifFalse_", [(function(){return smalltalk.send(smalltalk.send(self, "_collection", []), "_at_", [((($receiver = smalltalk.send(self, "_position", [])).klass === smalltalk.Number) ? $receiver +(1) : smalltalk.send($receiver, "__plus", [(1)]))]);})]));
         
     | 
| 
      
 225 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 226 
     | 
    
         
            +
            }),
         
     | 
| 
      
 227 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 228 
     | 
    
         
            +
             
     | 
| 
      
 229 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 230 
     | 
    
         
            +
            unescape('_atEnd'),
         
     | 
| 
      
 231 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 232 
     | 
    
         
            +
            selector: unescape('atEnd'),
         
     | 
| 
      
 233 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 234 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 235 
     | 
    
         
            +
            return smalltalk.send(smalltalk.send(self, "_position", []), "__eq", [smalltalk.send(self, "_size", [])]);
         
     | 
| 
      
 236 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 237 
     | 
    
         
            +
            }),
         
     | 
| 
      
 238 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 239 
     | 
    
         
            +
             
     | 
| 
      
 240 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 241 
     | 
    
         
            +
            unescape('_atStart'),
         
     | 
| 
      
 242 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 243 
     | 
    
         
            +
            selector: unescape('atStart'),
         
     | 
| 
      
 244 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 245 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 246 
     | 
    
         
            +
            return smalltalk.send(smalltalk.send(self, "_position", []), "__eq", [(0)]);
         
     | 
| 
      
 247 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 248 
     | 
    
         
            +
            }),
         
     | 
| 
      
 249 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 250 
     | 
    
         
            +
             
     | 
| 
      
 251 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 252 
     | 
    
         
            +
            unescape('_isEmpty'),
         
     | 
| 
      
 253 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 254 
     | 
    
         
            +
            selector: unescape('isEmpty'),
         
     | 
| 
      
 255 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 256 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 257 
     | 
    
         
            +
            return smalltalk.send(smalltalk.send(self, "_size", []), "__eq", [(0)]);
         
     | 
| 
      
 258 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 259 
     | 
    
         
            +
            }),
         
     | 
| 
      
 260 
     | 
    
         
            +
            smalltalk.Stream);
         
     | 
| 
      
 261 
     | 
    
         
            +
             
     | 
| 
      
 262 
     | 
    
         
            +
             
     | 
| 
      
 263 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 264 
     | 
    
         
            +
            unescape('_on_'),
         
     | 
| 
      
 265 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 266 
     | 
    
         
            +
            selector: unescape('on%3A'),
         
     | 
| 
      
 267 
     | 
    
         
            +
            fn: function (aCollection){
         
     | 
| 
      
 268 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 269 
     | 
    
         
            +
            return (function($rec){smalltalk.send($rec, "_setCollection_", [aCollection]);smalltalk.send($rec, "_setStreamSize_", [smalltalk.send(aCollection, "_size", [])]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new", []));
         
     | 
| 
      
 270 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 271 
     | 
    
         
            +
            }),
         
     | 
| 
      
 272 
     | 
    
         
            +
            smalltalk.Stream.klass);
         
     | 
| 
      
 273 
     | 
    
         
            +
             
     | 
| 
      
 274 
     | 
    
         
            +
             
     | 
| 
      
 275 
     | 
    
         
            +
            smalltalk.addClass('Association', smalltalk.Object, ['key', 'value'], 'Kernel-Collections');
         
     | 
| 
      
 276 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 277 
     | 
    
         
            +
            unescape('__eq'),
         
     | 
| 
      
 278 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 279 
     | 
    
         
            +
            selector: unescape('%3D'),
         
     | 
| 
      
 280 
     | 
    
         
            +
            fn: function (anAssociation){
         
     | 
| 
      
 281 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 282 
     | 
    
         
            +
            return smalltalk.send(smalltalk.send(smalltalk.send(self, "_class", []), "__eq", [smalltalk.send(anAssociation, "_class", [])]), "_and_", [(function(){return smalltalk.send(smalltalk.send(smalltalk.send(self, "_key", []), "__eq", [smalltalk.send(anAssociation, "_key", [])]), "_and_", [(function(){return smalltalk.send(smalltalk.send(self, "_value", []), "__eq", [smalltalk.send(anAssociation, "_value", [])]);})]);})]);
         
     | 
| 
      
 283 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 284 
     | 
    
         
            +
            }),
         
     | 
| 
      
 285 
     | 
    
         
            +
            smalltalk.Association);
         
     | 
| 
      
 286 
     | 
    
         
            +
             
     | 
| 
      
 287 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 288 
     | 
    
         
            +
            unescape('_key_'),
         
     | 
| 
      
 289 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 290 
     | 
    
         
            +
            selector: unescape('key%3A'),
         
     | 
| 
      
 291 
     | 
    
         
            +
            fn: function (aKey){
         
     | 
| 
      
 292 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 293 
     | 
    
         
            +
            (self['@key']=aKey);
         
     | 
| 
      
 294 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 295 
     | 
    
         
            +
            }),
         
     | 
| 
      
 296 
     | 
    
         
            +
            smalltalk.Association);
         
     | 
| 
      
 297 
     | 
    
         
            +
             
     | 
| 
      
 298 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 299 
     | 
    
         
            +
            unescape('_key'),
         
     | 
| 
      
 300 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 301 
     | 
    
         
            +
            selector: unescape('key'),
         
     | 
| 
      
 302 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 303 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 304 
     | 
    
         
            +
            return self['@key'];
         
     | 
| 
      
 305 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 306 
     | 
    
         
            +
            }),
         
     | 
| 
      
 307 
     | 
    
         
            +
            smalltalk.Association);
         
     | 
| 
      
 308 
     | 
    
         
            +
             
     | 
| 
      
 309 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 310 
     | 
    
         
            +
            unescape('_value_'),
         
     | 
| 
      
 311 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 312 
     | 
    
         
            +
            selector: unescape('value%3A'),
         
     | 
| 
      
 313 
     | 
    
         
            +
            fn: function (aValue){
         
     | 
| 
      
 314 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 315 
     | 
    
         
            +
            (self['@value']=aValue);
         
     | 
| 
      
 316 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 317 
     | 
    
         
            +
            }),
         
     | 
| 
      
 318 
     | 
    
         
            +
            smalltalk.Association);
         
     | 
| 
      
 319 
     | 
    
         
            +
             
     | 
| 
      
 320 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 321 
     | 
    
         
            +
            unescape('_value'),
         
     | 
| 
      
 322 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 323 
     | 
    
         
            +
            selector: unescape('value'),
         
     | 
| 
      
 324 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
      
 325 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 326 
     | 
    
         
            +
            return self['@value'];
         
     | 
| 
      
 327 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 328 
     | 
    
         
            +
            }),
         
     | 
| 
      
 329 
     | 
    
         
            +
            smalltalk.Association);
         
     | 
| 
      
 330 
     | 
    
         
            +
             
     | 
| 
      
 331 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 332 
     | 
    
         
            +
            unescape('_storeOn_'),
         
     | 
| 
      
 333 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 334 
     | 
    
         
            +
            selector: unescape('storeOn%3A'),
         
     | 
| 
      
 335 
     | 
    
         
            +
            fn: function (aStream){
         
     | 
| 
      
 336 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 337 
     | 
    
         
            +
            smalltalk.send(self['@key'], "_storeOn_", [aStream]);
         
     | 
| 
      
 338 
     | 
    
         
            +
            smalltalk.send(aStream, "_nextPutAll_", [unescape("-%3E")]);
         
     | 
| 
      
 339 
     | 
    
         
            +
            smalltalk.send(self['@value'], "_storeOn_", [aStream]);
         
     | 
| 
      
 340 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 341 
     | 
    
         
            +
            }),
         
     | 
| 
      
 342 
     | 
    
         
            +
            smalltalk.Association);
         
     | 
| 
      
 343 
     | 
    
         
            +
             
     | 
| 
      
 344 
     | 
    
         
            +
             
     | 
| 
      
 345 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 346 
     | 
    
         
            +
            unescape('_key_value_'),
         
     | 
| 
      
 347 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 348 
     | 
    
         
            +
            selector: unescape('key%3Avalue%3A'),
         
     | 
| 
      
 349 
     | 
    
         
            +
            fn: function (aKey, aValue){
         
     | 
| 
      
 350 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 351 
     | 
    
         
            +
            return (function($rec){smalltalk.send($rec, "_key_", [aKey]);smalltalk.send($rec, "_value_", [aValue]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new", []));
         
     | 
| 
      
 352 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 353 
     | 
    
         
            +
            }),
         
     | 
| 
      
 354 
     | 
    
         
            +
            smalltalk.Association.klass);
         
     | 
| 
      
 355 
     | 
    
         
            +
             
     | 
| 
      
 356 
     | 
    
         
            +
             
     | 
| 
      
 357 
     | 
    
         
            +
            smalltalk.addClass('RegularExpression', smalltalk.Object, [], 'Kernel-Collections');
         
     | 
| 
      
 358 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 359 
     | 
    
         
            +
            unescape('_compile_'),
         
     | 
| 
      
 360 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 361 
     | 
    
         
            +
            selector: unescape('compile%3A'),
         
     | 
| 
      
 362 
     | 
    
         
            +
            fn: function (aString){
         
     | 
| 
      
 363 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 364 
     | 
    
         
            +
            return self.compile(aString);
         
     | 
| 
      
 365 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 366 
     | 
    
         
            +
            }),
         
     | 
| 
      
 367 
     | 
    
         
            +
            smalltalk.RegularExpression);
         
     | 
| 
      
 368 
     | 
    
         
            +
             
     | 
| 
      
 369 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 370 
     | 
    
         
            +
            unescape('_exec_'),
         
     | 
| 
      
 371 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 372 
     | 
    
         
            +
            selector: unescape('exec%3A'),
         
     | 
| 
      
 373 
     | 
    
         
            +
            fn: function (aString){
         
     | 
| 
      
 374 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 375 
     | 
    
         
            +
            return self.exec(aString) || nil;
         
     | 
| 
      
 376 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 377 
     | 
    
         
            +
            }),
         
     | 
| 
      
 378 
     | 
    
         
            +
            smalltalk.RegularExpression);
         
     | 
| 
      
 379 
     | 
    
         
            +
             
     | 
| 
      
 380 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 381 
     | 
    
         
            +
            unescape('_test_'),
         
     | 
| 
      
 382 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 383 
     | 
    
         
            +
            selector: unescape('test%3A'),
         
     | 
| 
      
 384 
     | 
    
         
            +
            fn: function (aString){
         
     | 
| 
      
 385 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 386 
     | 
    
         
            +
            return self.test(aString);
         
     | 
| 
      
 387 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 388 
     | 
    
         
            +
            }),
         
     | 
| 
      
 389 
     | 
    
         
            +
            smalltalk.RegularExpression);
         
     | 
| 
      
 390 
     | 
    
         
            +
             
     | 
| 
      
 391 
     | 
    
         
            +
             
     | 
| 
      
 392 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 393 
     | 
    
         
            +
            unescape('_fromString_flag_'),
         
     | 
| 
      
 394 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 395 
     | 
    
         
            +
            selector: unescape('fromString%3Aflag%3A'),
         
     | 
| 
      
 396 
     | 
    
         
            +
            fn: function (aString, anotherString){
         
     | 
| 
      
 397 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 398 
     | 
    
         
            +
            return new RegExp(aString, anotherString);
         
     | 
| 
      
 399 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 400 
     | 
    
         
            +
            }),
         
     | 
| 
      
 401 
     | 
    
         
            +
            smalltalk.RegularExpression.klass);
         
     | 
| 
      
 402 
     | 
    
         
            +
             
     | 
| 
      
 403 
     | 
    
         
            +
            smalltalk.addMethod(
         
     | 
| 
      
 404 
     | 
    
         
            +
            unescape('_fromString_'),
         
     | 
| 
      
 405 
     | 
    
         
            +
            smalltalk.method({
         
     | 
| 
      
 406 
     | 
    
         
            +
            selector: unescape('fromString%3A'),
         
     | 
| 
      
 407 
     | 
    
         
            +
            fn: function (aString){
         
     | 
| 
      
 408 
     | 
    
         
            +
            var self=this;
         
     | 
| 
      
 409 
     | 
    
         
            +
            return smalltalk.send(self, "_fromString_flag_", [aString, ""]);
         
     | 
| 
      
 410 
     | 
    
         
            +
            return self;}
         
     | 
| 
      
 411 
     | 
    
         
            +
            }),
         
     | 
| 
      
 412 
     | 
    
         
            +
            smalltalk.RegularExpression.klass);
         
     | 
| 
      
 413 
     | 
    
         
            +
             
     | 
| 
      
 414 
     | 
    
         
            +
             
     | 
| 
       2 
415 
     | 
    
         
             
            smalltalk.addClass('Collection', smalltalk.Object, [], 'Kernel-Collections');
         
     | 
| 
       3 
416 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       4 
     | 
    
         
            -
            '_size',
         
     | 
| 
      
 417 
     | 
    
         
            +
            unescape('_size'),
         
     | 
| 
       5 
418 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       6 
     | 
    
         
            -
            selector: 'size',
         
     | 
| 
      
 419 
     | 
    
         
            +
            selector: unescape('size'),
         
     | 
| 
       7 
420 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       8 
421 
     | 
    
         
             
            var self=this;
         
     | 
| 
       9 
422 
     | 
    
         
             
            smalltalk.send(self, "_subclassResponsibility", []);
         
     | 
| 
         @@ -12,9 +425,9 @@ return self;} 
     | 
|
| 
       12 
425 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       13 
426 
     | 
    
         | 
| 
       14 
427 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       15 
     | 
    
         
            -
            '_readStream',
         
     | 
| 
      
 428 
     | 
    
         
            +
            unescape('_readStream'),
         
     | 
| 
       16 
429 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       17 
     | 
    
         
            -
            selector: 'readStream',
         
     | 
| 
      
 430 
     | 
    
         
            +
            selector: unescape('readStream'),
         
     | 
| 
       18 
431 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       19 
432 
     | 
    
         
             
            var self=this;
         
     | 
| 
       20 
433 
     | 
    
         
             
            return smalltalk.send(self, "_stream", []);
         
     | 
| 
         @@ -23,9 +436,9 @@ return self;} 
     | 
|
| 
       23 
436 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       24 
437 
     | 
    
         | 
| 
       25 
438 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       26 
     | 
    
         
            -
            '_writeStream',
         
     | 
| 
      
 439 
     | 
    
         
            +
            unescape('_writeStream'),
         
     | 
| 
       27 
440 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       28 
     | 
    
         
            -
            selector: 'writeStream',
         
     | 
| 
      
 441 
     | 
    
         
            +
            selector: unescape('writeStream'),
         
     | 
| 
       29 
442 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       30 
443 
     | 
    
         
             
            var self=this;
         
     | 
| 
       31 
444 
     | 
    
         
             
            return smalltalk.send(self, "_stream", []);
         
     | 
| 
         @@ -34,9 +447,9 @@ return self;} 
     | 
|
| 
       34 
447 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       35 
448 
     | 
    
         | 
| 
       36 
449 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       37 
     | 
    
         
            -
            '_stream',
         
     | 
| 
      
 450 
     | 
    
         
            +
            unescape('_stream'),
         
     | 
| 
       38 
451 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       39 
     | 
    
         
            -
            selector: 'stream',
         
     | 
| 
      
 452 
     | 
    
         
            +
            selector: unescape('stream'),
         
     | 
| 
       40 
453 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       41 
454 
     | 
    
         
             
            var self=this;
         
     | 
| 
       42 
455 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_streamClass", []), "_on_", [self]);
         
     | 
| 
         @@ -45,9 +458,9 @@ return self;} 
     | 
|
| 
       45 
458 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       46 
459 
     | 
    
         | 
| 
       47 
460 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       48 
     | 
    
         
            -
            '_streamClass',
         
     | 
| 
      
 461 
     | 
    
         
            +
            unescape('_streamClass'),
         
     | 
| 
       49 
462 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       50 
     | 
    
         
            -
            selector: 'streamClass',
         
     | 
| 
      
 463 
     | 
    
         
            +
            selector: unescape('streamClass'),
         
     | 
| 
       51 
464 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       52 
465 
     | 
    
         
             
            var self=this;
         
     | 
| 
       53 
466 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_class", []), "_streamClass", []);
         
     | 
| 
         @@ -56,9 +469,9 @@ return self;} 
     | 
|
| 
       56 
469 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       57 
470 
     | 
    
         | 
| 
       58 
471 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       59 
     | 
    
         
            -
            '_add_',
         
     | 
| 
      
 472 
     | 
    
         
            +
            unescape('_add_'),
         
     | 
| 
       60 
473 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       61 
     | 
    
         
            -
            selector: 'add 
     | 
| 
      
 474 
     | 
    
         
            +
            selector: unescape('add%3A'),
         
     | 
| 
       62 
475 
     | 
    
         
             
            fn: function (anObject){
         
     | 
| 
       63 
476 
     | 
    
         
             
            var self=this;
         
     | 
| 
       64 
477 
     | 
    
         
             
            smalltalk.send(self, "_subclassResponsibility", []);
         
     | 
| 
         @@ -67,9 +480,9 @@ return self;} 
     | 
|
| 
       67 
480 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       68 
481 
     | 
    
         | 
| 
       69 
482 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       70 
     | 
    
         
            -
            '_addAll_',
         
     | 
| 
      
 483 
     | 
    
         
            +
            unescape('_addAll_'),
         
     | 
| 
       71 
484 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       72 
     | 
    
         
            -
            selector: 'addAll 
     | 
| 
      
 485 
     | 
    
         
            +
            selector: unescape('addAll%3A'),
         
     | 
| 
       73 
486 
     | 
    
         
             
            fn: function (aCollection){
         
     | 
| 
       74 
487 
     | 
    
         
             
            var self=this;
         
     | 
| 
       75 
488 
     | 
    
         
             
            smalltalk.send(aCollection, "_do_", [(function(each){return smalltalk.send(self, "_add_", [each]);})]);
         
     | 
| 
         @@ -79,9 +492,9 @@ return self;} 
     | 
|
| 
       79 
492 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       80 
493 
     | 
    
         | 
| 
       81 
494 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       82 
     | 
    
         
            -
            '__comma',
         
     | 
| 
      
 495 
     | 
    
         
            +
            unescape('__comma'),
         
     | 
| 
       83 
496 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       84 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 497 
     | 
    
         
            +
            selector: unescape('%2C'),
         
     | 
| 
       85 
498 
     | 
    
         
             
            fn: function (aCollection){
         
     | 
| 
       86 
499 
     | 
    
         
             
            var self=this;
         
     | 
| 
       87 
500 
     | 
    
         
             
            return (function($rec){smalltalk.send($rec, "_addAll_", [aCollection]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_copy", []));
         
     | 
| 
         @@ -90,9 +503,9 @@ return self;} 
     | 
|
| 
       90 
503 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       91 
504 
     | 
    
         | 
| 
       92 
505 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       93 
     | 
    
         
            -
            '_copyWith_',
         
     | 
| 
      
 506 
     | 
    
         
            +
            unescape('_copyWith_'),
         
     | 
| 
       94 
507 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       95 
     | 
    
         
            -
            selector: 'copyWith 
     | 
| 
      
 508 
     | 
    
         
            +
            selector: unescape('copyWith%3A'),
         
     | 
| 
       96 
509 
     | 
    
         
             
            fn: function (anObject){
         
     | 
| 
       97 
510 
     | 
    
         
             
            var self=this;
         
     | 
| 
       98 
511 
     | 
    
         
             
            return (function($rec){smalltalk.send($rec, "_add_", [anObject]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_copy", []));
         
     | 
| 
         @@ -101,9 +514,9 @@ return self;} 
     | 
|
| 
       101 
514 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       102 
515 
     | 
    
         | 
| 
       103 
516 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       104 
     | 
    
         
            -
            '_copyWithAll_',
         
     | 
| 
      
 517 
     | 
    
         
            +
            unescape('_copyWithAll_'),
         
     | 
| 
       105 
518 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       106 
     | 
    
         
            -
            selector: 'copyWithAll 
     | 
| 
      
 519 
     | 
    
         
            +
            selector: unescape('copyWithAll%3A'),
         
     | 
| 
       107 
520 
     | 
    
         
             
            fn: function (aCollection){
         
     | 
| 
       108 
521 
     | 
    
         
             
            var self=this;
         
     | 
| 
       109 
522 
     | 
    
         
             
            return (function($rec){smalltalk.send($rec, "_addAll_", [aCollection]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_copy", []));
         
     | 
| 
         @@ -112,9 +525,9 @@ return self;} 
     | 
|
| 
       112 
525 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       113 
526 
     | 
    
         | 
| 
       114 
527 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       115 
     | 
    
         
            -
            '_asArray',
         
     | 
| 
      
 528 
     | 
    
         
            +
            unescape('_asArray'),
         
     | 
| 
       116 
529 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       117 
     | 
    
         
            -
            selector: 'asArray',
         
     | 
| 
      
 530 
     | 
    
         
            +
            selector: unescape('asArray'),
         
     | 
| 
       118 
531 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       119 
532 
     | 
    
         
             
            var self=this;
         
     | 
| 
       120 
533 
     | 
    
         
             
            return smalltalk.send((smalltalk.Array || Array), "_withAll_", [self]);
         
     | 
| 
         @@ -123,9 +536,9 @@ return self;} 
     | 
|
| 
       123 
536 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       124 
537 
     | 
    
         | 
| 
       125 
538 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       126 
     | 
    
         
            -
            '_do_',
         
     | 
| 
      
 539 
     | 
    
         
            +
            unescape('_do_'),
         
     | 
| 
       127 
540 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       128 
     | 
    
         
            -
            selector: 'do 
     | 
| 
      
 541 
     | 
    
         
            +
            selector: unescape('do%3A'),
         
     | 
| 
       129 
542 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       130 
543 
     | 
    
         
             
            var self=this;
         
     | 
| 
       131 
544 
     | 
    
         
             
            for(var i=0;i<self.length;i++){aBlock(self[i]);};
         
     | 
| 
         @@ -134,9 +547,9 @@ return self;} 
     | 
|
| 
       134 
547 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       135 
548 
     | 
    
         | 
| 
       136 
549 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       137 
     | 
    
         
            -
            '_collect_',
         
     | 
| 
      
 550 
     | 
    
         
            +
            unescape('_collect_'),
         
     | 
| 
       138 
551 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       139 
     | 
    
         
            -
            selector: 'collect 
     | 
| 
      
 552 
     | 
    
         
            +
            selector: unescape('collect%3A'),
         
     | 
| 
       140 
553 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       141 
554 
     | 
    
         
             
            var self=this;
         
     | 
| 
       142 
555 
     | 
    
         
             
            var newCollection=nil;
         
     | 
| 
         @@ -148,9 +561,9 @@ return self;} 
     | 
|
| 
       148 
561 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       149 
562 
     | 
    
         | 
| 
       150 
563 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       151 
     | 
    
         
            -
            '_detect_',
         
     | 
| 
      
 564 
     | 
    
         
            +
            unescape('_detect_'),
         
     | 
| 
       152 
565 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       153 
     | 
    
         
            -
            selector: 'detect 
     | 
| 
      
 566 
     | 
    
         
            +
            selector: unescape('detect%3A'),
         
     | 
| 
       154 
567 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       155 
568 
     | 
    
         
             
            var self=this;
         
     | 
| 
       156 
569 
     | 
    
         
             
            return smalltalk.send(self, "_detect_ifNone_", [aBlock, (function(){return smalltalk.send(self, "_errorNotFound", []);})]);
         
     | 
| 
         @@ -159,9 +572,9 @@ return self;} 
     | 
|
| 
       159 
572 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       160 
573 
     | 
    
         | 
| 
       161 
574 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       162 
     | 
    
         
            -
            '_detect_ifNone_',
         
     | 
| 
      
 575 
     | 
    
         
            +
            unescape('_detect_ifNone_'),
         
     | 
| 
       163 
576 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       164 
     | 
    
         
            -
            selector: 'detect 
     | 
| 
      
 577 
     | 
    
         
            +
            selector: unescape('detect%3AifNone%3A'),
         
     | 
| 
       165 
578 
     | 
    
         
             
            fn: function (aBlock, anotherBlock){
         
     | 
| 
       166 
579 
     | 
    
         
             
            var self=this;
         
     | 
| 
       167 
580 
     | 
    
         | 
| 
         @@ -175,9 +588,9 @@ return self;} 
     | 
|
| 
       175 
588 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       176 
589 
     | 
    
         | 
| 
       177 
590 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       178 
     | 
    
         
            -
            '_do_separatedBy_',
         
     | 
| 
      
 591 
     | 
    
         
            +
            unescape('_do_separatedBy_'),
         
     | 
| 
       179 
592 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       180 
     | 
    
         
            -
            selector: 'do 
     | 
| 
      
 593 
     | 
    
         
            +
            selector: unescape('do%3AseparatedBy%3A'),
         
     | 
| 
       181 
594 
     | 
    
         
             
            fn: function (aBlock, anotherBlock){
         
     | 
| 
       182 
595 
     | 
    
         
             
            var self=this;
         
     | 
| 
       183 
596 
     | 
    
         
             
            var first=nil;
         
     | 
| 
         @@ -188,9 +601,9 @@ return self;} 
     | 
|
| 
       188 
601 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       189 
602 
     | 
    
         | 
| 
       190 
603 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       191 
     | 
    
         
            -
            '_inject_into_',
         
     | 
| 
      
 604 
     | 
    
         
            +
            unescape('_inject_into_'),
         
     | 
| 
       192 
605 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       193 
     | 
    
         
            -
            selector: 'inject 
     | 
| 
      
 606 
     | 
    
         
            +
            selector: unescape('inject%3Ainto%3A'),
         
     | 
| 
       194 
607 
     | 
    
         
             
            fn: function (anObject, aBlock){
         
     | 
| 
       195 
608 
     | 
    
         
             
            var self=this;
         
     | 
| 
       196 
609 
     | 
    
         
             
            var result=nil;
         
     | 
| 
         @@ -202,9 +615,9 @@ return self;} 
     | 
|
| 
       202 
615 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       203 
616 
     | 
    
         | 
| 
       204 
617 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       205 
     | 
    
         
            -
            '_reject_',
         
     | 
| 
      
 618 
     | 
    
         
            +
            unescape('_reject_'),
         
     | 
| 
       206 
619 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       207 
     | 
    
         
            -
            selector: 'reject 
     | 
| 
      
 620 
     | 
    
         
            +
            selector: unescape('reject%3A'),
         
     | 
| 
       208 
621 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       209 
622 
     | 
    
         
             
            var self=this;
         
     | 
| 
       210 
623 
     | 
    
         
             
            return smalltalk.send(self, "_select_", [(function(each){return smalltalk.send(smalltalk.send(aBlock, "_value_", [each]), "__eq", [false]);})]);
         
     | 
| 
         @@ -213,9 +626,9 @@ return self;} 
     | 
|
| 
       213 
626 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       214 
627 
     | 
    
         | 
| 
       215 
628 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       216 
     | 
    
         
            -
            '_select_',
         
     | 
| 
      
 629 
     | 
    
         
            +
            unescape('_select_'),
         
     | 
| 
       217 
630 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       218 
     | 
    
         
            -
            selector: 'select 
     | 
| 
      
 631 
     | 
    
         
            +
            selector: unescape('select%3A'),
         
     | 
| 
       219 
632 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       220 
633 
     | 
    
         
             
            var self=this;
         
     | 
| 
       221 
634 
     | 
    
         
             
            var stream=nil;
         
     | 
| 
         @@ -227,9 +640,9 @@ return self;} 
     | 
|
| 
       227 
640 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       228 
641 
     | 
    
         | 
| 
       229 
642 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       230 
     | 
    
         
            -
            '_errorNotFound',
         
     | 
| 
      
 643 
     | 
    
         
            +
            unescape('_errorNotFound'),
         
     | 
| 
       231 
644 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       232 
     | 
    
         
            -
            selector: 'errorNotFound',
         
     | 
| 
      
 645 
     | 
    
         
            +
            selector: unescape('errorNotFound'),
         
     | 
| 
       233 
646 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       234 
647 
     | 
    
         
             
            var self=this;
         
     | 
| 
       235 
648 
     | 
    
         
             
            smalltalk.send(self, "_error_", ["Object is not in the collection"]);
         
     | 
| 
         @@ -238,9 +651,9 @@ return self;} 
     | 
|
| 
       238 
651 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       239 
652 
     | 
    
         | 
| 
       240 
653 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       241 
     | 
    
         
            -
            '_includes_',
         
     | 
| 
      
 654 
     | 
    
         
            +
            unescape('_includes_'),
         
     | 
| 
       242 
655 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       243 
     | 
    
         
            -
            selector: 'includes 
     | 
| 
      
 656 
     | 
    
         
            +
            selector: unescape('includes%3A'),
         
     | 
| 
       244 
657 
     | 
    
         
             
            fn: function (anObject){
         
     | 
| 
       245 
658 
     | 
    
         
             
            var self=this;
         
     | 
| 
       246 
659 
     | 
    
         | 
| 
         @@ -255,9 +668,9 @@ return self;} 
     | 
|
| 
       255 
668 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       256 
669 
     | 
    
         | 
| 
       257 
670 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       258 
     | 
    
         
            -
            '_notEmpty',
         
     | 
| 
      
 671 
     | 
    
         
            +
            unescape('_notEmpty'),
         
     | 
| 
       259 
672 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       260 
     | 
    
         
            -
            selector: 'notEmpty',
         
     | 
| 
      
 673 
     | 
    
         
            +
            selector: unescape('notEmpty'),
         
     | 
| 
       261 
674 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       262 
675 
     | 
    
         
             
            var self=this;
         
     | 
| 
       263 
676 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_isEmpty", []), "_not", []);
         
     | 
| 
         @@ -266,9 +679,9 @@ return self;} 
     | 
|
| 
       266 
679 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       267 
680 
     | 
    
         | 
| 
       268 
681 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       269 
     | 
    
         
            -
            '_isEmpty',
         
     | 
| 
      
 682 
     | 
    
         
            +
            unescape('_isEmpty'),
         
     | 
| 
       270 
683 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       271 
     | 
    
         
            -
            selector: 'isEmpty',
         
     | 
| 
      
 684 
     | 
    
         
            +
            selector: unescape('isEmpty'),
         
     | 
| 
       272 
685 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       273 
686 
     | 
    
         
             
            var self=this;
         
     | 
| 
       274 
687 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_size", []), "__eq", [(0)]);
         
     | 
| 
         @@ -277,9 +690,9 @@ return self;} 
     | 
|
| 
       277 
690 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       278 
691 
     | 
    
         | 
| 
       279 
692 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       280 
     | 
    
         
            -
            '_remove_',
         
     | 
| 
      
 693 
     | 
    
         
            +
            unescape('_remove_'),
         
     | 
| 
       281 
694 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       282 
     | 
    
         
            -
            selector: 'remove 
     | 
| 
      
 695 
     | 
    
         
            +
            selector: unescape('remove%3A'),
         
     | 
| 
       283 
696 
     | 
    
         
             
            fn: function (anObject){
         
     | 
| 
       284 
697 
     | 
    
         
             
            var self=this;
         
     | 
| 
       285 
698 
     | 
    
         
             
            return smalltalk.send(self, "_remove_ifAbsent_", [anObject, (function(){return smalltalk.send(self, "_errorNotFound", []);})]);
         
     | 
| 
         @@ -288,9 +701,9 @@ return self;} 
     | 
|
| 
       288 
701 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       289 
702 
     | 
    
         | 
| 
       290 
703 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       291 
     | 
    
         
            -
            '_asSet',
         
     | 
| 
      
 704 
     | 
    
         
            +
            unescape('_asSet'),
         
     | 
| 
       292 
705 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       293 
     | 
    
         
            -
            selector: 'asSet',
         
     | 
| 
      
 706 
     | 
    
         
            +
            selector: unescape('asSet'),
         
     | 
| 
       294 
707 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       295 
708 
     | 
    
         
             
            var self=this;
         
     | 
| 
       296 
709 
     | 
    
         
             
            return smalltalk.send((smalltalk.Set || Set), "_withAll_", [self]);
         
     | 
| 
         @@ -299,9 +712,9 @@ return self;} 
     | 
|
| 
       299 
712 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       300 
713 
     | 
    
         | 
| 
       301 
714 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       302 
     | 
    
         
            -
            '_ifNotEmpty_',
         
     | 
| 
      
 715 
     | 
    
         
            +
            unescape('_ifNotEmpty_'),
         
     | 
| 
       303 
716 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       304 
     | 
    
         
            -
            selector: 'ifNotEmpty 
     | 
| 
      
 717 
     | 
    
         
            +
            selector: unescape('ifNotEmpty%3A'),
         
     | 
| 
       305 
718 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       306 
719 
     | 
    
         
             
            var self=this;
         
     | 
| 
       307 
720 
     | 
    
         
             
            smalltalk.send(smalltalk.send(self, "_notEmpty", []), "_ifTrue_", [aBlock]);
         
     | 
| 
         @@ -310,9 +723,9 @@ return self;} 
     | 
|
| 
       310 
723 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       311 
724 
     | 
    
         | 
| 
       312 
725 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       313 
     | 
    
         
            -
            '_ifEmpty_',
         
     | 
| 
      
 726 
     | 
    
         
            +
            unescape('_ifEmpty_'),
         
     | 
| 
       314 
727 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       315 
     | 
    
         
            -
            selector: 'ifEmpty 
     | 
| 
      
 728 
     | 
    
         
            +
            selector: unescape('ifEmpty%3A'),
         
     | 
| 
       316 
729 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       317 
730 
     | 
    
         
             
            var self=this;
         
     | 
| 
       318 
731 
     | 
    
         
             
            smalltalk.send(smalltalk.send(self, "_isEmpty", []), "_ifTrue_", [aBlock]);
         
     | 
| 
         @@ -321,9 +734,9 @@ return self;} 
     | 
|
| 
       321 
734 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       322 
735 
     | 
    
         | 
| 
       323 
736 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       324 
     | 
    
         
            -
            '_copyWithoutAll_',
         
     | 
| 
      
 737 
     | 
    
         
            +
            unescape('_copyWithoutAll_'),
         
     | 
| 
       325 
738 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       326 
     | 
    
         
            -
            selector: 'copyWithoutAll 
     | 
| 
      
 739 
     | 
    
         
            +
            selector: unescape('copyWithoutAll%3A'),
         
     | 
| 
       327 
740 
     | 
    
         
             
            fn: function (aCollection){
         
     | 
| 
       328 
741 
     | 
    
         
             
            var self=this;
         
     | 
| 
       329 
742 
     | 
    
         
             
            return smalltalk.send(self, "_reject_", [(function(each){return smalltalk.send(aCollection, "_includes_", [each]);})]);
         
     | 
| 
         @@ -332,9 +745,9 @@ return self;} 
     | 
|
| 
       332 
745 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       333 
746 
     | 
    
         | 
| 
       334 
747 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       335 
     | 
    
         
            -
            '_remove_ifAbsent_',
         
     | 
| 
      
 748 
     | 
    
         
            +
            unescape('_remove_ifAbsent_'),
         
     | 
| 
       336 
749 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       337 
     | 
    
         
            -
            selector: 'remove 
     | 
| 
      
 750 
     | 
    
         
            +
            selector: unescape('remove%3AifAbsent%3A'),
         
     | 
| 
       338 
751 
     | 
    
         
             
            fn: function (anObject, aBlock){
         
     | 
| 
       339 
752 
     | 
    
         
             
            var self=this;
         
     | 
| 
       340 
753 
     | 
    
         
             
            smalltalk.send(self, "_subclassResponsibility", []);
         
     | 
| 
         @@ -343,9 +756,9 @@ return self;} 
     | 
|
| 
       343 
756 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       344 
757 
     | 
    
         | 
| 
       345 
758 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       346 
     | 
    
         
            -
            '_asJSONString',
         
     | 
| 
      
 759 
     | 
    
         
            +
            unescape('_asJSONString'),
         
     | 
| 
       347 
760 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       348 
     | 
    
         
            -
            selector: 'asJSONString',
         
     | 
| 
      
 761 
     | 
    
         
            +
            selector: unescape('asJSONString'),
         
     | 
| 
       349 
762 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       350 
763 
     | 
    
         
             
            var self=this;
         
     | 
| 
       351 
764 
     | 
    
         
             
            return smalltalk.send((smalltalk.JSON || JSON), "_stringify_", [smalltalk.send(self, "_collect_", [(function(each){return smalltalk.send(each, "_asJSONString", []);})])]);
         
     | 
| 
         @@ -354,21 +767,21 @@ return self;} 
     | 
|
| 
       354 
767 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       355 
768 
     | 
    
         | 
| 
       356 
769 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       357 
     | 
    
         
            -
            '_asOrderedCollection',
         
     | 
| 
      
 770 
     | 
    
         
            +
            unescape('_asOrderedCollection'),
         
     | 
| 
       358 
771 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       359 
     | 
    
         
            -
            selector: 'asOrderedCollection',
         
     | 
| 
      
 772 
     | 
    
         
            +
            selector: unescape('asOrderedCollection'),
         
     | 
| 
       360 
773 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       361 
774 
     | 
    
         
             
            var self=this;
         
     | 
| 
       362 
     | 
    
         
            -
            return smalltalk.send( 
     | 
| 
      
 775 
     | 
    
         
            +
            return smalltalk.send(self, "_asArray", []);
         
     | 
| 
       363 
776 
     | 
    
         
             
            return self;}
         
     | 
| 
       364 
777 
     | 
    
         
             
            }),
         
     | 
| 
       365 
778 
     | 
    
         
             
            smalltalk.Collection);
         
     | 
| 
       366 
779 
     | 
    
         | 
| 
       367 
780 
     | 
    
         | 
| 
       368 
781 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       369 
     | 
    
         
            -
            '_streamClass',
         
     | 
| 
      
 782 
     | 
    
         
            +
            unescape('_streamClass'),
         
     | 
| 
       370 
783 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       371 
     | 
    
         
            -
            selector: 'streamClass',
         
     | 
| 
      
 784 
     | 
    
         
            +
            selector: unescape('streamClass'),
         
     | 
| 
       372 
785 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       373 
786 
     | 
    
         
             
            var self=this;
         
     | 
| 
       374 
787 
     | 
    
         
             
            return (smalltalk.Stream || Stream);
         
     | 
| 
         @@ -377,9 +790,9 @@ return self;} 
     | 
|
| 
       377 
790 
     | 
    
         
             
            smalltalk.Collection.klass);
         
     | 
| 
       378 
791 
     | 
    
         | 
| 
       379 
792 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       380 
     | 
    
         
            -
            '_with_',
         
     | 
| 
      
 793 
     | 
    
         
            +
            unescape('_with_'),
         
     | 
| 
       381 
794 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       382 
     | 
    
         
            -
            selector: 'with 
     | 
| 
      
 795 
     | 
    
         
            +
            selector: unescape('with%3A'),
         
     | 
| 
       383 
796 
     | 
    
         
             
            fn: function (anObject){
         
     | 
| 
       384 
797 
     | 
    
         
             
            var self=this;
         
     | 
| 
       385 
798 
     | 
    
         
             
            return (function($rec){smalltalk.send($rec, "_add_", [anObject]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new", []));
         
     | 
| 
         @@ -388,9 +801,9 @@ return self;} 
     | 
|
| 
       388 
801 
     | 
    
         
             
            smalltalk.Collection.klass);
         
     | 
| 
       389 
802 
     | 
    
         | 
| 
       390 
803 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       391 
     | 
    
         
            -
            '_with_with_',
         
     | 
| 
      
 804 
     | 
    
         
            +
            unescape('_with_with_'),
         
     | 
| 
       392 
805 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       393 
     | 
    
         
            -
            selector: 'with 
     | 
| 
      
 806 
     | 
    
         
            +
            selector: unescape('with%3Awith%3A'),
         
     | 
| 
       394 
807 
     | 
    
         
             
            fn: function (anObject, anotherObject){
         
     | 
| 
       395 
808 
     | 
    
         
             
            var self=this;
         
     | 
| 
       396 
809 
     | 
    
         
             
            return (function($rec){smalltalk.send($rec, "_add_", [anObject]);smalltalk.send($rec, "_add_", [anotherObject]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new", []));
         
     | 
| 
         @@ -399,9 +812,9 @@ return self;} 
     | 
|
| 
       399 
812 
     | 
    
         
             
            smalltalk.Collection.klass);
         
     | 
| 
       400 
813 
     | 
    
         | 
| 
       401 
814 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       402 
     | 
    
         
            -
            '_with_with_with_',
         
     | 
| 
      
 815 
     | 
    
         
            +
            unescape('_with_with_with_'),
         
     | 
| 
       403 
816 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       404 
     | 
    
         
            -
            selector: 'with 
     | 
| 
      
 817 
     | 
    
         
            +
            selector: unescape('with%3Awith%3Awith%3A'),
         
     | 
| 
       405 
818 
     | 
    
         
             
            fn: function (firstObject, secondObject, thirdObject){
         
     | 
| 
       406 
819 
     | 
    
         
             
            var self=this;
         
     | 
| 
       407 
820 
     | 
    
         
             
            return (function($rec){smalltalk.send($rec, "_add_", [firstObject]);smalltalk.send($rec, "_add_", [secondObject]);smalltalk.send($rec, "_add_", [thirdObject]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new", []));
         
     | 
| 
         @@ -410,9 +823,9 @@ return self;} 
     | 
|
| 
       410 
823 
     | 
    
         
             
            smalltalk.Collection.klass);
         
     | 
| 
       411 
824 
     | 
    
         | 
| 
       412 
825 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       413 
     | 
    
         
            -
            '_withAll_',
         
     | 
| 
      
 826 
     | 
    
         
            +
            unescape('_withAll_'),
         
     | 
| 
       414 
827 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       415 
     | 
    
         
            -
            selector: 'withAll 
     | 
| 
      
 828 
     | 
    
         
            +
            selector: unescape('withAll%3A'),
         
     | 
| 
       416 
829 
     | 
    
         
             
            fn: function (aCollection){
         
     | 
| 
       417 
830 
     | 
    
         
             
            var self=this;
         
     | 
| 
       418 
831 
     | 
    
         
             
            return (function($rec){smalltalk.send($rec, "_addAll_", [aCollection]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new", []));
         
     | 
| 
         @@ -421,9 +834,9 @@ return self;} 
     | 
|
| 
       421 
834 
     | 
    
         
             
            smalltalk.Collection.klass);
         
     | 
| 
       422 
835 
     | 
    
         | 
| 
       423 
836 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       424 
     | 
    
         
            -
            '_new_',
         
     | 
| 
      
 837 
     | 
    
         
            +
            unescape('_new_'),
         
     | 
| 
       425 
838 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       426 
     | 
    
         
            -
            selector: 'new 
     | 
| 
      
 839 
     | 
    
         
            +
            selector: unescape('new%3A'),
         
     | 
| 
       427 
840 
     | 
    
         
             
            fn: function (anInteger){
         
     | 
| 
       428 
841 
     | 
    
         
             
            var self=this;
         
     | 
| 
       429 
842 
     | 
    
         
             
            return smalltalk.send(self, "_new", []);
         
     | 
| 
         @@ -434,9 +847,9 @@ smalltalk.Collection.klass); 
     | 
|
| 
       434 
847 
     | 
    
         | 
| 
       435 
848 
     | 
    
         
             
            smalltalk.addClass('SequenceableCollection', smalltalk.Collection, [], 'Kernel-Collections');
         
     | 
| 
       436 
849 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       437 
     | 
    
         
            -
            '_at_',
         
     | 
| 
      
 850 
     | 
    
         
            +
            unescape('_at_'),
         
     | 
| 
       438 
851 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       439 
     | 
    
         
            -
            selector: 'at 
     | 
| 
      
 852 
     | 
    
         
            +
            selector: unescape('at%3A'),
         
     | 
| 
       440 
853 
     | 
    
         
             
            fn: function (anIndex){
         
     | 
| 
       441 
854 
     | 
    
         
             
            var self=this;
         
     | 
| 
       442 
855 
     | 
    
         
             
            return smalltalk.send(self, "_at_ifAbsent_", [anIndex, (function(){return smalltalk.send(self, "_errorNotFound", []);})]);
         
     | 
| 
         @@ -445,9 +858,9 @@ return self;} 
     | 
|
| 
       445 
858 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       446 
859 
     | 
    
         | 
| 
       447 
860 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       448 
     | 
    
         
            -
            '_at_ifAbsent_',
         
     | 
| 
      
 861 
     | 
    
         
            +
            unescape('_at_ifAbsent_'),
         
     | 
| 
       449 
862 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       450 
     | 
    
         
            -
            selector: 'at 
     | 
| 
      
 863 
     | 
    
         
            +
            selector: unescape('at%3AifAbsent%3A'),
         
     | 
| 
       451 
864 
     | 
    
         
             
            fn: function (anIndex, aBlock){
         
     | 
| 
       452 
865 
     | 
    
         
             
            var self=this;
         
     | 
| 
       453 
866 
     | 
    
         
             
            smalltalk.send(self, "_subclassResponsibility", []);
         
     | 
| 
         @@ -456,9 +869,9 @@ return self;} 
     | 
|
| 
       456 
869 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       457 
870 
     | 
    
         | 
| 
       458 
871 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       459 
     | 
    
         
            -
            '_at_put_',
         
     | 
| 
      
 872 
     | 
    
         
            +
            unescape('_at_put_'),
         
     | 
| 
       460 
873 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       461 
     | 
    
         
            -
            selector: 'at 
     | 
| 
      
 874 
     | 
    
         
            +
            selector: unescape('at%3Aput%3A'),
         
     | 
| 
       462 
875 
     | 
    
         
             
            fn: function (anIndex, anObject){
         
     | 
| 
       463 
876 
     | 
    
         
             
            var self=this;
         
     | 
| 
       464 
877 
     | 
    
         
             
            smalltalk.send(self, "_subclassResponsibility", []);
         
     | 
| 
         @@ -467,25 +880,25 @@ return self;} 
     | 
|
| 
       467 
880 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       468 
881 
     | 
    
         | 
| 
       469 
882 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       470 
     | 
    
         
            -
            '_copyFrom_to_',
         
     | 
| 
      
 883 
     | 
    
         
            +
            unescape('_copyFrom_to_'),
         
     | 
| 
       471 
884 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       472 
     | 
    
         
            -
            selector: 'copyFrom 
     | 
| 
      
 885 
     | 
    
         
            +
            selector: unescape('copyFrom%3Ato%3A'),
         
     | 
| 
       473 
886 
     | 
    
         
             
            fn: function (anIndex, anotherIndex){
         
     | 
| 
       474 
887 
     | 
    
         
             
            var self=this;
         
     | 
| 
       475 
888 
     | 
    
         
             
            var range=nil;
         
     | 
| 
       476 
889 
     | 
    
         
             
            var newCollection=nil;
         
     | 
| 
       477 
890 
     | 
    
         
             
            (range=smalltalk.send(anIndex, "_to_", [anotherIndex]));
         
     | 
| 
       478 
891 
     | 
    
         
             
            (newCollection=smalltalk.send(smalltalk.send(self, "_class", []), "_new_", [smalltalk.send(range, "_size", [])]));
         
     | 
| 
       479 
     | 
    
         
            -
            smalltalk.send(range, " 
     | 
| 
      
 892 
     | 
    
         
            +
            smalltalk.send(range, "_withIndexDo_", [(function(each, i){return smalltalk.send(newCollection, "_at_put_", [i, smalltalk.send(self, "_at_", [each])]);})]);
         
     | 
| 
       480 
893 
     | 
    
         
             
            return newCollection;
         
     | 
| 
       481 
894 
     | 
    
         
             
            return self;}
         
     | 
| 
       482 
895 
     | 
    
         
             
            }),
         
     | 
| 
       483 
896 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       484 
897 
     | 
    
         | 
| 
       485 
898 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       486 
     | 
    
         
            -
            '_first',
         
     | 
| 
      
 899 
     | 
    
         
            +
            unescape('_first'),
         
     | 
| 
       487 
900 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       488 
     | 
    
         
            -
            selector: 'first',
         
     | 
| 
      
 901 
     | 
    
         
            +
            selector: unescape('first'),
         
     | 
| 
       489 
902 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       490 
903 
     | 
    
         
             
            var self=this;
         
     | 
| 
       491 
904 
     | 
    
         
             
            return smalltalk.send(self, "_at_", [(1)]);
         
     | 
| 
         @@ -494,9 +907,9 @@ return self;} 
     | 
|
| 
       494 
907 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       495 
908 
     | 
    
         | 
| 
       496 
909 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       497 
     | 
    
         
            -
            '_fourth',
         
     | 
| 
      
 910 
     | 
    
         
            +
            unescape('_fourth'),
         
     | 
| 
       498 
911 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       499 
     | 
    
         
            -
            selector: 'fourth',
         
     | 
| 
      
 912 
     | 
    
         
            +
            selector: unescape('fourth'),
         
     | 
| 
       500 
913 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       501 
914 
     | 
    
         
             
            var self=this;
         
     | 
| 
       502 
915 
     | 
    
         
             
            return smalltalk.send(self, "_at_", [(4)]);
         
     | 
| 
         @@ -505,9 +918,9 @@ return self;} 
     | 
|
| 
       505 
918 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       506 
919 
     | 
    
         | 
| 
       507 
920 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       508 
     | 
    
         
            -
            '_last',
         
     | 
| 
      
 921 
     | 
    
         
            +
            unescape('_last'),
         
     | 
| 
       509 
922 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       510 
     | 
    
         
            -
            selector: 'last',
         
     | 
| 
      
 923 
     | 
    
         
            +
            selector: unescape('last'),
         
     | 
| 
       511 
924 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       512 
925 
     | 
    
         
             
            var self=this;
         
     | 
| 
       513 
926 
     | 
    
         
             
            return smalltalk.send(self, "_at_", [smalltalk.send(self, "_size", [])]);
         
     | 
| 
         @@ -516,9 +929,9 @@ return self;} 
     | 
|
| 
       516 
929 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       517 
930 
     | 
    
         | 
| 
       518 
931 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       519 
     | 
    
         
            -
            '_second',
         
     | 
| 
      
 932 
     | 
    
         
            +
            unescape('_second'),
         
     | 
| 
       520 
933 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       521 
     | 
    
         
            -
            selector: 'second',
         
     | 
| 
      
 934 
     | 
    
         
            +
            selector: unescape('second'),
         
     | 
| 
       522 
935 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       523 
936 
     | 
    
         
             
            var self=this;
         
     | 
| 
       524 
937 
     | 
    
         
             
            return smalltalk.send(self, "_at_", [(2)]);
         
     | 
| 
         @@ -527,9 +940,9 @@ return self;} 
     | 
|
| 
       527 
940 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       528 
941 
     | 
    
         | 
| 
       529 
942 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       530 
     | 
    
         
            -
            '_third',
         
     | 
| 
      
 943 
     | 
    
         
            +
            unescape('_third'),
         
     | 
| 
       531 
944 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       532 
     | 
    
         
            -
            selector: 'third',
         
     | 
| 
      
 945 
     | 
    
         
            +
            selector: unescape('third'),
         
     | 
| 
       533 
946 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       534 
947 
     | 
    
         
             
            var self=this;
         
     | 
| 
       535 
948 
     | 
    
         
             
            return smalltalk.send(self, "_at_", [(3)]);
         
     | 
| 
         @@ -538,9 +951,9 @@ return self;} 
     | 
|
| 
       538 
951 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       539 
952 
     | 
    
         | 
| 
       540 
953 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       541 
     | 
    
         
            -
            '_removeLast',
         
     | 
| 
      
 954 
     | 
    
         
            +
            unescape('_removeLast'),
         
     | 
| 
       542 
955 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       543 
     | 
    
         
            -
            selector: 'removeLast',
         
     | 
| 
      
 956 
     | 
    
         
            +
            selector: unescape('removeLast'),
         
     | 
| 
       544 
957 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       545 
958 
     | 
    
         
             
            var self=this;
         
     | 
| 
       546 
959 
     | 
    
         
             
            smalltalk.send(self, "_remove_", [smalltalk.send(self, "_last", [])]);
         
     | 
| 
         @@ -549,9 +962,9 @@ return self;} 
     | 
|
| 
       549 
962 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       550 
963 
     | 
    
         | 
| 
       551 
964 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       552 
     | 
    
         
            -
            '_addLast_',
         
     | 
| 
      
 965 
     | 
    
         
            +
            unescape('_addLast_'),
         
     | 
| 
       553 
966 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       554 
     | 
    
         
            -
            selector: 'addLast 
     | 
| 
      
 967 
     | 
    
         
            +
            selector: unescape('addLast%3A'),
         
     | 
| 
       555 
968 
     | 
    
         
             
            fn: function (anObject){
         
     | 
| 
       556 
969 
     | 
    
         
             
            var self=this;
         
     | 
| 
       557 
970 
     | 
    
         
             
            smalltalk.send(self, "_add_", [anObject]);
         
     | 
| 
         @@ -560,9 +973,9 @@ return self;} 
     | 
|
| 
       560 
973 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       561 
974 
     | 
    
         | 
| 
       562 
975 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       563 
     | 
    
         
            -
            '_withIndexDo_',
         
     | 
| 
      
 976 
     | 
    
         
            +
            unescape('_withIndexDo_'),
         
     | 
| 
       564 
977 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       565 
     | 
    
         
            -
            selector: 'withIndexDo 
     | 
| 
      
 978 
     | 
    
         
            +
            selector: unescape('withIndexDo%3A'),
         
     | 
| 
       566 
979 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       567 
980 
     | 
    
         
             
            var self=this;
         
     | 
| 
       568 
981 
     | 
    
         
             
            for(var i=0;i<self.length;i++){aBlock(self[i], i+1);};
         
     | 
| 
         @@ -571,9 +984,9 @@ return self;} 
     | 
|
| 
       571 
984 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       572 
985 
     | 
    
         | 
| 
       573 
986 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       574 
     | 
    
         
            -
            '_allButFirst',
         
     | 
| 
      
 987 
     | 
    
         
            +
            unescape('_allButFirst'),
         
     | 
| 
       575 
988 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       576 
     | 
    
         
            -
            selector: 'allButFirst',
         
     | 
| 
      
 989 
     | 
    
         
            +
            selector: unescape('allButFirst'),
         
     | 
| 
       577 
990 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       578 
991 
     | 
    
         
             
            var self=this;
         
     | 
| 
       579 
992 
     | 
    
         
             
            return smalltalk.send(self, "_copyFrom_to_", [(2), smalltalk.send(self, "_size", [])]);
         
     | 
| 
         @@ -582,9 +995,9 @@ return self;} 
     | 
|
| 
       582 
995 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       583 
996 
     | 
    
         | 
| 
       584 
997 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       585 
     | 
    
         
            -
            '_allButLast',
         
     | 
| 
      
 998 
     | 
    
         
            +
            unescape('_allButLast'),
         
     | 
| 
       586 
999 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       587 
     | 
    
         
            -
            selector: 'allButLast',
         
     | 
| 
      
 1000 
     | 
    
         
            +
            selector: unescape('allButLast'),
         
     | 
| 
       588 
1001 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       589 
1002 
     | 
    
         
             
            var self=this;
         
     | 
| 
       590 
1003 
     | 
    
         
             
            return smalltalk.send(self, "_copyFrom_to_", [(1), ((($receiver = smalltalk.send(self, "_size", [])).klass === smalltalk.Number) ? $receiver -(1) : smalltalk.send($receiver, "__minus", [(1)]))]);
         
     | 
| 
         @@ -593,9 +1006,9 @@ return self;} 
     | 
|
| 
       593 
1006 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       594 
1007 
     | 
    
         | 
| 
       595 
1008 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       596 
     | 
    
         
            -
            '_indexOf_',
         
     | 
| 
      
 1009 
     | 
    
         
            +
            unescape('_indexOf_'),
         
     | 
| 
       597 
1010 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       598 
     | 
    
         
            -
            selector: 'indexOf 
     | 
| 
      
 1011 
     | 
    
         
            +
            selector: unescape('indexOf%3A'),
         
     | 
| 
       599 
1012 
     | 
    
         
             
            fn: function (anObject){
         
     | 
| 
       600 
1013 
     | 
    
         
             
            var self=this;
         
     | 
| 
       601 
1014 
     | 
    
         
             
            return smalltalk.send(self, "_indexOf_ifAbsent_", [anObject, (function(){return smalltalk.send(self, "_errorNotFound", []);})]);
         
     | 
| 
         @@ -604,9 +1017,9 @@ return self;} 
     | 
|
| 
       604 
1017 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       605 
1018 
     | 
    
         | 
| 
       606 
1019 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       607 
     | 
    
         
            -
            '_indexOf_ifAbsent_',
         
     | 
| 
      
 1020 
     | 
    
         
            +
            unescape('_indexOf_ifAbsent_'),
         
     | 
| 
       608 
1021 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       609 
     | 
    
         
            -
            selector: 'indexOf 
     | 
| 
      
 1022 
     | 
    
         
            +
            selector: unescape('indexOf%3AifAbsent%3A'),
         
     | 
| 
       610 
1023 
     | 
    
         
             
            fn: function (anObject, aBlock){
         
     | 
| 
       611 
1024 
     | 
    
         
             
            var self=this;
         
     | 
| 
       612 
1025 
     | 
    
         | 
| 
         @@ -620,9 +1033,9 @@ return self;} 
     | 
|
| 
       620 
1033 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       621 
1034 
     | 
    
         | 
| 
       622 
1035 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       623 
     | 
    
         
            -
            '_indexOf_startingAt_ifAbsent_',
         
     | 
| 
      
 1036 
     | 
    
         
            +
            unescape('_indexOf_startingAt_ifAbsent_'),
         
     | 
| 
       624 
1037 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       625 
     | 
    
         
            -
            selector: 'indexOf 
     | 
| 
      
 1038 
     | 
    
         
            +
            selector: unescape('indexOf%3AstartingAt%3AifAbsent%3A'),
         
     | 
| 
       626 
1039 
     | 
    
         
             
            fn: function (anObject, start, aBlock){
         
     | 
| 
       627 
1040 
     | 
    
         
             
            var self=this;
         
     | 
| 
       628 
1041 
     | 
    
         | 
| 
         @@ -636,9 +1049,9 @@ return self;} 
     | 
|
| 
       636 
1049 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       637 
1050 
     | 
    
         | 
| 
       638 
1051 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       639 
     | 
    
         
            -
            '_indexOf_startingAt_',
         
     | 
| 
      
 1052 
     | 
    
         
            +
            unescape('_indexOf_startingAt_'),
         
     | 
| 
       640 
1053 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       641 
     | 
    
         
            -
            selector: 'indexOf 
     | 
| 
      
 1054 
     | 
    
         
            +
            selector: unescape('indexOf%3AstartingAt%3A'),
         
     | 
| 
       642 
1055 
     | 
    
         
             
            fn: function (anObject, start){
         
     | 
| 
       643 
1056 
     | 
    
         
             
            var self=this;
         
     | 
| 
       644 
1057 
     | 
    
         
             
            return smalltalk.send(self, "_indexOf_startingAt_ifAbsent_", [anObject, start, (function(){return (0);})]);
         
     | 
| 
         @@ -647,9 +1060,9 @@ return self;} 
     | 
|
| 
       647 
1060 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       648 
1061 
     | 
    
         | 
| 
       649 
1062 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       650 
     | 
    
         
            -
            '_reversed',
         
     | 
| 
      
 1063 
     | 
    
         
            +
            unescape('_reversed'),
         
     | 
| 
       651 
1064 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       652 
     | 
    
         
            -
            selector: 'reversed',
         
     | 
| 
      
 1065 
     | 
    
         
            +
            selector: unescape('reversed'),
         
     | 
| 
       653 
1066 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       654 
1067 
     | 
    
         
             
            var self=this;
         
     | 
| 
       655 
1068 
     | 
    
         
             
            smalltalk.send(self, "_subclassResponsibility", []);
         
     | 
| 
         @@ -658,9 +1071,9 @@ return self;} 
     | 
|
| 
       658 
1071 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       659 
1072 
     | 
    
         | 
| 
       660 
1073 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       661 
     | 
    
         
            -
            '_atRandom',
         
     | 
| 
      
 1074 
     | 
    
         
            +
            unescape('_atRandom'),
         
     | 
| 
       662 
1075 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       663 
     | 
    
         
            -
            selector: 'atRandom',
         
     | 
| 
      
 1076 
     | 
    
         
            +
            selector: unescape('atRandom'),
         
     | 
| 
       664 
1077 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       665 
1078 
     | 
    
         
             
            var self=this;
         
     | 
| 
       666 
1079 
     | 
    
         
             
            return smalltalk.send(self, "_at_", [smalltalk.send(smalltalk.send(self, "_size", []), "_atRandom", [])]);
         
     | 
| 
         @@ -669,9 +1082,9 @@ return self;} 
     | 
|
| 
       669 
1082 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       670 
1083 
     | 
    
         | 
| 
       671 
1084 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       672 
     | 
    
         
            -
            '__eq',
         
     | 
| 
      
 1085 
     | 
    
         
            +
            unescape('__eq'),
         
     | 
| 
       673 
1086 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       674 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 1087 
     | 
    
         
            +
            selector: unescape('%3D'),
         
     | 
| 
       675 
1088 
     | 
    
         
             
            fn: function (aCollection){
         
     | 
| 
       676 
1089 
     | 
    
         
             
            var self=this;
         
     | 
| 
       677 
1090 
     | 
    
         
             
            try{((($receiver = smalltalk.send(smalltalk.send(smalltalk.send(self, "_class", []), "__eq", [smalltalk.send(aCollection, "_class", [])]), "_and_", [(function(){return smalltalk.send(smalltalk.send(self, "_size", []), "__eq", [smalltalk.send(aCollection, "_size", [])]);})])).klass === smalltalk.Boolean) ? (! $receiver ? (function(){return (function(){throw({name: 'stReturn', selector: '__eq', fn: function(){return false}})})();})() : nil) : smalltalk.send($receiver, "_ifFalse_", [(function(){return (function(){throw({name: 'stReturn', selector: '__eq', fn: function(){return false}})})();})]));
         
     | 
| 
         @@ -683,9 +1096,9 @@ return self; 
     | 
|
| 
       683 
1096 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       684 
1097 
     | 
    
         | 
| 
       685 
1098 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       686 
     | 
    
         
            -
            '_shallowCopy',
         
     | 
| 
      
 1099 
     | 
    
         
            +
            unescape('_shallowCopy'),
         
     | 
| 
       687 
1100 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       688 
     | 
    
         
            -
            selector: 'shallowCopy',
         
     | 
| 
      
 1101 
     | 
    
         
            +
            selector: unescape('shallowCopy'),
         
     | 
| 
       689 
1102 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       690 
1103 
     | 
    
         
             
            var self=this;
         
     | 
| 
       691 
1104 
     | 
    
         
             
            var newCollection=nil;
         
     | 
| 
         @@ -697,9 +1110,9 @@ return self;} 
     | 
|
| 
       697 
1110 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       698 
1111 
     | 
    
         | 
| 
       699 
1112 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       700 
     | 
    
         
            -
            '_deepCopy',
         
     | 
| 
      
 1113 
     | 
    
         
            +
            unescape('_deepCopy'),
         
     | 
| 
       701 
1114 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       702 
     | 
    
         
            -
            selector: 'deepCopy',
         
     | 
| 
      
 1115 
     | 
    
         
            +
            selector: unescape('deepCopy'),
         
     | 
| 
       703 
1116 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       704 
1117 
     | 
    
         
             
            var self=this;
         
     | 
| 
       705 
1118 
     | 
    
         
             
            var newCollection=nil;
         
     | 
| 
         @@ -711,9 +1124,9 @@ return self;} 
     | 
|
| 
       711 
1124 
     | 
    
         
             
            smalltalk.SequenceableCollection);
         
     | 
| 
       712 
1125 
     | 
    
         | 
| 
       713 
1126 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       714 
     | 
    
         
            -
            '_printString',
         
     | 
| 
      
 1127 
     | 
    
         
            +
            unescape('_printString'),
         
     | 
| 
       715 
1128 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       716 
     | 
    
         
            -
            selector: 'printString',
         
     | 
| 
      
 1129 
     | 
    
         
            +
            selector: unescape('printString'),
         
     | 
| 
       717 
1130 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       718 
1131 
     | 
    
         
             
            var self=this;
         
     | 
| 
       719 
1132 
     | 
    
         
             
            var str=nil;
         
     | 
| 
         @@ -730,9 +1143,9 @@ smalltalk.SequenceableCollection); 
     | 
|
| 
       730 
1143 
     | 
    
         | 
| 
       731 
1144 
     | 
    
         
             
            smalltalk.addClass('CharacterArray', smalltalk.SequenceableCollection, [], 'Kernel-Collections');
         
     | 
| 
       732 
1145 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       733 
     | 
    
         
            -
            '_at_put_',
         
     | 
| 
      
 1146 
     | 
    
         
            +
            unescape('_at_put_'),
         
     | 
| 
       734 
1147 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       735 
     | 
    
         
            -
            selector: 'at 
     | 
| 
      
 1148 
     | 
    
         
            +
            selector: unescape('at%3Aput%3A'),
         
     | 
| 
       736 
1149 
     | 
    
         
             
            fn: function (anIndex, anObject){
         
     | 
| 
       737 
1150 
     | 
    
         
             
            var self=this;
         
     | 
| 
       738 
1151 
     | 
    
         
             
            smalltalk.send(self, "_errorReadOnly", []);
         
     | 
| 
         @@ -741,9 +1154,9 @@ return self;} 
     | 
|
| 
       741 
1154 
     | 
    
         
             
            smalltalk.CharacterArray);
         
     | 
| 
       742 
1155 
     | 
    
         | 
| 
       743 
1156 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       744 
     | 
    
         
            -
            '_add_',
         
     | 
| 
      
 1157 
     | 
    
         
            +
            unescape('_add_'),
         
     | 
| 
       745 
1158 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       746 
     | 
    
         
            -
            selector: 'add 
     | 
| 
      
 1159 
     | 
    
         
            +
            selector: unescape('add%3A'),
         
     | 
| 
       747 
1160 
     | 
    
         
             
            fn: function (anObject){
         
     | 
| 
       748 
1161 
     | 
    
         
             
            var self=this;
         
     | 
| 
       749 
1162 
     | 
    
         
             
            smalltalk.send(self, "_errorReadOnly", []);
         
     | 
| 
         @@ -752,9 +1165,9 @@ return self;} 
     | 
|
| 
       752 
1165 
     | 
    
         
             
            smalltalk.CharacterArray);
         
     | 
| 
       753 
1166 
     | 
    
         | 
| 
       754 
1167 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       755 
     | 
    
         
            -
            '__comma',
         
     | 
| 
      
 1168 
     | 
    
         
            +
            unescape('__comma'),
         
     | 
| 
       756 
1169 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       757 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 1170 
     | 
    
         
            +
            selector: unescape('%2C'),
         
     | 
| 
       758 
1171 
     | 
    
         
             
            fn: function (aString){
         
     | 
| 
       759 
1172 
     | 
    
         
             
            var self=this;
         
     | 
| 
       760 
1173 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_asString", []), "__comma", [smalltalk.send(aString, "_asString", [])]);
         
     | 
| 
         @@ -763,9 +1176,9 @@ return self;} 
     | 
|
| 
       763 
1176 
     | 
    
         
             
            smalltalk.CharacterArray);
         
     | 
| 
       764 
1177 
     | 
    
         | 
| 
       765 
1178 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       766 
     | 
    
         
            -
            '_asString',
         
     | 
| 
      
 1179 
     | 
    
         
            +
            unescape('_asString'),
         
     | 
| 
       767 
1180 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       768 
     | 
    
         
            -
            selector: 'asString',
         
     | 
| 
      
 1181 
     | 
    
         
            +
            selector: unescape('asString'),
         
     | 
| 
       769 
1182 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       770 
1183 
     | 
    
         
             
            var self=this;
         
     | 
| 
       771 
1184 
     | 
    
         
             
            return smalltalk.send(self, "_subclassResponsibility", []);
         
     | 
| 
         @@ -774,9 +1187,9 @@ return self;} 
     | 
|
| 
       774 
1187 
     | 
    
         
             
            smalltalk.CharacterArray);
         
     | 
| 
       775 
1188 
     | 
    
         | 
| 
       776 
1189 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       777 
     | 
    
         
            -
            '_asNumber',
         
     | 
| 
      
 1190 
     | 
    
         
            +
            unescape('_asNumber'),
         
     | 
| 
       778 
1191 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       779 
     | 
    
         
            -
            selector: 'asNumber',
         
     | 
| 
      
 1192 
     | 
    
         
            +
            selector: unescape('asNumber'),
         
     | 
| 
       780 
1193 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       781 
1194 
     | 
    
         
             
            var self=this;
         
     | 
| 
       782 
1195 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_asString", []), "_asNumber", []);
         
     | 
| 
         @@ -785,9 +1198,9 @@ return self;} 
     | 
|
| 
       785 
1198 
     | 
    
         
             
            smalltalk.CharacterArray);
         
     | 
| 
       786 
1199 
     | 
    
         | 
| 
       787 
1200 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       788 
     | 
    
         
            -
            '_errorReadOnly',
         
     | 
| 
      
 1201 
     | 
    
         
            +
            unescape('_errorReadOnly'),
         
     | 
| 
       789 
1202 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       790 
     | 
    
         
            -
            selector: 'errorReadOnly',
         
     | 
| 
      
 1203 
     | 
    
         
            +
            selector: unescape('errorReadOnly'),
         
     | 
| 
       791 
1204 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       792 
1205 
     | 
    
         
             
            var self=this;
         
     | 
| 
       793 
1206 
     | 
    
         
             
            smalltalk.send(self, "_error_", [unescape("Object%20is%20read-only")]);
         
     | 
| 
         @@ -796,9 +1209,9 @@ return self;} 
     | 
|
| 
       796 
1209 
     | 
    
         
             
            smalltalk.CharacterArray);
         
     | 
| 
       797 
1210 
     | 
    
         | 
| 
       798 
1211 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       799 
     | 
    
         
            -
            '_printString',
         
     | 
| 
      
 1212 
     | 
    
         
            +
            unescape('_printString'),
         
     | 
| 
       800 
1213 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       801 
     | 
    
         
            -
            selector: 'printString',
         
     | 
| 
      
 1214 
     | 
    
         
            +
            selector: unescape('printString'),
         
     | 
| 
       802 
1215 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       803 
1216 
     | 
    
         
             
            var self=this;
         
     | 
| 
       804 
1217 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_asString", []), "_printString", []);
         
     | 
| 
         @@ -807,9 +1220,9 @@ return self;} 
     | 
|
| 
       807 
1220 
     | 
    
         
             
            smalltalk.CharacterArray);
         
     | 
| 
       808 
1221 
     | 
    
         | 
| 
       809 
1222 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       810 
     | 
    
         
            -
            '_remove_',
         
     | 
| 
      
 1223 
     | 
    
         
            +
            unescape('_remove_'),
         
     | 
| 
       811 
1224 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       812 
     | 
    
         
            -
            selector: 'remove 
     | 
| 
      
 1225 
     | 
    
         
            +
            selector: unescape('remove%3A'),
         
     | 
| 
       813 
1226 
     | 
    
         
             
            fn: function (anObject){
         
     | 
| 
       814 
1227 
     | 
    
         
             
            var self=this;
         
     | 
| 
       815 
1228 
     | 
    
         
             
            smalltalk.send(self, "_errorReadOnly", []);
         
     | 
| 
         @@ -818,9 +1231,9 @@ return self;} 
     | 
|
| 
       818 
1231 
     | 
    
         
             
            smalltalk.CharacterArray);
         
     | 
| 
       819 
1232 
     | 
    
         | 
| 
       820 
1233 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       821 
     | 
    
         
            -
            '_asUppercase',
         
     | 
| 
      
 1234 
     | 
    
         
            +
            unescape('_asUppercase'),
         
     | 
| 
       822 
1235 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       823 
     | 
    
         
            -
            selector: 'asUppercase',
         
     | 
| 
      
 1236 
     | 
    
         
            +
            selector: unescape('asUppercase'),
         
     | 
| 
       824 
1237 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       825 
1238 
     | 
    
         
             
            var self=this;
         
     | 
| 
       826 
1239 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_class", []), "_fromString_", [smalltalk.send(smalltalk.send(self, "_asString", []), "_asUppercase", [])]);
         
     | 
| 
         @@ -829,9 +1242,9 @@ return self;} 
     | 
|
| 
       829 
1242 
     | 
    
         
             
            smalltalk.CharacterArray);
         
     | 
| 
       830 
1243 
     | 
    
         | 
| 
       831 
1244 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       832 
     | 
    
         
            -
            '_asSymbol',
         
     | 
| 
      
 1245 
     | 
    
         
            +
            unescape('_asSymbol'),
         
     | 
| 
       833 
1246 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       834 
     | 
    
         
            -
            selector: 'asSymbol',
         
     | 
| 
      
 1247 
     | 
    
         
            +
            selector: unescape('asSymbol'),
         
     | 
| 
       835 
1248 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       836 
1249 
     | 
    
         
             
            var self=this;
         
     | 
| 
       837 
1250 
     | 
    
         
             
            return smalltalk.send(self, "_subclassResponsibility", []);
         
     | 
| 
         @@ -840,9 +1253,9 @@ return self;} 
     | 
|
| 
       840 
1253 
     | 
    
         
             
            smalltalk.CharacterArray);
         
     | 
| 
       841 
1254 
     | 
    
         | 
| 
       842 
1255 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       843 
     | 
    
         
            -
            '_asLowercase',
         
     | 
| 
      
 1256 
     | 
    
         
            +
            unescape('_asLowercase'),
         
     | 
| 
       844 
1257 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       845 
     | 
    
         
            -
            selector: 'asLowercase',
         
     | 
| 
      
 1258 
     | 
    
         
            +
            selector: unescape('asLowercase'),
         
     | 
| 
       846 
1259 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       847 
1260 
     | 
    
         
             
            var self=this;
         
     | 
| 
       848 
1261 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_class", []), "_fromString_", [smalltalk.send(smalltalk.send(self, "_asString", []), "_asLowercase", [])]);
         
     | 
| 
         @@ -852,9 +1265,9 @@ smalltalk.CharacterArray); 
     | 
|
| 
       852 
1265 
     | 
    
         | 
| 
       853 
1266 
     | 
    
         | 
| 
       854 
1267 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       855 
     | 
    
         
            -
            '_fromString_',
         
     | 
| 
      
 1268 
     | 
    
         
            +
            unescape('_fromString_'),
         
     | 
| 
       856 
1269 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       857 
     | 
    
         
            -
            selector: 'fromString 
     | 
| 
      
 1270 
     | 
    
         
            +
            selector: unescape('fromString%3A'),
         
     | 
| 
       858 
1271 
     | 
    
         
             
            fn: function (aString){
         
     | 
| 
       859 
1272 
     | 
    
         
             
            var self=this;
         
     | 
| 
       860 
1273 
     | 
    
         
             
            smalltalk.send(self, "_subclassResponsibility", []);
         
     | 
| 
         @@ -865,9 +1278,9 @@ smalltalk.CharacterArray.klass); 
     | 
|
| 
       865 
1278 
     | 
    
         | 
| 
       866 
1279 
     | 
    
         
             
            smalltalk.addClass('String', smalltalk.CharacterArray, [], 'Kernel-Collections');
         
     | 
| 
       867 
1280 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       868 
     | 
    
         
            -
            '__eq',
         
     | 
| 
      
 1281 
     | 
    
         
            +
            unescape('__eq'),
         
     | 
| 
       869 
1282 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       870 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 1283 
     | 
    
         
            +
            selector: unescape('%3D'),
         
     | 
| 
       871 
1284 
     | 
    
         
             
            fn: function (aString){
         
     | 
| 
       872 
1285 
     | 
    
         
             
            var self=this;
         
     | 
| 
       873 
1286 
     | 
    
         
             
            try{((($receiver = smalltalk.send(smalltalk.send(aString, "_class", []), "__eq", [smalltalk.send(self, "_class", [])])).klass === smalltalk.Boolean) ? (! $receiver ? (function(){return (function(){throw({name: 'stReturn', selector: '__eq', fn: function(){return false}})})();})() : nil) : smalltalk.send($receiver, "_ifFalse_", [(function(){return (function(){throw({name: 'stReturn', selector: '__eq', fn: function(){return false}})})();})]));
         
     | 
| 
         @@ -878,9 +1291,9 @@ return self; 
     | 
|
| 
       878 
1291 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       879 
1292 
     | 
    
         | 
| 
       880 
1293 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       881 
     | 
    
         
            -
            '_size',
         
     | 
| 
      
 1294 
     | 
    
         
            +
            unescape('_size'),
         
     | 
| 
       882 
1295 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       883 
     | 
    
         
            -
            selector: 'size',
         
     | 
| 
      
 1296 
     | 
    
         
            +
            selector: unescape('size'),
         
     | 
| 
       884 
1297 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       885 
1298 
     | 
    
         
             
            var self=this;
         
     | 
| 
       886 
1299 
     | 
    
         
             
            return self.length;
         
     | 
| 
         @@ -889,9 +1302,9 @@ return self;} 
     | 
|
| 
       889 
1302 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       890 
1303 
     | 
    
         | 
| 
       891 
1304 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       892 
     | 
    
         
            -
            '_at_ifAbsent_',
         
     | 
| 
      
 1305 
     | 
    
         
            +
            unescape('_at_ifAbsent_'),
         
     | 
| 
       893 
1306 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       894 
     | 
    
         
            -
            selector: 'at 
     | 
| 
      
 1307 
     | 
    
         
            +
            selector: unescape('at%3AifAbsent%3A'),
         
     | 
| 
       895 
1308 
     | 
    
         
             
            fn: function (anIndex, aBlock){
         
     | 
| 
       896 
1309 
     | 
    
         
             
            var self=this;
         
     | 
| 
       897 
1310 
     | 
    
         
             
            return self[anIndex - 1] || aBlock();
         
     | 
| 
         @@ -900,9 +1313,9 @@ return self;} 
     | 
|
| 
       900 
1313 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       901 
1314 
     | 
    
         | 
| 
       902 
1315 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       903 
     | 
    
         
            -
            '_escaped',
         
     | 
| 
      
 1316 
     | 
    
         
            +
            unescape('_escaped'),
         
     | 
| 
       904 
1317 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       905 
     | 
    
         
            -
            selector: 'escaped',
         
     | 
| 
      
 1318 
     | 
    
         
            +
            selector: unescape('escaped'),
         
     | 
| 
       906 
1319 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       907 
1320 
     | 
    
         
             
            var self=this;
         
     | 
| 
       908 
1321 
     | 
    
         
             
            return escape(self);
         
     | 
| 
         @@ -911,9 +1324,9 @@ return self;} 
     | 
|
| 
       911 
1324 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       912 
1325 
     | 
    
         | 
| 
       913 
1326 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       914 
     | 
    
         
            -
            '_unescaped',
         
     | 
| 
      
 1327 
     | 
    
         
            +
            unescape('_unescaped'),
         
     | 
| 
       915 
1328 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       916 
     | 
    
         
            -
            selector: 'unescaped',
         
     | 
| 
      
 1329 
     | 
    
         
            +
            selector: unescape('unescaped'),
         
     | 
| 
       917 
1330 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       918 
1331 
     | 
    
         
             
            var self=this;
         
     | 
| 
       919 
1332 
     | 
    
         
             
            return unescape(self);
         
     | 
| 
         @@ -922,9 +1335,9 @@ return self;} 
     | 
|
| 
       922 
1335 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       923 
1336 
     | 
    
         | 
| 
       924 
1337 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       925 
     | 
    
         
            -
            '__comma',
         
     | 
| 
      
 1338 
     | 
    
         
            +
            unescape('__comma'),
         
     | 
| 
       926 
1339 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       927 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 1340 
     | 
    
         
            +
            selector: unescape('%2C'),
         
     | 
| 
       928 
1341 
     | 
    
         
             
            fn: function (aString){
         
     | 
| 
       929 
1342 
     | 
    
         
             
            var self=this;
         
     | 
| 
       930 
1343 
     | 
    
         
             
            return self + aString;
         
     | 
| 
         @@ -933,9 +1346,9 @@ return self;} 
     | 
|
| 
       933 
1346 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       934 
1347 
     | 
    
         | 
| 
       935 
1348 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       936 
     | 
    
         
            -
            '_copyFrom_to_',
         
     | 
| 
      
 1349 
     | 
    
         
            +
            unescape('_copyFrom_to_'),
         
     | 
| 
       937 
1350 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       938 
     | 
    
         
            -
            selector: 'copyFrom 
     | 
| 
      
 1351 
     | 
    
         
            +
            selector: unescape('copyFrom%3Ato%3A'),
         
     | 
| 
       939 
1352 
     | 
    
         
             
            fn: function (anIndex, anotherIndex){
         
     | 
| 
       940 
1353 
     | 
    
         
             
            var self=this;
         
     | 
| 
       941 
1354 
     | 
    
         
             
            return self.substring(anIndex - 1, anotherIndex);
         
     | 
| 
         @@ -944,9 +1357,9 @@ return self;} 
     | 
|
| 
       944 
1357 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       945 
1358 
     | 
    
         | 
| 
       946 
1359 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       947 
     | 
    
         
            -
            '_shallowCopy',
         
     | 
| 
      
 1360 
     | 
    
         
            +
            unescape('_shallowCopy'),
         
     | 
| 
       948 
1361 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       949 
     | 
    
         
            -
            selector: 'shallowCopy',
         
     | 
| 
      
 1362 
     | 
    
         
            +
            selector: unescape('shallowCopy'),
         
     | 
| 
       950 
1363 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       951 
1364 
     | 
    
         
             
            var self=this;
         
     | 
| 
       952 
1365 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_class", []), "_fromString_", [self]);
         
     | 
| 
         @@ -955,9 +1368,9 @@ return self;} 
     | 
|
| 
       955 
1368 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       956 
1369 
     | 
    
         | 
| 
       957 
1370 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       958 
     | 
    
         
            -
            '_deepCopy',
         
     | 
| 
      
 1371 
     | 
    
         
            +
            unescape('_deepCopy'),
         
     | 
| 
       959 
1372 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       960 
     | 
    
         
            -
            selector: 'deepCopy',
         
     | 
| 
      
 1373 
     | 
    
         
            +
            selector: unescape('deepCopy'),
         
     | 
| 
       961 
1374 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       962 
1375 
     | 
    
         
             
            var self=this;
         
     | 
| 
       963 
1376 
     | 
    
         
             
            return smalltalk.send(self, "_shallowCopy", []);
         
     | 
| 
         @@ -966,9 +1379,9 @@ return self;} 
     | 
|
| 
       966 
1379 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       967 
1380 
     | 
    
         | 
| 
       968 
1381 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       969 
     | 
    
         
            -
            '_asSelector',
         
     | 
| 
      
 1382 
     | 
    
         
            +
            unescape('_asSelector'),
         
     | 
| 
       970 
1383 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       971 
     | 
    
         
            -
            selector: 'asSelector',
         
     | 
| 
      
 1384 
     | 
    
         
            +
            selector: unescape('asSelector'),
         
     | 
| 
       972 
1385 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       973 
1386 
     | 
    
         
             
            var self=this;
         
     | 
| 
       974 
1387 
     | 
    
         
             
            var selector=nil;
         
     | 
| 
         @@ -989,9 +1402,9 @@ return self;} 
     | 
|
| 
       989 
1402 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       990 
1403 
     | 
    
         | 
| 
       991 
1404 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       992 
     | 
    
         
            -
            '_asJavascript',
         
     | 
| 
      
 1405 
     | 
    
         
            +
            unescape('_asJavascript'),
         
     | 
| 
       993 
1406 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       994 
     | 
    
         
            -
            selector: 'asJavascript',
         
     | 
| 
      
 1407 
     | 
    
         
            +
            selector: unescape('asJavascript'),
         
     | 
| 
       995 
1408 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       996 
1409 
     | 
    
         
             
            var self=this;
         
     | 
| 
       997 
1410 
     | 
    
         | 
| 
         @@ -1005,9 +1418,9 @@ return self;} 
     | 
|
| 
       1005 
1418 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1006 
1419 
     | 
    
         | 
| 
       1007 
1420 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1008 
     | 
    
         
            -
            '_replace_with_',
         
     | 
| 
      
 1421 
     | 
    
         
            +
            unescape('_replace_with_'),
         
     | 
| 
       1009 
1422 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1010 
     | 
    
         
            -
            selector: 'replace 
     | 
| 
      
 1423 
     | 
    
         
            +
            selector: unescape('replace%3Awith%3A'),
         
     | 
| 
       1011 
1424 
     | 
    
         
             
            fn: function (aString, anotherString){
         
     | 
| 
       1012 
1425 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1013 
1426 
     | 
    
         
             
            return smalltalk.send(self, "_replaceRegexp_with_", [smalltalk.send((smalltalk.RegularExpression || RegularExpression), "_fromString_flag_", [aString, "g"]), anotherString]);
         
     | 
| 
         @@ -1016,9 +1429,9 @@ return self;} 
     | 
|
| 
       1016 
1429 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1017 
1430 
     | 
    
         | 
| 
       1018 
1431 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1019 
     | 
    
         
            -
            '_replaceRegexp_with_',
         
     | 
| 
      
 1432 
     | 
    
         
            +
            unescape('_replaceRegexp_with_'),
         
     | 
| 
       1020 
1433 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1021 
     | 
    
         
            -
            selector: 'replaceRegexp 
     | 
| 
      
 1434 
     | 
    
         
            +
            selector: unescape('replaceRegexp%3Awith%3A'),
         
     | 
| 
       1022 
1435 
     | 
    
         
             
            fn: function (aRegexp, aString){
         
     | 
| 
       1023 
1436 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1024 
1437 
     | 
    
         
             
            return self.replace(aRegexp, aString);
         
     | 
| 
         @@ -1027,9 +1440,9 @@ return self;} 
     | 
|
| 
       1027 
1440 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1028 
1441 
     | 
    
         | 
| 
       1029 
1442 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1030 
     | 
    
         
            -
            '_tokenize_',
         
     | 
| 
      
 1443 
     | 
    
         
            +
            unescape('_tokenize_'),
         
     | 
| 
       1031 
1444 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1032 
     | 
    
         
            -
            selector: 'tokenize 
     | 
| 
      
 1445 
     | 
    
         
            +
            selector: unescape('tokenize%3A'),
         
     | 
| 
       1033 
1446 
     | 
    
         
             
            fn: function (aString){
         
     | 
| 
       1034 
1447 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1035 
1448 
     | 
    
         
             
            return self.split(aString);
         
     | 
| 
         @@ -1038,9 +1451,9 @@ return self;} 
     | 
|
| 
       1038 
1451 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1039 
1452 
     | 
    
         | 
| 
       1040 
1453 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1041 
     | 
    
         
            -
            '_match_',
         
     | 
| 
      
 1454 
     | 
    
         
            +
            unescape('_match_'),
         
     | 
| 
       1042 
1455 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1043 
     | 
    
         
            -
            selector: 'match 
     | 
| 
      
 1456 
     | 
    
         
            +
            selector: unescape('match%3A'),
         
     | 
| 
       1044 
1457 
     | 
    
         
             
            fn: function (aRegexp){
         
     | 
| 
       1045 
1458 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1046 
1459 
     | 
    
         
             
            return self.search(aRegexp) != -1;
         
     | 
| 
         @@ -1049,9 +1462,9 @@ return self;} 
     | 
|
| 
       1049 
1462 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1050 
1463 
     | 
    
         | 
| 
       1051 
1464 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1052 
     | 
    
         
            -
            '_asString',
         
     | 
| 
      
 1465 
     | 
    
         
            +
            unescape('_asString'),
         
     | 
| 
       1053 
1466 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1054 
     | 
    
         
            -
            selector: 'asString',
         
     | 
| 
      
 1467 
     | 
    
         
            +
            selector: unescape('asString'),
         
     | 
| 
       1055 
1468 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1056 
1469 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1057 
1470 
     | 
    
         
             
            return self;
         
     | 
| 
         @@ -1060,9 +1473,9 @@ return self;} 
     | 
|
| 
       1060 
1473 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1061 
1474 
     | 
    
         | 
| 
       1062 
1475 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1063 
     | 
    
         
            -
            '_asNumber',
         
     | 
| 
      
 1476 
     | 
    
         
            +
            unescape('_asNumber'),
         
     | 
| 
       1064 
1477 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1065 
     | 
    
         
            -
            selector: 'asNumber',
         
     | 
| 
      
 1478 
     | 
    
         
            +
            selector: unescape('asNumber'),
         
     | 
| 
       1066 
1479 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1067 
1480 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1068 
1481 
     | 
    
         
             
            return Number(self);
         
     | 
| 
         @@ -1071,9 +1484,9 @@ return self;} 
     | 
|
| 
       1071 
1484 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1072 
1485 
     | 
    
         | 
| 
       1073 
1486 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1074 
     | 
    
         
            -
            '_printString',
         
     | 
| 
      
 1487 
     | 
    
         
            +
            unescape('_printString'),
         
     | 
| 
       1075 
1488 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1076 
     | 
    
         
            -
            selector: 'printString',
         
     | 
| 
      
 1489 
     | 
    
         
            +
            selector: unescape('printString'),
         
     | 
| 
       1077 
1490 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1078 
1491 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1079 
1492 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(unescape("%27"), "__comma", [self]), "__comma", [unescape("%27")]);
         
     | 
| 
         @@ -1082,9 +1495,9 @@ return self;} 
     | 
|
| 
       1082 
1495 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1083 
1496 
     | 
    
         | 
| 
       1084 
1497 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1085 
     | 
    
         
            -
            '_printNl',
         
     | 
| 
      
 1498 
     | 
    
         
            +
            unescape('_printNl'),
         
     | 
| 
       1086 
1499 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1087 
     | 
    
         
            -
            selector: 'printNl',
         
     | 
| 
      
 1500 
     | 
    
         
            +
            selector: unescape('printNl'),
         
     | 
| 
       1088 
1501 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1089 
1502 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1090 
1503 
     | 
    
         
             
            console.log(self);
         
     | 
| 
         @@ -1093,9 +1506,9 @@ return self;} 
     | 
|
| 
       1093 
1506 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1094 
1507 
     | 
    
         | 
| 
       1095 
1508 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1096 
     | 
    
         
            -
            '_isString',
         
     | 
| 
      
 1509 
     | 
    
         
            +
            unescape('_isString'),
         
     | 
| 
       1097 
1510 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1098 
     | 
    
         
            -
            selector: 'isString',
         
     | 
| 
      
 1511 
     | 
    
         
            +
            selector: unescape('isString'),
         
     | 
| 
       1099 
1512 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1100 
1513 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1101 
1514 
     | 
    
         
             
            return true;
         
     | 
| 
         @@ -1104,9 +1517,9 @@ return self;} 
     | 
|
| 
       1104 
1517 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1105 
1518 
     | 
    
         | 
| 
       1106 
1519 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1107 
     | 
    
         
            -
            '__gt',
         
     | 
| 
      
 1520 
     | 
    
         
            +
            unescape('__gt'),
         
     | 
| 
       1108 
1521 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1109 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 1522 
     | 
    
         
            +
            selector: unescape('%3E'),
         
     | 
| 
       1110 
1523 
     | 
    
         
             
            fn: function (aString){
         
     | 
| 
       1111 
1524 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1112 
1525 
     | 
    
         
             
            return String(self) > aString._asString();
         
     | 
| 
         @@ -1115,9 +1528,9 @@ return self;} 
     | 
|
| 
       1115 
1528 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1116 
1529 
     | 
    
         | 
| 
       1117 
1530 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1118 
     | 
    
         
            -
            '__lt',
         
     | 
| 
      
 1531 
     | 
    
         
            +
            unescape('__lt'),
         
     | 
| 
       1119 
1532 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1120 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 1533 
     | 
    
         
            +
            selector: unescape('%3C'),
         
     | 
| 
       1121 
1534 
     | 
    
         
             
            fn: function (aString){
         
     | 
| 
       1122 
1535 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1123 
1536 
     | 
    
         
             
            return String(self) < aString._asString();
         
     | 
| 
         @@ -1126,9 +1539,9 @@ return self;} 
     | 
|
| 
       1126 
1539 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1127 
1540 
     | 
    
         | 
| 
       1128 
1541 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1129 
     | 
    
         
            -
            '__gt_eq',
         
     | 
| 
      
 1542 
     | 
    
         
            +
            unescape('__gt_eq'),
         
     | 
| 
       1130 
1543 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1131 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 1544 
     | 
    
         
            +
            selector: unescape('%3E%3D'),
         
     | 
| 
       1132 
1545 
     | 
    
         
             
            fn: function (aString){
         
     | 
| 
       1133 
1546 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1134 
1547 
     | 
    
         
             
            return String(self) >= aString._asString();
         
     | 
| 
         @@ -1137,9 +1550,9 @@ return self;} 
     | 
|
| 
       1137 
1550 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1138 
1551 
     | 
    
         | 
| 
       1139 
1552 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1140 
     | 
    
         
            -
            '__lt_eq',
         
     | 
| 
      
 1553 
     | 
    
         
            +
            unescape('__lt_eq'),
         
     | 
| 
       1141 
1554 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1142 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 1555 
     | 
    
         
            +
            selector: unescape('%3C%3D'),
         
     | 
| 
       1143 
1556 
     | 
    
         
             
            fn: function (aString){
         
     | 
| 
       1144 
1557 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1145 
1558 
     | 
    
         
             
            return String(self) <= aString._asString();
         
     | 
| 
         @@ -1148,9 +1561,9 @@ return self;} 
     | 
|
| 
       1148 
1561 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1149 
1562 
     | 
    
         | 
| 
       1150 
1563 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1151 
     | 
    
         
            -
            '_trimLeft_',
         
     | 
| 
      
 1564 
     | 
    
         
            +
            unescape('_trimLeft_'),
         
     | 
| 
       1152 
1565 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1153 
     | 
    
         
            -
            selector: 'trimLeft 
     | 
| 
      
 1566 
     | 
    
         
            +
            selector: unescape('trimLeft%3A'),
         
     | 
| 
       1154 
1567 
     | 
    
         
             
            fn: function (separators){
         
     | 
| 
       1155 
1568 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1156 
1569 
     | 
    
         
             
            return smalltalk.send(self, "_replaceRegexp_with_", [smalltalk.send((smalltalk.RegularExpression || RegularExpression), "_fromString_flag_", [smalltalk.send(smalltalk.send(unescape("%5E%5B"), "__comma", [separators]), "__comma", [unescape("%5D+")]), "g"]), ""]);
         
     | 
| 
         @@ -1159,9 +1572,9 @@ return self;} 
     | 
|
| 
       1159 
1572 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1160 
1573 
     | 
    
         | 
| 
       1161 
1574 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1162 
     | 
    
         
            -
            '_trimRight_',
         
     | 
| 
      
 1575 
     | 
    
         
            +
            unescape('_trimRight_'),
         
     | 
| 
       1163 
1576 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1164 
     | 
    
         
            -
            selector: 'trimRight 
     | 
| 
      
 1577 
     | 
    
         
            +
            selector: unescape('trimRight%3A'),
         
     | 
| 
       1165 
1578 
     | 
    
         
             
            fn: function (separators){
         
     | 
| 
       1166 
1579 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1167 
1580 
     | 
    
         
             
            return smalltalk.send(self, "_replaceRegexp_with_", [smalltalk.send((smalltalk.RegularExpression || RegularExpression), "_fromString_flag_", [smalltalk.send(smalltalk.send(unescape("%5B"), "__comma", [separators]), "__comma", [unescape("%5D+%24")]), "g"]), ""]);
         
     | 
| 
         @@ -1170,9 +1583,9 @@ return self;} 
     | 
|
| 
       1170 
1583 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1171 
1584 
     | 
    
         | 
| 
       1172 
1585 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1173 
     | 
    
         
            -
            '_trimLeft',
         
     | 
| 
      
 1586 
     | 
    
         
            +
            unescape('_trimLeft'),
         
     | 
| 
       1174 
1587 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1175 
     | 
    
         
            -
            selector: 'trimLeft',
         
     | 
| 
      
 1588 
     | 
    
         
            +
            selector: unescape('trimLeft'),
         
     | 
| 
       1176 
1589 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1177 
1590 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1178 
1591 
     | 
    
         
             
            return smalltalk.send(self, "_trimLeft_", [unescape("%5Cs")]);
         
     | 
| 
         @@ -1181,9 +1594,9 @@ return self;} 
     | 
|
| 
       1181 
1594 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1182 
1595 
     | 
    
         | 
| 
       1183 
1596 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1184 
     | 
    
         
            -
            '_trimRight',
         
     | 
| 
      
 1597 
     | 
    
         
            +
            unescape('_trimRight'),
         
     | 
| 
       1185 
1598 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1186 
     | 
    
         
            -
            selector: 'trimRight',
         
     | 
| 
      
 1599 
     | 
    
         
            +
            selector: unescape('trimRight'),
         
     | 
| 
       1187 
1600 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1188 
1601 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1189 
1602 
     | 
    
         
             
            return smalltalk.send(self, "_trimRight_", [unescape("%5Cs")]);
         
     | 
| 
         @@ -1192,9 +1605,9 @@ return self;} 
     | 
|
| 
       1192 
1605 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1193 
1606 
     | 
    
         | 
| 
       1194 
1607 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1195 
     | 
    
         
            -
            '_trimBoth',
         
     | 
| 
      
 1608 
     | 
    
         
            +
            unescape('_trimBoth'),
         
     | 
| 
       1196 
1609 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1197 
     | 
    
         
            -
            selector: 'trimBoth',
         
     | 
| 
      
 1610 
     | 
    
         
            +
            selector: unescape('trimBoth'),
         
     | 
| 
       1198 
1611 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1199 
1612 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1200 
1613 
     | 
    
         
             
            return smalltalk.send(self, "_trimBoth_", [unescape("%5Cs")]);
         
     | 
| 
         @@ -1203,9 +1616,9 @@ return self;} 
     | 
|
| 
       1203 
1616 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1204 
1617 
     | 
    
         | 
| 
       1205 
1618 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1206 
     | 
    
         
            -
            '_trimBoth_',
         
     | 
| 
      
 1619 
     | 
    
         
            +
            unescape('_trimBoth_'),
         
     | 
| 
       1207 
1620 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1208 
     | 
    
         
            -
            selector: 'trimBoth 
     | 
| 
      
 1621 
     | 
    
         
            +
            selector: unescape('trimBoth%3A'),
         
     | 
| 
       1209 
1622 
     | 
    
         
             
            fn: function (separators){
         
     | 
| 
       1210 
1623 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1211 
1624 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_trimLeft_", [separators]), "_trimRight_", [separators]);
         
     | 
| 
         @@ -1214,9 +1627,9 @@ return self;} 
     | 
|
| 
       1214 
1627 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1215 
1628 
     | 
    
         | 
| 
       1216 
1629 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1217 
     | 
    
         
            -
            '_asLowercase',
         
     | 
| 
      
 1630 
     | 
    
         
            +
            unescape('_asLowercase'),
         
     | 
| 
       1218 
1631 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1219 
     | 
    
         
            -
            selector: 'asLowercase',
         
     | 
| 
      
 1632 
     | 
    
         
            +
            selector: unescape('asLowercase'),
         
     | 
| 
       1220 
1633 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1221 
1634 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1222 
1635 
     | 
    
         
             
            return self.toLowerCase();
         
     | 
| 
         @@ -1225,9 +1638,9 @@ return self;} 
     | 
|
| 
       1225 
1638 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1226 
1639 
     | 
    
         | 
| 
       1227 
1640 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1228 
     | 
    
         
            -
            '_asUppercase',
         
     | 
| 
      
 1641 
     | 
    
         
            +
            unescape('_asUppercase'),
         
     | 
| 
       1229 
1642 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1230 
     | 
    
         
            -
            selector: 'asUppercase',
         
     | 
| 
      
 1643 
     | 
    
         
            +
            selector: unescape('asUppercase'),
         
     | 
| 
       1231 
1644 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1232 
1645 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1233 
1646 
     | 
    
         
             
            return self.toUpperCase();
         
     | 
| 
         @@ -1236,9 +1649,9 @@ return self;} 
     | 
|
| 
       1236 
1649 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1237 
1650 
     | 
    
         | 
| 
       1238 
1651 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1239 
     | 
    
         
            -
            '_join_',
         
     | 
| 
      
 1652 
     | 
    
         
            +
            unescape('_join_'),
         
     | 
| 
       1240 
1653 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1241 
     | 
    
         
            -
            selector: 'join 
     | 
| 
      
 1654 
     | 
    
         
            +
            selector: unescape('join%3A'),
         
     | 
| 
       1242 
1655 
     | 
    
         
             
            fn: function (aCollection){
         
     | 
| 
       1243 
1656 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1244 
1657 
     | 
    
         
             
            return smalltalk.send((smalltalk.String || String), "_streamContents_", [(function(stream){return smalltalk.send(aCollection, "_do_separatedBy_", [(function(each){return smalltalk.send(stream, "_nextPutAll_", [smalltalk.send(each, "_asString", [])]);}), (function(){return smalltalk.send(stream, "_nextPutAll_", [self]);})]);})]);
         
     | 
| 
         @@ -1247,9 +1660,9 @@ return self;} 
     | 
|
| 
       1247 
1660 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1248 
1661 
     | 
    
         | 
| 
       1249 
1662 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1250 
     | 
    
         
            -
            '_includesSubString_',
         
     | 
| 
      
 1663 
     | 
    
         
            +
            unescape('_includesSubString_'),
         
     | 
| 
       1251 
1664 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1252 
     | 
    
         
            -
            selector: 'includesSubString 
     | 
| 
      
 1665 
     | 
    
         
            +
            selector: unescape('includesSubString%3A'),
         
     | 
| 
       1253 
1666 
     | 
    
         
             
            fn: function (subString){
         
     | 
| 
       1254 
1667 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1255 
1668 
     | 
    
         
             
             return self.indexOf(subString) != -1 ;
         
     | 
| 
         @@ -1258,9 +1671,9 @@ return self;} 
     | 
|
| 
       1258 
1671 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1259 
1672 
     | 
    
         | 
| 
       1260 
1673 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1261 
     | 
    
         
            -
            '_asciiValue',
         
     | 
| 
      
 1674 
     | 
    
         
            +
            unescape('_asciiValue'),
         
     | 
| 
       1262 
1675 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1263 
     | 
    
         
            -
            selector: 'asciiValue',
         
     | 
| 
      
 1676 
     | 
    
         
            +
            selector: unescape('asciiValue'),
         
     | 
| 
       1264 
1677 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1265 
1678 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1266 
1679 
     | 
    
         
             
            return self.charCodeAt(0);;
         
     | 
| 
         @@ -1269,9 +1682,9 @@ return self;} 
     | 
|
| 
       1269 
1682 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1270 
1683 
     | 
    
         | 
| 
       1271 
1684 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1272 
     | 
    
         
            -
            '_lineIndicesDo_',
         
     | 
| 
      
 1685 
     | 
    
         
            +
            unescape('_lineIndicesDo_'),
         
     | 
| 
       1273 
1686 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1274 
     | 
    
         
            -
            selector: 'lineIndicesDo 
     | 
| 
      
 1687 
     | 
    
         
            +
            selector: unescape('lineIndicesDo%3A'),
         
     | 
| 
       1275 
1688 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       1276 
1689 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1277 
1690 
     | 
    
         
             
            try{var cr=nil;
         
     | 
| 
         @@ -1293,9 +1706,9 @@ return self; 
     | 
|
| 
       1293 
1706 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1294 
1707 
     | 
    
         | 
| 
       1295 
1708 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1296 
     | 
    
         
            -
            '_linesDo_',
         
     | 
| 
      
 1709 
     | 
    
         
            +
            unescape('_linesDo_'),
         
     | 
| 
       1297 
1710 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1298 
     | 
    
         
            -
            selector: 'linesDo 
     | 
| 
      
 1711 
     | 
    
         
            +
            selector: unescape('linesDo%3A'),
         
     | 
| 
       1299 
1712 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       1300 
1713 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1301 
1714 
     | 
    
         
             
            smalltalk.send(self, "_lineIndicesDo_", [(function(start, endWithoutDelimiters, end){return smalltalk.send(aBlock, "_value_", [smalltalk.send(self, "_copyFrom_to_", [start, endWithoutDelimiters])]);})]);
         
     | 
| 
         @@ -1304,9 +1717,9 @@ return self;} 
     | 
|
| 
       1304 
1717 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1305 
1718 
     | 
    
         | 
| 
       1306 
1719 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1307 
     | 
    
         
            -
            '_lines',
         
     | 
| 
      
 1720 
     | 
    
         
            +
            unescape('_lines'),
         
     | 
| 
       1308 
1721 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1309 
     | 
    
         
            -
            selector: 'lines',
         
     | 
| 
      
 1722 
     | 
    
         
            +
            selector: unescape('lines'),
         
     | 
| 
       1310 
1723 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1311 
1724 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1312 
1725 
     | 
    
         
             
            var lines=nil;
         
     | 
| 
         @@ -1318,9 +1731,9 @@ return self;} 
     | 
|
| 
       1318 
1731 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1319 
1732 
     | 
    
         | 
| 
       1320 
1733 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1321 
     | 
    
         
            -
            '_lineNumber_',
         
     | 
| 
      
 1734 
     | 
    
         
            +
            unescape('_lineNumber_'),
         
     | 
| 
       1322 
1735 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1323 
     | 
    
         
            -
            selector: 'lineNumber 
     | 
| 
      
 1736 
     | 
    
         
            +
            selector: unescape('lineNumber%3A'),
         
     | 
| 
       1324 
1737 
     | 
    
         
             
            fn: function (anIndex){
         
     | 
| 
       1325 
1738 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1326 
1739 
     | 
    
         
             
            try{var lineCount=nil;
         
     | 
| 
         @@ -1333,9 +1746,9 @@ return self; 
     | 
|
| 
       1333 
1746 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1334 
1747 
     | 
    
         | 
| 
       1335 
1748 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1336 
     | 
    
         
            -
            '_reversed',
         
     | 
| 
      
 1749 
     | 
    
         
            +
            unescape('_reversed'),
         
     | 
| 
       1337 
1750 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1338 
     | 
    
         
            -
            selector: 'reversed',
         
     | 
| 
      
 1751 
     | 
    
         
            +
            selector: unescape('reversed'),
         
     | 
| 
       1339 
1752 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1340 
1753 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1341 
1754 
     | 
    
         
             
            return self.split("").reverse().join("");
         
     | 
| 
         @@ -1344,9 +1757,9 @@ return self;} 
     | 
|
| 
       1344 
1757 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1345 
1758 
     | 
    
         | 
| 
       1346 
1759 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1347 
     | 
    
         
            -
            '_asJavaScriptSelector',
         
     | 
| 
      
 1760 
     | 
    
         
            +
            unescape('_asJavaScriptSelector'),
         
     | 
| 
       1348 
1761 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1349 
     | 
    
         
            -
            selector: 'asJavaScriptSelector',
         
     | 
| 
      
 1762 
     | 
    
         
            +
            selector: unescape('asJavaScriptSelector'),
         
     | 
| 
       1350 
1763 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1351 
1764 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1352 
1765 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(smalltalk.send(self, "_asSelector", []), "_replace_with_", [unescape("%5E_"), ""]), "_replace_with_", [unescape("_.*"), ""]);
         
     | 
| 
         @@ -1355,9 +1768,9 @@ return self;} 
     | 
|
| 
       1355 
1768 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1356 
1769 
     | 
    
         | 
| 
       1357 
1770 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1358 
     | 
    
         
            -
            '_asJSONString',
         
     | 
| 
      
 1771 
     | 
    
         
            +
            unescape('_asJSONString'),
         
     | 
| 
       1359 
1772 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1360 
     | 
    
         
            -
            selector: 'asJSONString',
         
     | 
| 
      
 1773 
     | 
    
         
            +
            selector: unescape('asJSONString'),
         
     | 
| 
       1361 
1774 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1362 
1775 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1363 
1776 
     | 
    
         
             
            return self;
         
     | 
| 
         @@ -1366,9 +1779,9 @@ return self;} 
     | 
|
| 
       1366 
1779 
     | 
    
         
             
            smalltalk.String);
         
     | 
| 
       1367 
1780 
     | 
    
         | 
| 
       1368 
1781 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1369 
     | 
    
         
            -
            '_asSymbol',
         
     | 
| 
      
 1782 
     | 
    
         
            +
            unescape('_asSymbol'),
         
     | 
| 
       1370 
1783 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1371 
     | 
    
         
            -
            selector: 'asSymbol',
         
     | 
| 
      
 1784 
     | 
    
         
            +
            selector: unescape('asSymbol'),
         
     | 
| 
       1372 
1785 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1373 
1786 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1374 
1787 
     | 
    
         
             
            return smalltalk.send((smalltalk.Symbol || Symbol), "_lookup_", [self]);
         
     | 
| 
         @@ -1378,9 +1791,9 @@ smalltalk.String); 
     | 
|
| 
       1378 
1791 
     | 
    
         | 
| 
       1379 
1792 
     | 
    
         | 
| 
       1380 
1793 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1381 
     | 
    
         
            -
            '_streamClass',
         
     | 
| 
      
 1794 
     | 
    
         
            +
            unescape('_streamClass'),
         
     | 
| 
       1382 
1795 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1383 
     | 
    
         
            -
            selector: 'streamClass',
         
     | 
| 
      
 1796 
     | 
    
         
            +
            selector: unescape('streamClass'),
         
     | 
| 
       1384 
1797 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1385 
1798 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1386 
1799 
     | 
    
         
             
            return (smalltalk.StringStream || StringStream);
         
     | 
| 
         @@ -1389,9 +1802,9 @@ return self;} 
     | 
|
| 
       1389 
1802 
     | 
    
         
             
            smalltalk.String.klass);
         
     | 
| 
       1390 
1803 
     | 
    
         | 
| 
       1391 
1804 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1392 
     | 
    
         
            -
            '_fromString_',
         
     | 
| 
      
 1805 
     | 
    
         
            +
            unescape('_fromString_'),
         
     | 
| 
       1393 
1806 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1394 
     | 
    
         
            -
            selector: 'fromString 
     | 
| 
      
 1807 
     | 
    
         
            +
            selector: unescape('fromString%3A'),
         
     | 
| 
       1395 
1808 
     | 
    
         
             
            fn: function (aString){
         
     | 
| 
       1396 
1809 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1397 
1810 
     | 
    
         
             
            return new self.fn(aString);
         
     | 
| 
         @@ -1400,9 +1813,9 @@ return self;} 
     | 
|
| 
       1400 
1813 
     | 
    
         
             
            smalltalk.String.klass);
         
     | 
| 
       1401 
1814 
     | 
    
         | 
| 
       1402 
1815 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1403 
     | 
    
         
            -
            '_cr',
         
     | 
| 
      
 1816 
     | 
    
         
            +
            unescape('_cr'),
         
     | 
| 
       1404 
1817 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1405 
     | 
    
         
            -
            selector: 'cr',
         
     | 
| 
      
 1818 
     | 
    
         
            +
            selector: unescape('cr'),
         
     | 
| 
       1406 
1819 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1407 
1820 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1408 
1821 
     | 
    
         
             
            return '\r';
         
     | 
| 
         @@ -1411,9 +1824,9 @@ return self;} 
     | 
|
| 
       1411 
1824 
     | 
    
         
             
            smalltalk.String.klass);
         
     | 
| 
       1412 
1825 
     | 
    
         | 
| 
       1413 
1826 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1414 
     | 
    
         
            -
            '_lf',
         
     | 
| 
      
 1827 
     | 
    
         
            +
            unescape('_lf'),
         
     | 
| 
       1415 
1828 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1416 
     | 
    
         
            -
            selector: 'lf',
         
     | 
| 
      
 1829 
     | 
    
         
            +
            selector: unescape('lf'),
         
     | 
| 
       1417 
1830 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1418 
1831 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1419 
1832 
     | 
    
         
             
            return '\n';
         
     | 
| 
         @@ -1422,9 +1835,9 @@ return self;} 
     | 
|
| 
       1422 
1835 
     | 
    
         
             
            smalltalk.String.klass);
         
     | 
| 
       1423 
1836 
     | 
    
         | 
| 
       1424 
1837 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1425 
     | 
    
         
            -
            '_space',
         
     | 
| 
      
 1838 
     | 
    
         
            +
            unescape('_space'),
         
     | 
| 
       1426 
1839 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1427 
     | 
    
         
            -
            selector: 'space',
         
     | 
| 
      
 1840 
     | 
    
         
            +
            selector: unescape('space'),
         
     | 
| 
       1428 
1841 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1429 
1842 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1430 
1843 
     | 
    
         
             
            return ' ';
         
     | 
| 
         @@ -1433,9 +1846,9 @@ return self;} 
     | 
|
| 
       1433 
1846 
     | 
    
         
             
            smalltalk.String.klass);
         
     | 
| 
       1434 
1847 
     | 
    
         | 
| 
       1435 
1848 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1436 
     | 
    
         
            -
            '_tab',
         
     | 
| 
      
 1849 
     | 
    
         
            +
            unescape('_tab'),
         
     | 
| 
       1437 
1850 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1438 
     | 
    
         
            -
            selector: 'tab',
         
     | 
| 
      
 1851 
     | 
    
         
            +
            selector: unescape('tab'),
         
     | 
| 
       1439 
1852 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1440 
1853 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1441 
1854 
     | 
    
         
             
            return '\t';
         
     | 
| 
         @@ -1444,9 +1857,9 @@ return self;} 
     | 
|
| 
       1444 
1857 
     | 
    
         
             
            smalltalk.String.klass);
         
     | 
| 
       1445 
1858 
     | 
    
         | 
| 
       1446 
1859 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1447 
     | 
    
         
            -
            '_crlf',
         
     | 
| 
      
 1860 
     | 
    
         
            +
            unescape('_crlf'),
         
     | 
| 
       1448 
1861 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1449 
     | 
    
         
            -
            selector: 'crlf',
         
     | 
| 
      
 1862 
     | 
    
         
            +
            selector: unescape('crlf'),
         
     | 
| 
       1450 
1863 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1451 
1864 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1452 
1865 
     | 
    
         
             
            return '\r\n';
         
     | 
| 
         @@ -1455,9 +1868,9 @@ return self;} 
     | 
|
| 
       1455 
1868 
     | 
    
         
             
            smalltalk.String.klass);
         
     | 
| 
       1456 
1869 
     | 
    
         | 
| 
       1457 
1870 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1458 
     | 
    
         
            -
            '_streamContents_',
         
     | 
| 
      
 1871 
     | 
    
         
            +
            unescape('_streamContents_'),
         
     | 
| 
       1459 
1872 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1460 
     | 
    
         
            -
            selector: 'streamContents 
     | 
| 
      
 1873 
     | 
    
         
            +
            selector: unescape('streamContents%3A'),
         
     | 
| 
       1461 
1874 
     | 
    
         
             
            fn: function (blockWithArg){
         
     | 
| 
       1462 
1875 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1463 
1876 
     | 
    
         
             
            var stream=nil;
         
     | 
| 
         @@ -1469,9 +1882,9 @@ return self;} 
     | 
|
| 
       1469 
1882 
     | 
    
         
             
            smalltalk.String.klass);
         
     | 
| 
       1470 
1883 
     | 
    
         | 
| 
       1471 
1884 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1472 
     | 
    
         
            -
            '_value_',
         
     | 
| 
      
 1885 
     | 
    
         
            +
            unescape('_value_'),
         
     | 
| 
       1473 
1886 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1474 
     | 
    
         
            -
            selector: 'value 
     | 
| 
      
 1887 
     | 
    
         
            +
            selector: unescape('value%3A'),
         
     | 
| 
       1475 
1888 
     | 
    
         
             
            fn: function (aUTFCharCode){
         
     | 
| 
       1476 
1889 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1477 
1890 
     | 
    
         
             
            return String.fromCharCode(aUTFCharCode);;
         
     | 
| 
         @@ -1482,9 +1895,9 @@ smalltalk.String.klass); 
     | 
|
| 
       1482 
1895 
     | 
    
         | 
| 
       1483 
1896 
     | 
    
         
             
            smalltalk.addClass('Symbol', smalltalk.CharacterArray, [], 'Kernel-Collections');
         
     | 
| 
       1484 
1897 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1485 
     | 
    
         
            -
            '_at_ifAbsent_',
         
     | 
| 
      
 1898 
     | 
    
         
            +
            unescape('_at_ifAbsent_'),
         
     | 
| 
       1486 
1899 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1487 
     | 
    
         
            -
            selector: 'at 
     | 
| 
      
 1900 
     | 
    
         
            +
            selector: unescape('at%3AifAbsent%3A'),
         
     | 
| 
       1488 
1901 
     | 
    
         
             
            fn: function (anIndex, aBlock){
         
     | 
| 
       1489 
1902 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1490 
1903 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_asString", []), "_at_ifAbsent_", [anIndex, aBlock]);
         
     | 
| 
         @@ -1493,9 +1906,9 @@ return self;} 
     | 
|
| 
       1493 
1906 
     | 
    
         
             
            smalltalk.Symbol);
         
     | 
| 
       1494 
1907 
     | 
    
         | 
| 
       1495 
1908 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1496 
     | 
    
         
            -
            '_asString',
         
     | 
| 
      
 1909 
     | 
    
         
            +
            unescape('_asString'),
         
     | 
| 
       1497 
1910 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1498 
     | 
    
         
            -
            selector: 'asString',
         
     | 
| 
      
 1911 
     | 
    
         
            +
            selector: unescape('asString'),
         
     | 
| 
       1499 
1912 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1500 
1913 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1501 
1914 
     | 
    
         
             
            return self.value;
         
     | 
| 
         @@ -1504,9 +1917,9 @@ return self;} 
     | 
|
| 
       1504 
1917 
     | 
    
         
             
            smalltalk.Symbol);
         
     | 
| 
       1505 
1918 
     | 
    
         | 
| 
       1506 
1919 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1507 
     | 
    
         
            -
            '_printString',
         
     | 
| 
      
 1920 
     | 
    
         
            +
            unescape('_printString'),
         
     | 
| 
       1508 
1921 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1509 
     | 
    
         
            -
            selector: 'printString',
         
     | 
| 
      
 1922 
     | 
    
         
            +
            selector: unescape('printString'),
         
     | 
| 
       1510 
1923 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1511 
1924 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1512 
1925 
     | 
    
         
             
            return smalltalk.send(unescape("%23"), "__comma", [smalltalk.send(self, "_asString", [])]);
         
     | 
| 
         @@ -1515,9 +1928,9 @@ return self;} 
     | 
|
| 
       1515 
1928 
     | 
    
         
             
            smalltalk.Symbol);
         
     | 
| 
       1516 
1929 
     | 
    
         | 
| 
       1517 
1930 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1518 
     | 
    
         
            -
            '_size',
         
     | 
| 
      
 1931 
     | 
    
         
            +
            unescape('_size'),
         
     | 
| 
       1519 
1932 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1520 
     | 
    
         
            -
            selector: 'size',
         
     | 
| 
      
 1933 
     | 
    
         
            +
            selector: unescape('size'),
         
     | 
| 
       1521 
1934 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1522 
1935 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1523 
1936 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_asString", []), "_size", []);
         
     | 
| 
         @@ -1526,9 +1939,9 @@ return self;} 
     | 
|
| 
       1526 
1939 
     | 
    
         
             
            smalltalk.Symbol);
         
     | 
| 
       1527 
1940 
     | 
    
         | 
| 
       1528 
1941 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1529 
     | 
    
         
            -
            '_asSymbol',
         
     | 
| 
      
 1942 
     | 
    
         
            +
            unescape('_asSymbol'),
         
     | 
| 
       1530 
1943 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1531 
     | 
    
         
            -
            selector: 'asSymbol',
         
     | 
| 
      
 1944 
     | 
    
         
            +
            selector: unescape('asSymbol'),
         
     | 
| 
       1532 
1945 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1533 
1946 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1534 
1947 
     | 
    
         
             
            return self;
         
     | 
| 
         @@ -1537,9 +1950,9 @@ return self;} 
     | 
|
| 
       1537 
1950 
     | 
    
         
             
            smalltalk.Symbol);
         
     | 
| 
       1538 
1951 
     | 
    
         | 
| 
       1539 
1952 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1540 
     | 
    
         
            -
            '_copyFrom_to_',
         
     | 
| 
      
 1953 
     | 
    
         
            +
            unescape('_copyFrom_to_'),
         
     | 
| 
       1541 
1954 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1542 
     | 
    
         
            -
            selector: 'copyFrom 
     | 
| 
      
 1955 
     | 
    
         
            +
            selector: unescape('copyFrom%3Ato%3A'),
         
     | 
| 
       1543 
1956 
     | 
    
         
             
            fn: function (anIndex, anotherIndex){
         
     | 
| 
       1544 
1957 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1545 
1958 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_class", []), "_fromString_", [smalltalk.send(smalltalk.send(self, "_asString", []), "_copyFrom_to_", [anIndex, anotherIndex])]);
         
     | 
| 
         @@ -1548,9 +1961,9 @@ return self;} 
     | 
|
| 
       1548 
1961 
     | 
    
         
             
            smalltalk.Symbol);
         
     | 
| 
       1549 
1962 
     | 
    
         | 
| 
       1550 
1963 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1551 
     | 
    
         
            -
            '_deepCopy',
         
     | 
| 
      
 1964 
     | 
    
         
            +
            unescape('_deepCopy'),
         
     | 
| 
       1552 
1965 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1553 
     | 
    
         
            -
            selector: 'deepCopy',
         
     | 
| 
      
 1966 
     | 
    
         
            +
            selector: unescape('deepCopy'),
         
     | 
| 
       1554 
1967 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1555 
1968 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1556 
1969 
     | 
    
         
             
            return self;
         
     | 
| 
         @@ -1559,9 +1972,9 @@ return self;} 
     | 
|
| 
       1559 
1972 
     | 
    
         
             
            smalltalk.Symbol);
         
     | 
| 
       1560 
1973 
     | 
    
         | 
| 
       1561 
1974 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1562 
     | 
    
         
            -
            '__lt',
         
     | 
| 
      
 1975 
     | 
    
         
            +
            unescape('__lt'),
         
     | 
| 
       1563 
1976 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1564 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 1977 
     | 
    
         
            +
            selector: unescape('%3C'),
         
     | 
| 
       1565 
1978 
     | 
    
         
             
            fn: function (aSymbol){
         
     | 
| 
       1566 
1979 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1567 
1980 
     | 
    
         
             
            return ((($receiver = smalltalk.send(self, "_asString", [])).klass === smalltalk.Number) ? $receiver <smalltalk.send(aSymbol, "_asString", []) : smalltalk.send($receiver, "__lt", [smalltalk.send(aSymbol, "_asString", [])]));
         
     | 
| 
         @@ -1570,9 +1983,9 @@ return self;} 
     | 
|
| 
       1570 
1983 
     | 
    
         
             
            smalltalk.Symbol);
         
     | 
| 
       1571 
1984 
     | 
    
         | 
| 
       1572 
1985 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1573 
     | 
    
         
            -
            '__lt_eq',
         
     | 
| 
      
 1986 
     | 
    
         
            +
            unescape('__lt_eq'),
         
     | 
| 
       1574 
1987 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1575 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 1988 
     | 
    
         
            +
            selector: unescape('%3C%3D'),
         
     | 
| 
       1576 
1989 
     | 
    
         
             
            fn: function (aSymbol){
         
     | 
| 
       1577 
1990 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1578 
1991 
     | 
    
         
             
            return ((($receiver = smalltalk.send(self, "_asString", [])).klass === smalltalk.Number) ? $receiver <=smalltalk.send(aSymbol, "_asString", []) : smalltalk.send($receiver, "__lt_eq", [smalltalk.send(aSymbol, "_asString", [])]));
         
     | 
| 
         @@ -1581,9 +1994,9 @@ return self;} 
     | 
|
| 
       1581 
1994 
     | 
    
         
             
            smalltalk.Symbol);
         
     | 
| 
       1582 
1995 
     | 
    
         | 
| 
       1583 
1996 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1584 
     | 
    
         
            -
            '__gt_eq',
         
     | 
| 
      
 1997 
     | 
    
         
            +
            unescape('__gt_eq'),
         
     | 
| 
       1585 
1998 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1586 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 1999 
     | 
    
         
            +
            selector: unescape('%3E%3D'),
         
     | 
| 
       1587 
2000 
     | 
    
         
             
            fn: function (aSymbol){
         
     | 
| 
       1588 
2001 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1589 
2002 
     | 
    
         
             
            return ((($receiver = smalltalk.send(self, "_asString", [])).klass === smalltalk.Number) ? $receiver >=smalltalk.send(aSymbol, "_asString", []) : smalltalk.send($receiver, "__gt_eq", [smalltalk.send(aSymbol, "_asString", [])]));
         
     | 
| 
         @@ -1592,9 +2005,9 @@ return self;} 
     | 
|
| 
       1592 
2005 
     | 
    
         
             
            smalltalk.Symbol);
         
     | 
| 
       1593 
2006 
     | 
    
         | 
| 
       1594 
2007 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1595 
     | 
    
         
            -
            '__eq',
         
     | 
| 
      
 2008 
     | 
    
         
            +
            unescape('__eq'),
         
     | 
| 
       1596 
2009 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1597 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 2010 
     | 
    
         
            +
            selector: unescape('%3D'),
         
     | 
| 
       1598 
2011 
     | 
    
         
             
            fn: function (aSymbol){
         
     | 
| 
       1599 
2012 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1600 
2013 
     | 
    
         
             
            try{((($receiver = smalltalk.send(smalltalk.send(aSymbol, "_class", []), "__eq", [smalltalk.send(self, "_class", [])])).klass === smalltalk.Boolean) ? (! $receiver ? (function(){return (function(){throw({name: 'stReturn', selector: '__eq', fn: function(){return false}})})();})() : nil) : smalltalk.send($receiver, "_ifFalse_", [(function(){return (function(){throw({name: 'stReturn', selector: '__eq', fn: function(){return false}})})();})]));
         
     | 
| 
         @@ -1605,9 +2018,9 @@ return self; 
     | 
|
| 
       1605 
2018 
     | 
    
         
             
            smalltalk.Symbol);
         
     | 
| 
       1606 
2019 
     | 
    
         | 
| 
       1607 
2020 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1608 
     | 
    
         
            -
            '_isSymbol',
         
     | 
| 
      
 2021 
     | 
    
         
            +
            unescape('_isSymbol'),
         
     | 
| 
       1609 
2022 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1610 
     | 
    
         
            -
            selector: 'isSymbol',
         
     | 
| 
      
 2023 
     | 
    
         
            +
            selector: unescape('isSymbol'),
         
     | 
| 
       1611 
2024 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1612 
2025 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1613 
2026 
     | 
    
         
             
            return true;
         
     | 
| 
         @@ -1616,9 +2029,9 @@ return self;} 
     | 
|
| 
       1616 
2029 
     | 
    
         
             
            smalltalk.Symbol);
         
     | 
| 
       1617 
2030 
     | 
    
         | 
| 
       1618 
2031 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1619 
     | 
    
         
            -
            '_asJavascript',
         
     | 
| 
      
 2032 
     | 
    
         
            +
            unescape('_asJavascript'),
         
     | 
| 
       1620 
2033 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1621 
     | 
    
         
            -
            selector: 'asJavascript',
         
     | 
| 
      
 2034 
     | 
    
         
            +
            selector: unescape('asJavascript'),
         
     | 
| 
       1622 
2035 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1623 
2036 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1624 
2037 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(unescape("smalltalk.symbolFor%28%22"), "__comma", [smalltalk.send(self, "_asString", [])]), "__comma", [unescape("%22%29")]);
         
     | 
| 
         @@ -1627,9 +2040,9 @@ return self;} 
     | 
|
| 
       1627 
2040 
     | 
    
         
             
            smalltalk.Symbol);
         
     | 
| 
       1628 
2041 
     | 
    
         | 
| 
       1629 
2042 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1630 
     | 
    
         
            -
            '__gt',
         
     | 
| 
      
 2043 
     | 
    
         
            +
            unescape('__gt'),
         
     | 
| 
       1631 
2044 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1632 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 2045 
     | 
    
         
            +
            selector: unescape('%3E'),
         
     | 
| 
       1633 
2046 
     | 
    
         
             
            fn: function (aSymbol){
         
     | 
| 
       1634 
2047 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1635 
2048 
     | 
    
         
             
            return ((($receiver = smalltalk.send(self, "_asString", [])).klass === smalltalk.Number) ? $receiver >smalltalk.send(aSymbol, "_asString", []) : smalltalk.send($receiver, "__gt", [smalltalk.send(aSymbol, "_asString", [])]));
         
     | 
| 
         @@ -1638,9 +2051,9 @@ return self;} 
     | 
|
| 
       1638 
2051 
     | 
    
         
             
            smalltalk.Symbol);
         
     | 
| 
       1639 
2052 
     | 
    
         | 
| 
       1640 
2053 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1641 
     | 
    
         
            -
            '_shallowCopy',
         
     | 
| 
      
 2054 
     | 
    
         
            +
            unescape('_shallowCopy'),
         
     | 
| 
       1642 
2055 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1643 
     | 
    
         
            -
            selector: 'shallowCopy',
         
     | 
| 
      
 2056 
     | 
    
         
            +
            selector: unescape('shallowCopy'),
         
     | 
| 
       1644 
2057 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1645 
2058 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1646 
2059 
     | 
    
         
             
            return self;
         
     | 
| 
         @@ -1649,9 +2062,9 @@ return self;} 
     | 
|
| 
       1649 
2062 
     | 
    
         
             
            smalltalk.Symbol);
         
     | 
| 
       1650 
2063 
     | 
    
         | 
| 
       1651 
2064 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1652 
     | 
    
         
            -
            '_asSelector',
         
     | 
| 
      
 2065 
     | 
    
         
            +
            unescape('_asSelector'),
         
     | 
| 
       1653 
2066 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1654 
     | 
    
         
            -
            selector: 'asSelector',
         
     | 
| 
      
 2067 
     | 
    
         
            +
            selector: unescape('asSelector'),
         
     | 
| 
       1655 
2068 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1656 
2069 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1657 
2070 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_asString", []), "_asSelector", []);
         
     | 
| 
         @@ -1661,9 +2074,9 @@ smalltalk.Symbol); 
     | 
|
| 
       1661 
2074 
     | 
    
         | 
| 
       1662 
2075 
     | 
    
         | 
| 
       1663 
2076 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1664 
     | 
    
         
            -
            '_lookup_',
         
     | 
| 
      
 2077 
     | 
    
         
            +
            unescape('_lookup_'),
         
     | 
| 
       1665 
2078 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1666 
     | 
    
         
            -
            selector: 'lookup 
     | 
| 
      
 2079 
     | 
    
         
            +
            selector: unescape('lookup%3A'),
         
     | 
| 
       1667 
2080 
     | 
    
         
             
            fn: function (aString){
         
     | 
| 
       1668 
2081 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1669 
2082 
     | 
    
         
             
            return smalltalk.symbolFor(aString);;
         
     | 
| 
         @@ -1672,9 +2085,9 @@ return self;} 
     | 
|
| 
       1672 
2085 
     | 
    
         
             
            smalltalk.Symbol.klass);
         
     | 
| 
       1673 
2086 
     | 
    
         | 
| 
       1674 
2087 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1675 
     | 
    
         
            -
            '_basicNew',
         
     | 
| 
      
 2088 
     | 
    
         
            +
            unescape('_basicNew'),
         
     | 
| 
       1676 
2089 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1677 
     | 
    
         
            -
            selector: 'basicNew',
         
     | 
| 
      
 2090 
     | 
    
         
            +
            selector: unescape('basicNew'),
         
     | 
| 
       1678 
2091 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1679 
2092 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1680 
2093 
     | 
    
         
             
            smalltalk.send(self, "_shouldNotImplement", []);
         
     | 
| 
         @@ -1683,9 +2096,9 @@ return self;} 
     | 
|
| 
       1683 
2096 
     | 
    
         
             
            smalltalk.Symbol.klass);
         
     | 
| 
       1684 
2097 
     | 
    
         | 
| 
       1685 
2098 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1686 
     | 
    
         
            -
            '_fromString_',
         
     | 
| 
      
 2099 
     | 
    
         
            +
            unescape('_fromString_'),
         
     | 
| 
       1687 
2100 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1688 
     | 
    
         
            -
            selector: 'fromString 
     | 
| 
      
 2101 
     | 
    
         
            +
            selector: unescape('fromString%3A'),
         
     | 
| 
       1689 
2102 
     | 
    
         
             
            fn: function (aString){
         
     | 
| 
       1690 
2103 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1691 
2104 
     | 
    
         
             
            return smalltalk.send(self, "_lookup_", [aString]);
         
     | 
| 
         @@ -1696,9 +2109,9 @@ smalltalk.Symbol.klass); 
     | 
|
| 
       1696 
2109 
     | 
    
         | 
| 
       1697 
2110 
     | 
    
         
             
            smalltalk.addClass('Array', smalltalk.SequenceableCollection, [], 'Kernel-Collections');
         
     | 
| 
       1698 
2111 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1699 
     | 
    
         
            -
            '_size',
         
     | 
| 
      
 2112 
     | 
    
         
            +
            unescape('_size'),
         
     | 
| 
       1700 
2113 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1701 
     | 
    
         
            -
            selector: 'size',
         
     | 
| 
      
 2114 
     | 
    
         
            +
            selector: unescape('size'),
         
     | 
| 
       1702 
2115 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1703 
2116 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1704 
2117 
     | 
    
         
             
            return self.length;
         
     | 
| 
         @@ -1707,9 +2120,9 @@ return self;} 
     | 
|
| 
       1707 
2120 
     | 
    
         
             
            smalltalk.Array);
         
     | 
| 
       1708 
2121 
     | 
    
         | 
| 
       1709 
2122 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1710 
     | 
    
         
            -
            '_at_put_',
         
     | 
| 
      
 2123 
     | 
    
         
            +
            unescape('_at_put_'),
         
     | 
| 
       1711 
2124 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1712 
     | 
    
         
            -
            selector: 'at 
     | 
| 
      
 2125 
     | 
    
         
            +
            selector: unescape('at%3Aput%3A'),
         
     | 
| 
       1713 
2126 
     | 
    
         
             
            fn: function (anIndex, anObject){
         
     | 
| 
       1714 
2127 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1715 
2128 
     | 
    
         
             
            return self[anIndex - 1] = anObject;
         
     | 
| 
         @@ -1718,9 +2131,9 @@ return self;} 
     | 
|
| 
       1718 
2131 
     | 
    
         
             
            smalltalk.Array);
         
     | 
| 
       1719 
2132 
     | 
    
         | 
| 
       1720 
2133 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1721 
     | 
    
         
            -
            '_at_ifAbsent_',
         
     | 
| 
      
 2134 
     | 
    
         
            +
            unescape('_at_ifAbsent_'),
         
     | 
| 
       1722 
2135 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1723 
     | 
    
         
            -
            selector: 'at 
     | 
| 
      
 2136 
     | 
    
         
            +
            selector: unescape('at%3AifAbsent%3A'),
         
     | 
| 
       1724 
2137 
     | 
    
         
             
            fn: function (anIndex, aBlock){
         
     | 
| 
       1725 
2138 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1726 
2139 
     | 
    
         | 
| 
         @@ -1736,9 +2149,9 @@ return self;} 
     | 
|
| 
       1736 
2149 
     | 
    
         
             
            smalltalk.Array);
         
     | 
| 
       1737 
2150 
     | 
    
         | 
| 
       1738 
2151 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1739 
     | 
    
         
            -
            '_add_',
         
     | 
| 
      
 2152 
     | 
    
         
            +
            unescape('_add_'),
         
     | 
| 
       1740 
2153 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1741 
     | 
    
         
            -
            selector: 'add 
     | 
| 
      
 2154 
     | 
    
         
            +
            selector: unescape('add%3A'),
         
     | 
| 
       1742 
2155 
     | 
    
         
             
            fn: function (anObject){
         
     | 
| 
       1743 
2156 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1744 
2157 
     | 
    
         
             
            self.push(anObject); return anObject;;
         
     | 
| 
         @@ -1747,9 +2160,9 @@ return self;} 
     | 
|
| 
       1747 
2160 
     | 
    
         
             
            smalltalk.Array);
         
     | 
| 
       1748 
2161 
     | 
    
         | 
| 
       1749 
2162 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1750 
     | 
    
         
            -
            '_join_',
         
     | 
| 
      
 2163 
     | 
    
         
            +
            unescape('_join_'),
         
     | 
| 
       1751 
2164 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1752 
     | 
    
         
            -
            selector: 'join 
     | 
| 
      
 2165 
     | 
    
         
            +
            selector: unescape('join%3A'),
         
     | 
| 
       1753 
2166 
     | 
    
         
             
            fn: function (aString){
         
     | 
| 
       1754 
2167 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1755 
2168 
     | 
    
         
             
            return self.join(aString);
         
     | 
| 
         @@ -1758,9 +2171,9 @@ return self;} 
     | 
|
| 
       1758 
2171 
     | 
    
         
             
            smalltalk.Array);
         
     | 
| 
       1759 
2172 
     | 
    
         | 
| 
       1760 
2173 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1761 
     | 
    
         
            -
            '_asJavascript',
         
     | 
| 
      
 2174 
     | 
    
         
            +
            unescape('_asJavascript'),
         
     | 
| 
       1762 
2175 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1763 
     | 
    
         
            -
            selector: 'asJavascript',
         
     | 
| 
      
 2176 
     | 
    
         
            +
            selector: unescape('asJavascript'),
         
     | 
| 
       1764 
2177 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1765 
2178 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1766 
2179 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(unescape("%5B"), "__comma", [smalltalk.send(smalltalk.send(self, "_collect_", [(function(each){return smalltalk.send(each, "_asJavascript", []);})]), "_join_", [unescape("%2C%20")])]), "__comma", [unescape("%5D")]);
         
     | 
| 
         @@ -1769,9 +2182,9 @@ return self;} 
     | 
|
| 
       1769 
2182 
     | 
    
         
             
            smalltalk.Array);
         
     | 
| 
       1770 
2183 
     | 
    
         | 
| 
       1771 
2184 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1772 
     | 
    
         
            -
            '_sort',
         
     | 
| 
      
 2185 
     | 
    
         
            +
            unescape('_sort'),
         
     | 
| 
       1773 
2186 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1774 
     | 
    
         
            -
            selector: 'sort',
         
     | 
| 
      
 2187 
     | 
    
         
            +
            selector: unescape('sort'),
         
     | 
| 
       1775 
2188 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1776 
2189 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1777 
2190 
     | 
    
         
             
            return smalltalk.send(self, "_basicPerform_", ["sort"]);
         
     | 
| 
         @@ -1780,9 +2193,9 @@ return self;} 
     | 
|
| 
       1780 
2193 
     | 
    
         
             
            smalltalk.Array);
         
     | 
| 
       1781 
2194 
     | 
    
         | 
| 
       1782 
2195 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1783 
     | 
    
         
            -
            '_sort_',
         
     | 
| 
      
 2196 
     | 
    
         
            +
            unescape('_sort_'),
         
     | 
| 
       1784 
2197 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1785 
     | 
    
         
            -
            selector: 'sort 
     | 
| 
      
 2198 
     | 
    
         
            +
            selector: unescape('sort%3A'),
         
     | 
| 
       1786 
2199 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       1787 
2200 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1788 
2201 
     | 
    
         | 
| 
         @@ -1795,9 +2208,9 @@ return self;} 
     | 
|
| 
       1795 
2208 
     | 
    
         
             
            smalltalk.Array);
         
     | 
| 
       1796 
2209 
     | 
    
         | 
| 
       1797 
2210 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1798 
     | 
    
         
            -
            '_remove_',
         
     | 
| 
      
 2211 
     | 
    
         
            +
            unescape('_remove_'),
         
     | 
| 
       1799 
2212 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1800 
     | 
    
         
            -
            selector: 'remove 
     | 
| 
      
 2213 
     | 
    
         
            +
            selector: unescape('remove%3A'),
         
     | 
| 
       1801 
2214 
     | 
    
         
             
            fn: function (anObject){
         
     | 
| 
       1802 
2215 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1803 
2216 
     | 
    
         | 
| 
         @@ -1813,9 +2226,9 @@ return self;} 
     | 
|
| 
       1813 
2226 
     | 
    
         
             
            smalltalk.Array);
         
     | 
| 
       1814 
2227 
     | 
    
         | 
| 
       1815 
2228 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1816 
     | 
    
         
            -
            '_sorted',
         
     | 
| 
      
 2229 
     | 
    
         
            +
            unescape('_sorted'),
         
     | 
| 
       1817 
2230 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1818 
     | 
    
         
            -
            selector: 'sorted',
         
     | 
| 
      
 2231 
     | 
    
         
            +
            selector: unescape('sorted'),
         
     | 
| 
       1819 
2232 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1820 
2233 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1821 
2234 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_copy", []), "_sort", []);
         
     | 
| 
         @@ -1824,9 +2237,9 @@ return self;} 
     | 
|
| 
       1824 
2237 
     | 
    
         
             
            smalltalk.Array);
         
     | 
| 
       1825 
2238 
     | 
    
         | 
| 
       1826 
2239 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1827 
     | 
    
         
            -
            '_sorted_',
         
     | 
| 
      
 2240 
     | 
    
         
            +
            unescape('_sorted_'),
         
     | 
| 
       1828 
2241 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1829 
     | 
    
         
            -
            selector: 'sorted 
     | 
| 
      
 2242 
     | 
    
         
            +
            selector: unescape('sorted%3A'),
         
     | 
| 
       1830 
2243 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       1831 
2244 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1832 
2245 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_copy", []), "_sort_", [aBlock]);
         
     | 
| 
         @@ -1835,9 +2248,9 @@ return self;} 
     | 
|
| 
       1835 
2248 
     | 
    
         
             
            smalltalk.Array);
         
     | 
| 
       1836 
2249 
     | 
    
         | 
| 
       1837 
2250 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1838 
     | 
    
         
            -
            '_removeFrom_to_',
         
     | 
| 
      
 2251 
     | 
    
         
            +
            unescape('_removeFrom_to_'),
         
     | 
| 
       1839 
2252 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1840 
     | 
    
         
            -
            selector: 'removeFrom 
     | 
| 
      
 2253 
     | 
    
         
            +
            selector: unescape('removeFrom%3Ato%3A'),
         
     | 
| 
       1841 
2254 
     | 
    
         
             
            fn: function (aNumber, anotherNumber){
         
     | 
| 
       1842 
2255 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1843 
2256 
     | 
    
         
             
            self.splice(aNumber - 1,anotherNumber - 1);
         
     | 
| 
         @@ -1846,9 +2259,9 @@ return self;} 
     | 
|
| 
       1846 
2259 
     | 
    
         
             
            smalltalk.Array);
         
     | 
| 
       1847 
2260 
     | 
    
         | 
| 
       1848 
2261 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1849 
     | 
    
         
            -
            '_reversed',
         
     | 
| 
      
 2262 
     | 
    
         
            +
            unescape('_reversed'),
         
     | 
| 
       1850 
2263 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1851 
     | 
    
         
            -
            selector: 'reversed',
         
     | 
| 
      
 2264 
     | 
    
         
            +
            selector: unescape('reversed'),
         
     | 
| 
       1852 
2265 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       1853 
2266 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1854 
2267 
     | 
    
         
             
            return self._copy().reverse();
         
     | 
| 
         @@ -1858,9 +2271,9 @@ smalltalk.Array); 
     | 
|
| 
       1858 
2271 
     | 
    
         | 
| 
       1859 
2272 
     | 
    
         | 
| 
       1860 
2273 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1861 
     | 
    
         
            -
            '_new_',
         
     | 
| 
      
 2274 
     | 
    
         
            +
            unescape('_new_'),
         
     | 
| 
       1862 
2275 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1863 
     | 
    
         
            -
            selector: 'new 
     | 
| 
      
 2276 
     | 
    
         
            +
            selector: unescape('new%3A'),
         
     | 
| 
       1864 
2277 
     | 
    
         
             
            fn: function (anInteger){
         
     | 
| 
       1865 
2278 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1866 
2279 
     | 
    
         
             
            return new Array(anInteger);
         
     | 
| 
         @@ -1869,9 +2282,9 @@ return self;} 
     | 
|
| 
       1869 
2282 
     | 
    
         
             
            smalltalk.Array.klass);
         
     | 
| 
       1870 
2283 
     | 
    
         | 
| 
       1871 
2284 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1872 
     | 
    
         
            -
            '_with_',
         
     | 
| 
      
 2285 
     | 
    
         
            +
            unescape('_with_'),
         
     | 
| 
       1873 
2286 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1874 
     | 
    
         
            -
            selector: 'with 
     | 
| 
      
 2287 
     | 
    
         
            +
            selector: unescape('with%3A'),
         
     | 
| 
       1875 
2288 
     | 
    
         
             
            fn: function (anObject){
         
     | 
| 
       1876 
2289 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1877 
2290 
     | 
    
         
             
            return (function($rec){smalltalk.send($rec, "_at_put_", [(1), anObject]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new_", [(1)]));
         
     | 
| 
         @@ -1880,9 +2293,9 @@ return self;} 
     | 
|
| 
       1880 
2293 
     | 
    
         
             
            smalltalk.Array.klass);
         
     | 
| 
       1881 
2294 
     | 
    
         | 
| 
       1882 
2295 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1883 
     | 
    
         
            -
            '_with_with_',
         
     | 
| 
      
 2296 
     | 
    
         
            +
            unescape('_with_with_'),
         
     | 
| 
       1884 
2297 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1885 
     | 
    
         
            -
            selector: 'with 
     | 
| 
      
 2298 
     | 
    
         
            +
            selector: unescape('with%3Awith%3A'),
         
     | 
| 
       1886 
2299 
     | 
    
         
             
            fn: function (anObject, anObject2){
         
     | 
| 
       1887 
2300 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1888 
2301 
     | 
    
         
             
            return (function($rec){smalltalk.send($rec, "_at_put_", [(1), anObject]);smalltalk.send($rec, "_at_put_", [(2), anObject2]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new_", [(2)]));
         
     | 
| 
         @@ -1891,9 +2304,9 @@ return self;} 
     | 
|
| 
       1891 
2304 
     | 
    
         
             
            smalltalk.Array.klass);
         
     | 
| 
       1892 
2305 
     | 
    
         | 
| 
       1893 
2306 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1894 
     | 
    
         
            -
            '_with_with_with_',
         
     | 
| 
      
 2307 
     | 
    
         
            +
            unescape('_with_with_with_'),
         
     | 
| 
       1895 
2308 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1896 
     | 
    
         
            -
            selector: 'with 
     | 
| 
      
 2309 
     | 
    
         
            +
            selector: unescape('with%3Awith%3Awith%3A'),
         
     | 
| 
       1897 
2310 
     | 
    
         
             
            fn: function (anObject, anObject2, anObject3){
         
     | 
| 
       1898 
2311 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1899 
2312 
     | 
    
         
             
            return (function($rec){smalltalk.send($rec, "_at_put_", [(1), anObject]);smalltalk.send($rec, "_at_put_", [(2), anObject2]);smalltalk.send($rec, "_at_put_", [(3), anObject3]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new_", [(3)]));
         
     | 
| 
         @@ -1902,9 +2315,9 @@ return self;} 
     | 
|
| 
       1902 
2315 
     | 
    
         
             
            smalltalk.Array.klass);
         
     | 
| 
       1903 
2316 
     | 
    
         | 
| 
       1904 
2317 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       1905 
     | 
    
         
            -
            '_withAll_',
         
     | 
| 
      
 2318 
     | 
    
         
            +
            unescape('_withAll_'),
         
     | 
| 
       1906 
2319 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       1907 
     | 
    
         
            -
            selector: 'withAll 
     | 
| 
      
 2320 
     | 
    
         
            +
            selector: unescape('withAll%3A'),
         
     | 
| 
       1908 
2321 
     | 
    
         
             
            fn: function (aCollection){
         
     | 
| 
       1909 
2322 
     | 
    
         
             
            var self=this;
         
     | 
| 
       1910 
2323 
     | 
    
         
             
            var instance=nil;
         
     | 
| 
         @@ -1916,424 +2329,233 @@ return self;} 
     | 
|
| 
       1916 
2329 
     | 
    
         
             
            smalltalk.Array.klass);
         
     | 
| 
       1917 
2330 
     | 
    
         | 
| 
       1918 
2331 
     | 
    
         | 
| 
       1919 
     | 
    
         
            -
            smalltalk.addClass(' 
     | 
| 
       1920 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       1921 
     | 
    
         
            -
            '_compile_',
         
     | 
| 
       1922 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       1923 
     | 
    
         
            -
            selector: 'compile:',
         
     | 
| 
       1924 
     | 
    
         
            -
            fn: function (aString){
         
     | 
| 
       1925 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       1926 
     | 
    
         
            -
            return self.compile(aString);
         
     | 
| 
       1927 
     | 
    
         
            -
            return self;}
         
     | 
| 
       1928 
     | 
    
         
            -
            }),
         
     | 
| 
       1929 
     | 
    
         
            -
            smalltalk.RegularExpression);
         
     | 
| 
       1930 
     | 
    
         
            -
             
     | 
| 
       1931 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       1932 
     | 
    
         
            -
            '_exec_',
         
     | 
| 
       1933 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       1934 
     | 
    
         
            -
            selector: 'exec:',
         
     | 
| 
       1935 
     | 
    
         
            -
            fn: function (aString){
         
     | 
| 
       1936 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       1937 
     | 
    
         
            -
            return self.exec(aString) || nil;
         
     | 
| 
       1938 
     | 
    
         
            -
            return self;}
         
     | 
| 
       1939 
     | 
    
         
            -
            }),
         
     | 
| 
       1940 
     | 
    
         
            -
            smalltalk.RegularExpression);
         
     | 
| 
       1941 
     | 
    
         
            -
             
     | 
| 
       1942 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       1943 
     | 
    
         
            -
            '_test_',
         
     | 
| 
       1944 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       1945 
     | 
    
         
            -
            selector: 'test:',
         
     | 
| 
       1946 
     | 
    
         
            -
            fn: function (aString){
         
     | 
| 
       1947 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       1948 
     | 
    
         
            -
            return self.test(aString);
         
     | 
| 
       1949 
     | 
    
         
            -
            return self;}
         
     | 
| 
       1950 
     | 
    
         
            -
            }),
         
     | 
| 
       1951 
     | 
    
         
            -
            smalltalk.RegularExpression);
         
     | 
| 
       1952 
     | 
    
         
            -
             
     | 
| 
       1953 
     | 
    
         
            -
             
     | 
| 
       1954 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       1955 
     | 
    
         
            -
            '_fromString_flag_',
         
     | 
| 
       1956 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       1957 
     | 
    
         
            -
            selector: 'fromString:flag:',
         
     | 
| 
       1958 
     | 
    
         
            -
            fn: function (aString, anotherString){
         
     | 
| 
       1959 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       1960 
     | 
    
         
            -
            return new RegExp(aString, anotherString);
         
     | 
| 
       1961 
     | 
    
         
            -
            return self;}
         
     | 
| 
       1962 
     | 
    
         
            -
            }),
         
     | 
| 
       1963 
     | 
    
         
            -
            smalltalk.RegularExpression.klass);
         
     | 
| 
       1964 
     | 
    
         
            -
             
     | 
| 
       1965 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       1966 
     | 
    
         
            -
            '_fromString_',
         
     | 
| 
       1967 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       1968 
     | 
    
         
            -
            selector: 'fromString:',
         
     | 
| 
       1969 
     | 
    
         
            -
            fn: function (aString){
         
     | 
| 
       1970 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       1971 
     | 
    
         
            -
            return smalltalk.send(self, "_fromString_flag_", [aString, ""]);
         
     | 
| 
       1972 
     | 
    
         
            -
            return self;}
         
     | 
| 
       1973 
     | 
    
         
            -
            }),
         
     | 
| 
       1974 
     | 
    
         
            -
            smalltalk.RegularExpression.klass);
         
     | 
| 
       1975 
     | 
    
         
            -
             
     | 
| 
       1976 
     | 
    
         
            -
             
     | 
| 
       1977 
     | 
    
         
            -
            smalltalk.addClass('Association', smalltalk.Object, ['key', 'value'], 'Kernel-Collections');
         
     | 
| 
       1978 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       1979 
     | 
    
         
            -
            '__eq',
         
     | 
| 
       1980 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       1981 
     | 
    
         
            -
            selector: '=',
         
     | 
| 
       1982 
     | 
    
         
            -
            fn: function (anAssociation){
         
     | 
| 
       1983 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       1984 
     | 
    
         
            -
            return smalltalk.send(smalltalk.send(smalltalk.send(self, "_class", []), "__eq", [smalltalk.send(anAssociation, "_class", [])]), "_and_", [(function(){return smalltalk.send(smalltalk.send(smalltalk.send(self, "_key", []), "__eq", [smalltalk.send(anAssociation, "_key", [])]), "_and_", [(function(){return smalltalk.send(smalltalk.send(self, "_value", []), "__eq", [smalltalk.send(anAssociation, "_value", [])]);})]);})]);
         
     | 
| 
       1985 
     | 
    
         
            -
            return self;}
         
     | 
| 
       1986 
     | 
    
         
            -
            }),
         
     | 
| 
       1987 
     | 
    
         
            -
            smalltalk.Association);
         
     | 
| 
       1988 
     | 
    
         
            -
             
     | 
| 
       1989 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       1990 
     | 
    
         
            -
            '_key_',
         
     | 
| 
       1991 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       1992 
     | 
    
         
            -
            selector: 'key:',
         
     | 
| 
       1993 
     | 
    
         
            -
            fn: function (aKey){
         
     | 
| 
       1994 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       1995 
     | 
    
         
            -
            (self['@key']=aKey);
         
     | 
| 
       1996 
     | 
    
         
            -
            return self;}
         
     | 
| 
       1997 
     | 
    
         
            -
            }),
         
     | 
| 
       1998 
     | 
    
         
            -
            smalltalk.Association);
         
     | 
| 
       1999 
     | 
    
         
            -
             
     | 
| 
       2000 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       2001 
     | 
    
         
            -
            '_key',
         
     | 
| 
       2002 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       2003 
     | 
    
         
            -
            selector: 'key',
         
     | 
| 
       2004 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
       2005 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       2006 
     | 
    
         
            -
            return self['@key'];
         
     | 
| 
       2007 
     | 
    
         
            -
            return self;}
         
     | 
| 
       2008 
     | 
    
         
            -
            }),
         
     | 
| 
       2009 
     | 
    
         
            -
            smalltalk.Association);
         
     | 
| 
       2010 
     | 
    
         
            -
             
     | 
| 
       2011 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       2012 
     | 
    
         
            -
            '_value_',
         
     | 
| 
       2013 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       2014 
     | 
    
         
            -
            selector: 'value:',
         
     | 
| 
       2015 
     | 
    
         
            -
            fn: function (aValue){
         
     | 
| 
       2016 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       2017 
     | 
    
         
            -
            (self['@value']=aValue);
         
     | 
| 
       2018 
     | 
    
         
            -
            return self;}
         
     | 
| 
       2019 
     | 
    
         
            -
            }),
         
     | 
| 
       2020 
     | 
    
         
            -
            smalltalk.Association);
         
     | 
| 
       2021 
     | 
    
         
            -
             
     | 
| 
       2022 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       2023 
     | 
    
         
            -
            '_value',
         
     | 
| 
       2024 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       2025 
     | 
    
         
            -
            selector: 'value',
         
     | 
| 
       2026 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
       2027 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       2028 
     | 
    
         
            -
            return self['@value'];
         
     | 
| 
       2029 
     | 
    
         
            -
            return self;}
         
     | 
| 
       2030 
     | 
    
         
            -
            }),
         
     | 
| 
       2031 
     | 
    
         
            -
            smalltalk.Association);
         
     | 
| 
       2032 
     | 
    
         
            -
             
     | 
| 
       2033 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       2034 
     | 
    
         
            -
            '_storeOn_',
         
     | 
| 
       2035 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       2036 
     | 
    
         
            -
            selector: 'storeOn:',
         
     | 
| 
       2037 
     | 
    
         
            -
            fn: function (aStream){
         
     | 
| 
       2038 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       2039 
     | 
    
         
            -
            smalltalk.send(self['@key'], "_storeOn_", [aStream]);
         
     | 
| 
       2040 
     | 
    
         
            -
            smalltalk.send(aStream, "_nextPutAll_", [unescape("-%3E")]);
         
     | 
| 
       2041 
     | 
    
         
            -
            smalltalk.send(self['@value'], "_storeOn_", [aStream]);
         
     | 
| 
       2042 
     | 
    
         
            -
            return self;}
         
     | 
| 
       2043 
     | 
    
         
            -
            }),
         
     | 
| 
       2044 
     | 
    
         
            -
            smalltalk.Association);
         
     | 
| 
       2045 
     | 
    
         
            -
             
     | 
| 
       2046 
     | 
    
         
            -
             
     | 
| 
       2047 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       2048 
     | 
    
         
            -
            '_key_value_',
         
     | 
| 
       2049 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       2050 
     | 
    
         
            -
            selector: 'key:value:',
         
     | 
| 
       2051 
     | 
    
         
            -
            fn: function (aKey, aValue){
         
     | 
| 
       2052 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       2053 
     | 
    
         
            -
            return (function($rec){smalltalk.send($rec, "_key_", [aKey]);smalltalk.send($rec, "_value_", [aValue]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new", []));
         
     | 
| 
       2054 
     | 
    
         
            -
            return self;}
         
     | 
| 
       2055 
     | 
    
         
            -
            }),
         
     | 
| 
       2056 
     | 
    
         
            -
            smalltalk.Association.klass);
         
     | 
| 
       2057 
     | 
    
         
            -
             
     | 
| 
       2058 
     | 
    
         
            -
             
     | 
| 
       2059 
     | 
    
         
            -
            smalltalk.addClass('Stream', smalltalk.Object, ['collection', 'position', 'streamSize'], 'Kernel-Collections');
         
     | 
| 
       2060 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       2061 
     | 
    
         
            -
            '_collection',
         
     | 
| 
       2062 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       2063 
     | 
    
         
            -
            selector: 'collection',
         
     | 
| 
       2064 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
       2065 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       2066 
     | 
    
         
            -
            return self['@collection'];
         
     | 
| 
       2067 
     | 
    
         
            -
            return self;}
         
     | 
| 
       2068 
     | 
    
         
            -
            }),
         
     | 
| 
       2069 
     | 
    
         
            -
            smalltalk.Stream);
         
     | 
| 
       2070 
     | 
    
         
            -
             
     | 
| 
       2071 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       2072 
     | 
    
         
            -
            '_setCollection_',
         
     | 
| 
       2073 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       2074 
     | 
    
         
            -
            selector: 'setCollection:',
         
     | 
| 
       2075 
     | 
    
         
            -
            fn: function (aCollection){
         
     | 
| 
       2076 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       2077 
     | 
    
         
            -
            (self['@collection']=aCollection);
         
     | 
| 
       2078 
     | 
    
         
            -
            return self;}
         
     | 
| 
       2079 
     | 
    
         
            -
            }),
         
     | 
| 
       2080 
     | 
    
         
            -
            smalltalk.Stream);
         
     | 
| 
       2081 
     | 
    
         
            -
             
     | 
| 
       2082 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       2083 
     | 
    
         
            -
            '_position',
         
     | 
| 
       2084 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       2085 
     | 
    
         
            -
            selector: 'position',
         
     | 
| 
       2086 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
       2087 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       2088 
     | 
    
         
            -
            return (($receiver = self['@position']) == nil || $receiver == undefined) ? (function(){return (self['@position']=(0));})() : $receiver;
         
     | 
| 
       2089 
     | 
    
         
            -
            return self;}
         
     | 
| 
       2090 
     | 
    
         
            -
            }),
         
     | 
| 
       2091 
     | 
    
         
            -
            smalltalk.Stream);
         
     | 
| 
       2092 
     | 
    
         
            -
             
     | 
| 
       2093 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       2094 
     | 
    
         
            -
            '_position_',
         
     | 
| 
       2095 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       2096 
     | 
    
         
            -
            selector: 'position:',
         
     | 
| 
       2097 
     | 
    
         
            -
            fn: function (anInteger){
         
     | 
| 
       2098 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       2099 
     | 
    
         
            -
            (self['@position']=anInteger);
         
     | 
| 
       2100 
     | 
    
         
            -
            return self;}
         
     | 
| 
       2101 
     | 
    
         
            -
            }),
         
     | 
| 
       2102 
     | 
    
         
            -
            smalltalk.Stream);
         
     | 
| 
       2103 
     | 
    
         
            -
             
     | 
| 
      
 2332 
     | 
    
         
            +
            smalltalk.addClass('Array', smalltalk.SequenceableCollection, [], 'Kernel-Collections');
         
     | 
| 
       2104 
2333 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2105 
     | 
    
         
            -
            ' 
     | 
| 
      
 2334 
     | 
    
         
            +
            unescape('_size'),
         
     | 
| 
       2106 
2335 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2107 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 2336 
     | 
    
         
            +
            selector: unescape('size'),
         
     | 
| 
       2108 
2337 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2109 
2338 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2110 
     | 
    
         
            -
            return self 
     | 
| 
      
 2339 
     | 
    
         
            +
            return self.length;
         
     | 
| 
       2111 
2340 
     | 
    
         
             
            return self;}
         
     | 
| 
       2112 
2341 
     | 
    
         
             
            }),
         
     | 
| 
       2113 
     | 
    
         
            -
            smalltalk. 
     | 
| 
      
 2342 
     | 
    
         
            +
            smalltalk.Array);
         
     | 
| 
       2114 
2343 
     | 
    
         | 
| 
       2115 
2344 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2116 
     | 
    
         
            -
            ' 
     | 
| 
      
 2345 
     | 
    
         
            +
            unescape('_at_put_'),
         
     | 
| 
       2117 
2346 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2118 
     | 
    
         
            -
            selector: ' 
     | 
| 
       2119 
     | 
    
         
            -
            fn: function ( 
     | 
| 
      
 2347 
     | 
    
         
            +
            selector: unescape('at%3Aput%3A'),
         
     | 
| 
      
 2348 
     | 
    
         
            +
            fn: function (anIndex, anObject){
         
     | 
| 
       2120 
2349 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2121 
     | 
    
         
            -
             
     | 
| 
      
 2350 
     | 
    
         
            +
            return self[anIndex - 1] = anObject;
         
     | 
| 
       2122 
2351 
     | 
    
         
             
            return self;}
         
     | 
| 
       2123 
2352 
     | 
    
         
             
            }),
         
     | 
| 
       2124 
     | 
    
         
            -
            smalltalk. 
     | 
| 
      
 2353 
     | 
    
         
            +
            smalltalk.Array);
         
     | 
| 
       2125 
2354 
     | 
    
         | 
| 
       2126 
2355 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2127 
     | 
    
         
            -
            ' 
     | 
| 
      
 2356 
     | 
    
         
            +
            unescape('_at_ifAbsent_'),
         
     | 
| 
       2128 
2357 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2129 
     | 
    
         
            -
            selector: ' 
     | 
| 
       2130 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
      
 2358 
     | 
    
         
            +
            selector: unescape('at%3AifAbsent%3A'),
         
     | 
| 
      
 2359 
     | 
    
         
            +
            fn: function (anIndex, aBlock){
         
     | 
| 
       2131 
2360 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2132 
     | 
    
         
            -
            return smalltalk.send(smalltalk.send(self, "_collection", []), "_copyFrom_to_", [(1), smalltalk.send(self, "_streamSize", [])]);
         
     | 
| 
       2133 
     | 
    
         
            -
            return self;}
         
     | 
| 
       2134 
     | 
    
         
            -
            }),
         
     | 
| 
       2135 
     | 
    
         
            -
            smalltalk.Stream);
         
     | 
| 
       2136 
2361 
     | 
    
         | 
| 
       2137 
     | 
    
         
            -
             
     | 
| 
       2138 
     | 
    
         
            -
             
     | 
| 
       2139 
     | 
    
         
            -
             
     | 
| 
       2140 
     | 
    
         
            -
             
     | 
| 
       2141 
     | 
    
         
            -
             
     | 
| 
       2142 
     | 
    
         
            -
             
     | 
| 
       2143 
     | 
    
         
            -
             
     | 
| 
      
 2362 
     | 
    
         
            +
            	    var value = self[anIndex - 1];
         
     | 
| 
      
 2363 
     | 
    
         
            +
            	    if(value === undefined) {
         
     | 
| 
      
 2364 
     | 
    
         
            +
            		return aBlock();
         
     | 
| 
      
 2365 
     | 
    
         
            +
            	    } else {
         
     | 
| 
      
 2366 
     | 
    
         
            +
            		return value;
         
     | 
| 
      
 2367 
     | 
    
         
            +
            	    }
         
     | 
| 
      
 2368 
     | 
    
         
            +
            	;
         
     | 
| 
       2144 
2369 
     | 
    
         
             
            return self;}
         
     | 
| 
       2145 
2370 
     | 
    
         
             
            }),
         
     | 
| 
       2146 
     | 
    
         
            -
            smalltalk. 
     | 
| 
      
 2371 
     | 
    
         
            +
            smalltalk.Array);
         
     | 
| 
       2147 
2372 
     | 
    
         | 
| 
       2148 
2373 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2149 
     | 
    
         
            -
            ' 
     | 
| 
      
 2374 
     | 
    
         
            +
            unescape('_add_'),
         
     | 
| 
       2150 
2375 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2151 
     | 
    
         
            -
            selector: ' 
     | 
| 
       2152 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
      
 2376 
     | 
    
         
            +
            selector: unescape('add%3A'),
         
     | 
| 
      
 2377 
     | 
    
         
            +
            fn: function (anObject){
         
     | 
| 
       2153 
2378 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2154 
     | 
    
         
            -
             
     | 
| 
      
 2379 
     | 
    
         
            +
            self.push(anObject); return anObject;;
         
     | 
| 
       2155 
2380 
     | 
    
         
             
            return self;}
         
     | 
| 
       2156 
2381 
     | 
    
         
             
            }),
         
     | 
| 
       2157 
     | 
    
         
            -
            smalltalk. 
     | 
| 
      
 2382 
     | 
    
         
            +
            smalltalk.Array);
         
     | 
| 
       2158 
2383 
     | 
    
         | 
| 
       2159 
2384 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2160 
     | 
    
         
            -
            ' 
     | 
| 
      
 2385 
     | 
    
         
            +
            unescape('_join_'),
         
     | 
| 
       2161 
2386 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2162 
     | 
    
         
            -
            selector: ' 
     | 
| 
       2163 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
      
 2387 
     | 
    
         
            +
            selector: unescape('join%3A'),
         
     | 
| 
      
 2388 
     | 
    
         
            +
            fn: function (aString){
         
     | 
| 
       2164 
2389 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2165 
     | 
    
         
            -
             
     | 
| 
      
 2390 
     | 
    
         
            +
            return self.join(aString);
         
     | 
| 
       2166 
2391 
     | 
    
         
             
            return self;}
         
     | 
| 
       2167 
2392 
     | 
    
         
             
            }),
         
     | 
| 
       2168 
     | 
    
         
            -
            smalltalk. 
     | 
| 
      
 2393 
     | 
    
         
            +
            smalltalk.Array);
         
     | 
| 
       2169 
2394 
     | 
    
         | 
| 
       2170 
2395 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2171 
     | 
    
         
            -
            ' 
     | 
| 
      
 2396 
     | 
    
         
            +
            unescape('_asJavascript'),
         
     | 
| 
       2172 
2397 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2173 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 2398 
     | 
    
         
            +
            selector: unescape('asJavascript'),
         
     | 
| 
       2174 
2399 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2175 
2400 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2176 
     | 
    
         
            -
             
     | 
| 
      
 2401 
     | 
    
         
            +
            return smalltalk.send(smalltalk.send(unescape("%5B"), "__comma", [smalltalk.send(smalltalk.send(self, "_collect_", [(function(each){return smalltalk.send(each, "_asJavascript", []);})]), "_join_", [unescape("%2C%20")])]), "__comma", [unescape("%5D")]);
         
     | 
| 
       2177 
2402 
     | 
    
         
             
            return self;}
         
     | 
| 
       2178 
2403 
     | 
    
         
             
            }),
         
     | 
| 
       2179 
     | 
    
         
            -
            smalltalk. 
     | 
| 
      
 2404 
     | 
    
         
            +
            smalltalk.Array);
         
     | 
| 
       2180 
2405 
     | 
    
         | 
| 
       2181 
2406 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2182 
     | 
    
         
            -
            ' 
     | 
| 
      
 2407 
     | 
    
         
            +
            unescape('_sort'),
         
     | 
| 
       2183 
2408 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2184 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 2409 
     | 
    
         
            +
            selector: unescape('sort'),
         
     | 
| 
       2185 
2410 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2186 
2411 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2187 
     | 
    
         
            -
            smalltalk.send(self, " 
     | 
| 
       2188 
     | 
    
         
            -
            smalltalk.send(self, "_setStreamSize_", [(0)]);
         
     | 
| 
      
 2412 
     | 
    
         
            +
            return smalltalk.send(self, "_basicPerform_", ["sort"]);
         
     | 
| 
       2189 
2413 
     | 
    
         
             
            return self;}
         
     | 
| 
       2190 
2414 
     | 
    
         
             
            }),
         
     | 
| 
       2191 
     | 
    
         
            -
            smalltalk. 
     | 
| 
      
 2415 
     | 
    
         
            +
            smalltalk.Array);
         
     | 
| 
       2192 
2416 
     | 
    
         | 
| 
       2193 
2417 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2194 
     | 
    
         
            -
            ' 
     | 
| 
      
 2418 
     | 
    
         
            +
            unescape('_sort_'),
         
     | 
| 
       2195 
2419 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2196 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 2420 
     | 
    
         
            +
            selector: unescape('sort%3A'),
         
     | 
| 
       2197 
2421 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       2198 
2422 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2199 
     | 
    
         
            -
            (function(){while(!(function(){return smalltalk.send(self, "_atEnd", []);})()) {(function(){return smalltalk.send(aBlock, "_value_", [smalltalk.send(self, "_next", [])]);})()}})();
         
     | 
| 
       2200 
     | 
    
         
            -
            return self;}
         
     | 
| 
       2201 
     | 
    
         
            -
            }),
         
     | 
| 
       2202 
     | 
    
         
            -
            smalltalk.Stream);
         
     | 
| 
       2203 
2423 
     | 
    
         | 
| 
       2204 
     | 
    
         
            -
             
     | 
| 
       2205 
     | 
    
         
            -
             
     | 
| 
       2206 
     | 
    
         
            -
             
     | 
| 
       2207 
     | 
    
         
            -
             
     | 
| 
       2208 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
       2209 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       2210 
     | 
    
         
            -
            smalltalk.send(self, "_position_", [smalltalk.send(self, "_size", [])]);
         
     | 
| 
      
 2424 
     | 
    
         
            +
            		return self.sort(function(a, b) {
         
     | 
| 
      
 2425 
     | 
    
         
            +
            			if(aBlock(a,b)) {return -1} else {return 1}
         
     | 
| 
      
 2426 
     | 
    
         
            +
            		})
         
     | 
| 
      
 2427 
     | 
    
         
            +
            	;
         
     | 
| 
       2211 
2428 
     | 
    
         
             
            return self;}
         
     | 
| 
       2212 
2429 
     | 
    
         
             
            }),
         
     | 
| 
       2213 
     | 
    
         
            -
            smalltalk. 
     | 
| 
      
 2430 
     | 
    
         
            +
            smalltalk.Array);
         
     | 
| 
       2214 
2431 
     | 
    
         | 
| 
       2215 
2432 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2216 
     | 
    
         
            -
            ' 
     | 
| 
      
 2433 
     | 
    
         
            +
            unescape('_remove_'),
         
     | 
| 
       2217 
2434 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2218 
     | 
    
         
            -
            selector: ' 
     | 
| 
       2219 
     | 
    
         
            -
            fn: function ( 
     | 
| 
      
 2435 
     | 
    
         
            +
            selector: unescape('remove%3A'),
         
     | 
| 
      
 2436 
     | 
    
         
            +
            fn: function (anObject){
         
     | 
| 
       2220 
2437 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2221 
     | 
    
         
            -
             
     | 
| 
      
 2438 
     | 
    
         
            +
             
     | 
| 
      
 2439 
     | 
    
         
            +
            		for(var i=0;i<self.length;i++) {
         
     | 
| 
      
 2440 
     | 
    
         
            +
            			if(self[i] == anObject) {
         
     | 
| 
      
 2441 
     | 
    
         
            +
            				self.splice(i,1);
         
     | 
| 
      
 2442 
     | 
    
         
            +
            				break;
         
     | 
| 
      
 2443 
     | 
    
         
            +
            			}
         
     | 
| 
      
 2444 
     | 
    
         
            +
            		}
         
     | 
| 
      
 2445 
     | 
    
         
            +
            	;
         
     | 
| 
       2222 
2446 
     | 
    
         
             
            return self;}
         
     | 
| 
       2223 
2447 
     | 
    
         
             
            }),
         
     | 
| 
       2224 
     | 
    
         
            -
            smalltalk. 
     | 
| 
      
 2448 
     | 
    
         
            +
            smalltalk.Array);
         
     | 
| 
       2225 
2449 
     | 
    
         | 
| 
       2226 
2450 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2227 
     | 
    
         
            -
            ' 
     | 
| 
      
 2451 
     | 
    
         
            +
            unescape('_sorted'),
         
     | 
| 
       2228 
2452 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2229 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 2453 
     | 
    
         
            +
            selector: unescape('sorted'),
         
     | 
| 
       2230 
2454 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2231 
2455 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2232 
     | 
    
         
            -
            return  
     | 
| 
      
 2456 
     | 
    
         
            +
            return smalltalk.send(smalltalk.send(self, "_copy", []), "_sort", []);
         
     | 
| 
       2233 
2457 
     | 
    
         
             
            return self;}
         
     | 
| 
       2234 
2458 
     | 
    
         
             
            }),
         
     | 
| 
       2235 
     | 
    
         
            -
            smalltalk. 
     | 
| 
      
 2459 
     | 
    
         
            +
            smalltalk.Array);
         
     | 
| 
       2236 
2460 
     | 
    
         | 
| 
       2237 
2461 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2238 
     | 
    
         
            -
            ' 
     | 
| 
      
 2462 
     | 
    
         
            +
            unescape('_sorted_'),
         
     | 
| 
       2239 
2463 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2240 
     | 
    
         
            -
            selector: ' 
     | 
| 
       2241 
     | 
    
         
            -
            fn: function ( 
     | 
| 
      
 2464 
     | 
    
         
            +
            selector: unescape('sorted%3A'),
         
     | 
| 
      
 2465 
     | 
    
         
            +
            fn: function (aBlock){
         
     | 
| 
       2242 
2466 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2243 
     | 
    
         
            -
             
     | 
| 
       2244 
     | 
    
         
            -
            (tempCollection=smalltalk.send(smalltalk.send(smalltalk.send(self, "_collection", []), "_class", []), "_new", []));
         
     | 
| 
       2245 
     | 
    
         
            -
            smalltalk.send(anInteger, "_timesRepeat_", [(function(){return ((($receiver = smalltalk.send(self, "_atEnd", [])).klass === smalltalk.Boolean) ? (! $receiver ? (function(){return smalltalk.send(tempCollection, "_add_", [smalltalk.send(self, "_next", [])]);})() : nil) : smalltalk.send($receiver, "_ifFalse_", [(function(){return smalltalk.send(tempCollection, "_add_", [smalltalk.send(self, "_next", [])]);})]));})]);
         
     | 
| 
       2246 
     | 
    
         
            -
            return tempCollection;
         
     | 
| 
      
 2467 
     | 
    
         
            +
            return smalltalk.send(smalltalk.send(self, "_copy", []), "_sort_", [aBlock]);
         
     | 
| 
       2247 
2468 
     | 
    
         
             
            return self;}
         
     | 
| 
       2248 
2469 
     | 
    
         
             
            }),
         
     | 
| 
       2249 
     | 
    
         
            -
            smalltalk. 
     | 
| 
      
 2470 
     | 
    
         
            +
            smalltalk.Array);
         
     | 
| 
       2250 
2471 
     | 
    
         | 
| 
       2251 
2472 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2252 
     | 
    
         
            -
            ' 
     | 
| 
      
 2473 
     | 
    
         
            +
            unescape('_removeFrom_to_'),
         
     | 
| 
       2253 
2474 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2254 
     | 
    
         
            -
            selector: ' 
     | 
| 
       2255 
     | 
    
         
            -
            fn: function ( 
     | 
| 
      
 2475 
     | 
    
         
            +
            selector: unescape('removeFrom%3Ato%3A'),
         
     | 
| 
      
 2476 
     | 
    
         
            +
            fn: function (aNumber, anotherNumber){
         
     | 
| 
       2256 
2477 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2257 
     | 
    
         
            -
             
     | 
| 
       2258 
     | 
    
         
            -
            smalltalk.send(smalltalk.send(self, "_collection", []), "_at_put_", [smalltalk.send(self, "_position", []), anObject]);
         
     | 
| 
       2259 
     | 
    
         
            -
            smalltalk.send(self, "_setStreamSize_", [smalltalk.send(smalltalk.send(self, "_streamSize", []), "_max_", [smalltalk.send(self, "_position", [])])]);
         
     | 
| 
      
 2478 
     | 
    
         
            +
            self.splice(aNumber - 1,anotherNumber - 1);
         
     | 
| 
       2260 
2479 
     | 
    
         
             
            return self;}
         
     | 
| 
       2261 
2480 
     | 
    
         
             
            }),
         
     | 
| 
       2262 
     | 
    
         
            -
            smalltalk. 
     | 
| 
      
 2481 
     | 
    
         
            +
            smalltalk.Array);
         
     | 
| 
       2263 
2482 
     | 
    
         | 
| 
       2264 
2483 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2265 
     | 
    
         
            -
            ' 
     | 
| 
      
 2484 
     | 
    
         
            +
            unescape('_reversed'),
         
     | 
| 
       2266 
2485 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2267 
     | 
    
         
            -
            selector: ' 
     | 
| 
       2268 
     | 
    
         
            -
            fn: function ( 
     | 
| 
      
 2486 
     | 
    
         
            +
            selector: unescape('reversed'),
         
     | 
| 
      
 2487 
     | 
    
         
            +
            fn: function (){
         
     | 
| 
       2269 
2488 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2270 
     | 
    
         
            -
             
     | 
| 
      
 2489 
     | 
    
         
            +
            return self._copy().reverse();
         
     | 
| 
       2271 
2490 
     | 
    
         
             
            return self;}
         
     | 
| 
       2272 
2491 
     | 
    
         
             
            }),
         
     | 
| 
       2273 
     | 
    
         
            -
            smalltalk. 
     | 
| 
      
 2492 
     | 
    
         
            +
            smalltalk.Array);
         
     | 
| 
      
 2493 
     | 
    
         
            +
             
     | 
| 
       2274 
2494 
     | 
    
         | 
| 
       2275 
2495 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2276 
     | 
    
         
            -
            ' 
     | 
| 
      
 2496 
     | 
    
         
            +
            unescape('_new_'),
         
     | 
| 
       2277 
2497 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2278 
     | 
    
         
            -
            selector: ' 
     | 
| 
       2279 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
      
 2498 
     | 
    
         
            +
            selector: unescape('new%3A'),
         
     | 
| 
      
 2499 
     | 
    
         
            +
            fn: function (anInteger){
         
     | 
| 
       2280 
2500 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2281 
     | 
    
         
            -
            return  
     | 
| 
      
 2501 
     | 
    
         
            +
            return new Array(anInteger);
         
     | 
| 
       2282 
2502 
     | 
    
         
             
            return self;}
         
     | 
| 
       2283 
2503 
     | 
    
         
             
            }),
         
     | 
| 
       2284 
     | 
    
         
            -
            smalltalk. 
     | 
| 
      
 2504 
     | 
    
         
            +
            smalltalk.Array.klass);
         
     | 
| 
       2285 
2505 
     | 
    
         | 
| 
       2286 
2506 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2287 
     | 
    
         
            -
            ' 
     | 
| 
      
 2507 
     | 
    
         
            +
            unescape('_with_'),
         
     | 
| 
       2288 
2508 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2289 
     | 
    
         
            -
            selector: ' 
     | 
| 
       2290 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
      
 2509 
     | 
    
         
            +
            selector: unescape('with%3A'),
         
     | 
| 
      
 2510 
     | 
    
         
            +
            fn: function (anObject){
         
     | 
| 
       2291 
2511 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2292 
     | 
    
         
            -
            return  
     | 
| 
      
 2512 
     | 
    
         
            +
            return (function($rec){smalltalk.send($rec, "_at_put_", [(1), anObject]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new_", [(1)]));
         
     | 
| 
       2293 
2513 
     | 
    
         
             
            return self;}
         
     | 
| 
       2294 
2514 
     | 
    
         
             
            }),
         
     | 
| 
       2295 
     | 
    
         
            -
            smalltalk. 
     | 
| 
      
 2515 
     | 
    
         
            +
            smalltalk.Array.klass);
         
     | 
| 
       2296 
2516 
     | 
    
         | 
| 
       2297 
2517 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2298 
     | 
    
         
            -
            ' 
     | 
| 
      
 2518 
     | 
    
         
            +
            unescape('_with_with_'),
         
     | 
| 
       2299 
2519 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2300 
     | 
    
         
            -
            selector: ' 
     | 
| 
       2301 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
      
 2520 
     | 
    
         
            +
            selector: unescape('with%3Awith%3A'),
         
     | 
| 
      
 2521 
     | 
    
         
            +
            fn: function (anObject, anObject2){
         
     | 
| 
       2302 
2522 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2303 
     | 
    
         
            -
            return smalltalk.send(smalltalk.send( 
     | 
| 
      
 2523 
     | 
    
         
            +
            return (function($rec){smalltalk.send($rec, "_at_put_", [(1), anObject]);smalltalk.send($rec, "_at_put_", [(2), anObject2]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new_", [(2)]));
         
     | 
| 
       2304 
2524 
     | 
    
         
             
            return self;}
         
     | 
| 
       2305 
2525 
     | 
    
         
             
            }),
         
     | 
| 
       2306 
     | 
    
         
            -
            smalltalk. 
     | 
| 
      
 2526 
     | 
    
         
            +
            smalltalk.Array.klass);
         
     | 
| 
       2307 
2527 
     | 
    
         | 
| 
       2308 
2528 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2309 
     | 
    
         
            -
            ' 
     | 
| 
      
 2529 
     | 
    
         
            +
            unescape('_with_with_with_'),
         
     | 
| 
       2310 
2530 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2311 
     | 
    
         
            -
            selector: ' 
     | 
| 
       2312 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
      
 2531 
     | 
    
         
            +
            selector: unescape('with%3Awith%3Awith%3A'),
         
     | 
| 
      
 2532 
     | 
    
         
            +
            fn: function (anObject, anObject2, anObject3){
         
     | 
| 
       2313 
2533 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2314 
     | 
    
         
            -
            return smalltalk.send(smalltalk.send( 
     | 
| 
      
 2534 
     | 
    
         
            +
            return (function($rec){smalltalk.send($rec, "_at_put_", [(1), anObject]);smalltalk.send($rec, "_at_put_", [(2), anObject2]);smalltalk.send($rec, "_at_put_", [(3), anObject3]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new_", [(3)]));
         
     | 
| 
       2315 
2535 
     | 
    
         
             
            return self;}
         
     | 
| 
       2316 
2536 
     | 
    
         
             
            }),
         
     | 
| 
       2317 
     | 
    
         
            -
            smalltalk. 
     | 
| 
       2318 
     | 
    
         
            -
             
     | 
| 
      
 2537 
     | 
    
         
            +
            smalltalk.Array.klass);
         
     | 
| 
       2319 
2538 
     | 
    
         | 
| 
       2320 
2539 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2321 
     | 
    
         
            -
            ' 
     | 
| 
      
 2540 
     | 
    
         
            +
            unescape('_withAll_'),
         
     | 
| 
       2322 
2541 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2323 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 2542 
     | 
    
         
            +
            selector: unescape('withAll%3A'),
         
     | 
| 
       2324 
2543 
     | 
    
         
             
            fn: function (aCollection){
         
     | 
| 
       2325 
2544 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2326 
     | 
    
         
            -
             
     | 
| 
      
 2545 
     | 
    
         
            +
            var instance=nil;
         
     | 
| 
      
 2546 
     | 
    
         
            +
            (instance=smalltalk.send(self, "_new_", [smalltalk.send(aCollection, "_size", [])]));
         
     | 
| 
      
 2547 
     | 
    
         
            +
            smalltalk.send(aCollection, "_withIndexDo_", [(function(index, each){return smalltalk.send(instance, "_at_put_", [index, each]);})]);
         
     | 
| 
      
 2548 
     | 
    
         
            +
            return instance;
         
     | 
| 
       2327 
2549 
     | 
    
         
             
            return self;}
         
     | 
| 
       2328 
2550 
     | 
    
         
             
            }),
         
     | 
| 
       2329 
     | 
    
         
            -
            smalltalk. 
     | 
| 
      
 2551 
     | 
    
         
            +
            smalltalk.Array.klass);
         
     | 
| 
       2330 
2552 
     | 
    
         | 
| 
       2331 
2553 
     | 
    
         | 
| 
       2332 
2554 
     | 
    
         
             
            smalltalk.addClass('StringStream', smalltalk.Stream, [], 'Kernel-Collections');
         
     | 
| 
       2333 
2555 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2334 
     | 
    
         
            -
            '_next_',
         
     | 
| 
      
 2556 
     | 
    
         
            +
            unescape('_next_'),
         
     | 
| 
       2335 
2557 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2336 
     | 
    
         
            -
            selector: 'next 
     | 
| 
      
 2558 
     | 
    
         
            +
            selector: unescape('next%3A'),
         
     | 
| 
       2337 
2559 
     | 
    
         
             
            fn: function (anInteger){
         
     | 
| 
       2338 
2560 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2339 
2561 
     | 
    
         
             
            var tempCollection=nil;
         
     | 
| 
         @@ -2345,9 +2567,9 @@ return self;} 
     | 
|
| 
       2345 
2567 
     | 
    
         
             
            smalltalk.StringStream);
         
     | 
| 
       2346 
2568 
     | 
    
         | 
| 
       2347 
2569 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2348 
     | 
    
         
            -
            '_nextPut_',
         
     | 
| 
      
 2570 
     | 
    
         
            +
            unescape('_nextPut_'),
         
     | 
| 
       2349 
2571 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2350 
     | 
    
         
            -
            selector: 'nextPut 
     | 
| 
      
 2572 
     | 
    
         
            +
            selector: unescape('nextPut%3A'),
         
     | 
| 
       2351 
2573 
     | 
    
         
             
            fn: function (aString){
         
     | 
| 
       2352 
2574 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2353 
2575 
     | 
    
         
             
            smalltalk.send(self, "_nextPutAll_", [aString]);
         
     | 
| 
         @@ -2356,9 +2578,9 @@ return self;} 
     | 
|
| 
       2356 
2578 
     | 
    
         
             
            smalltalk.StringStream);
         
     | 
| 
       2357 
2579 
     | 
    
         | 
| 
       2358 
2580 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2359 
     | 
    
         
            -
            '_nextPutAll_',
         
     | 
| 
      
 2581 
     | 
    
         
            +
            unescape('_nextPutAll_'),
         
     | 
| 
       2360 
2582 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2361 
     | 
    
         
            -
            selector: 'nextPutAll 
     | 
| 
      
 2583 
     | 
    
         
            +
            selector: unescape('nextPutAll%3A'),
         
     | 
| 
       2362 
2584 
     | 
    
         
             
            fn: function (aString){
         
     | 
| 
       2363 
2585 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2364 
2586 
     | 
    
         
             
            smalltalk.send(self, "_setCollection_", [smalltalk.send(smalltalk.send(smalltalk.send(smalltalk.send(self, "_collection", []), "_copyFrom_to_", [(1), smalltalk.send(self, "_position", [])]), "__comma", [aString]), "__comma", [smalltalk.send(smalltalk.send(self, "_collection", []), "_copyFrom_to_", [((($receiver = ((($receiver = smalltalk.send(self, "_position", [])).klass === smalltalk.Number) ? $receiver +(1) : smalltalk.send($receiver, "__plus", [(1)]))).klass === smalltalk.Number) ? $receiver +smalltalk.send(aString, "_size", []) : smalltalk.send($receiver, "__plus", [smalltalk.send(aString, "_size", [])])), smalltalk.send(smalltalk.send(self, "_collection", []), "_size", [])])])]);
         
     | 
| 
         @@ -2369,9 +2591,9 @@ return self;} 
     | 
|
| 
       2369 
2591 
     | 
    
         
             
            smalltalk.StringStream);
         
     | 
| 
       2370 
2592 
     | 
    
         | 
| 
       2371 
2593 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2372 
     | 
    
         
            -
            '_cr',
         
     | 
| 
      
 2594 
     | 
    
         
            +
            unescape('_cr'),
         
     | 
| 
       2373 
2595 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2374 
     | 
    
         
            -
            selector: 'cr',
         
     | 
| 
      
 2596 
     | 
    
         
            +
            selector: unescape('cr'),
         
     | 
| 
       2375 
2597 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2376 
2598 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2377 
2599 
     | 
    
         
             
            return smalltalk.send(self, "_nextPutAll_", [smalltalk.send((smalltalk.String || String), "_cr", [])]);
         
     | 
| 
         @@ -2380,9 +2602,9 @@ return self;} 
     | 
|
| 
       2380 
2602 
     | 
    
         
             
            smalltalk.StringStream);
         
     | 
| 
       2381 
2603 
     | 
    
         | 
| 
       2382 
2604 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2383 
     | 
    
         
            -
            '_crlf',
         
     | 
| 
      
 2605 
     | 
    
         
            +
            unescape('_crlf'),
         
     | 
| 
       2384 
2606 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2385 
     | 
    
         
            -
            selector: 'crlf',
         
     | 
| 
      
 2607 
     | 
    
         
            +
            selector: unescape('crlf'),
         
     | 
| 
       2386 
2608 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2387 
2609 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2388 
2610 
     | 
    
         
             
            return smalltalk.send(self, "_nextPutAll_", [smalltalk.send((smalltalk.String || String), "_crlf", [])]);
         
     | 
| 
         @@ -2391,9 +2613,9 @@ return self;} 
     | 
|
| 
       2391 
2613 
     | 
    
         
             
            smalltalk.StringStream);
         
     | 
| 
       2392 
2614 
     | 
    
         | 
| 
       2393 
2615 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2394 
     | 
    
         
            -
            '_lf',
         
     | 
| 
      
 2616 
     | 
    
         
            +
            unescape('_lf'),
         
     | 
| 
       2395 
2617 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2396 
     | 
    
         
            -
            selector: 'lf',
         
     | 
| 
      
 2618 
     | 
    
         
            +
            selector: unescape('lf'),
         
     | 
| 
       2397 
2619 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2398 
2620 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2399 
2621 
     | 
    
         
             
            return smalltalk.send(self, "_nextPutAll_", [smalltalk.send((smalltalk.String || String), "_lf", [])]);
         
     | 
| 
         @@ -2402,9 +2624,9 @@ return self;} 
     | 
|
| 
       2402 
2624 
     | 
    
         
             
            smalltalk.StringStream);
         
     | 
| 
       2403 
2625 
     | 
    
         | 
| 
       2404 
2626 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2405 
     | 
    
         
            -
            '_space',
         
     | 
| 
      
 2627 
     | 
    
         
            +
            unescape('_space'),
         
     | 
| 
       2406 
2628 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2407 
     | 
    
         
            -
            selector: 'space',
         
     | 
| 
      
 2629 
     | 
    
         
            +
            selector: unescape('space'),
         
     | 
| 
       2408 
2630 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2409 
2631 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2410 
2632 
     | 
    
         
             
            smalltalk.send(self, "_nextPut_", [" "]);
         
     | 
| 
         @@ -2416,14 +2638,14 @@ smalltalk.StringStream); 
     | 
|
| 
       2416 
2638 
     | 
    
         | 
| 
       2417 
2639 
     | 
    
         
             
            smalltalk.addClass('Set', smalltalk.Collection, ['elements'], 'Kernel-Collections');
         
     | 
| 
       2418 
2640 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2419 
     | 
    
         
            -
            '_add_',
         
     | 
| 
      
 2641 
     | 
    
         
            +
            unescape('_add_'),
         
     | 
| 
       2420 
2642 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2421 
     | 
    
         
            -
            selector: 'add 
     | 
| 
      
 2643 
     | 
    
         
            +
            selector: unescape('add%3A'),
         
     | 
| 
       2422 
2644 
     | 
    
         
             
            fn: function (anObject){
         
     | 
| 
       2423 
2645 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2424 
2646 
     | 
    
         | 
| 
       2425 
2647 
     | 
    
         
             
            		var found;
         
     | 
| 
       2426 
     | 
    
         
            -
            		for(var i  
     | 
| 
      
 2648 
     | 
    
         
            +
            		for(var i=0; i < self['@elements'].length; i++) {
         
     | 
| 
       2427 
2649 
     | 
    
         
             
            			if(anObject == self['@elements'][i]) {
         
     | 
| 
       2428 
2650 
     | 
    
         
             
            				found = true;
         
     | 
| 
       2429 
2651 
     | 
    
         
             
            				break;
         
     | 
| 
         @@ -2436,9 +2658,9 @@ return self;} 
     | 
|
| 
       2436 
2658 
     | 
    
         
             
            smalltalk.Set);
         
     | 
| 
       2437 
2659 
     | 
    
         | 
| 
       2438 
2660 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2439 
     | 
    
         
            -
            '_remove_',
         
     | 
| 
      
 2661 
     | 
    
         
            +
            unescape('_remove_'),
         
     | 
| 
       2440 
2662 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2441 
     | 
    
         
            -
            selector: 'remove 
     | 
| 
      
 2663 
     | 
    
         
            +
            selector: unescape('remove%3A'),
         
     | 
| 
       2442 
2664 
     | 
    
         
             
            fn: function (anObject){
         
     | 
| 
       2443 
2665 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2444 
2666 
     | 
    
         
             
            smalltalk.send(self['@elements'], "_remove_", [anObject]);
         
     | 
| 
         @@ -2447,9 +2669,9 @@ return self;} 
     | 
|
| 
       2447 
2669 
     | 
    
         
             
            smalltalk.Set);
         
     | 
| 
       2448 
2670 
     | 
    
         | 
| 
       2449 
2671 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2450 
     | 
    
         
            -
            '_initialize',
         
     | 
| 
      
 2672 
     | 
    
         
            +
            unescape('_initialize'),
         
     | 
| 
       2451 
2673 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2452 
     | 
    
         
            -
            selector: 'initialize',
         
     | 
| 
      
 2674 
     | 
    
         
            +
            selector: unescape('initialize'),
         
     | 
| 
       2453 
2675 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2454 
2676 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2455 
2677 
     | 
    
         
             
            smalltalk.send(self, "_initialize", [], smalltalk.Collection);
         
     | 
| 
         @@ -2459,9 +2681,9 @@ return self;} 
     | 
|
| 
       2459 
2681 
     | 
    
         
             
            smalltalk.Set);
         
     | 
| 
       2460 
2682 
     | 
    
         | 
| 
       2461 
2683 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2462 
     | 
    
         
            -
            '_size',
         
     | 
| 
      
 2684 
     | 
    
         
            +
            unescape('_size'),
         
     | 
| 
       2463 
2685 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2464 
     | 
    
         
            -
            selector: 'size',
         
     | 
| 
      
 2686 
     | 
    
         
            +
            selector: unescape('size'),
         
     | 
| 
       2465 
2687 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2466 
2688 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2467 
2689 
     | 
    
         
             
            return smalltalk.send(self['@elements'], "_size", []);
         
     | 
| 
         @@ -2470,9 +2692,9 @@ return self;} 
     | 
|
| 
       2470 
2692 
     | 
    
         
             
            smalltalk.Set);
         
     | 
| 
       2471 
2693 
     | 
    
         | 
| 
       2472 
2694 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2473 
     | 
    
         
            -
            '_asArray',
         
     | 
| 
      
 2695 
     | 
    
         
            +
            unescape('_asArray'),
         
     | 
| 
       2474 
2696 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2475 
     | 
    
         
            -
            selector: 'asArray',
         
     | 
| 
      
 2697 
     | 
    
         
            +
            selector: unescape('asArray'),
         
     | 
| 
       2476 
2698 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2477 
2699 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2478 
2700 
     | 
    
         
             
            return smalltalk.send(self['@elements'], "_copy", []);
         
     | 
| 
         @@ -2481,9 +2703,9 @@ return self;} 
     | 
|
| 
       2481 
2703 
     | 
    
         
             
            smalltalk.Set);
         
     | 
| 
       2482 
2704 
     | 
    
         | 
| 
       2483 
2705 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2484 
     | 
    
         
            -
            '_detect_ifNone_',
         
     | 
| 
      
 2706 
     | 
    
         
            +
            unescape('_detect_ifNone_'),
         
     | 
| 
       2485 
2707 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2486 
     | 
    
         
            -
            selector: 'detect 
     | 
| 
      
 2708 
     | 
    
         
            +
            selector: unescape('detect%3AifNone%3A'),
         
     | 
| 
       2487 
2709 
     | 
    
         
             
            fn: function (aBlock, anotherBlock){
         
     | 
| 
       2488 
2710 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2489 
2711 
     | 
    
         
             
            return smalltalk.send(self['@elements'], "_detect_ifNone_", [aBlock, anotherBlock]);
         
     | 
| 
         @@ -2492,9 +2714,9 @@ return self;} 
     | 
|
| 
       2492 
2714 
     | 
    
         
             
            smalltalk.Set);
         
     | 
| 
       2493 
2715 
     | 
    
         | 
| 
       2494 
2716 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2495 
     | 
    
         
            -
            '_do_',
         
     | 
| 
      
 2717 
     | 
    
         
            +
            unescape('_do_'),
         
     | 
| 
       2496 
2718 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2497 
     | 
    
         
            -
            selector: 'do 
     | 
| 
      
 2719 
     | 
    
         
            +
            selector: unescape('do%3A'),
         
     | 
| 
       2498 
2720 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       2499 
2721 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2500 
2722 
     | 
    
         
             
            smalltalk.send(self['@elements'], "_do_", [aBlock]);
         
     | 
| 
         @@ -2503,9 +2725,9 @@ return self;} 
     | 
|
| 
       2503 
2725 
     | 
    
         
             
            smalltalk.Set);
         
     | 
| 
       2504 
2726 
     | 
    
         | 
| 
       2505 
2727 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2506 
     | 
    
         
            -
            '_includes_',
         
     | 
| 
      
 2728 
     | 
    
         
            +
            unescape('_includes_'),
         
     | 
| 
       2507 
2729 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2508 
     | 
    
         
            -
            selector: 'includes 
     | 
| 
      
 2730 
     | 
    
         
            +
            selector: unescape('includes%3A'),
         
     | 
| 
       2509 
2731 
     | 
    
         
             
            fn: function (anObject){
         
     | 
| 
       2510 
2732 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2511 
2733 
     | 
    
         
             
            return smalltalk.send(self['@elements'], "_includes_", [anObject]);
         
     | 
| 
         @@ -2514,9 +2736,9 @@ return self;} 
     | 
|
| 
       2514 
2736 
     | 
    
         
             
            smalltalk.Set);
         
     | 
| 
       2515 
2737 
     | 
    
         | 
| 
       2516 
2738 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2517 
     | 
    
         
            -
            '__eq',
         
     | 
| 
      
 2739 
     | 
    
         
            +
            unescape('__eq'),
         
     | 
| 
       2518 
2740 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2519 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 2741 
     | 
    
         
            +
            selector: unescape('%3D'),
         
     | 
| 
       2520 
2742 
     | 
    
         
             
            fn: function (aCollection){
         
     | 
| 
       2521 
2743 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2522 
2744 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(smalltalk.send(self, "_class", []), "__eq", [smalltalk.send(aCollection, "_class", [])]), "_and_", [(function(){return smalltalk.send(self['@elements'], "__eq", [smalltalk.send(aCollection, "_asArray", [])]);})]);
         
     | 
| 
         @@ -2525,9 +2747,9 @@ return self;} 
     | 
|
| 
       2525 
2747 
     | 
    
         
             
            smalltalk.Set);
         
     | 
| 
       2526 
2748 
     | 
    
         | 
| 
       2527 
2749 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2528 
     | 
    
         
            -
            '_select_',
         
     | 
| 
      
 2750 
     | 
    
         
            +
            unescape('_select_'),
         
     | 
| 
       2529 
2751 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2530 
     | 
    
         
            -
            selector: 'select 
     | 
| 
      
 2752 
     | 
    
         
            +
            selector: unescape('select%3A'),
         
     | 
| 
       2531 
2753 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       2532 
2754 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2533 
2755 
     | 
    
         
             
            var collection=nil;
         
     | 
| 
         @@ -2542,9 +2764,9 @@ smalltalk.Set); 
     | 
|
| 
       2542 
2764 
     | 
    
         | 
| 
       2543 
2765 
     | 
    
         
             
            smalltalk.addClass('HashedCollection', smalltalk.Collection, [], 'Kernel-Collections');
         
     | 
| 
       2544 
2766 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2545 
     | 
    
         
            -
            '_size',
         
     | 
| 
      
 2767 
     | 
    
         
            +
            unescape('_size'),
         
     | 
| 
       2546 
2768 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2547 
     | 
    
         
            -
            selector: 'size',
         
     | 
| 
      
 2769 
     | 
    
         
            +
            selector: unescape('size'),
         
     | 
| 
       2548 
2770 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2549 
2771 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2550 
2772 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_keys", []), "_size", []);
         
     | 
| 
         @@ -2553,9 +2775,9 @@ return self;} 
     | 
|
| 
       2553 
2775 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2554 
2776 
     | 
    
         | 
| 
       2555 
2777 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2556 
     | 
    
         
            -
            '_associations',
         
     | 
| 
      
 2778 
     | 
    
         
            +
            unescape('_associations'),
         
     | 
| 
       2557 
2779 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2558 
     | 
    
         
            -
            selector: 'associations',
         
     | 
| 
      
 2780 
     | 
    
         
            +
            selector: unescape('associations'),
         
     | 
| 
       2559 
2781 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2560 
2782 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2561 
2783 
     | 
    
         
             
            var associations=nil;
         
     | 
| 
         @@ -2567,9 +2789,9 @@ return self;} 
     | 
|
| 
       2567 
2789 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2568 
2790 
     | 
    
         | 
| 
       2569 
2791 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2570 
     | 
    
         
            -
            '_keys',
         
     | 
| 
      
 2792 
     | 
    
         
            +
            unescape('_keys'),
         
     | 
| 
       2571 
2793 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2572 
     | 
    
         
            -
            selector: 'keys',
         
     | 
| 
      
 2794 
     | 
    
         
            +
            selector: unescape('keys'),
         
     | 
| 
       2573 
2795 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2574 
2796 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2575 
2797 
     | 
    
         | 
| 
         @@ -2586,9 +2808,9 @@ return self;} 
     | 
|
| 
       2586 
2808 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2587 
2809 
     | 
    
         | 
| 
       2588 
2810 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2589 
     | 
    
         
            -
            '_values',
         
     | 
| 
      
 2811 
     | 
    
         
            +
            unescape('_values'),
         
     | 
| 
       2590 
2812 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2591 
     | 
    
         
            -
            selector: 'values',
         
     | 
| 
      
 2813 
     | 
    
         
            +
            selector: unescape('values'),
         
     | 
| 
       2592 
2814 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2593 
2815 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2594 
2816 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_keys", []), "_collect_", [(function(each){return smalltalk.send(self, "_at_", [each]);})]);
         
     | 
| 
         @@ -2597,9 +2819,9 @@ return self;} 
     | 
|
| 
       2597 
2819 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2598 
2820 
     | 
    
         | 
| 
       2599 
2821 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2600 
     | 
    
         
            -
            '_at_put_',
         
     | 
| 
      
 2822 
     | 
    
         
            +
            unescape('_at_put_'),
         
     | 
| 
       2601 
2823 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2602 
     | 
    
         
            -
            selector: 'at 
     | 
| 
      
 2824 
     | 
    
         
            +
            selector: unescape('at%3Aput%3A'),
         
     | 
| 
       2603 
2825 
     | 
    
         
             
            fn: function (aKey, aValue){
         
     | 
| 
       2604 
2826 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2605 
2827 
     | 
    
         
             
            return smalltalk.send(self, "_basicAt_put_", [aKey, aValue]);
         
     | 
| 
         @@ -2608,9 +2830,9 @@ return self;} 
     | 
|
| 
       2608 
2830 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2609 
2831 
     | 
    
         | 
| 
       2610 
2832 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2611 
     | 
    
         
            -
            '_at_ifAbsent_',
         
     | 
| 
      
 2833 
     | 
    
         
            +
            unescape('_at_ifAbsent_'),
         
     | 
| 
       2612 
2834 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2613 
     | 
    
         
            -
            selector: 'at 
     | 
| 
      
 2835 
     | 
    
         
            +
            selector: unescape('at%3AifAbsent%3A'),
         
     | 
| 
       2614 
2836 
     | 
    
         
             
            fn: function (aKey, aBlock){
         
     | 
| 
       2615 
2837 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2616 
2838 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_includesKey_", [aKey]), "_ifTrue_ifFalse_", [(function(){return smalltalk.send(self, "_basicAt_", [aKey]);}), aBlock]);
         
     | 
| 
         @@ -2619,9 +2841,9 @@ return self;} 
     | 
|
| 
       2619 
2841 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2620 
2842 
     | 
    
         | 
| 
       2621 
2843 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2622 
     | 
    
         
            -
            '_at_ifAbsentPut_',
         
     | 
| 
      
 2844 
     | 
    
         
            +
            unescape('_at_ifAbsentPut_'),
         
     | 
| 
       2623 
2845 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2624 
     | 
    
         
            -
            selector: 'at 
     | 
| 
      
 2846 
     | 
    
         
            +
            selector: unescape('at%3AifAbsentPut%3A'),
         
     | 
| 
       2625 
2847 
     | 
    
         
             
            fn: function (aKey, aBlock){
         
     | 
| 
       2626 
2848 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2627 
2849 
     | 
    
         
             
            return smalltalk.send(self, "_at_ifAbsent_", [aKey, (function(){return smalltalk.send(self, "_at_put_", [aKey, smalltalk.send(aBlock, "_value", [])]);})]);
         
     | 
| 
         @@ -2630,9 +2852,9 @@ return self;} 
     | 
|
| 
       2630 
2852 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2631 
2853 
     | 
    
         | 
| 
       2632 
2854 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2633 
     | 
    
         
            -
            '_at_ifPresent_',
         
     | 
| 
      
 2855 
     | 
    
         
            +
            unescape('_at_ifPresent_'),
         
     | 
| 
       2634 
2856 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2635 
     | 
    
         
            -
            selector: 'at 
     | 
| 
      
 2857 
     | 
    
         
            +
            selector: unescape('at%3AifPresent%3A'),
         
     | 
| 
       2636 
2858 
     | 
    
         
             
            fn: function (aKey, aBlock){
         
     | 
| 
       2637 
2859 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2638 
2860 
     | 
    
         
             
            return (($receiver = smalltalk.send(self, "_basicAt_", [aKey])) != nil && $receiver != undefined) ? (function(){return smalltalk.send(aBlock, "_value_", [smalltalk.send(self, "_at_", [aKey])]);})() : nil;
         
     | 
| 
         @@ -2641,9 +2863,9 @@ return self;} 
     | 
|
| 
       2641 
2863 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2642 
2864 
     | 
    
         | 
| 
       2643 
2865 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2644 
     | 
    
         
            -
            '_at_ifPresent_ifAbsent_',
         
     | 
| 
      
 2866 
     | 
    
         
            +
            unescape('_at_ifPresent_ifAbsent_'),
         
     | 
| 
       2645 
2867 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2646 
     | 
    
         
            -
            selector: 'at 
     | 
| 
      
 2868 
     | 
    
         
            +
            selector: unescape('at%3AifPresent%3AifAbsent%3A'),
         
     | 
| 
       2647 
2869 
     | 
    
         
             
            fn: function (aKey, aBlock, anotherBlock){
         
     | 
| 
       2648 
2870 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2649 
2871 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_basicAt_", [aKey]), "_ifNil_ifNotNil_", [anotherBlock, (function(){return smalltalk.send(aBlock, "_value_", [smalltalk.send(self, "_at_", [aKey])]);})]);
         
     | 
| 
         @@ -2652,9 +2874,9 @@ return self;} 
     | 
|
| 
       2652 
2874 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2653 
2875 
     | 
    
         | 
| 
       2654 
2876 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2655 
     | 
    
         
            -
            '_at_',
         
     | 
| 
      
 2877 
     | 
    
         
            +
            unescape('_at_'),
         
     | 
| 
       2656 
2878 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2657 
     | 
    
         
            -
            selector: 'at 
     | 
| 
      
 2879 
     | 
    
         
            +
            selector: unescape('at%3A'),
         
     | 
| 
       2658 
2880 
     | 
    
         
             
            fn: function (aKey){
         
     | 
| 
       2659 
2881 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2660 
2882 
     | 
    
         
             
            return smalltalk.send(self, "_at_ifAbsent_", [aKey, (function(){return smalltalk.send(self, "_errorNotFound", []);})]);
         
     | 
| 
         @@ -2663,9 +2885,9 @@ return self;} 
     | 
|
| 
       2663 
2885 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2664 
2886 
     | 
    
         | 
| 
       2665 
2887 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2666 
     | 
    
         
            -
            '_add_',
         
     | 
| 
      
 2888 
     | 
    
         
            +
            unescape('_add_'),
         
     | 
| 
       2667 
2889 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2668 
     | 
    
         
            -
            selector: 'add 
     | 
| 
      
 2890 
     | 
    
         
            +
            selector: unescape('add%3A'),
         
     | 
| 
       2669 
2891 
     | 
    
         
             
            fn: function (anAssociation){
         
     | 
| 
       2670 
2892 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2671 
2893 
     | 
    
         
             
            smalltalk.send(self, "_at_put_", [smalltalk.send(anAssociation, "_key", []), smalltalk.send(anAssociation, "_value", [])]);
         
     | 
| 
         @@ -2674,9 +2896,9 @@ return self;} 
     | 
|
| 
       2674 
2896 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2675 
2897 
     | 
    
         | 
| 
       2676 
2898 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2677 
     | 
    
         
            -
            '_addAll_',
         
     | 
| 
      
 2899 
     | 
    
         
            +
            unescape('_addAll_'),
         
     | 
| 
       2678 
2900 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2679 
     | 
    
         
            -
            selector: 'addAll 
     | 
| 
      
 2901 
     | 
    
         
            +
            selector: unescape('addAll%3A'),
         
     | 
| 
       2680 
2902 
     | 
    
         
             
            fn: function (aHashedCollection){
         
     | 
| 
       2681 
2903 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2682 
2904 
     | 
    
         
             
            smalltalk.send(self, "_addAll_", [smalltalk.send(aHashedCollection, "_associations", [])], smalltalk.Collection);
         
     | 
| 
         @@ -2686,9 +2908,9 @@ return self;} 
     | 
|
| 
       2686 
2908 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2687 
2909 
     | 
    
         | 
| 
       2688 
2910 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2689 
     | 
    
         
            -
            '_removeKey_',
         
     | 
| 
      
 2911 
     | 
    
         
            +
            unescape('_removeKey_'),
         
     | 
| 
       2690 
2912 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2691 
     | 
    
         
            -
            selector: 'removeKey 
     | 
| 
      
 2913 
     | 
    
         
            +
            selector: unescape('removeKey%3A'),
         
     | 
| 
       2692 
2914 
     | 
    
         
             
            fn: function (aKey){
         
     | 
| 
       2693 
2915 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2694 
2916 
     | 
    
         
             
            smalltalk.send(self, "_remove_", [aKey]);
         
     | 
| 
         @@ -2697,9 +2919,9 @@ return self;} 
     | 
|
| 
       2697 
2919 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2698 
2920 
     | 
    
         | 
| 
       2699 
2921 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2700 
     | 
    
         
            -
            '_remove_ifAbsent_',
         
     | 
| 
      
 2922 
     | 
    
         
            +
            unescape('_remove_ifAbsent_'),
         
     | 
| 
       2701 
2923 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2702 
     | 
    
         
            -
            selector: 'remove 
     | 
| 
      
 2924 
     | 
    
         
            +
            selector: unescape('remove%3AifAbsent%3A'),
         
     | 
| 
       2703 
2925 
     | 
    
         
             
            fn: function (aKey, aBlock){
         
     | 
| 
       2704 
2926 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2705 
2927 
     | 
    
         
             
            return smalltalk.send(self, "_removeKey_ifAbsent_", [aKey, aBlock]);
         
     | 
| 
         @@ -2708,9 +2930,9 @@ return self;} 
     | 
|
| 
       2708 
2930 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2709 
2931 
     | 
    
         | 
| 
       2710 
2932 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2711 
     | 
    
         
            -
            '_removeKey_ifAbsent_',
         
     | 
| 
      
 2933 
     | 
    
         
            +
            unescape('_removeKey_ifAbsent_'),
         
     | 
| 
       2712 
2934 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2713 
     | 
    
         
            -
            selector: 'removeKey 
     | 
| 
      
 2935 
     | 
    
         
            +
            selector: unescape('removeKey%3AifAbsent%3A'),
         
     | 
| 
       2714 
2936 
     | 
    
         
             
            fn: function (aKey, aBlock){
         
     | 
| 
       2715 
2937 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2716 
2938 
     | 
    
         
             
            return ((($receiver = smalltalk.send(self, "_includesKey_", [aKey])).klass === smalltalk.Boolean) ? (! $receiver ? (function(){return smalltalk.send(aBlock, "_value", []);})() : (function(){return smalltalk.send(self, "_basicDelete_", [aKey]);})()) : smalltalk.send($receiver, "_ifFalse_ifTrue_", [(function(){return smalltalk.send(aBlock, "_value", []);}), (function(){return smalltalk.send(self, "_basicDelete_", [aKey]);})]));
         
     | 
| 
         @@ -2719,9 +2941,9 @@ return self;} 
     | 
|
| 
       2719 
2941 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2720 
2942 
     | 
    
         | 
| 
       2721 
2943 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2722 
     | 
    
         
            -
            '__eq',
         
     | 
| 
      
 2944 
     | 
    
         
            +
            unescape('__eq'),
         
     | 
| 
       2723 
2945 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2724 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 2946 
     | 
    
         
            +
            selector: unescape('%3D'),
         
     | 
| 
       2725 
2947 
     | 
    
         
             
            fn: function (aHashedCollection){
         
     | 
| 
       2726 
2948 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2727 
2949 
     | 
    
         
             
            try{((($receiver = smalltalk.send(smalltalk.send(self, "_class", []), "__eq", [smalltalk.send(aHashedCollection, "_class", [])])).klass === smalltalk.Boolean) ? (! $receiver ? (function(){return (function(){throw({name: 'stReturn', selector: '__eq', fn: function(){return false}})})();})() : nil) : smalltalk.send($receiver, "_ifFalse_", [(function(){return (function(){throw({name: 'stReturn', selector: '__eq', fn: function(){return false}})})();})]));
         
     | 
| 
         @@ -2733,9 +2955,9 @@ return self; 
     | 
|
| 
       2733 
2955 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2734 
2956 
     | 
    
         | 
| 
       2735 
2957 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2736 
     | 
    
         
            -
            '_shallowCopy',
         
     | 
| 
      
 2958 
     | 
    
         
            +
            unescape('_shallowCopy'),
         
     | 
| 
       2737 
2959 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2738 
     | 
    
         
            -
            selector: 'shallowCopy',
         
     | 
| 
      
 2960 
     | 
    
         
            +
            selector: unescape('shallowCopy'),
         
     | 
| 
       2739 
2961 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2740 
2962 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2741 
2963 
     | 
    
         
             
            var copy=nil;
         
     | 
| 
         @@ -2747,9 +2969,9 @@ return self;} 
     | 
|
| 
       2747 
2969 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2748 
2970 
     | 
    
         | 
| 
       2749 
2971 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2750 
     | 
    
         
            -
            '__comma',
         
     | 
| 
      
 2972 
     | 
    
         
            +
            unescape('__comma'),
         
     | 
| 
       2751 
2973 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2752 
     | 
    
         
            -
            selector: ' 
     | 
| 
      
 2974 
     | 
    
         
            +
            selector: unescape('%2C'),
         
     | 
| 
       2753 
2975 
     | 
    
         
             
            fn: function (aCollection){
         
     | 
| 
       2754 
2976 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2755 
2977 
     | 
    
         
             
            smalltalk.send(self, "_shouldNotImplement", []);
         
     | 
| 
         @@ -2758,9 +2980,9 @@ return self;} 
     | 
|
| 
       2758 
2980 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2759 
2981 
     | 
    
         | 
| 
       2760 
2982 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2761 
     | 
    
         
            -
            '_copyFrom_to_',
         
     | 
| 
      
 2983 
     | 
    
         
            +
            unescape('_copyFrom_to_'),
         
     | 
| 
       2762 
2984 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2763 
     | 
    
         
            -
            selector: 'copyFrom 
     | 
| 
      
 2985 
     | 
    
         
            +
            selector: unescape('copyFrom%3Ato%3A'),
         
     | 
| 
       2764 
2986 
     | 
    
         
             
            fn: function (anIndex, anotherIndex){
         
     | 
| 
       2765 
2987 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2766 
2988 
     | 
    
         
             
            smalltalk.send(self, "_shouldNotImplement", []);
         
     | 
| 
         @@ -2769,9 +2991,9 @@ return self;} 
     | 
|
| 
       2769 
2991 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2770 
2992 
     | 
    
         | 
| 
       2771 
2993 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2772 
     | 
    
         
            -
            '_deepCopy',
         
     | 
| 
      
 2994 
     | 
    
         
            +
            unescape('_deepCopy'),
         
     | 
| 
       2773 
2995 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2774 
     | 
    
         
            -
            selector: 'deepCopy',
         
     | 
| 
      
 2996 
     | 
    
         
            +
            selector: unescape('deepCopy'),
         
     | 
| 
       2775 
2997 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2776 
2998 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2777 
2999 
     | 
    
         
             
            var copy=nil;
         
     | 
| 
         @@ -2783,9 +3005,9 @@ return self;} 
     | 
|
| 
       2783 
3005 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2784 
3006 
     | 
    
         | 
| 
       2785 
3007 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2786 
     | 
    
         
            -
            '_associationsDo_',
         
     | 
| 
      
 3008 
     | 
    
         
            +
            unescape('_associationsDo_'),
         
     | 
| 
       2787 
3009 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2788 
     | 
    
         
            -
            selector: 'associationsDo 
     | 
| 
      
 3010 
     | 
    
         
            +
            selector: unescape('associationsDo%3A'),
         
     | 
| 
       2789 
3011 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       2790 
3012 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2791 
3013 
     | 
    
         
             
            smalltalk.send(smalltalk.send(self, "_associations", []), "_do_", [aBlock]);
         
     | 
| 
         @@ -2794,9 +3016,9 @@ return self;} 
     | 
|
| 
       2794 
3016 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2795 
3017 
     | 
    
         | 
| 
       2796 
3018 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2797 
     | 
    
         
            -
            '_keysAndValuesDo_',
         
     | 
| 
      
 3019 
     | 
    
         
            +
            unescape('_keysAndValuesDo_'),
         
     | 
| 
       2798 
3020 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2799 
     | 
    
         
            -
            selector: 'keysAndValuesDo 
     | 
| 
      
 3021 
     | 
    
         
            +
            selector: unescape('keysAndValuesDo%3A'),
         
     | 
| 
       2800 
3022 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       2801 
3023 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2802 
3024 
     | 
    
         
             
            smalltalk.send(self, "_associationsDo_", [(function(each){return smalltalk.send(aBlock, "_value_value_", [smalltalk.send(each, "_key", []), smalltalk.send(each, "_value", [])]);})]);
         
     | 
| 
         @@ -2805,9 +3027,9 @@ return self;} 
     | 
|
| 
       2805 
3027 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2806 
3028 
     | 
    
         | 
| 
       2807 
3029 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2808 
     | 
    
         
            -
            '_do_',
         
     | 
| 
      
 3030 
     | 
    
         
            +
            unescape('_do_'),
         
     | 
| 
       2809 
3031 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2810 
     | 
    
         
            -
            selector: 'do 
     | 
| 
      
 3032 
     | 
    
         
            +
            selector: unescape('do%3A'),
         
     | 
| 
       2811 
3033 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       2812 
3034 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2813 
3035 
     | 
    
         
             
            smalltalk.send(smalltalk.send(self, "_values", []), "_do_", [aBlock]);
         
     | 
| 
         @@ -2816,9 +3038,9 @@ return self;} 
     | 
|
| 
       2816 
3038 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2817 
3039 
     | 
    
         | 
| 
       2818 
3040 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2819 
     | 
    
         
            -
            '_select_',
         
     | 
| 
      
 3041 
     | 
    
         
            +
            unescape('_select_'),
         
     | 
| 
       2820 
3042 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2821 
     | 
    
         
            -
            selector: 'select 
     | 
| 
      
 3043 
     | 
    
         
            +
            selector: unescape('select%3A'),
         
     | 
| 
       2822 
3044 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       2823 
3045 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2824 
3046 
     | 
    
         
             
            var newDict=nil;
         
     | 
| 
         @@ -2830,9 +3052,9 @@ return self;} 
     | 
|
| 
       2830 
3052 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2831 
3053 
     | 
    
         | 
| 
       2832 
3054 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2833 
     | 
    
         
            -
            '_collect_',
         
     | 
| 
      
 3055 
     | 
    
         
            +
            unescape('_collect_'),
         
     | 
| 
       2834 
3056 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2835 
     | 
    
         
            -
            selector: 'collect 
     | 
| 
      
 3057 
     | 
    
         
            +
            selector: unescape('collect%3A'),
         
     | 
| 
       2836 
3058 
     | 
    
         
             
            fn: function (aBlock){
         
     | 
| 
       2837 
3059 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2838 
3060 
     | 
    
         
             
            var newDict=nil;
         
     | 
| 
         @@ -2844,9 +3066,9 @@ return self;} 
     | 
|
| 
       2844 
3066 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2845 
3067 
     | 
    
         | 
| 
       2846 
3068 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2847 
     | 
    
         
            -
            '_detect_ifNone_',
         
     | 
| 
      
 3069 
     | 
    
         
            +
            unescape('_detect_ifNone_'),
         
     | 
| 
       2848 
3070 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2849 
     | 
    
         
            -
            selector: 'detect 
     | 
| 
      
 3071 
     | 
    
         
            +
            selector: unescape('detect%3AifNone%3A'),
         
     | 
| 
       2850 
3072 
     | 
    
         
             
            fn: function (aBlock, anotherBlock){
         
     | 
| 
       2851 
3073 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2852 
3074 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_values", []), "_detect_ifNone_", [aBlock, anotherBlock]);
         
     | 
| 
         @@ -2855,9 +3077,9 @@ return self;} 
     | 
|
| 
       2855 
3077 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2856 
3078 
     | 
    
         | 
| 
       2857 
3079 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2858 
     | 
    
         
            -
            '_includes_',
         
     | 
| 
      
 3080 
     | 
    
         
            +
            unescape('_includes_'),
         
     | 
| 
       2859 
3081 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2860 
     | 
    
         
            -
            selector: 'includes 
     | 
| 
      
 3082 
     | 
    
         
            +
            selector: unescape('includes%3A'),
         
     | 
| 
       2861 
3083 
     | 
    
         
             
            fn: function (anObject){
         
     | 
| 
       2862 
3084 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2863 
3085 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_values", []), "_includes_", [anObject]);
         
     | 
| 
         @@ -2866,9 +3088,9 @@ return self;} 
     | 
|
| 
       2866 
3088 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2867 
3089 
     | 
    
         | 
| 
       2868 
3090 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2869 
     | 
    
         
            -
            '_printString',
         
     | 
| 
      
 3091 
     | 
    
         
            +
            unescape('_printString'),
         
     | 
| 
       2870 
3092 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2871 
     | 
    
         
            -
            selector: 'printString',
         
     | 
| 
      
 3093 
     | 
    
         
            +
            selector: unescape('printString'),
         
     | 
| 
       2872 
3094 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2873 
3095 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2874 
3096 
     | 
    
         
             
            return smalltalk.send((smalltalk.String || String), "_streamContents_", [(function(aStream){(function($rec){smalltalk.send($rec, "_nextPutAll_", [smalltalk.send(self, "_printString", [], smalltalk.Collection)]);return smalltalk.send($rec, "_nextPutAll_", [unescape("%28")]);})(aStream);smalltalk.send(smalltalk.send(self, "_associations", []), "_do_separatedBy_", [(function(anAssociation){return (function($rec){smalltalk.send($rec, "_nextPutAll_", [smalltalk.send(smalltalk.send(anAssociation, "_key", []), "_printString", [])]);smalltalk.send($rec, "_nextPutAll_", [unescape("%20-%3E%20")]);return smalltalk.send($rec, "_nextPutAll_", [smalltalk.send(smalltalk.send(anAssociation, "_value", []), "_printString", [])]);})(aStream);}), (function(){return smalltalk.send(aStream, "_nextPutAll_", [unescape("%20%2C%20")]);})]);return smalltalk.send(aStream, "_nextPutAll_", [unescape("%29")]);})]);
         
     | 
| 
         @@ -2877,9 +3099,9 @@ return self;} 
     | 
|
| 
       2877 
3099 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2878 
3100 
     | 
    
         | 
| 
       2879 
3101 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2880 
     | 
    
         
            -
            '_storeOn_',
         
     | 
| 
      
 3102 
     | 
    
         
            +
            unescape('_storeOn_'),
         
     | 
| 
       2881 
3103 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2882 
     | 
    
         
            -
            selector: 'storeOn 
     | 
| 
      
 3104 
     | 
    
         
            +
            selector: unescape('storeOn%3A'),
         
     | 
| 
       2883 
3105 
     | 
    
         
             
            fn: function (aStream){
         
     | 
| 
       2884 
3106 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2885 
3107 
     | 
    
         
             
            smalltalk.send(aStream, "_nextPutAll_", [unescape("%23%7B")]);
         
     | 
| 
         @@ -2890,9 +3112,9 @@ return self;} 
     | 
|
| 
       2890 
3112 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2891 
3113 
     | 
    
         | 
| 
       2892 
3114 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2893 
     | 
    
         
            -
            '_includesKey_',
         
     | 
| 
      
 3115 
     | 
    
         
            +
            unescape('_includesKey_'),
         
     | 
| 
       2894 
3116 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2895 
     | 
    
         
            -
            selector: 'includesKey 
     | 
| 
      
 3117 
     | 
    
         
            +
            selector: unescape('includesKey%3A'),
         
     | 
| 
       2896 
3118 
     | 
    
         
             
            fn: function (aKey){
         
     | 
| 
       2897 
3119 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2898 
3120 
     | 
    
         
             
            return self.hasOwnProperty(aKey);
         
     | 
| 
         @@ -2901,9 +3123,9 @@ return self;} 
     | 
|
| 
       2901 
3123 
     | 
    
         
             
            smalltalk.HashedCollection);
         
     | 
| 
       2902 
3124 
     | 
    
         | 
| 
       2903 
3125 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2904 
     | 
    
         
            -
            '_asDictionary',
         
     | 
| 
      
 3126 
     | 
    
         
            +
            unescape('_asDictionary'),
         
     | 
| 
       2905 
3127 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2906 
     | 
    
         
            -
            selector: 'asDictionary',
         
     | 
| 
      
 3128 
     | 
    
         
            +
            selector: unescape('asDictionary'),
         
     | 
| 
       2907 
3129 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2908 
3130 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2909 
3131 
     | 
    
         
             
            return smalltalk.send((smalltalk.Dictionary || Dictionary), "_fromPairs_", [smalltalk.send(self, "_associations", [])]);
         
     | 
| 
         @@ -2913,9 +3135,9 @@ smalltalk.HashedCollection); 
     | 
|
| 
       2913 
3135 
     | 
    
         | 
| 
       2914 
3136 
     | 
    
         | 
| 
       2915 
3137 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2916 
     | 
    
         
            -
            '_fromPairs_',
         
     | 
| 
      
 3138 
     | 
    
         
            +
            unescape('_fromPairs_'),
         
     | 
| 
       2917 
3139 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2918 
     | 
    
         
            -
            selector: 'fromPairs 
     | 
| 
      
 3140 
     | 
    
         
            +
            selector: unescape('fromPairs%3A'),
         
     | 
| 
       2919 
3141 
     | 
    
         
             
            fn: function (aCollection){
         
     | 
| 
       2920 
3142 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2921 
3143 
     | 
    
         
             
            var dict=nil;
         
     | 
| 
         @@ -2929,9 +3151,9 @@ smalltalk.HashedCollection.klass); 
     | 
|
| 
       2929 
3151 
     | 
    
         | 
| 
       2930 
3152 
     | 
    
         
             
            smalltalk.addClass('Dictionary', smalltalk.HashedCollection, ['keys', 'values'], 'Kernel-Collections');
         
     | 
| 
       2931 
3153 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2932 
     | 
    
         
            -
            '_at_ifAbsent_',
         
     | 
| 
      
 3154 
     | 
    
         
            +
            unescape('_at_ifAbsent_'),
         
     | 
| 
       2933 
3155 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2934 
     | 
    
         
            -
            selector: 'at 
     | 
| 
      
 3156 
     | 
    
         
            +
            selector: unescape('at%3AifAbsent%3A'),
         
     | 
| 
       2935 
3157 
     | 
    
         
             
            fn: function (aKey, aBlock){
         
     | 
| 
       2936 
3158 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2937 
3159 
     | 
    
         | 
| 
         @@ -2950,9 +3172,9 @@ return self;} 
     | 
|
| 
       2950 
3172 
     | 
    
         
             
            smalltalk.Dictionary);
         
     | 
| 
       2951 
3173 
     | 
    
         | 
| 
       2952 
3174 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2953 
     | 
    
         
            -
            '_keys',
         
     | 
| 
      
 3175 
     | 
    
         
            +
            unescape('_keys'),
         
     | 
| 
       2954 
3176 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2955 
     | 
    
         
            -
            selector: 'keys',
         
     | 
| 
      
 3177 
     | 
    
         
            +
            selector: unescape('keys'),
         
     | 
| 
       2956 
3178 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2957 
3179 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2958 
3180 
     | 
    
         
             
            return smalltalk.send(self['@keys'], "_copy", []);
         
     | 
| 
         @@ -2961,9 +3183,9 @@ return self;} 
     | 
|
| 
       2961 
3183 
     | 
    
         
             
            smalltalk.Dictionary);
         
     | 
| 
       2962 
3184 
     | 
    
         | 
| 
       2963 
3185 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2964 
     | 
    
         
            -
            '_values',
         
     | 
| 
      
 3186 
     | 
    
         
            +
            unescape('_values'),
         
     | 
| 
       2965 
3187 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2966 
     | 
    
         
            -
            selector: 'values',
         
     | 
| 
      
 3188 
     | 
    
         
            +
            selector: unescape('values'),
         
     | 
| 
       2967 
3189 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       2968 
3190 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2969 
3191 
     | 
    
         
             
            return smalltalk.send(self['@values'], "_copy", []);
         
     | 
| 
         @@ -2972,9 +3194,9 @@ return self;} 
     | 
|
| 
       2972 
3194 
     | 
    
         
             
            smalltalk.Dictionary);
         
     | 
| 
       2973 
3195 
     | 
    
         | 
| 
       2974 
3196 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2975 
     | 
    
         
            -
            '_at_put_',
         
     | 
| 
      
 3197 
     | 
    
         
            +
            unescape('_at_put_'),
         
     | 
| 
       2976 
3198 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2977 
     | 
    
         
            -
            selector: 'at 
     | 
| 
      
 3199 
     | 
    
         
            +
            selector: unescape('at%3Aput%3A'),
         
     | 
| 
       2978 
3200 
     | 
    
         
             
            fn: function (aKey, aValue){
         
     | 
| 
       2979 
3201 
     | 
    
         
             
            var self=this;
         
     | 
| 
       2980 
3202 
     | 
    
         | 
| 
         @@ -2993,9 +3215,9 @@ return self;} 
     | 
|
| 
       2993 
3215 
     | 
    
         
             
            smalltalk.Dictionary);
         
     | 
| 
       2994 
3216 
     | 
    
         | 
| 
       2995 
3217 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       2996 
     | 
    
         
            -
            '_removeKey_ifAbsent_',
         
     | 
| 
      
 3218 
     | 
    
         
            +
            unescape('_removeKey_ifAbsent_'),
         
     | 
| 
       2997 
3219 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       2998 
     | 
    
         
            -
            selector: 'removeKey 
     | 
| 
      
 3220 
     | 
    
         
            +
            selector: unescape('removeKey%3AifAbsent%3A'),
         
     | 
| 
       2999 
3221 
     | 
    
         
             
            fn: function (aKey, aBlock){
         
     | 
| 
       3000 
3222 
     | 
    
         
             
            var self=this;
         
     | 
| 
       3001 
3223 
     | 
    
         | 
| 
         @@ -3013,9 +3235,9 @@ return self;} 
     | 
|
| 
       3013 
3235 
     | 
    
         
             
            smalltalk.Dictionary);
         
     | 
| 
       3014 
3236 
     | 
    
         | 
| 
       3015 
3237 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       3016 
     | 
    
         
            -
            '_initialize',
         
     | 
| 
      
 3238 
     | 
    
         
            +
            unescape('_initialize'),
         
     | 
| 
       3017 
3239 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       3018 
     | 
    
         
            -
            selector: 'initialize',
         
     | 
| 
      
 3240 
     | 
    
         
            +
            selector: unescape('initialize'),
         
     | 
| 
       3019 
3241 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       3020 
3242 
     | 
    
         
             
            var self=this;
         
     | 
| 
       3021 
3243 
     | 
    
         
             
            smalltalk.send(self, "_initialize", [], smalltalk.HashedCollection);
         
     | 
| 
         @@ -3026,9 +3248,9 @@ return self;} 
     | 
|
| 
       3026 
3248 
     | 
    
         
             
            smalltalk.Dictionary);
         
     | 
| 
       3027 
3249 
     | 
    
         | 
| 
       3028 
3250 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       3029 
     | 
    
         
            -
            '_includesKey_',
         
     | 
| 
      
 3251 
     | 
    
         
            +
            unescape('_includesKey_'),
         
     | 
| 
       3030 
3252 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       3031 
     | 
    
         
            -
            selector: 'includesKey 
     | 
| 
      
 3253 
     | 
    
         
            +
            selector: unescape('includesKey%3A'),
         
     | 
| 
       3032 
3254 
     | 
    
         
             
            fn: function (aKey){
         
     | 
| 
       3033 
3255 
     | 
    
         
             
            var self=this;
         
     | 
| 
       3034 
3256 
     | 
    
         
             
            return smalltalk.send(self['@keys'], "_includes_", [aKey]);
         
     | 
| 
         @@ -3037,9 +3259,9 @@ return self;} 
     | 
|
| 
       3037 
3259 
     | 
    
         
             
            smalltalk.Dictionary);
         
     | 
| 
       3038 
3260 
     | 
    
         | 
| 
       3039 
3261 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       3040 
     | 
    
         
            -
            '_asHashedCollection',
         
     | 
| 
      
 3262 
     | 
    
         
            +
            unescape('_asHashedCollection'),
         
     | 
| 
       3041 
3263 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       3042 
     | 
    
         
            -
            selector: 'asHashedCollection',
         
     | 
| 
      
 3264 
     | 
    
         
            +
            selector: unescape('asHashedCollection'),
         
     | 
| 
       3043 
3265 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       3044 
3266 
     | 
    
         
             
            var self=this;
         
     | 
| 
       3045 
3267 
     | 
    
         
             
            return smalltalk.send((smalltalk.HashedCollection || HashedCollection), "_fromPairs_", [smalltalk.send(self, "_associations", [])]);
         
     | 
| 
         @@ -3048,9 +3270,9 @@ return self;} 
     | 
|
| 
       3048 
3270 
     | 
    
         
             
            smalltalk.Dictionary);
         
     | 
| 
       3049 
3271 
     | 
    
         | 
| 
       3050 
3272 
     | 
    
         
             
            smalltalk.addMethod(
         
     | 
| 
       3051 
     | 
    
         
            -
            '_asJSONString',
         
     | 
| 
      
 3273 
     | 
    
         
            +
            unescape('_asJSONString'),
         
     | 
| 
       3052 
3274 
     | 
    
         
             
            smalltalk.method({
         
     | 
| 
       3053 
     | 
    
         
            -
            selector: 'asJSONString',
         
     | 
| 
      
 3275 
     | 
    
         
            +
            selector: unescape('asJSONString'),
         
     | 
| 
       3054 
3276 
     | 
    
         
             
            fn: function (){
         
     | 
| 
       3055 
3277 
     | 
    
         
             
            var self=this;
         
     | 
| 
       3056 
3278 
     | 
    
         
             
            return smalltalk.send(smalltalk.send(self, "_asHashedCollection", []), "_asJSONString", []);
         
     | 
| 
         @@ -3060,214 +3282,3 @@ smalltalk.Dictionary); 
     | 
|
| 
       3060 
3282 
     | 
    
         | 
| 
       3061 
3283 
     | 
    
         | 
| 
       3062 
3284 
     | 
    
         | 
| 
       3063 
     | 
    
         
            -
            smalltalk.addClass('OrderedCollection', smalltalk.SequenceableCollection, ['elements'], 'Kernel-Collections');
         
     | 
| 
       3064 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3065 
     | 
    
         
            -
            '_size',
         
     | 
| 
       3066 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3067 
     | 
    
         
            -
            selector: 'size',
         
     | 
| 
       3068 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
       3069 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3070 
     | 
    
         
            -
            return smalltalk.send(self['@elements'], "_size", []);
         
     | 
| 
       3071 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3072 
     | 
    
         
            -
            }),
         
     | 
| 
       3073 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3074 
     | 
    
         
            -
             
     | 
| 
       3075 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3076 
     | 
    
         
            -
            '_at_put_',
         
     | 
| 
       3077 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3078 
     | 
    
         
            -
            selector: 'at:put:',
         
     | 
| 
       3079 
     | 
    
         
            -
            fn: function (anIndex, anObject){
         
     | 
| 
       3080 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3081 
     | 
    
         
            -
            return self['@elements'][anIndex - 1] = anObject;
         
     | 
| 
       3082 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3083 
     | 
    
         
            -
            }),
         
     | 
| 
       3084 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3085 
     | 
    
         
            -
             
     | 
| 
       3086 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3087 
     | 
    
         
            -
            '_at_ifAbsent_',
         
     | 
| 
       3088 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3089 
     | 
    
         
            -
            selector: 'at:ifAbsent:',
         
     | 
| 
       3090 
     | 
    
         
            -
            fn: function (anIndex, aBlock){
         
     | 
| 
       3091 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3092 
     | 
    
         
            -
            return smalltalk.send(self['@elements'], "_at_ifAbsent_", [anIndex, aBlock]);
         
     | 
| 
       3093 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3094 
     | 
    
         
            -
            }),
         
     | 
| 
       3095 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3096 
     | 
    
         
            -
             
     | 
| 
       3097 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3098 
     | 
    
         
            -
            '_add_',
         
     | 
| 
       3099 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3100 
     | 
    
         
            -
            selector: 'add:',
         
     | 
| 
       3101 
     | 
    
         
            -
            fn: function (anObject){
         
     | 
| 
       3102 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3103 
     | 
    
         
            -
            self['@elements'].push(anObject); return anObject;;
         
     | 
| 
       3104 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3105 
     | 
    
         
            -
            }),
         
     | 
| 
       3106 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3107 
     | 
    
         
            -
             
     | 
| 
       3108 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3109 
     | 
    
         
            -
            '_join_',
         
     | 
| 
       3110 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3111 
     | 
    
         
            -
            selector: 'join:',
         
     | 
| 
       3112 
     | 
    
         
            -
            fn: function (aString){
         
     | 
| 
       3113 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3114 
     | 
    
         
            -
            return smalltalk.send(self['@elements'], "_join_", [aString]);
         
     | 
| 
       3115 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3116 
     | 
    
         
            -
            }),
         
     | 
| 
       3117 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3118 
     | 
    
         
            -
             
     | 
| 
       3119 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3120 
     | 
    
         
            -
            '_sort',
         
     | 
| 
       3121 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3122 
     | 
    
         
            -
            selector: 'sort',
         
     | 
| 
       3123 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
       3124 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3125 
     | 
    
         
            -
            smalltalk.send(self['@elements'], "_sort", []);
         
     | 
| 
       3126 
     | 
    
         
            -
            return self;
         
     | 
| 
       3127 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3128 
     | 
    
         
            -
            }),
         
     | 
| 
       3129 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3130 
     | 
    
         
            -
             
     | 
| 
       3131 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3132 
     | 
    
         
            -
            '_sort_',
         
     | 
| 
       3133 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3134 
     | 
    
         
            -
            selector: 'sort:',
         
     | 
| 
       3135 
     | 
    
         
            -
            fn: function (aBlock){
         
     | 
| 
       3136 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3137 
     | 
    
         
            -
            smalltalk.send(self['@elements'], "_sort_", [aBlock]);
         
     | 
| 
       3138 
     | 
    
         
            -
            return self;
         
     | 
| 
       3139 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3140 
     | 
    
         
            -
            }),
         
     | 
| 
       3141 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3142 
     | 
    
         
            -
             
     | 
| 
       3143 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3144 
     | 
    
         
            -
            '_remove_',
         
     | 
| 
       3145 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3146 
     | 
    
         
            -
            selector: 'remove:',
         
     | 
| 
       3147 
     | 
    
         
            -
            fn: function (anObject){
         
     | 
| 
       3148 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3149 
     | 
    
         
            -
             
     | 
| 
       3150 
     | 
    
         
            -
            		for(var i=0;i<self['@elements'].length;i++) {
         
     | 
| 
       3151 
     | 
    
         
            -
            			if(self['@elements'][i] == anObject) {
         
     | 
| 
       3152 
     | 
    
         
            -
            				self['@elements'].splice(i,1);
         
     | 
| 
       3153 
     | 
    
         
            -
            				break;
         
     | 
| 
       3154 
     | 
    
         
            -
            			}
         
     | 
| 
       3155 
     | 
    
         
            -
            		}
         
     | 
| 
       3156 
     | 
    
         
            -
            	;
         
     | 
| 
       3157 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3158 
     | 
    
         
            -
            }),
         
     | 
| 
       3159 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3160 
     | 
    
         
            -
             
     | 
| 
       3161 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3162 
     | 
    
         
            -
            '_sorted',
         
     | 
| 
       3163 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3164 
     | 
    
         
            -
            selector: 'sorted',
         
     | 
| 
       3165 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
       3166 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3167 
     | 
    
         
            -
            return smalltalk.send(smalltalk.send(self, "_copy", []), "_sort", []);
         
     | 
| 
       3168 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3169 
     | 
    
         
            -
            }),
         
     | 
| 
       3170 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3171 
     | 
    
         
            -
             
     | 
| 
       3172 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3173 
     | 
    
         
            -
            '_sorted_',
         
     | 
| 
       3174 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3175 
     | 
    
         
            -
            selector: 'sorted:',
         
     | 
| 
       3176 
     | 
    
         
            -
            fn: function (aBlock){
         
     | 
| 
       3177 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3178 
     | 
    
         
            -
            return smalltalk.send(smalltalk.send(self, "_copy", []), "_sort_", [aBlock]);
         
     | 
| 
       3179 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3180 
     | 
    
         
            -
            }),
         
     | 
| 
       3181 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3182 
     | 
    
         
            -
             
     | 
| 
       3183 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3184 
     | 
    
         
            -
            '_removeFrom_to_',
         
     | 
| 
       3185 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3186 
     | 
    
         
            -
            selector: 'removeFrom:to:',
         
     | 
| 
       3187 
     | 
    
         
            -
            fn: function (aNumber, anotherNumber){
         
     | 
| 
       3188 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3189 
     | 
    
         
            -
            self['@elements'].splice(aNumber - 1,anotherNumber - 1);
         
     | 
| 
       3190 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3191 
     | 
    
         
            -
            }),
         
     | 
| 
       3192 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3193 
     | 
    
         
            -
             
     | 
| 
       3194 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3195 
     | 
    
         
            -
            '_reversed',
         
     | 
| 
       3196 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3197 
     | 
    
         
            -
            selector: 'reversed',
         
     | 
| 
       3198 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
       3199 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3200 
     | 
    
         
            -
            return smalltalk.send(smalltalk.send(smalltalk.send(self, "_asArray", []), "_reversed", []), "_asOrderedCollection", []);
         
     | 
| 
       3201 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3202 
     | 
    
         
            -
            }),
         
     | 
| 
       3203 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3204 
     | 
    
         
            -
             
     | 
| 
       3205 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3206 
     | 
    
         
            -
            '_initialize',
         
     | 
| 
       3207 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3208 
     | 
    
         
            -
            selector: 'initialize',
         
     | 
| 
       3209 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
       3210 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3211 
     | 
    
         
            -
            smalltalk.send(self, "_initialize", [], smalltalk.SequenceableCollection);
         
     | 
| 
       3212 
     | 
    
         
            -
            (self['@elements']=[]);
         
     | 
| 
       3213 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3214 
     | 
    
         
            -
            }),
         
     | 
| 
       3215 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3216 
     | 
    
         
            -
             
     | 
| 
       3217 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3218 
     | 
    
         
            -
            '_withIndexDo_',
         
     | 
| 
       3219 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3220 
     | 
    
         
            -
            selector: 'withIndexDo:',
         
     | 
| 
       3221 
     | 
    
         
            -
            fn: function (aBlock){
         
     | 
| 
       3222 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3223 
     | 
    
         
            -
            smalltalk.send(self['@elements'], "_withIndexDo_", [aBlock]);
         
     | 
| 
       3224 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3225 
     | 
    
         
            -
            }),
         
     | 
| 
       3226 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3227 
     | 
    
         
            -
             
     | 
| 
       3228 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3229 
     | 
    
         
            -
            '_detect_ifNone_',
         
     | 
| 
       3230 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3231 
     | 
    
         
            -
            selector: 'detect:ifNone:',
         
     | 
| 
       3232 
     | 
    
         
            -
            fn: function (aBlock, anotherBlock){
         
     | 
| 
       3233 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3234 
     | 
    
         
            -
            return smalltalk.send(self['@elements'], "_detect_ifNone_", [aBlock, anotherBlock]);
         
     | 
| 
       3235 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3236 
     | 
    
         
            -
            }),
         
     | 
| 
       3237 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3238 
     | 
    
         
            -
             
     | 
| 
       3239 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3240 
     | 
    
         
            -
            '_do_',
         
     | 
| 
       3241 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3242 
     | 
    
         
            -
            selector: 'do:',
         
     | 
| 
       3243 
     | 
    
         
            -
            fn: function (aBlock){
         
     | 
| 
       3244 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3245 
     | 
    
         
            -
            smalltalk.send(self['@elements'], "_do_", [aBlock]);
         
     | 
| 
       3246 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3247 
     | 
    
         
            -
            }),
         
     | 
| 
       3248 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3249 
     | 
    
         
            -
             
     | 
| 
       3250 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3251 
     | 
    
         
            -
            '_asOrderedCollection',
         
     | 
| 
       3252 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3253 
     | 
    
         
            -
            selector: 'asOrderedCollection',
         
     | 
| 
       3254 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
       3255 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3256 
     | 
    
         
            -
            return self;
         
     | 
| 
       3257 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3258 
     | 
    
         
            -
            }),
         
     | 
| 
       3259 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3260 
     | 
    
         
            -
             
     | 
| 
       3261 
     | 
    
         
            -
            smalltalk.addMethod(
         
     | 
| 
       3262 
     | 
    
         
            -
            '_asArray',
         
     | 
| 
       3263 
     | 
    
         
            -
            smalltalk.method({
         
     | 
| 
       3264 
     | 
    
         
            -
            selector: 'asArray',
         
     | 
| 
       3265 
     | 
    
         
            -
            fn: function (){
         
     | 
| 
       3266 
     | 
    
         
            -
            var self=this;
         
     | 
| 
       3267 
     | 
    
         
            -
            return smalltalk.send(self['@elements'], "_copy", []);
         
     | 
| 
       3268 
     | 
    
         
            -
            return self;}
         
     | 
| 
       3269 
     | 
    
         
            -
            }),
         
     | 
| 
       3270 
     | 
    
         
            -
            smalltalk.OrderedCollection);
         
     | 
| 
       3271 
     | 
    
         
            -
             
     | 
| 
       3272 
     | 
    
         
            -
             
     | 
| 
       3273 
     | 
    
         
            -
             
     |