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
    
        data/amber/js/Canvas.deploy.js
    CHANGED
    
    | @@ -1,9 +1,819 @@ | |
| 1 1 | 
             
            smalltalk.addPackage('Canvas', {});
         | 
| 2 | 
            +
            smalltalk.addClass('Widget', smalltalk.Object, [], 'Canvas');
         | 
| 3 | 
            +
            smalltalk.addMethod(
         | 
| 4 | 
            +
            unescape('_appendToBrush_'),
         | 
| 5 | 
            +
            smalltalk.method({
         | 
| 6 | 
            +
            selector: unescape('appendToBrush%3A'),
         | 
| 7 | 
            +
            fn: function (aTagBrush){
         | 
| 8 | 
            +
            var self=this;
         | 
| 9 | 
            +
            smalltalk.send(self, "_appendToJQuery_", [smalltalk.send(aTagBrush, "_asJQuery", [])]);
         | 
| 10 | 
            +
            return self;}
         | 
| 11 | 
            +
            }),
         | 
| 12 | 
            +
            smalltalk.Widget);
         | 
| 13 | 
            +
             | 
| 14 | 
            +
            smalltalk.addMethod(
         | 
| 15 | 
            +
            unescape('_appendToJQuery_'),
         | 
| 16 | 
            +
            smalltalk.method({
         | 
| 17 | 
            +
            selector: unescape('appendToJQuery%3A'),
         | 
| 18 | 
            +
            fn: function (aJQuery){
         | 
| 19 | 
            +
            var self=this;
         | 
| 20 | 
            +
            smalltalk.send(self, "_renderOn_", [smalltalk.send((smalltalk.HTMLCanvas || HTMLCanvas), "_onJQuery_", [aJQuery])]);
         | 
| 21 | 
            +
            return self;}
         | 
| 22 | 
            +
            }),
         | 
| 23 | 
            +
            smalltalk.Widget);
         | 
| 24 | 
            +
             | 
| 25 | 
            +
            smalltalk.addMethod(
         | 
| 26 | 
            +
            unescape('_renderOn_'),
         | 
| 27 | 
            +
            smalltalk.method({
         | 
| 28 | 
            +
            selector: unescape('renderOn%3A'),
         | 
| 29 | 
            +
            fn: function (html){
         | 
| 30 | 
            +
            var self=this;
         | 
| 31 | 
            +
            self;
         | 
| 32 | 
            +
            return self;}
         | 
| 33 | 
            +
            }),
         | 
| 34 | 
            +
            smalltalk.Widget);
         | 
| 35 | 
            +
             | 
| 36 | 
            +
             | 
| 37 | 
            +
             | 
| 38 | 
            +
            smalltalk.addClass('TagBrush', smalltalk.Object, ['canvas', 'element'], 'Canvas');
         | 
| 39 | 
            +
            smalltalk.addMethod(
         | 
| 40 | 
            +
            unescape('_element'),
         | 
| 41 | 
            +
            smalltalk.method({
         | 
| 42 | 
            +
            selector: unescape('element'),
         | 
| 43 | 
            +
            fn: function (){
         | 
| 44 | 
            +
            var self=this;
         | 
| 45 | 
            +
            return self['@element'];
         | 
| 46 | 
            +
            return self;}
         | 
| 47 | 
            +
            }),
         | 
| 48 | 
            +
            smalltalk.TagBrush);
         | 
| 49 | 
            +
             | 
| 50 | 
            +
            smalltalk.addMethod(
         | 
| 51 | 
            +
            unescape('_contents_'),
         | 
| 52 | 
            +
            smalltalk.method({
         | 
| 53 | 
            +
            selector: unescape('contents%3A'),
         | 
| 54 | 
            +
            fn: function (anObject){
         | 
| 55 | 
            +
            var self=this;
         | 
| 56 | 
            +
            (function($rec){smalltalk.send($rec, "_empty", []);return smalltalk.send($rec, "_append_", [anObject]);})(self);
         | 
| 57 | 
            +
            return self;}
         | 
| 58 | 
            +
            }),
         | 
| 59 | 
            +
            smalltalk.TagBrush);
         | 
| 60 | 
            +
             | 
| 61 | 
            +
            smalltalk.addMethod(
         | 
| 62 | 
            +
            unescape('_addBrush_'),
         | 
| 63 | 
            +
            smalltalk.method({
         | 
| 64 | 
            +
            selector: unescape('addBrush%3A'),
         | 
| 65 | 
            +
            fn: function (aTagBrush){
         | 
| 66 | 
            +
            var self=this;
         | 
| 67 | 
            +
            smalltalk.send(self, "_appendChild_", [smalltalk.send(aTagBrush, "_element", [])]);
         | 
| 68 | 
            +
            return aTagBrush;
         | 
| 69 | 
            +
            return self;}
         | 
| 70 | 
            +
            }),
         | 
| 71 | 
            +
            smalltalk.TagBrush);
         | 
| 72 | 
            +
             | 
| 73 | 
            +
            smalltalk.addMethod(
         | 
| 74 | 
            +
            unescape('_with_'),
         | 
| 75 | 
            +
            smalltalk.method({
         | 
| 76 | 
            +
            selector: unescape('with%3A'),
         | 
| 77 | 
            +
            fn: function (anObject){
         | 
| 78 | 
            +
            var self=this;
         | 
| 79 | 
            +
            smalltalk.send(self, "_append_", [anObject]);
         | 
| 80 | 
            +
            return self;}
         | 
| 81 | 
            +
            }),
         | 
| 82 | 
            +
            smalltalk.TagBrush);
         | 
| 83 | 
            +
             | 
| 84 | 
            +
            smalltalk.addMethod(
         | 
| 85 | 
            +
            unescape('_append_'),
         | 
| 86 | 
            +
            smalltalk.method({
         | 
| 87 | 
            +
            selector: unescape('append%3A'),
         | 
| 88 | 
            +
            fn: function (anObject){
         | 
| 89 | 
            +
            var self=this;
         | 
| 90 | 
            +
            smalltalk.send(anObject, "_appendToBrush_", [self]);
         | 
| 91 | 
            +
            return self;}
         | 
| 92 | 
            +
            }),
         | 
| 93 | 
            +
            smalltalk.TagBrush);
         | 
| 94 | 
            +
             | 
| 95 | 
            +
            smalltalk.addMethod(
         | 
| 96 | 
            +
            unescape('_appendToBrush_'),
         | 
| 97 | 
            +
            smalltalk.method({
         | 
| 98 | 
            +
            selector: unescape('appendToBrush%3A'),
         | 
| 99 | 
            +
            fn: function (aTagBrush){
         | 
| 100 | 
            +
            var self=this;
         | 
| 101 | 
            +
            smalltalk.send(aTagBrush, "_addBrush_", [self]);
         | 
| 102 | 
            +
            return self;}
         | 
| 103 | 
            +
            }),
         | 
| 104 | 
            +
            smalltalk.TagBrush);
         | 
| 105 | 
            +
             | 
| 106 | 
            +
            smalltalk.addMethod(
         | 
| 107 | 
            +
            unescape('_appendBlock_'),
         | 
| 108 | 
            +
            smalltalk.method({
         | 
| 109 | 
            +
            selector: unescape('appendBlock%3A'),
         | 
| 110 | 
            +
            fn: function (aBlock){
         | 
| 111 | 
            +
            var self=this;
         | 
| 112 | 
            +
            var root=nil;
         | 
| 113 | 
            +
            (root=smalltalk.send(self['@canvas'], "_root", []));
         | 
| 114 | 
            +
            smalltalk.send(self['@canvas'], "_root_", [self]);
         | 
| 115 | 
            +
            smalltalk.send(aBlock, "_value_", [self['@canvas']]);
         | 
| 116 | 
            +
            smalltalk.send(self['@canvas'], "_root_", [root]);
         | 
| 117 | 
            +
            return self;}
         | 
| 118 | 
            +
            }),
         | 
| 119 | 
            +
            smalltalk.TagBrush);
         | 
| 120 | 
            +
             | 
| 121 | 
            +
            smalltalk.addMethod(
         | 
| 122 | 
            +
            unescape('_appendChild_'),
         | 
| 123 | 
            +
            smalltalk.method({
         | 
| 124 | 
            +
            selector: unescape('appendChild%3A'),
         | 
| 125 | 
            +
            fn: function (anElement){
         | 
| 126 | 
            +
            var self=this;
         | 
| 127 | 
            +
            var element=self['@element'];
         | 
| 128 | 
            +
             	if (null == element.canHaveChildren || element.canHaveChildren) {
         | 
| 129 | 
            +
            		element.appendChild(anElement);
         | 
| 130 | 
            +
             	} else {
         | 
| 131 | 
            +
             		element.text = String(element.text) +  anElement.innerHTML;
         | 
| 132 | 
            +
             	} ;
         | 
| 133 | 
            +
            return self;}
         | 
| 134 | 
            +
            }),
         | 
| 135 | 
            +
            smalltalk.TagBrush);
         | 
| 136 | 
            +
             | 
| 137 | 
            +
            smalltalk.addMethod(
         | 
| 138 | 
            +
            unescape('_appendString_'),
         | 
| 139 | 
            +
            smalltalk.method({
         | 
| 140 | 
            +
            selector: unescape('appendString%3A'),
         | 
| 141 | 
            +
            fn: function (aString){
         | 
| 142 | 
            +
            var self=this;
         | 
| 143 | 
            +
            smalltalk.send(self, "_appendChild_", [smalltalk.send(self, "_createTextNodeFor_", [aString])]);
         | 
| 144 | 
            +
            return self;}
         | 
| 145 | 
            +
            }),
         | 
| 146 | 
            +
            smalltalk.TagBrush);
         | 
| 147 | 
            +
             | 
| 148 | 
            +
            smalltalk.addMethod(
         | 
| 149 | 
            +
            unescape('_empty'),
         | 
| 150 | 
            +
            smalltalk.method({
         | 
| 151 | 
            +
            selector: unescape('empty'),
         | 
| 152 | 
            +
            fn: function (){
         | 
| 153 | 
            +
            var self=this;
         | 
| 154 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_empty", []);
         | 
| 155 | 
            +
            return self;}
         | 
| 156 | 
            +
            }),
         | 
| 157 | 
            +
            smalltalk.TagBrush);
         | 
| 158 | 
            +
             | 
| 159 | 
            +
            smalltalk.addMethod(
         | 
| 160 | 
            +
            unescape('_at_put_'),
         | 
| 161 | 
            +
            smalltalk.method({
         | 
| 162 | 
            +
            selector: unescape('at%3Aput%3A'),
         | 
| 163 | 
            +
            fn: function (aString, aValue){
         | 
| 164 | 
            +
            var self=this;
         | 
| 165 | 
            +
            self['@element'].setAttribute(aString, aValue);
         | 
| 166 | 
            +
            return self;}
         | 
| 167 | 
            +
            }),
         | 
| 168 | 
            +
            smalltalk.TagBrush);
         | 
| 169 | 
            +
             | 
| 170 | 
            +
            smalltalk.addMethod(
         | 
| 171 | 
            +
            unescape('_removeAt_'),
         | 
| 172 | 
            +
            smalltalk.method({
         | 
| 173 | 
            +
            selector: unescape('removeAt%3A'),
         | 
| 174 | 
            +
            fn: function (aString){
         | 
| 175 | 
            +
            var self=this;
         | 
| 176 | 
            +
            self['@element'].removeAttribute(aString);
         | 
| 177 | 
            +
            return self;}
         | 
| 178 | 
            +
            }),
         | 
| 179 | 
            +
            smalltalk.TagBrush);
         | 
| 180 | 
            +
             | 
| 181 | 
            +
            smalltalk.addMethod(
         | 
| 182 | 
            +
            unescape('_class_'),
         | 
| 183 | 
            +
            smalltalk.method({
         | 
| 184 | 
            +
            selector: unescape('class%3A'),
         | 
| 185 | 
            +
            fn: function (aString){
         | 
| 186 | 
            +
            var self=this;
         | 
| 187 | 
            +
            self['@element'].className = aString;
         | 
| 188 | 
            +
            return self;}
         | 
| 189 | 
            +
            }),
         | 
| 190 | 
            +
            smalltalk.TagBrush);
         | 
| 191 | 
            +
             | 
| 192 | 
            +
            smalltalk.addMethod(
         | 
| 193 | 
            +
            unescape('_id_'),
         | 
| 194 | 
            +
            smalltalk.method({
         | 
| 195 | 
            +
            selector: unescape('id%3A'),
         | 
| 196 | 
            +
            fn: function (aString){
         | 
| 197 | 
            +
            var self=this;
         | 
| 198 | 
            +
            smalltalk.send(self, "_at_put_", ["id", aString]);
         | 
| 199 | 
            +
            return self;}
         | 
| 200 | 
            +
            }),
         | 
| 201 | 
            +
            smalltalk.TagBrush);
         | 
| 202 | 
            +
             | 
| 203 | 
            +
            smalltalk.addMethod(
         | 
| 204 | 
            +
            unescape('_src_'),
         | 
| 205 | 
            +
            smalltalk.method({
         | 
| 206 | 
            +
            selector: unescape('src%3A'),
         | 
| 207 | 
            +
            fn: function (aString){
         | 
| 208 | 
            +
            var self=this;
         | 
| 209 | 
            +
            smalltalk.send(self, "_at_put_", ["src", aString]);
         | 
| 210 | 
            +
            return self;}
         | 
| 211 | 
            +
            }),
         | 
| 212 | 
            +
            smalltalk.TagBrush);
         | 
| 213 | 
            +
             | 
| 214 | 
            +
            smalltalk.addMethod(
         | 
| 215 | 
            +
            unescape('_href_'),
         | 
| 216 | 
            +
            smalltalk.method({
         | 
| 217 | 
            +
            selector: unescape('href%3A'),
         | 
| 218 | 
            +
            fn: function (aString){
         | 
| 219 | 
            +
            var self=this;
         | 
| 220 | 
            +
            smalltalk.send(self, "_at_put_", ["href", aString]);
         | 
| 221 | 
            +
            return self;}
         | 
| 222 | 
            +
            }),
         | 
| 223 | 
            +
            smalltalk.TagBrush);
         | 
| 224 | 
            +
             | 
| 225 | 
            +
            smalltalk.addMethod(
         | 
| 226 | 
            +
            unescape('_title_'),
         | 
| 227 | 
            +
            smalltalk.method({
         | 
| 228 | 
            +
            selector: unescape('title%3A'),
         | 
| 229 | 
            +
            fn: function (aString){
         | 
| 230 | 
            +
            var self=this;
         | 
| 231 | 
            +
            smalltalk.send(self, "_at_put_", ["title", aString]);
         | 
| 232 | 
            +
            return self;}
         | 
| 233 | 
            +
            }),
         | 
| 234 | 
            +
            smalltalk.TagBrush);
         | 
| 235 | 
            +
             | 
| 236 | 
            +
            smalltalk.addMethod(
         | 
| 237 | 
            +
            unescape('_style_'),
         | 
| 238 | 
            +
            smalltalk.method({
         | 
| 239 | 
            +
            selector: unescape('style%3A'),
         | 
| 240 | 
            +
            fn: function (aString){
         | 
| 241 | 
            +
            var self=this;
         | 
| 242 | 
            +
            smalltalk.send(self, "_at_put_", ["style", aString]);
         | 
| 243 | 
            +
            return self;}
         | 
| 244 | 
            +
            }),
         | 
| 245 | 
            +
            smalltalk.TagBrush);
         | 
| 246 | 
            +
             | 
| 247 | 
            +
            smalltalk.addMethod(
         | 
| 248 | 
            +
            unescape('_type_'),
         | 
| 249 | 
            +
            smalltalk.method({
         | 
| 250 | 
            +
            selector: unescape('type%3A'),
         | 
| 251 | 
            +
            fn: function (aString){
         | 
| 252 | 
            +
            var self=this;
         | 
| 253 | 
            +
            smalltalk.send(self, "_at_put_", ["type", aString]);
         | 
| 254 | 
            +
            return self;}
         | 
| 255 | 
            +
            }),
         | 
| 256 | 
            +
            smalltalk.TagBrush);
         | 
| 257 | 
            +
             | 
| 258 | 
            +
            smalltalk.addMethod(
         | 
| 259 | 
            +
            unescape('_media_'),
         | 
| 260 | 
            +
            smalltalk.method({
         | 
| 261 | 
            +
            selector: unescape('media%3A'),
         | 
| 262 | 
            +
            fn: function (aString){
         | 
| 263 | 
            +
            var self=this;
         | 
| 264 | 
            +
            smalltalk.send(self, "_at_put_", ["media", aString]);
         | 
| 265 | 
            +
            return self;}
         | 
| 266 | 
            +
            }),
         | 
| 267 | 
            +
            smalltalk.TagBrush);
         | 
| 268 | 
            +
             | 
| 269 | 
            +
            smalltalk.addMethod(
         | 
| 270 | 
            +
            unescape('_rel_'),
         | 
| 271 | 
            +
            smalltalk.method({
         | 
| 272 | 
            +
            selector: unescape('rel%3A'),
         | 
| 273 | 
            +
            fn: function (aString){
         | 
| 274 | 
            +
            var self=this;
         | 
| 275 | 
            +
            smalltalk.send(self, "_at_put_", ["rel", aString]);
         | 
| 276 | 
            +
            return self;}
         | 
| 277 | 
            +
            }),
         | 
| 278 | 
            +
            smalltalk.TagBrush);
         | 
| 279 | 
            +
             | 
| 280 | 
            +
            smalltalk.addMethod(
         | 
| 281 | 
            +
            unescape('_width_'),
         | 
| 282 | 
            +
            smalltalk.method({
         | 
| 283 | 
            +
            selector: unescape('width%3A'),
         | 
| 284 | 
            +
            fn: function (aString){
         | 
| 285 | 
            +
            var self=this;
         | 
| 286 | 
            +
            smalltalk.send(self, "_at_put_", ["width", aString]);
         | 
| 287 | 
            +
            return self;}
         | 
| 288 | 
            +
            }),
         | 
| 289 | 
            +
            smalltalk.TagBrush);
         | 
| 290 | 
            +
             | 
| 291 | 
            +
            smalltalk.addMethod(
         | 
| 292 | 
            +
            unescape('_height_'),
         | 
| 293 | 
            +
            smalltalk.method({
         | 
| 294 | 
            +
            selector: unescape('height%3A'),
         | 
| 295 | 
            +
            fn: function (aString){
         | 
| 296 | 
            +
            var self=this;
         | 
| 297 | 
            +
            smalltalk.send(self, "_at_put_", ["height", aString]);
         | 
| 298 | 
            +
            return self;}
         | 
| 299 | 
            +
            }),
         | 
| 300 | 
            +
            smalltalk.TagBrush);
         | 
| 301 | 
            +
             | 
| 302 | 
            +
            smalltalk.addMethod(
         | 
| 303 | 
            +
            unescape('_value_'),
         | 
| 304 | 
            +
            smalltalk.method({
         | 
| 305 | 
            +
            selector: unescape('value%3A'),
         | 
| 306 | 
            +
            fn: function (aString){
         | 
| 307 | 
            +
            var self=this;
         | 
| 308 | 
            +
            smalltalk.send(self, "_at_put_", ["value", aString]);
         | 
| 309 | 
            +
            return self;}
         | 
| 310 | 
            +
            }),
         | 
| 311 | 
            +
            smalltalk.TagBrush);
         | 
| 312 | 
            +
             | 
| 313 | 
            +
            smalltalk.addMethod(
         | 
| 314 | 
            +
            unescape('_asJQuery'),
         | 
| 315 | 
            +
            smalltalk.method({
         | 
| 316 | 
            +
            selector: unescape('asJQuery'),
         | 
| 317 | 
            +
            fn: function (){
         | 
| 318 | 
            +
            var self=this;
         | 
| 319 | 
            +
            return smalltalk.send((typeof window == 'undefined' ? nil : window), "_jQuery_", [smalltalk.send(self, "_element", [])]);
         | 
| 320 | 
            +
            return self;}
         | 
| 321 | 
            +
            }),
         | 
| 322 | 
            +
            smalltalk.TagBrush);
         | 
| 323 | 
            +
             | 
| 324 | 
            +
            smalltalk.addMethod(
         | 
| 325 | 
            +
            unescape('_onKeyDown_'),
         | 
| 326 | 
            +
            smalltalk.method({
         | 
| 327 | 
            +
            selector: unescape('onKeyDown%3A'),
         | 
| 328 | 
            +
            fn: function (aBlock){
         | 
| 329 | 
            +
            var self=this;
         | 
| 330 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["keydown", aBlock]);
         | 
| 331 | 
            +
            return self;}
         | 
| 332 | 
            +
            }),
         | 
| 333 | 
            +
            smalltalk.TagBrush);
         | 
| 334 | 
            +
             | 
| 335 | 
            +
            smalltalk.addMethod(
         | 
| 336 | 
            +
            unescape('_onKeyPress_'),
         | 
| 337 | 
            +
            smalltalk.method({
         | 
| 338 | 
            +
            selector: unescape('onKeyPress%3A'),
         | 
| 339 | 
            +
            fn: function (aBlock){
         | 
| 340 | 
            +
            var self=this;
         | 
| 341 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["keypress", aBlock]);
         | 
| 342 | 
            +
            return self;}
         | 
| 343 | 
            +
            }),
         | 
| 344 | 
            +
            smalltalk.TagBrush);
         | 
| 345 | 
            +
             | 
| 346 | 
            +
            smalltalk.addMethod(
         | 
| 347 | 
            +
            unescape('_onKeyUp_'),
         | 
| 348 | 
            +
            smalltalk.method({
         | 
| 349 | 
            +
            selector: unescape('onKeyUp%3A'),
         | 
| 350 | 
            +
            fn: function (aBlock){
         | 
| 351 | 
            +
            var self=this;
         | 
| 352 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["keyup", aBlock]);
         | 
| 353 | 
            +
            return self;}
         | 
| 354 | 
            +
            }),
         | 
| 355 | 
            +
            smalltalk.TagBrush);
         | 
| 356 | 
            +
             | 
| 357 | 
            +
            smalltalk.addMethod(
         | 
| 358 | 
            +
            unescape('_onFocus_'),
         | 
| 359 | 
            +
            smalltalk.method({
         | 
| 360 | 
            +
            selector: unescape('onFocus%3A'),
         | 
| 361 | 
            +
            fn: function (aBlock){
         | 
| 362 | 
            +
            var self=this;
         | 
| 363 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["focus", aBlock]);
         | 
| 364 | 
            +
            return self;}
         | 
| 365 | 
            +
            }),
         | 
| 366 | 
            +
            smalltalk.TagBrush);
         | 
| 367 | 
            +
             | 
| 368 | 
            +
            smalltalk.addMethod(
         | 
| 369 | 
            +
            unescape('_onBlur_'),
         | 
| 370 | 
            +
            smalltalk.method({
         | 
| 371 | 
            +
            selector: unescape('onBlur%3A'),
         | 
| 372 | 
            +
            fn: function (aBlock){
         | 
| 373 | 
            +
            var self=this;
         | 
| 374 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["blur", aBlock]);
         | 
| 375 | 
            +
            return self;}
         | 
| 376 | 
            +
            }),
         | 
| 377 | 
            +
            smalltalk.TagBrush);
         | 
| 378 | 
            +
             | 
| 379 | 
            +
            smalltalk.addMethod(
         | 
| 380 | 
            +
            unescape('_onChange_'),
         | 
| 381 | 
            +
            smalltalk.method({
         | 
| 382 | 
            +
            selector: unescape('onChange%3A'),
         | 
| 383 | 
            +
            fn: function (aBlock){
         | 
| 384 | 
            +
            var self=this;
         | 
| 385 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["change", aBlock]);
         | 
| 386 | 
            +
            return self;}
         | 
| 387 | 
            +
            }),
         | 
| 388 | 
            +
            smalltalk.TagBrush);
         | 
| 389 | 
            +
             | 
| 390 | 
            +
            smalltalk.addMethod(
         | 
| 391 | 
            +
            unescape('_onClick_'),
         | 
| 392 | 
            +
            smalltalk.method({
         | 
| 393 | 
            +
            selector: unescape('onClick%3A'),
         | 
| 394 | 
            +
            fn: function (aBlock){
         | 
| 395 | 
            +
            var self=this;
         | 
| 396 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["click", aBlock]);
         | 
| 397 | 
            +
            return self;}
         | 
| 398 | 
            +
            }),
         | 
| 399 | 
            +
            smalltalk.TagBrush);
         | 
| 400 | 
            +
             | 
| 401 | 
            +
            smalltalk.addMethod(
         | 
| 402 | 
            +
            unescape('_initializeFromString_canvas_'),
         | 
| 403 | 
            +
            smalltalk.method({
         | 
| 404 | 
            +
            selector: unescape('initializeFromString%3Acanvas%3A'),
         | 
| 405 | 
            +
            fn: function (aString, aCanvas){
         | 
| 406 | 
            +
            var self=this;
         | 
| 407 | 
            +
            (self['@element']=smalltalk.send(self, "_createElementFor_", [aString]));
         | 
| 408 | 
            +
            (self['@canvas']=aCanvas);
         | 
| 409 | 
            +
            return self;}
         | 
| 410 | 
            +
            }),
         | 
| 411 | 
            +
            smalltalk.TagBrush);
         | 
| 412 | 
            +
             | 
| 413 | 
            +
            smalltalk.addMethod(
         | 
| 414 | 
            +
            unescape('_initializeFromJQuery_canvas_'),
         | 
| 415 | 
            +
            smalltalk.method({
         | 
| 416 | 
            +
            selector: unescape('initializeFromJQuery%3Acanvas%3A'),
         | 
| 417 | 
            +
            fn: function (aJQuery, aCanvas){
         | 
| 418 | 
            +
            var self=this;
         | 
| 419 | 
            +
            (self['@element']=smalltalk.send(aJQuery, "_get_", [(0)]));
         | 
| 420 | 
            +
            (self['@canvas']=aCanvas);
         | 
| 421 | 
            +
            return self;}
         | 
| 422 | 
            +
            }),
         | 
| 423 | 
            +
            smalltalk.TagBrush);
         | 
| 424 | 
            +
             | 
| 425 | 
            +
            smalltalk.addMethod(
         | 
| 426 | 
            +
            unescape('_createElementFor_'),
         | 
| 427 | 
            +
            smalltalk.method({
         | 
| 428 | 
            +
            selector: unescape('createElementFor%3A'),
         | 
| 429 | 
            +
            fn: function (aString){
         | 
| 430 | 
            +
            var self=this;
         | 
| 431 | 
            +
            return document.createElement(String(aString));
         | 
| 432 | 
            +
            return self;}
         | 
| 433 | 
            +
            }),
         | 
| 434 | 
            +
            smalltalk.TagBrush);
         | 
| 435 | 
            +
             | 
| 436 | 
            +
            smalltalk.addMethod(
         | 
| 437 | 
            +
            unescape('_createTextNodeFor_'),
         | 
| 438 | 
            +
            smalltalk.method({
         | 
| 439 | 
            +
            selector: unescape('createTextNodeFor%3A'),
         | 
| 440 | 
            +
            fn: function (aString){
         | 
| 441 | 
            +
            var self=this;
         | 
| 442 | 
            +
            return document.createTextNode(String(aString));
         | 
| 443 | 
            +
            return self;}
         | 
| 444 | 
            +
            }),
         | 
| 445 | 
            +
            smalltalk.TagBrush);
         | 
| 446 | 
            +
             | 
| 447 | 
            +
            smalltalk.addMethod(
         | 
| 448 | 
            +
            unescape('_onSubmit_'),
         | 
| 449 | 
            +
            smalltalk.method({
         | 
| 450 | 
            +
            selector: unescape('onSubmit%3A'),
         | 
| 451 | 
            +
            fn: function (aBlock){
         | 
| 452 | 
            +
            var self=this;
         | 
| 453 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["submit", aBlock]);
         | 
| 454 | 
            +
            return self;}
         | 
| 455 | 
            +
            }),
         | 
| 456 | 
            +
            smalltalk.TagBrush);
         | 
| 457 | 
            +
             | 
| 458 | 
            +
            smalltalk.addMethod(
         | 
| 459 | 
            +
            unescape('_onDblClick_'),
         | 
| 460 | 
            +
            smalltalk.method({
         | 
| 461 | 
            +
            selector: unescape('onDblClick%3A'),
         | 
| 462 | 
            +
            fn: function (aBlock){
         | 
| 463 | 
            +
            var self=this;
         | 
| 464 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["dblclick", aBlock]);
         | 
| 465 | 
            +
            return self;}
         | 
| 466 | 
            +
            }),
         | 
| 467 | 
            +
            smalltalk.TagBrush);
         | 
| 468 | 
            +
             | 
| 469 | 
            +
            smalltalk.addMethod(
         | 
| 470 | 
            +
            unescape('_onHover_'),
         | 
| 471 | 
            +
            smalltalk.method({
         | 
| 472 | 
            +
            selector: unescape('onHover%3A'),
         | 
| 473 | 
            +
            fn: function (aBlock){
         | 
| 474 | 
            +
            var self=this;
         | 
| 475 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["hover", aBlock]);
         | 
| 476 | 
            +
            return self;}
         | 
| 477 | 
            +
            }),
         | 
| 478 | 
            +
            smalltalk.TagBrush);
         | 
| 479 | 
            +
             | 
| 480 | 
            +
            smalltalk.addMethod(
         | 
| 481 | 
            +
            unescape('_onFocusIn_'),
         | 
| 482 | 
            +
            smalltalk.method({
         | 
| 483 | 
            +
            selector: unescape('onFocusIn%3A'),
         | 
| 484 | 
            +
            fn: function (aBlock){
         | 
| 485 | 
            +
            var self=this;
         | 
| 486 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["focusin", aBlock]);
         | 
| 487 | 
            +
            return self;}
         | 
| 488 | 
            +
            }),
         | 
| 489 | 
            +
            smalltalk.TagBrush);
         | 
| 490 | 
            +
             | 
| 491 | 
            +
            smalltalk.addMethod(
         | 
| 492 | 
            +
            unescape('_onFocusOut_'),
         | 
| 493 | 
            +
            smalltalk.method({
         | 
| 494 | 
            +
            selector: unescape('onFocusOut%3A'),
         | 
| 495 | 
            +
            fn: function (aBlock){
         | 
| 496 | 
            +
            var self=this;
         | 
| 497 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["focusout", aBlock]);
         | 
| 498 | 
            +
            return self;}
         | 
| 499 | 
            +
            }),
         | 
| 500 | 
            +
            smalltalk.TagBrush);
         | 
| 501 | 
            +
             | 
| 502 | 
            +
            smalltalk.addMethod(
         | 
| 503 | 
            +
            unescape('_onMouseDown_'),
         | 
| 504 | 
            +
            smalltalk.method({
         | 
| 505 | 
            +
            selector: unescape('onMouseDown%3A'),
         | 
| 506 | 
            +
            fn: function (aBlock){
         | 
| 507 | 
            +
            var self=this;
         | 
| 508 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["mousedown", aBlock]);
         | 
| 509 | 
            +
            return self;}
         | 
| 510 | 
            +
            }),
         | 
| 511 | 
            +
            smalltalk.TagBrush);
         | 
| 512 | 
            +
             | 
| 513 | 
            +
            smalltalk.addMethod(
         | 
| 514 | 
            +
            unescape('_onMouseUp_'),
         | 
| 515 | 
            +
            smalltalk.method({
         | 
| 516 | 
            +
            selector: unescape('onMouseUp%3A'),
         | 
| 517 | 
            +
            fn: function (aBlock){
         | 
| 518 | 
            +
            var self=this;
         | 
| 519 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["mouseup", aBlock]);
         | 
| 520 | 
            +
            return self;}
         | 
| 521 | 
            +
            }),
         | 
| 522 | 
            +
            smalltalk.TagBrush);
         | 
| 523 | 
            +
             | 
| 524 | 
            +
            smalltalk.addMethod(
         | 
| 525 | 
            +
            unescape('_onMouseEnter_'),
         | 
| 526 | 
            +
            smalltalk.method({
         | 
| 527 | 
            +
            selector: unescape('onMouseEnter%3A'),
         | 
| 528 | 
            +
            fn: function (aBlock){
         | 
| 529 | 
            +
            var self=this;
         | 
| 530 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["mouseenter", aBlock]);
         | 
| 531 | 
            +
            return self;}
         | 
| 532 | 
            +
            }),
         | 
| 533 | 
            +
            smalltalk.TagBrush);
         | 
| 534 | 
            +
             | 
| 535 | 
            +
            smalltalk.addMethod(
         | 
| 536 | 
            +
            unescape('_onMouseLeave_'),
         | 
| 537 | 
            +
            smalltalk.method({
         | 
| 538 | 
            +
            selector: unescape('onMouseLeave%3A'),
         | 
| 539 | 
            +
            fn: function (aBlock){
         | 
| 540 | 
            +
            var self=this;
         | 
| 541 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["mouseleave", aBlock]);
         | 
| 542 | 
            +
            return self;}
         | 
| 543 | 
            +
            }),
         | 
| 544 | 
            +
            smalltalk.TagBrush);
         | 
| 545 | 
            +
             | 
| 546 | 
            +
            smalltalk.addMethod(
         | 
| 547 | 
            +
            unescape('_onMouseMove_'),
         | 
| 548 | 
            +
            smalltalk.method({
         | 
| 549 | 
            +
            selector: unescape('onMouseMove%3A'),
         | 
| 550 | 
            +
            fn: function (aBlock){
         | 
| 551 | 
            +
            var self=this;
         | 
| 552 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["mousemove", aBlock]);
         | 
| 553 | 
            +
            return self;}
         | 
| 554 | 
            +
            }),
         | 
| 555 | 
            +
            smalltalk.TagBrush);
         | 
| 556 | 
            +
             | 
| 557 | 
            +
            smalltalk.addMethod(
         | 
| 558 | 
            +
            unescape('_onMouseOut_'),
         | 
| 559 | 
            +
            smalltalk.method({
         | 
| 560 | 
            +
            selector: unescape('onMouseOut%3A'),
         | 
| 561 | 
            +
            fn: function (aBlock){
         | 
| 562 | 
            +
            var self=this;
         | 
| 563 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["mouseout", aBlock]);
         | 
| 564 | 
            +
            return self;}
         | 
| 565 | 
            +
            }),
         | 
| 566 | 
            +
            smalltalk.TagBrush);
         | 
| 567 | 
            +
             | 
| 568 | 
            +
            smalltalk.addMethod(
         | 
| 569 | 
            +
            unescape('_onMouseOver_'),
         | 
| 570 | 
            +
            smalltalk.method({
         | 
| 571 | 
            +
            selector: unescape('onMouseOver%3A'),
         | 
| 572 | 
            +
            fn: function (aBlock){
         | 
| 573 | 
            +
            var self=this;
         | 
| 574 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["mouseover", aBlock]);
         | 
| 575 | 
            +
            return self;}
         | 
| 576 | 
            +
            }),
         | 
| 577 | 
            +
            smalltalk.TagBrush);
         | 
| 578 | 
            +
             | 
| 579 | 
            +
            smalltalk.addMethod(
         | 
| 580 | 
            +
            unescape('_onSelect_'),
         | 
| 581 | 
            +
            smalltalk.method({
         | 
| 582 | 
            +
            selector: unescape('onSelect%3A'),
         | 
| 583 | 
            +
            fn: function (aBlock){
         | 
| 584 | 
            +
            var self=this;
         | 
| 585 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["select", aBlock]);
         | 
| 586 | 
            +
            return self;}
         | 
| 587 | 
            +
            }),
         | 
| 588 | 
            +
            smalltalk.TagBrush);
         | 
| 589 | 
            +
             | 
| 590 | 
            +
            smalltalk.addMethod(
         | 
| 591 | 
            +
            unescape('_onUnload_'),
         | 
| 592 | 
            +
            smalltalk.method({
         | 
| 593 | 
            +
            selector: unescape('onUnload%3A'),
         | 
| 594 | 
            +
            fn: function (aBlock){
         | 
| 595 | 
            +
            var self=this;
         | 
| 596 | 
            +
            smalltalk.send(smalltalk.send(self, "_asJQuery", []), "_bind_do_", ["unload", aBlock]);
         | 
| 597 | 
            +
            return self;}
         | 
| 598 | 
            +
            }),
         | 
| 599 | 
            +
            smalltalk.TagBrush);
         | 
| 600 | 
            +
             | 
| 601 | 
            +
            smalltalk.addMethod(
         | 
| 602 | 
            +
            unescape('_for_'),
         | 
| 603 | 
            +
            smalltalk.method({
         | 
| 604 | 
            +
            selector: unescape('for%3A'),
         | 
| 605 | 
            +
            fn: function (aString){
         | 
| 606 | 
            +
            var self=this;
         | 
| 607 | 
            +
            smalltalk.send(self, "_at_put_", ["for", aString]);
         | 
| 608 | 
            +
            return self;}
         | 
| 609 | 
            +
            }),
         | 
| 610 | 
            +
            smalltalk.TagBrush);
         | 
| 611 | 
            +
             | 
| 612 | 
            +
            smalltalk.addMethod(
         | 
| 613 | 
            +
            unescape('_placeholder_'),
         | 
| 614 | 
            +
            smalltalk.method({
         | 
| 615 | 
            +
            selector: unescape('placeholder%3A'),
         | 
| 616 | 
            +
            fn: function (aString){
         | 
| 617 | 
            +
            var self=this;
         | 
| 618 | 
            +
            smalltalk.send(self, "_at_put_", ["placeholder", aString]);
         | 
| 619 | 
            +
            return self;}
         | 
| 620 | 
            +
            }),
         | 
| 621 | 
            +
            smalltalk.TagBrush);
         | 
| 622 | 
            +
             | 
| 623 | 
            +
            smalltalk.addMethod(
         | 
| 624 | 
            +
            unescape('_accesskey_'),
         | 
| 625 | 
            +
            smalltalk.method({
         | 
| 626 | 
            +
            selector: unescape('accesskey%3A'),
         | 
| 627 | 
            +
            fn: function (aString){
         | 
| 628 | 
            +
            var self=this;
         | 
| 629 | 
            +
            smalltalk.send(self, "_at_put_", ["accesskey", aString]);
         | 
| 630 | 
            +
            return self;}
         | 
| 631 | 
            +
            }),
         | 
| 632 | 
            +
            smalltalk.TagBrush);
         | 
| 633 | 
            +
             | 
| 634 | 
            +
            smalltalk.addMethod(
         | 
| 635 | 
            +
            unescape('_contenteditable_'),
         | 
| 636 | 
            +
            smalltalk.method({
         | 
| 637 | 
            +
            selector: unescape('contenteditable%3A'),
         | 
| 638 | 
            +
            fn: function (aString){
         | 
| 639 | 
            +
            var self=this;
         | 
| 640 | 
            +
            smalltalk.send(self, "_at_put_", ["contenteditable", aString]);
         | 
| 641 | 
            +
            return self;}
         | 
| 642 | 
            +
            }),
         | 
| 643 | 
            +
            smalltalk.TagBrush);
         | 
| 644 | 
            +
             | 
| 645 | 
            +
            smalltalk.addMethod(
         | 
| 646 | 
            +
            unescape('_contextmenu_'),
         | 
| 647 | 
            +
            smalltalk.method({
         | 
| 648 | 
            +
            selector: unescape('contextmenu%3A'),
         | 
| 649 | 
            +
            fn: function (aString){
         | 
| 650 | 
            +
            var self=this;
         | 
| 651 | 
            +
            smalltalk.send(self, "_at_put_", ["contextmenu", aString]);
         | 
| 652 | 
            +
            return self;}
         | 
| 653 | 
            +
            }),
         | 
| 654 | 
            +
            smalltalk.TagBrush);
         | 
| 655 | 
            +
             | 
| 656 | 
            +
            smalltalk.addMethod(
         | 
| 657 | 
            +
            unescape('_draggable_'),
         | 
| 658 | 
            +
            smalltalk.method({
         | 
| 659 | 
            +
            selector: unescape('draggable%3A'),
         | 
| 660 | 
            +
            fn: function (aString){
         | 
| 661 | 
            +
            var self=this;
         | 
| 662 | 
            +
            smalltalk.send(self, "_at_put_", ["draggable", aString]);
         | 
| 663 | 
            +
            return self;}
         | 
| 664 | 
            +
            }),
         | 
| 665 | 
            +
            smalltalk.TagBrush);
         | 
| 666 | 
            +
             | 
| 667 | 
            +
            smalltalk.addMethod(
         | 
| 668 | 
            +
            unescape('_hidden'),
         | 
| 669 | 
            +
            smalltalk.method({
         | 
| 670 | 
            +
            selector: unescape('hidden'),
         | 
| 671 | 
            +
            fn: function (){
         | 
| 672 | 
            +
            var self=this;
         | 
| 673 | 
            +
            smalltalk.send(self, "_at_put_", ["hidden", "hidden"]);
         | 
| 674 | 
            +
            return self;}
         | 
| 675 | 
            +
            }),
         | 
| 676 | 
            +
            smalltalk.TagBrush);
         | 
| 677 | 
            +
             | 
| 678 | 
            +
            smalltalk.addMethod(
         | 
| 679 | 
            +
            unescape('_tabindex_'),
         | 
| 680 | 
            +
            smalltalk.method({
         | 
| 681 | 
            +
            selector: unescape('tabindex%3A'),
         | 
| 682 | 
            +
            fn: function (aNumber){
         | 
| 683 | 
            +
            var self=this;
         | 
| 684 | 
            +
            smalltalk.send(self, "_at_put_", ["tabindex", aNumber]);
         | 
| 685 | 
            +
            return self;}
         | 
| 686 | 
            +
            }),
         | 
| 687 | 
            +
            smalltalk.TagBrush);
         | 
| 688 | 
            +
             | 
| 689 | 
            +
            smalltalk.addMethod(
         | 
| 690 | 
            +
            unescape('_target_'),
         | 
| 691 | 
            +
            smalltalk.method({
         | 
| 692 | 
            +
            selector: unescape('target%3A'),
         | 
| 693 | 
            +
            fn: function (aString){
         | 
| 694 | 
            +
            var self=this;
         | 
| 695 | 
            +
            smalltalk.send(self, "_at_put_", ["target", aString]);
         | 
| 696 | 
            +
            return self;}
         | 
| 697 | 
            +
            }),
         | 
| 698 | 
            +
            smalltalk.TagBrush);
         | 
| 699 | 
            +
             | 
| 700 | 
            +
            smalltalk.addMethod(
         | 
| 701 | 
            +
            unescape('_align_'),
         | 
| 702 | 
            +
            smalltalk.method({
         | 
| 703 | 
            +
            selector: unescape('align%3A'),
         | 
| 704 | 
            +
            fn: function (aString){
         | 
| 705 | 
            +
            var self=this;
         | 
| 706 | 
            +
            smalltalk.send(self, "_at_put_", ["align", aString]);
         | 
| 707 | 
            +
            return self;}
         | 
| 708 | 
            +
            }),
         | 
| 709 | 
            +
            smalltalk.TagBrush);
         | 
| 710 | 
            +
             | 
| 711 | 
            +
            smalltalk.addMethod(
         | 
| 712 | 
            +
            unescape('_alt_'),
         | 
| 713 | 
            +
            smalltalk.method({
         | 
| 714 | 
            +
            selector: unescape('alt%3A'),
         | 
| 715 | 
            +
            fn: function (aString){
         | 
| 716 | 
            +
            var self=this;
         | 
| 717 | 
            +
            smalltalk.send(self, "_at_put_", ["alt", aString]);
         | 
| 718 | 
            +
            return self;}
         | 
| 719 | 
            +
            }),
         | 
| 720 | 
            +
            smalltalk.TagBrush);
         | 
| 721 | 
            +
             | 
| 722 | 
            +
            smalltalk.addMethod(
         | 
| 723 | 
            +
            unescape('_name_'),
         | 
| 724 | 
            +
            smalltalk.method({
         | 
| 725 | 
            +
            selector: unescape('name%3A'),
         | 
| 726 | 
            +
            fn: function (aString){
         | 
| 727 | 
            +
            var self=this;
         | 
| 728 | 
            +
            smalltalk.send(self, "_at_put_", ["name", aString]);
         | 
| 729 | 
            +
            return self;}
         | 
| 730 | 
            +
            }),
         | 
| 731 | 
            +
            smalltalk.TagBrush);
         | 
| 732 | 
            +
             | 
| 733 | 
            +
            smalltalk.addMethod(
         | 
| 734 | 
            +
            unescape('_valign_'),
         | 
| 735 | 
            +
            smalltalk.method({
         | 
| 736 | 
            +
            selector: unescape('valign%3A'),
         | 
| 737 | 
            +
            fn: function (aString){
         | 
| 738 | 
            +
            var self=this;
         | 
| 739 | 
            +
            smalltalk.send(self, "_at_put_", ["valign", aString]);
         | 
| 740 | 
            +
            return self;}
         | 
| 741 | 
            +
            }),
         | 
| 742 | 
            +
            smalltalk.TagBrush);
         | 
| 743 | 
            +
             | 
| 744 | 
            +
            smalltalk.addMethod(
         | 
| 745 | 
            +
            unescape('_method_'),
         | 
| 746 | 
            +
            smalltalk.method({
         | 
| 747 | 
            +
            selector: unescape('method%3A'),
         | 
| 748 | 
            +
            fn: function (aString){
         | 
| 749 | 
            +
            var self=this;
         | 
| 750 | 
            +
            smalltalk.send(self, "_at_put_", ["method", aString]);
         | 
| 751 | 
            +
            return self;}
         | 
| 752 | 
            +
            }),
         | 
| 753 | 
            +
            smalltalk.TagBrush);
         | 
| 754 | 
            +
             | 
| 755 | 
            +
            smalltalk.addMethod(
         | 
| 756 | 
            +
            unescape('_action_'),
         | 
| 757 | 
            +
            smalltalk.method({
         | 
| 758 | 
            +
            selector: unescape('action%3A'),
         | 
| 759 | 
            +
            fn: function (aString){
         | 
| 760 | 
            +
            var self=this;
         | 
| 761 | 
            +
            smalltalk.send(self, "_at_put_", ["action", aString]);
         | 
| 762 | 
            +
            return self;}
         | 
| 763 | 
            +
            }),
         | 
| 764 | 
            +
            smalltalk.TagBrush);
         | 
| 765 | 
            +
             | 
| 766 | 
            +
            smalltalk.addMethod(
         | 
| 767 | 
            +
            unescape('_rows_'),
         | 
| 768 | 
            +
            smalltalk.method({
         | 
| 769 | 
            +
            selector: unescape('rows%3A'),
         | 
| 770 | 
            +
            fn: function (aString){
         | 
| 771 | 
            +
            var self=this;
         | 
| 772 | 
            +
            smalltalk.send(self, "_at_put_", ["rows", aString]);
         | 
| 773 | 
            +
            return self;}
         | 
| 774 | 
            +
            }),
         | 
| 775 | 
            +
            smalltalk.TagBrush);
         | 
| 776 | 
            +
             | 
| 777 | 
            +
            smalltalk.addMethod(
         | 
| 778 | 
            +
            unescape('_cols_'),
         | 
| 779 | 
            +
            smalltalk.method({
         | 
| 780 | 
            +
            selector: unescape('cols%3A'),
         | 
| 781 | 
            +
            fn: function (aString){
         | 
| 782 | 
            +
            var self=this;
         | 
| 783 | 
            +
            smalltalk.send(self, "_at_put_", ["cols", aString]);
         | 
| 784 | 
            +
            return self;}
         | 
| 785 | 
            +
            }),
         | 
| 786 | 
            +
            smalltalk.TagBrush);
         | 
| 787 | 
            +
             | 
| 788 | 
            +
             | 
| 789 | 
            +
            smalltalk.addMethod(
         | 
| 790 | 
            +
            unescape('_fromString_canvas_'),
         | 
| 791 | 
            +
            smalltalk.method({
         | 
| 792 | 
            +
            selector: unescape('fromString%3Acanvas%3A'),
         | 
| 793 | 
            +
            fn: function (aString, aCanvas){
         | 
| 794 | 
            +
            var self=this;
         | 
| 795 | 
            +
            return (function($rec){smalltalk.send($rec, "_initializeFromString_canvas_", [aString, aCanvas]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new", []));
         | 
| 796 | 
            +
            return self;}
         | 
| 797 | 
            +
            }),
         | 
| 798 | 
            +
            smalltalk.TagBrush.klass);
         | 
| 799 | 
            +
             | 
| 800 | 
            +
            smalltalk.addMethod(
         | 
| 801 | 
            +
            unescape('_fromJQuery_canvas_'),
         | 
| 802 | 
            +
            smalltalk.method({
         | 
| 803 | 
            +
            selector: unescape('fromJQuery%3Acanvas%3A'),
         | 
| 804 | 
            +
            fn: function (aJQuery, aCanvas){
         | 
| 805 | 
            +
            var self=this;
         | 
| 806 | 
            +
            return (function($rec){smalltalk.send($rec, "_initializeFromJQuery_canvas_", [aJQuery, aCanvas]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new", []));
         | 
| 807 | 
            +
            return self;}
         | 
| 808 | 
            +
            }),
         | 
| 809 | 
            +
            smalltalk.TagBrush.klass);
         | 
| 810 | 
            +
             | 
| 811 | 
            +
             | 
| 2 812 | 
             
            smalltalk.addClass('HTMLCanvas', smalltalk.Object, ['root'], 'Canvas');
         | 
| 3 813 | 
             
            smalltalk.addMethod(
         | 
| 4 | 
            -
            '_root_',
         | 
| 814 | 
            +
            unescape('_root_'),
         | 
| 5 815 | 
             
            smalltalk.method({
         | 
| 6 | 
            -
            selector: 'root | 
| 816 | 
            +
            selector: unescape('root%3A'),
         | 
| 7 817 | 
             
            fn: function (aTagBrush){
         | 
| 8 818 | 
             
            var self=this;
         | 
| 9 819 | 
             
            (self['@root']=aTagBrush);
         | 
| @@ -12,9 +822,9 @@ return self;} | |
| 12 822 | 
             
            smalltalk.HTMLCanvas);
         | 
| 13 823 |  | 
| 14 824 | 
             
            smalltalk.addMethod(
         | 
| 15 | 
            -
            '_root',
         | 
| 825 | 
            +
            unescape('_root'),
         | 
| 16 826 | 
             
            smalltalk.method({
         | 
| 17 | 
            -
            selector: 'root',
         | 
| 827 | 
            +
            selector: unescape('root'),
         | 
| 18 828 | 
             
            fn: function (){
         | 
| 19 829 | 
             
            var self=this;
         | 
| 20 830 | 
             
            return self['@root'];
         | 
| @@ -23,9 +833,9 @@ return self;} | |
| 23 833 | 
             
            smalltalk.HTMLCanvas);
         | 
| 24 834 |  | 
| 25 835 | 
             
            smalltalk.addMethod(
         | 
| 26 | 
            -
            '_with_',
         | 
| 836 | 
            +
            unescape('_with_'),
         | 
| 27 837 | 
             
            smalltalk.method({
         | 
| 28 | 
            -
            selector: 'with | 
| 838 | 
            +
            selector: unescape('with%3A'),
         | 
| 29 839 | 
             
            fn: function (anObject){
         | 
| 30 840 | 
             
            var self=this;
         | 
| 31 841 | 
             
            return smalltalk.send(smalltalk.send(self, "_root", []), "_with_", [anObject]);
         | 
| @@ -34,9 +844,9 @@ return self;} | |
| 34 844 | 
             
            smalltalk.HTMLCanvas);
         | 
| 35 845 |  | 
| 36 846 | 
             
            smalltalk.addMethod(
         | 
| 37 | 
            -
            '_initialize',
         | 
| 847 | 
            +
            unescape('_initialize'),
         | 
| 38 848 | 
             
            smalltalk.method({
         | 
| 39 | 
            -
            selector: 'initialize',
         | 
| 849 | 
            +
            selector: unescape('initialize'),
         | 
| 40 850 | 
             
            fn: function (){
         | 
| 41 851 | 
             
            var self=this;
         | 
| 42 852 | 
             
            smalltalk.send(self, "_initialize", [], smalltalk.Object);
         | 
| @@ -46,9 +856,9 @@ return self;} | |
| 46 856 | 
             
            smalltalk.HTMLCanvas);
         | 
| 47 857 |  | 
| 48 858 | 
             
            smalltalk.addMethod(
         | 
| 49 | 
            -
            '_initializeFromJQuery_',
         | 
| 859 | 
            +
            unescape('_initializeFromJQuery_'),
         | 
| 50 860 | 
             
            smalltalk.method({
         | 
| 51 | 
            -
            selector: 'initializeFromJQuery | 
| 861 | 
            +
            selector: unescape('initializeFromJQuery%3A'),
         | 
| 52 862 | 
             
            fn: function (aJQuery){
         | 
| 53 863 | 
             
            var self=this;
         | 
| 54 864 | 
             
            (self['@root']=smalltalk.send((smalltalk.TagBrush || TagBrush), "_fromJQuery_canvas_", [aJQuery, self]));
         | 
| @@ -57,9 +867,9 @@ return self;} | |
| 57 867 | 
             
            smalltalk.HTMLCanvas);
         | 
| 58 868 |  | 
| 59 869 | 
             
            smalltalk.addMethod(
         | 
| 60 | 
            -
            '_newTag_',
         | 
| 870 | 
            +
            unescape('_newTag_'),
         | 
| 61 871 | 
             
            smalltalk.method({
         | 
| 62 | 
            -
            selector: 'newTag | 
| 872 | 
            +
            selector: unescape('newTag%3A'),
         | 
| 63 873 | 
             
            fn: function (aString){
         | 
| 64 874 | 
             
            var self=this;
         | 
| 65 875 | 
             
            return smalltalk.send((smalltalk.TagBrush || TagBrush), "_fromString_canvas_", [aString, self]);
         | 
| @@ -68,9 +878,9 @@ return self;} | |
| 68 878 | 
             
            smalltalk.HTMLCanvas);
         | 
| 69 879 |  | 
| 70 880 | 
             
            smalltalk.addMethod(
         | 
| 71 | 
            -
            '_tag_',
         | 
| 881 | 
            +
            unescape('_tag_'),
         | 
| 72 882 | 
             
            smalltalk.method({
         | 
| 73 | 
            -
            selector: 'tag | 
| 883 | 
            +
            selector: unescape('tag%3A'),
         | 
| 74 884 | 
             
            fn: function (aString){
         | 
| 75 885 | 
             
            var self=this;
         | 
| 76 886 | 
             
            return smalltalk.send(self['@root'], "_addBrush_", [smalltalk.send(self, "_newTag_", [aString])]);
         | 
| @@ -79,9 +889,9 @@ return self;} | |
| 79 889 | 
             
            smalltalk.HTMLCanvas);
         | 
| 80 890 |  | 
| 81 891 | 
             
            smalltalk.addMethod(
         | 
| 82 | 
            -
            '_h1',
         | 
| 892 | 
            +
            unescape('_h1'),
         | 
| 83 893 | 
             
            smalltalk.method({
         | 
| 84 | 
            -
            selector: 'h1',
         | 
| 894 | 
            +
            selector: unescape('h1'),
         | 
| 85 895 | 
             
            fn: function (){
         | 
| 86 896 | 
             
            var self=this;
         | 
| 87 897 | 
             
            return smalltalk.send(self, "_tag_", ["h1"]);
         | 
| @@ -90,9 +900,9 @@ return self;} | |
| 90 900 | 
             
            smalltalk.HTMLCanvas);
         | 
| 91 901 |  | 
| 92 902 | 
             
            smalltalk.addMethod(
         | 
| 93 | 
            -
            '_h2',
         | 
| 903 | 
            +
            unescape('_h2'),
         | 
| 94 904 | 
             
            smalltalk.method({
         | 
| 95 | 
            -
            selector: 'h2',
         | 
| 905 | 
            +
            selector: unescape('h2'),
         | 
| 96 906 | 
             
            fn: function (){
         | 
| 97 907 | 
             
            var self=this;
         | 
| 98 908 | 
             
            return smalltalk.send(self, "_tag_", ["h2"]);
         | 
| @@ -101,9 +911,9 @@ return self;} | |
| 101 911 | 
             
            smalltalk.HTMLCanvas);
         | 
| 102 912 |  | 
| 103 913 | 
             
            smalltalk.addMethod(
         | 
| 104 | 
            -
            '_h3',
         | 
| 914 | 
            +
            unescape('_h3'),
         | 
| 105 915 | 
             
            smalltalk.method({
         | 
| 106 | 
            -
            selector: 'h3',
         | 
| 916 | 
            +
            selector: unescape('h3'),
         | 
| 107 917 | 
             
            fn: function (){
         | 
| 108 918 | 
             
            var self=this;
         | 
| 109 919 | 
             
            return smalltalk.send(self, "_tag_", ["h3"]);
         | 
| @@ -112,9 +922,9 @@ return self;} | |
| 112 922 | 
             
            smalltalk.HTMLCanvas);
         | 
| 113 923 |  | 
| 114 924 | 
             
            smalltalk.addMethod(
         | 
| 115 | 
            -
            '_h4',
         | 
| 925 | 
            +
            unescape('_h4'),
         | 
| 116 926 | 
             
            smalltalk.method({
         | 
| 117 | 
            -
            selector: 'h4',
         | 
| 927 | 
            +
            selector: unescape('h4'),
         | 
| 118 928 | 
             
            fn: function (){
         | 
| 119 929 | 
             
            var self=this;
         | 
| 120 930 | 
             
            return smalltalk.send(self, "_tag_", ["h4"]);
         | 
| @@ -123,9 +933,9 @@ return self;} | |
| 123 933 | 
             
            smalltalk.HTMLCanvas);
         | 
| 124 934 |  | 
| 125 935 | 
             
            smalltalk.addMethod(
         | 
| 126 | 
            -
            '_h5',
         | 
| 936 | 
            +
            unescape('_h5'),
         | 
| 127 937 | 
             
            smalltalk.method({
         | 
| 128 | 
            -
            selector: 'h5',
         | 
| 938 | 
            +
            selector: unescape('h5'),
         | 
| 129 939 | 
             
            fn: function (){
         | 
| 130 940 | 
             
            var self=this;
         | 
| 131 941 | 
             
            return smalltalk.send(self, "_tag_", ["h5"]);
         | 
| @@ -134,9 +944,9 @@ return self;} | |
| 134 944 | 
             
            smalltalk.HTMLCanvas);
         | 
| 135 945 |  | 
| 136 946 | 
             
            smalltalk.addMethod(
         | 
| 137 | 
            -
            '_h6',
         | 
| 947 | 
            +
            unescape('_h6'),
         | 
| 138 948 | 
             
            smalltalk.method({
         | 
| 139 | 
            -
            selector: 'h6',
         | 
| 949 | 
            +
            selector: unescape('h6'),
         | 
| 140 950 | 
             
            fn: function (){
         | 
| 141 951 | 
             
            var self=this;
         | 
| 142 952 | 
             
            return smalltalk.send(self, "_tag_", ["h6"]);
         | 
| @@ -145,9 +955,9 @@ return self;} | |
| 145 955 | 
             
            smalltalk.HTMLCanvas);
         | 
| 146 956 |  | 
| 147 957 | 
             
            smalltalk.addMethod(
         | 
| 148 | 
            -
            '_p',
         | 
| 958 | 
            +
            unescape('_p'),
         | 
| 149 959 | 
             
            smalltalk.method({
         | 
| 150 | 
            -
            selector: 'p',
         | 
| 960 | 
            +
            selector: unescape('p'),
         | 
| 151 961 | 
             
            fn: function (){
         | 
| 152 962 | 
             
            var self=this;
         | 
| 153 963 | 
             
            return smalltalk.send(self, "_tag_", ["p"]);
         | 
| @@ -156,9 +966,9 @@ return self;} | |
| 156 966 | 
             
            smalltalk.HTMLCanvas);
         | 
| 157 967 |  | 
| 158 968 | 
             
            smalltalk.addMethod(
         | 
| 159 | 
            -
            '_div',
         | 
| 969 | 
            +
            unescape('_div'),
         | 
| 160 970 | 
             
            smalltalk.method({
         | 
| 161 | 
            -
            selector: 'div',
         | 
| 971 | 
            +
            selector: unescape('div'),
         | 
| 162 972 | 
             
            fn: function (){
         | 
| 163 973 | 
             
            var self=this;
         | 
| 164 974 | 
             
            return smalltalk.send(self, "_tag_", ["div"]);
         | 
| @@ -167,9 +977,9 @@ return self;} | |
| 167 977 | 
             
            smalltalk.HTMLCanvas);
         | 
| 168 978 |  | 
| 169 979 | 
             
            smalltalk.addMethod(
         | 
| 170 | 
            -
            '_span',
         | 
| 980 | 
            +
            unescape('_span'),
         | 
| 171 981 | 
             
            smalltalk.method({
         | 
| 172 | 
            -
            selector: 'span',
         | 
| 982 | 
            +
            selector: unescape('span'),
         | 
| 173 983 | 
             
            fn: function (){
         | 
| 174 984 | 
             
            var self=this;
         | 
| 175 985 | 
             
            return smalltalk.send(self, "_tag_", ["span"]);
         | 
| @@ -178,9 +988,9 @@ return self;} | |
| 178 988 | 
             
            smalltalk.HTMLCanvas);
         | 
| 179 989 |  | 
| 180 990 | 
             
            smalltalk.addMethod(
         | 
| 181 | 
            -
            '_img',
         | 
| 991 | 
            +
            unescape('_img'),
         | 
| 182 992 | 
             
            smalltalk.method({
         | 
| 183 | 
            -
            selector: 'img',
         | 
| 993 | 
            +
            selector: unescape('img'),
         | 
| 184 994 | 
             
            fn: function (){
         | 
| 185 995 | 
             
            var self=this;
         | 
| 186 996 | 
             
            return smalltalk.send(self, "_tag_", ["img"]);
         | 
| @@ -189,9 +999,9 @@ return self;} | |
| 189 999 | 
             
            smalltalk.HTMLCanvas);
         | 
| 190 1000 |  | 
| 191 1001 | 
             
            smalltalk.addMethod(
         | 
| 192 | 
            -
            '_ul',
         | 
| 1002 | 
            +
            unescape('_ul'),
         | 
| 193 1003 | 
             
            smalltalk.method({
         | 
| 194 | 
            -
            selector: 'ul',
         | 
| 1004 | 
            +
            selector: unescape('ul'),
         | 
| 195 1005 | 
             
            fn: function (){
         | 
| 196 1006 | 
             
            var self=this;
         | 
| 197 1007 | 
             
            return smalltalk.send(self, "_tag_", ["ul"]);
         | 
| @@ -200,9 +1010,9 @@ return self;} | |
| 200 1010 | 
             
            smalltalk.HTMLCanvas);
         | 
| 201 1011 |  | 
| 202 1012 | 
             
            smalltalk.addMethod(
         | 
| 203 | 
            -
            '_ol',
         | 
| 1013 | 
            +
            unescape('_ol'),
         | 
| 204 1014 | 
             
            smalltalk.method({
         | 
| 205 | 
            -
            selector: 'ol',
         | 
| 1015 | 
            +
            selector: unescape('ol'),
         | 
| 206 1016 | 
             
            fn: function (){
         | 
| 207 1017 | 
             
            var self=this;
         | 
| 208 1018 | 
             
            return smalltalk.send(self, "_tag_", ["ol"]);
         | 
| @@ -211,9 +1021,9 @@ return self;} | |
| 211 1021 | 
             
            smalltalk.HTMLCanvas);
         | 
| 212 1022 |  | 
| 213 1023 | 
             
            smalltalk.addMethod(
         | 
| 214 | 
            -
            '_li',
         | 
| 1024 | 
            +
            unescape('_li'),
         | 
| 215 1025 | 
             
            smalltalk.method({
         | 
| 216 | 
            -
            selector: 'li',
         | 
| 1026 | 
            +
            selector: unescape('li'),
         | 
| 217 1027 | 
             
            fn: function (){
         | 
| 218 1028 | 
             
            var self=this;
         | 
| 219 1029 | 
             
            return smalltalk.send(self, "_tag_", ["li"]);
         | 
| @@ -222,9 +1032,9 @@ return self;} | |
| 222 1032 | 
             
            smalltalk.HTMLCanvas);
         | 
| 223 1033 |  | 
| 224 1034 | 
             
            smalltalk.addMethod(
         | 
| 225 | 
            -
            '_table',
         | 
| 1035 | 
            +
            unescape('_table'),
         | 
| 226 1036 | 
             
            smalltalk.method({
         | 
| 227 | 
            -
            selector: 'table',
         | 
| 1037 | 
            +
            selector: unescape('table'),
         | 
| 228 1038 | 
             
            fn: function (){
         | 
| 229 1039 | 
             
            var self=this;
         | 
| 230 1040 | 
             
            return smalltalk.send(self, "_tag_", ["table"]);
         | 
| @@ -233,9 +1043,9 @@ return self;} | |
| 233 1043 | 
             
            smalltalk.HTMLCanvas);
         | 
| 234 1044 |  | 
| 235 1045 | 
             
            smalltalk.addMethod(
         | 
| 236 | 
            -
            '_tr',
         | 
| 1046 | 
            +
            unescape('_tr'),
         | 
| 237 1047 | 
             
            smalltalk.method({
         | 
| 238 | 
            -
            selector: 'tr',
         | 
| 1048 | 
            +
            selector: unescape('tr'),
         | 
| 239 1049 | 
             
            fn: function (){
         | 
| 240 1050 | 
             
            var self=this;
         | 
| 241 1051 | 
             
            return smalltalk.send(self, "_tag_", ["tr"]);
         | 
| @@ -244,9 +1054,9 @@ return self;} | |
| 244 1054 | 
             
            smalltalk.HTMLCanvas);
         | 
| 245 1055 |  | 
| 246 1056 | 
             
            smalltalk.addMethod(
         | 
| 247 | 
            -
            '_td',
         | 
| 1057 | 
            +
            unescape('_td'),
         | 
| 248 1058 | 
             
            smalltalk.method({
         | 
| 249 | 
            -
            selector: 'td',
         | 
| 1059 | 
            +
            selector: unescape('td'),
         | 
| 250 1060 | 
             
            fn: function (){
         | 
| 251 1061 | 
             
            var self=this;
         | 
| 252 1062 | 
             
            return smalltalk.send(self, "_tag_", ["td"]);
         | 
| @@ -255,9 +1065,9 @@ return self;} | |
| 255 1065 | 
             
            smalltalk.HTMLCanvas);
         | 
| 256 1066 |  | 
| 257 1067 | 
             
            smalltalk.addMethod(
         | 
| 258 | 
            -
            '_th',
         | 
| 1068 | 
            +
            unescape('_th'),
         | 
| 259 1069 | 
             
            smalltalk.method({
         | 
| 260 | 
            -
            selector: 'th',
         | 
| 1070 | 
            +
            selector: unescape('th'),
         | 
| 261 1071 | 
             
            fn: function (){
         | 
| 262 1072 | 
             
            var self=this;
         | 
| 263 1073 | 
             
            return smalltalk.send(self, "_tag_", ["th"]);
         | 
| @@ -266,9 +1076,9 @@ return self;} | |
| 266 1076 | 
             
            smalltalk.HTMLCanvas);
         | 
| 267 1077 |  | 
| 268 1078 | 
             
            smalltalk.addMethod(
         | 
| 269 | 
            -
            '_form',
         | 
| 1079 | 
            +
            unescape('_form'),
         | 
| 270 1080 | 
             
            smalltalk.method({
         | 
| 271 | 
            -
            selector: 'form',
         | 
| 1081 | 
            +
            selector: unescape('form'),
         | 
| 272 1082 | 
             
            fn: function (){
         | 
| 273 1083 | 
             
            var self=this;
         | 
| 274 1084 | 
             
            return smalltalk.send(self, "_tag_", ["form"]);
         | 
| @@ -277,9 +1087,9 @@ return self;} | |
| 277 1087 | 
             
            smalltalk.HTMLCanvas);
         | 
| 278 1088 |  | 
| 279 1089 | 
             
            smalltalk.addMethod(
         | 
| 280 | 
            -
            '_input',
         | 
| 1090 | 
            +
            unescape('_input'),
         | 
| 281 1091 | 
             
            smalltalk.method({
         | 
| 282 | 
            -
            selector: 'input',
         | 
| 1092 | 
            +
            selector: unescape('input'),
         | 
| 283 1093 | 
             
            fn: function (){
         | 
| 284 1094 | 
             
            var self=this;
         | 
| 285 1095 | 
             
            return smalltalk.send(self, "_tag_", ["input"]);
         | 
| @@ -288,9 +1098,9 @@ return self;} | |
| 288 1098 | 
             
            smalltalk.HTMLCanvas);
         | 
| 289 1099 |  | 
| 290 1100 | 
             
            smalltalk.addMethod(
         | 
| 291 | 
            -
            '_button',
         | 
| 1101 | 
            +
            unescape('_button'),
         | 
| 292 1102 | 
             
            smalltalk.method({
         | 
| 293 | 
            -
            selector: 'button',
         | 
| 1103 | 
            +
            selector: unescape('button'),
         | 
| 294 1104 | 
             
            fn: function (){
         | 
| 295 1105 | 
             
            var self=this;
         | 
| 296 1106 | 
             
            return smalltalk.send(self, "_tag_", ["button"]);
         | 
| @@ -299,9 +1109,9 @@ return self;} | |
| 299 1109 | 
             
            smalltalk.HTMLCanvas);
         | 
| 300 1110 |  | 
| 301 1111 | 
             
            smalltalk.addMethod(
         | 
| 302 | 
            -
            '_select',
         | 
| 1112 | 
            +
            unescape('_select'),
         | 
| 303 1113 | 
             
            smalltalk.method({
         | 
| 304 | 
            -
            selector: 'select',
         | 
| 1114 | 
            +
            selector: unescape('select'),
         | 
| 305 1115 | 
             
            fn: function (){
         | 
| 306 1116 | 
             
            var self=this;
         | 
| 307 1117 | 
             
            return smalltalk.send(self, "_tag_", ["select"]);
         | 
| @@ -310,9 +1120,9 @@ return self;} | |
| 310 1120 | 
             
            smalltalk.HTMLCanvas);
         | 
| 311 1121 |  | 
| 312 1122 | 
             
            smalltalk.addMethod(
         | 
| 313 | 
            -
            '_option',
         | 
| 1123 | 
            +
            unescape('_option'),
         | 
| 314 1124 | 
             
            smalltalk.method({
         | 
| 315 | 
            -
            selector: 'option',
         | 
| 1125 | 
            +
            selector: unescape('option'),
         | 
| 316 1126 | 
             
            fn: function (){
         | 
| 317 1127 | 
             
            var self=this;
         | 
| 318 1128 | 
             
            return smalltalk.send(self, "_tag_", ["option"]);
         | 
| @@ -321,9 +1131,9 @@ return self;} | |
| 321 1131 | 
             
            smalltalk.HTMLCanvas);
         | 
| 322 1132 |  | 
| 323 1133 | 
             
            smalltalk.addMethod(
         | 
| 324 | 
            -
            '_textarea',
         | 
| 1134 | 
            +
            unescape('_textarea'),
         | 
| 325 1135 | 
             
            smalltalk.method({
         | 
| 326 | 
            -
            selector: 'textarea',
         | 
| 1136 | 
            +
            selector: unescape('textarea'),
         | 
| 327 1137 | 
             
            fn: function (){
         | 
| 328 1138 | 
             
            var self=this;
         | 
| 329 1139 | 
             
            return smalltalk.send(self, "_tag_", ["textarea"]);
         | 
| @@ -332,9 +1142,9 @@ return self;} | |
| 332 1142 | 
             
            smalltalk.HTMLCanvas);
         | 
| 333 1143 |  | 
| 334 1144 | 
             
            smalltalk.addMethod(
         | 
| 335 | 
            -
            '_a',
         | 
| 1145 | 
            +
            unescape('_a'),
         | 
| 336 1146 | 
             
            smalltalk.method({
         | 
| 337 | 
            -
            selector: 'a',
         | 
| 1147 | 
            +
            selector: unescape('a'),
         | 
| 338 1148 | 
             
            fn: function (){
         | 
| 339 1149 | 
             
            var self=this;
         | 
| 340 1150 | 
             
            return smalltalk.send(self, "_tag_", ["a"]);
         | 
| @@ -343,9 +1153,9 @@ return self;} | |
| 343 1153 | 
             
            smalltalk.HTMLCanvas);
         | 
| 344 1154 |  | 
| 345 1155 | 
             
            smalltalk.addMethod(
         | 
| 346 | 
            -
            '_canvas',
         | 
| 1156 | 
            +
            unescape('_canvas'),
         | 
| 347 1157 | 
             
            smalltalk.method({
         | 
| 348 | 
            -
            selector: 'canvas',
         | 
| 1158 | 
            +
            selector: unescape('canvas'),
         | 
| 349 1159 | 
             
            fn: function (){
         | 
| 350 1160 | 
             
            var self=this;
         | 
| 351 1161 | 
             
            return smalltalk.send(self, "_tag_", ["canvas"]);
         | 
| @@ -354,9 +1164,9 @@ return self;} | |
| 354 1164 | 
             
            smalltalk.HTMLCanvas);
         | 
| 355 1165 |  | 
| 356 1166 | 
             
            smalltalk.addMethod(
         | 
| 357 | 
            -
            '_pre',
         | 
| 1167 | 
            +
            unescape('_pre'),
         | 
| 358 1168 | 
             
            smalltalk.method({
         | 
| 359 | 
            -
            selector: 'pre',
         | 
| 1169 | 
            +
            selector: unescape('pre'),
         | 
| 360 1170 | 
             
            fn: function (){
         | 
| 361 1171 | 
             
            var self=this;
         | 
| 362 1172 | 
             
            return smalltalk.send(self, "_tag_", ["pre"]);
         | 
| @@ -365,9 +1175,9 @@ return self;} | |
| 365 1175 | 
             
            smalltalk.HTMLCanvas);
         | 
| 366 1176 |  | 
| 367 1177 | 
             
            smalltalk.addMethod(
         | 
| 368 | 
            -
            '_code',
         | 
| 1178 | 
            +
            unescape('_code'),
         | 
| 369 1179 | 
             
            smalltalk.method({
         | 
| 370 | 
            -
            selector: 'code',
         | 
| 1180 | 
            +
            selector: unescape('code'),
         | 
| 371 1181 | 
             
            fn: function (){
         | 
| 372 1182 | 
             
            var self=this;
         | 
| 373 1183 | 
             
            return smalltalk.send(self, "_tag_", ["code"]);
         | 
| @@ -376,9 +1186,9 @@ return self;} | |
| 376 1186 | 
             
            smalltalk.HTMLCanvas);
         | 
| 377 1187 |  | 
| 378 1188 | 
             
            smalltalk.addMethod(
         | 
| 379 | 
            -
            '_br',
         | 
| 1189 | 
            +
            unescape('_br'),
         | 
| 380 1190 | 
             
            smalltalk.method({
         | 
| 381 | 
            -
            selector: 'br',
         | 
| 1191 | 
            +
            selector: unescape('br'),
         | 
| 382 1192 | 
             
            fn: function (){
         | 
| 383 1193 | 
             
            var self=this;
         | 
| 384 1194 | 
             
            return smalltalk.send(self, "_tag_", ["br"]);
         | 
| @@ -387,9 +1197,9 @@ return self;} | |
| 387 1197 | 
             
            smalltalk.HTMLCanvas);
         | 
| 388 1198 |  | 
| 389 1199 | 
             
            smalltalk.addMethod(
         | 
| 390 | 
            -
            '_script',
         | 
| 1200 | 
            +
            unescape('_script'),
         | 
| 391 1201 | 
             
            smalltalk.method({
         | 
| 392 | 
            -
            selector: 'script',
         | 
| 1202 | 
            +
            selector: unescape('script'),
         | 
| 393 1203 | 
             
            fn: function (){
         | 
| 394 1204 | 
             
            var self=this;
         | 
| 395 1205 | 
             
            return smalltalk.send(self, "_tag_", ["script"]);
         | 
| @@ -398,9 +1208,9 @@ return self;} | |
| 398 1208 | 
             
            smalltalk.HTMLCanvas);
         | 
| 399 1209 |  | 
| 400 1210 | 
             
            smalltalk.addMethod(
         | 
| 401 | 
            -
            '_link',
         | 
| 1211 | 
            +
            unescape('_link'),
         | 
| 402 1212 | 
             
            smalltalk.method({
         | 
| 403 | 
            -
            selector: 'link',
         | 
| 1213 | 
            +
            selector: unescape('link'),
         | 
| 404 1214 | 
             
            fn: function (){
         | 
| 405 1215 | 
             
            var self=this;
         | 
| 406 1216 | 
             
            return smalltalk.send(self, "_tag_", ["link"]);
         | 
| @@ -409,9 +1219,9 @@ return self;} | |
| 409 1219 | 
             
            smalltalk.HTMLCanvas);
         | 
| 410 1220 |  | 
| 411 1221 | 
             
            smalltalk.addMethod(
         | 
| 412 | 
            -
            '_style',
         | 
| 1222 | 
            +
            unescape('_style'),
         | 
| 413 1223 | 
             
            smalltalk.method({
         | 
| 414 | 
            -
            selector: 'style',
         | 
| 1224 | 
            +
            selector: unescape('style'),
         | 
| 415 1225 | 
             
            fn: function (){
         | 
| 416 1226 | 
             
            var self=this;
         | 
| 417 1227 | 
             
            return smalltalk.send(self['@root'], "_addBrush_", [smalltalk.send((smalltalk.StyleTag || StyleTag), "_canvas_", [self])]);
         | 
| @@ -420,9 +1230,9 @@ return self;} | |
| 420 1230 | 
             
            smalltalk.HTMLCanvas);
         | 
| 421 1231 |  | 
| 422 1232 | 
             
            smalltalk.addMethod(
         | 
| 423 | 
            -
            '_p_',
         | 
| 1233 | 
            +
            unescape('_p_'),
         | 
| 424 1234 | 
             
            smalltalk.method({
         | 
| 425 | 
            -
            selector: 'p | 
| 1235 | 
            +
            selector: unescape('p%3A'),
         | 
| 426 1236 | 
             
            fn: function (anObject){
         | 
| 427 1237 | 
             
            var self=this;
         | 
| 428 1238 | 
             
            return smalltalk.send(smalltalk.send(self, "_p", []), "_with_", [anObject]);
         | 
| @@ -431,9 +1241,9 @@ return self;} | |
| 431 1241 | 
             
            smalltalk.HTMLCanvas);
         | 
| 432 1242 |  | 
| 433 1243 | 
             
            smalltalk.addMethod(
         | 
| 434 | 
            -
            '_h1_',
         | 
| 1244 | 
            +
            unescape('_h1_'),
         | 
| 435 1245 | 
             
            smalltalk.method({
         | 
| 436 | 
            -
            selector: 'h1 | 
| 1246 | 
            +
            selector: unescape('h1%3A'),
         | 
| 437 1247 | 
             
            fn: function (anObject){
         | 
| 438 1248 | 
             
            var self=this;
         | 
| 439 1249 | 
             
            return smalltalk.send(smalltalk.send(self, "_h1", []), "_with_", [anObject]);
         | 
| @@ -442,9 +1252,9 @@ return self;} | |
| 442 1252 | 
             
            smalltalk.HTMLCanvas);
         | 
| 443 1253 |  | 
| 444 1254 | 
             
            smalltalk.addMethod(
         | 
| 445 | 
            -
            '_iframe',
         | 
| 1255 | 
            +
            unescape('_iframe'),
         | 
| 446 1256 | 
             
            smalltalk.method({
         | 
| 447 | 
            -
            selector: 'iframe',
         | 
| 1257 | 
            +
            selector: unescape('iframe'),
         | 
| 448 1258 | 
             
            fn: function (){
         | 
| 449 1259 | 
             
            var self=this;
         | 
| 450 1260 | 
             
            return smalltalk.send(self, "_tag_", ["iframe"]);
         | 
| @@ -453,9 +1263,9 @@ return self;} | |
| 453 1263 | 
             
            smalltalk.HTMLCanvas);
         | 
| 454 1264 |  | 
| 455 1265 | 
             
            smalltalk.addMethod(
         | 
| 456 | 
            -
            '_iframe_',
         | 
| 1266 | 
            +
            unescape('_iframe_'),
         | 
| 457 1267 | 
             
            smalltalk.method({
         | 
| 458 | 
            -
            selector: 'iframe | 
| 1268 | 
            +
            selector: unescape('iframe%3A'),
         | 
| 459 1269 | 
             
            fn: function (aString){
         | 
| 460 1270 | 
             
            var self=this;
         | 
| 461 1271 | 
             
            return smalltalk.send(smalltalk.send(self, "_iframe", []), "_src_", [aString]);
         | 
| @@ -464,9 +1274,9 @@ return self;} | |
| 464 1274 | 
             
            smalltalk.HTMLCanvas);
         | 
| 465 1275 |  | 
| 466 1276 | 
             
            smalltalk.addMethod(
         | 
| 467 | 
            -
            '_h2_',
         | 
| 1277 | 
            +
            unescape('_h2_'),
         | 
| 468 1278 | 
             
            smalltalk.method({
         | 
| 469 | 
            -
            selector: 'h2 | 
| 1279 | 
            +
            selector: unescape('h2%3A'),
         | 
| 470 1280 | 
             
            fn: function (anObject){
         | 
| 471 1281 | 
             
            var self=this;
         | 
| 472 1282 | 
             
            return smalltalk.send(smalltalk.send(self, "_h2", []), "_with_", [anObject]);
         | 
| @@ -475,9 +1285,9 @@ return self;} | |
| 475 1285 | 
             
            smalltalk.HTMLCanvas);
         | 
| 476 1286 |  | 
| 477 1287 | 
             
            smalltalk.addMethod(
         | 
| 478 | 
            -
            '_h3_',
         | 
| 1288 | 
            +
            unescape('_h3_'),
         | 
| 479 1289 | 
             
            smalltalk.method({
         | 
| 480 | 
            -
            selector: 'h3 | 
| 1290 | 
            +
            selector: unescape('h3%3A'),
         | 
| 481 1291 | 
             
            fn: function (anObject){
         | 
| 482 1292 | 
             
            var self=this;
         | 
| 483 1293 | 
             
            return smalltalk.send(smalltalk.send(self, "_h3", []), "_with_", [anObject]);
         | 
| @@ -486,9 +1296,9 @@ return self;} | |
| 486 1296 | 
             
            smalltalk.HTMLCanvas);
         | 
| 487 1297 |  | 
| 488 1298 | 
             
            smalltalk.addMethod(
         | 
| 489 | 
            -
            '_h4_',
         | 
| 1299 | 
            +
            unescape('_h4_'),
         | 
| 490 1300 | 
             
            smalltalk.method({
         | 
| 491 | 
            -
            selector: 'h4 | 
| 1301 | 
            +
            selector: unescape('h4%3A'),
         | 
| 492 1302 | 
             
            fn: function (anObject){
         | 
| 493 1303 | 
             
            var self=this;
         | 
| 494 1304 | 
             
            return smalltalk.send(smalltalk.send(self, "_h4", []), "_with_", [anObject]);
         | 
| @@ -497,9 +1307,9 @@ return self;} | |
| 497 1307 | 
             
            smalltalk.HTMLCanvas);
         | 
| 498 1308 |  | 
| 499 1309 | 
             
            smalltalk.addMethod(
         | 
| 500 | 
            -
            '_h5_',
         | 
| 1310 | 
            +
            unescape('_h5_'),
         | 
| 501 1311 | 
             
            smalltalk.method({
         | 
| 502 | 
            -
            selector: 'h5 | 
| 1312 | 
            +
            selector: unescape('h5%3A'),
         | 
| 503 1313 | 
             
            fn: function (anObject){
         | 
| 504 1314 | 
             
            var self=this;
         | 
| 505 1315 | 
             
            return smalltalk.send(smalltalk.send(self, "_h5", []), "_with_", [anObject]);
         | 
| @@ -508,9 +1318,9 @@ return self;} | |
| 508 1318 | 
             
            smalltalk.HTMLCanvas);
         | 
| 509 1319 |  | 
| 510 1320 | 
             
            smalltalk.addMethod(
         | 
| 511 | 
            -
            '_h6_',
         | 
| 1321 | 
            +
            unescape('_h6_'),
         | 
| 512 1322 | 
             
            smalltalk.method({
         | 
| 513 | 
            -
            selector: 'h6 | 
| 1323 | 
            +
            selector: unescape('h6%3A'),
         | 
| 514 1324 | 
             
            fn: function (anObject){
         | 
| 515 1325 | 
             
            var self=this;
         | 
| 516 1326 | 
             
            return smalltalk.send(smalltalk.send(self, "_h6", []), "_with_", [anObject]);
         | 
| @@ -519,9 +1329,9 @@ return self;} | |
| 519 1329 | 
             
            smalltalk.HTMLCanvas);
         | 
| 520 1330 |  | 
| 521 1331 | 
             
            smalltalk.addMethod(
         | 
| 522 | 
            -
            '_img_',
         | 
| 1332 | 
            +
            unescape('_img_'),
         | 
| 523 1333 | 
             
            smalltalk.method({
         | 
| 524 | 
            -
            selector: 'img | 
| 1334 | 
            +
            selector: unescape('img%3A'),
         | 
| 525 1335 | 
             
            fn: function (aString){
         | 
| 526 1336 | 
             
            var self=this;
         | 
| 527 1337 | 
             
            return smalltalk.send(smalltalk.send(self, "_img", []), "_src_", [aString]);
         | 
| @@ -530,9 +1340,9 @@ return self;} | |
| 530 1340 | 
             
            smalltalk.HTMLCanvas);
         | 
| 531 1341 |  | 
| 532 1342 | 
             
            smalltalk.addMethod(
         | 
| 533 | 
            -
            '_ol_',
         | 
| 1343 | 
            +
            unescape('_ol_'),
         | 
| 534 1344 | 
             
            smalltalk.method({
         | 
| 535 | 
            -
            selector: 'ol | 
| 1345 | 
            +
            selector: unescape('ol%3A'),
         | 
| 536 1346 | 
             
            fn: function (anObject){
         | 
| 537 1347 | 
             
            var self=this;
         | 
| 538 1348 | 
             
            return smalltalk.send(smalltalk.send(self, "_ol", []), "_with_", [anObject]);
         | 
| @@ -541,9 +1351,9 @@ return self;} | |
| 541 1351 | 
             
            smalltalk.HTMLCanvas);
         | 
| 542 1352 |  | 
| 543 1353 | 
             
            smalltalk.addMethod(
         | 
| 544 | 
            -
            '_li_',
         | 
| 1354 | 
            +
            unescape('_li_'),
         | 
| 545 1355 | 
             
            smalltalk.method({
         | 
| 546 | 
            -
            selector: 'li | 
| 1356 | 
            +
            selector: unescape('li%3A'),
         | 
| 547 1357 | 
             
            fn: function (anObject){
         | 
| 548 1358 | 
             
            var self=this;
         | 
| 549 1359 | 
             
            return smalltalk.send(smalltalk.send(self, "_li", []), "_with_", [anObject]);
         | 
| @@ -552,671 +1362,772 @@ return self;} | |
| 552 1362 | 
             
            smalltalk.HTMLCanvas);
         | 
| 553 1363 |  | 
| 554 1364 | 
             
            smalltalk.addMethod(
         | 
| 555 | 
            -
            '_ul_',
         | 
| 1365 | 
            +
            unescape('_ul_'),
         | 
| 1366 | 
            +
            smalltalk.method({
         | 
| 1367 | 
            +
            selector: unescape('ul%3A'),
         | 
| 1368 | 
            +
            fn: function (anObject){
         | 
| 1369 | 
            +
            var self=this;
         | 
| 1370 | 
            +
            return smalltalk.send(smalltalk.send(self, "_ul", []), "_with_", [anObject]);
         | 
| 1371 | 
            +
            return self;}
         | 
| 1372 | 
            +
            }),
         | 
| 1373 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1374 | 
            +
             | 
| 1375 | 
            +
            smalltalk.addMethod(
         | 
| 1376 | 
            +
            unescape('_span_'),
         | 
| 1377 | 
            +
            smalltalk.method({
         | 
| 1378 | 
            +
            selector: unescape('span%3A'),
         | 
| 1379 | 
            +
            fn: function (anObject){
         | 
| 1380 | 
            +
            var self=this;
         | 
| 1381 | 
            +
            return smalltalk.send(smalltalk.send(self, "_span", []), "_with_", [anObject]);
         | 
| 1382 | 
            +
            return self;}
         | 
| 1383 | 
            +
            }),
         | 
| 1384 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1385 | 
            +
             | 
| 1386 | 
            +
            smalltalk.addMethod(
         | 
| 1387 | 
            +
            unescape('_style_'),
         | 
| 1388 | 
            +
            smalltalk.method({
         | 
| 1389 | 
            +
            selector: unescape('style%3A'),
         | 
| 1390 | 
            +
            fn: function (aString){
         | 
| 1391 | 
            +
            var self=this;
         | 
| 1392 | 
            +
            return (function($rec){smalltalk.send($rec, "_with_", [aString]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_style", []));
         | 
| 1393 | 
            +
            return self;}
         | 
| 1394 | 
            +
            }),
         | 
| 1395 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1396 | 
            +
             | 
| 1397 | 
            +
            smalltalk.addMethod(
         | 
| 1398 | 
            +
            unescape('_audio'),
         | 
| 1399 | 
            +
            smalltalk.method({
         | 
| 1400 | 
            +
            selector: unescape('audio'),
         | 
| 1401 | 
            +
            fn: function (){
         | 
| 1402 | 
            +
            var self=this;
         | 
| 1403 | 
            +
            return smalltalk.send(self, "_tag_", ["audio"]);
         | 
| 1404 | 
            +
            return self;}
         | 
| 1405 | 
            +
            }),
         | 
| 1406 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1407 | 
            +
             | 
| 1408 | 
            +
            smalltalk.addMethod(
         | 
| 1409 | 
            +
            unescape('_fieldset'),
         | 
| 1410 | 
            +
            smalltalk.method({
         | 
| 1411 | 
            +
            selector: unescape('fieldset'),
         | 
| 1412 | 
            +
            fn: function (){
         | 
| 1413 | 
            +
            var self=this;
         | 
| 1414 | 
            +
            return smalltalk.send(self, "_tag_", ["fieldset"]);
         | 
| 1415 | 
            +
            return self;}
         | 
| 1416 | 
            +
            }),
         | 
| 1417 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1418 | 
            +
             | 
| 1419 | 
            +
            smalltalk.addMethod(
         | 
| 1420 | 
            +
            unescape('_footer'),
         | 
| 1421 | 
            +
            smalltalk.method({
         | 
| 1422 | 
            +
            selector: unescape('footer'),
         | 
| 1423 | 
            +
            fn: function (){
         | 
| 1424 | 
            +
            var self=this;
         | 
| 1425 | 
            +
            return smalltalk.send(self, "_tag_", ["footer"]);
         | 
| 1426 | 
            +
            return self;}
         | 
| 1427 | 
            +
            }),
         | 
| 1428 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1429 | 
            +
             | 
| 1430 | 
            +
            smalltalk.addMethod(
         | 
| 1431 | 
            +
            unescape('_header'),
         | 
| 1432 | 
            +
            smalltalk.method({
         | 
| 1433 | 
            +
            selector: unescape('header'),
         | 
| 1434 | 
            +
            fn: function (){
         | 
| 1435 | 
            +
            var self=this;
         | 
| 1436 | 
            +
            return smalltalk.send(self, "_tag_", ["header"]);
         | 
| 1437 | 
            +
            return self;}
         | 
| 1438 | 
            +
            }),
         | 
| 1439 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1440 | 
            +
             | 
| 1441 | 
            +
            smalltalk.addMethod(
         | 
| 1442 | 
            +
            unescape('_hr'),
         | 
| 1443 | 
            +
            smalltalk.method({
         | 
| 1444 | 
            +
            selector: unescape('hr'),
         | 
| 1445 | 
            +
            fn: function (){
         | 
| 1446 | 
            +
            var self=this;
         | 
| 1447 | 
            +
            return smalltalk.send(self, "_tag_", ["hr"]);
         | 
| 1448 | 
            +
            return self;}
         | 
| 1449 | 
            +
            }),
         | 
| 1450 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1451 | 
            +
             | 
| 1452 | 
            +
            smalltalk.addMethod(
         | 
| 1453 | 
            +
            unescape('_section'),
         | 
| 1454 | 
            +
            smalltalk.method({
         | 
| 1455 | 
            +
            selector: unescape('section'),
         | 
| 1456 | 
            +
            fn: function (){
         | 
| 1457 | 
            +
            var self=this;
         | 
| 1458 | 
            +
            return smalltalk.send(self, "_tag_", ["section"]);
         | 
| 1459 | 
            +
            return self;}
         | 
| 1460 | 
            +
            }),
         | 
| 1461 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1462 | 
            +
             | 
| 1463 | 
            +
            smalltalk.addMethod(
         | 
| 1464 | 
            +
            unescape('_tbody'),
         | 
| 1465 | 
            +
            smalltalk.method({
         | 
| 1466 | 
            +
            selector: unescape('tbody'),
         | 
| 1467 | 
            +
            fn: function (){
         | 
| 1468 | 
            +
            var self=this;
         | 
| 1469 | 
            +
            return smalltalk.send(self, "_tag_", ["tbody"]);
         | 
| 1470 | 
            +
            return self;}
         | 
| 1471 | 
            +
            }),
         | 
| 1472 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1473 | 
            +
             | 
| 1474 | 
            +
            smalltalk.addMethod(
         | 
| 1475 | 
            +
            unescape('_tfoot'),
         | 
| 1476 | 
            +
            smalltalk.method({
         | 
| 1477 | 
            +
            selector: unescape('tfoot'),
         | 
| 1478 | 
            +
            fn: function (){
         | 
| 1479 | 
            +
            var self=this;
         | 
| 1480 | 
            +
            return smalltalk.send(self, "_tag_", ["tfoot"]);
         | 
| 1481 | 
            +
            return self;}
         | 
| 1482 | 
            +
            }),
         | 
| 1483 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1484 | 
            +
             | 
| 1485 | 
            +
            smalltalk.addMethod(
         | 
| 1486 | 
            +
            unescape('_thead'),
         | 
| 556 1487 | 
             
            smalltalk.method({
         | 
| 557 | 
            -
            selector: ' | 
| 558 | 
            -
            fn: function ( | 
| 1488 | 
            +
            selector: unescape('thead'),
         | 
| 1489 | 
            +
            fn: function (){
         | 
| 559 1490 | 
             
            var self=this;
         | 
| 560 | 
            -
            return smalltalk.send( | 
| 1491 | 
            +
            return smalltalk.send(self, "_tag_", ["thead"]);
         | 
| 561 1492 | 
             
            return self;}
         | 
| 562 1493 | 
             
            }),
         | 
| 563 1494 | 
             
            smalltalk.HTMLCanvas);
         | 
| 564 1495 |  | 
| 565 1496 | 
             
            smalltalk.addMethod(
         | 
| 566 | 
            -
            ' | 
| 1497 | 
            +
            unescape('_video'),
         | 
| 567 1498 | 
             
            smalltalk.method({
         | 
| 568 | 
            -
            selector: ' | 
| 569 | 
            -
            fn: function ( | 
| 1499 | 
            +
            selector: unescape('video'),
         | 
| 1500 | 
            +
            fn: function (){
         | 
| 570 1501 | 
             
            var self=this;
         | 
| 571 | 
            -
            return smalltalk.send( | 
| 1502 | 
            +
            return smalltalk.send(self, "_tag_", ["video"]);
         | 
| 572 1503 | 
             
            return self;}
         | 
| 573 1504 | 
             
            }),
         | 
| 574 1505 | 
             
            smalltalk.HTMLCanvas);
         | 
| 575 1506 |  | 
| 576 1507 | 
             
            smalltalk.addMethod(
         | 
| 577 | 
            -
            ' | 
| 1508 | 
            +
            unescape('_label'),
         | 
| 578 1509 | 
             
            smalltalk.method({
         | 
| 579 | 
            -
            selector: ' | 
| 580 | 
            -
            fn: function ( | 
| 1510 | 
            +
            selector: unescape('label'),
         | 
| 1511 | 
            +
            fn: function (){
         | 
| 581 1512 | 
             
            var self=this;
         | 
| 582 | 
            -
            return  | 
| 1513 | 
            +
            return smalltalk.send(self, "_tag_", ["label"]);
         | 
| 583 1514 | 
             
            return self;}
         | 
| 584 1515 | 
             
            }),
         | 
| 585 1516 | 
             
            smalltalk.HTMLCanvas);
         | 
| 586 1517 |  | 
| 587 1518 | 
             
            smalltalk.addMethod(
         | 
| 588 | 
            -
            ' | 
| 1519 | 
            +
            unescape('_title'),
         | 
| 589 1520 | 
             
            smalltalk.method({
         | 
| 590 | 
            -
            selector: ' | 
| 1521 | 
            +
            selector: unescape('title'),
         | 
| 591 1522 | 
             
            fn: function (){
         | 
| 592 1523 | 
             
            var self=this;
         | 
| 593 | 
            -
            return smalltalk.send(self, "_tag_", [" | 
| 1524 | 
            +
            return smalltalk.send(self, "_tag_", ["title"]);
         | 
| 594 1525 | 
             
            return self;}
         | 
| 595 1526 | 
             
            }),
         | 
| 596 1527 | 
             
            smalltalk.HTMLCanvas);
         | 
| 597 1528 |  | 
| 598 1529 | 
             
            smalltalk.addMethod(
         | 
| 599 | 
            -
            ' | 
| 1530 | 
            +
            unescape('_time'),
         | 
| 600 1531 | 
             
            smalltalk.method({
         | 
| 601 | 
            -
            selector: ' | 
| 1532 | 
            +
            selector: unescape('time'),
         | 
| 602 1533 | 
             
            fn: function (){
         | 
| 603 1534 | 
             
            var self=this;
         | 
| 604 | 
            -
            return smalltalk.send(self, "_tag_", [" | 
| 1535 | 
            +
            return smalltalk.send(self, "_tag_", ["time"]);
         | 
| 605 1536 | 
             
            return self;}
         | 
| 606 1537 | 
             
            }),
         | 
| 607 1538 | 
             
            smalltalk.HTMLCanvas);
         | 
| 608 1539 |  | 
| 609 1540 | 
             
            smalltalk.addMethod(
         | 
| 610 | 
            -
            ' | 
| 1541 | 
            +
            unescape('_sup'),
         | 
| 611 1542 | 
             
            smalltalk.method({
         | 
| 612 | 
            -
            selector: ' | 
| 1543 | 
            +
            selector: unescape('sup'),
         | 
| 613 1544 | 
             
            fn: function (){
         | 
| 614 1545 | 
             
            var self=this;
         | 
| 615 | 
            -
            return smalltalk.send(self, "_tag_", [" | 
| 1546 | 
            +
            return smalltalk.send(self, "_tag_", ["sup"]);
         | 
| 616 1547 | 
             
            return self;}
         | 
| 617 1548 | 
             
            }),
         | 
| 618 1549 | 
             
            smalltalk.HTMLCanvas);
         | 
| 619 1550 |  | 
| 620 1551 | 
             
            smalltalk.addMethod(
         | 
| 621 | 
            -
            ' | 
| 1552 | 
            +
            unescape('_summary'),
         | 
| 622 1553 | 
             
            smalltalk.method({
         | 
| 623 | 
            -
            selector: ' | 
| 1554 | 
            +
            selector: unescape('summary'),
         | 
| 624 1555 | 
             
            fn: function (){
         | 
| 625 1556 | 
             
            var self=this;
         | 
| 626 | 
            -
            return smalltalk.send(self, "_tag_", [" | 
| 1557 | 
            +
            return smalltalk.send(self, "_tag_", ["summary"]);
         | 
| 627 1558 | 
             
            return self;}
         | 
| 628 1559 | 
             
            }),
         | 
| 629 1560 | 
             
            smalltalk.HTMLCanvas);
         | 
| 630 1561 |  | 
| 631 1562 | 
             
            smalltalk.addMethod(
         | 
| 632 | 
            -
            ' | 
| 1563 | 
            +
            unescape('_sub'),
         | 
| 633 1564 | 
             
            smalltalk.method({
         | 
| 634 | 
            -
            selector: ' | 
| 1565 | 
            +
            selector: unescape('sub'),
         | 
| 635 1566 | 
             
            fn: function (){
         | 
| 636 1567 | 
             
            var self=this;
         | 
| 637 | 
            -
            return smalltalk.send(self, "_tag_", [" | 
| 1568 | 
            +
            return smalltalk.send(self, "_tag_", ["sub"]);
         | 
| 638 1569 | 
             
            return self;}
         | 
| 639 1570 | 
             
            }),
         | 
| 640 1571 | 
             
            smalltalk.HTMLCanvas);
         | 
| 641 1572 |  | 
| 642 1573 | 
             
            smalltalk.addMethod(
         | 
| 643 | 
            -
            ' | 
| 1574 | 
            +
            unescape('_strong'),
         | 
| 644 1575 | 
             
            smalltalk.method({
         | 
| 645 | 
            -
            selector: ' | 
| 1576 | 
            +
            selector: unescape('strong'),
         | 
| 646 1577 | 
             
            fn: function (){
         | 
| 647 1578 | 
             
            var self=this;
         | 
| 648 | 
            -
            return smalltalk.send(self, "_tag_", [" | 
| 1579 | 
            +
            return smalltalk.send(self, "_tag_", ["strong"]);
         | 
| 649 1580 | 
             
            return self;}
         | 
| 650 1581 | 
             
            }),
         | 
| 651 1582 | 
             
            smalltalk.HTMLCanvas);
         | 
| 652 1583 |  | 
| 653 1584 | 
             
            smalltalk.addMethod(
         | 
| 654 | 
            -
            ' | 
| 1585 | 
            +
            unescape('_strong_'),
         | 
| 655 1586 | 
             
            smalltalk.method({
         | 
| 656 | 
            -
            selector: ' | 
| 657 | 
            -
            fn: function (){
         | 
| 1587 | 
            +
            selector: unescape('strong%3A'),
         | 
| 1588 | 
            +
            fn: function (anObject){
         | 
| 658 1589 | 
             
            var self=this;
         | 
| 659 | 
            -
            return smalltalk.send(self, " | 
| 1590 | 
            +
            return smalltalk.send(smalltalk.send(self, "_strong", []), "_with_", [anObject]);
         | 
| 660 1591 | 
             
            return self;}
         | 
| 661 1592 | 
             
            }),
         | 
| 662 1593 | 
             
            smalltalk.HTMLCanvas);
         | 
| 663 1594 |  | 
| 664 1595 | 
             
            smalltalk.addMethod(
         | 
| 665 | 
            -
            ' | 
| 1596 | 
            +
            unescape('_source'),
         | 
| 666 1597 | 
             
            smalltalk.method({
         | 
| 667 | 
            -
            selector: ' | 
| 1598 | 
            +
            selector: unescape('source'),
         | 
| 668 1599 | 
             
            fn: function (){
         | 
| 669 1600 | 
             
            var self=this;
         | 
| 670 | 
            -
            return smalltalk.send(self, "_tag_", [" | 
| 1601 | 
            +
            return smalltalk.send(self, "_tag_", ["source"]);
         | 
| 671 1602 | 
             
            return self;}
         | 
| 672 1603 | 
             
            }),
         | 
| 673 1604 | 
             
            smalltalk.HTMLCanvas);
         | 
| 674 1605 |  | 
| 675 1606 | 
             
            smalltalk.addMethod(
         | 
| 676 | 
            -
            ' | 
| 1607 | 
            +
            unescape('_small'),
         | 
| 677 1608 | 
             
            smalltalk.method({
         | 
| 678 | 
            -
            selector: ' | 
| 1609 | 
            +
            selector: unescape('small'),
         | 
| 679 1610 | 
             
            fn: function (){
         | 
| 680 1611 | 
             
            var self=this;
         | 
| 681 | 
            -
            return smalltalk.send(self, "_tag_", [" | 
| 1612 | 
            +
            return smalltalk.send(self, "_tag_", ["small"]);
         | 
| 682 1613 | 
             
            return self;}
         | 
| 683 1614 | 
             
            }),
         | 
| 684 1615 | 
             
            smalltalk.HTMLCanvas);
         | 
| 685 1616 |  | 
| 686 1617 | 
             
            smalltalk.addMethod(
         | 
| 687 | 
            -
            ' | 
| 1618 | 
            +
            unescape('_progress'),
         | 
| 688 1619 | 
             
            smalltalk.method({
         | 
| 689 | 
            -
            selector: ' | 
| 1620 | 
            +
            selector: unescape('progress'),
         | 
| 690 1621 | 
             
            fn: function (){
         | 
| 691 1622 | 
             
            var self=this;
         | 
| 692 | 
            -
            return smalltalk.send(self, "_tag_", [" | 
| 1623 | 
            +
            return smalltalk.send(self, "_tag_", ["progress"]);
         | 
| 693 1624 | 
             
            return self;}
         | 
| 694 1625 | 
             
            }),
         | 
| 695 1626 | 
             
            smalltalk.HTMLCanvas);
         | 
| 696 1627 |  | 
| 697 1628 | 
             
            smalltalk.addMethod(
         | 
| 698 | 
            -
            ' | 
| 1629 | 
            +
            unescape('_param'),
         | 
| 699 1630 | 
             
            smalltalk.method({
         | 
| 700 | 
            -
            selector: ' | 
| 1631 | 
            +
            selector: unescape('param'),
         | 
| 701 1632 | 
             
            fn: function (){
         | 
| 702 1633 | 
             
            var self=this;
         | 
| 703 | 
            -
            return smalltalk.send(self, "_tag_", [" | 
| 1634 | 
            +
            return smalltalk.send(self, "_tag_", ["param"]);
         | 
| 704 1635 | 
             
            return self;}
         | 
| 705 1636 | 
             
            }),
         | 
| 706 1637 | 
             
            smalltalk.HTMLCanvas);
         | 
| 707 1638 |  | 
| 708 | 
            -
             | 
| 709 1639 | 
             
            smalltalk.addMethod(
         | 
| 710 | 
            -
            ' | 
| 1640 | 
            +
            unescape('_output'),
         | 
| 711 1641 | 
             
            smalltalk.method({
         | 
| 712 | 
            -
            selector: ' | 
| 713 | 
            -
            fn: function ( | 
| 1642 | 
            +
            selector: unescape('output'),
         | 
| 1643 | 
            +
            fn: function (){
         | 
| 714 1644 | 
             
            var self=this;
         | 
| 715 | 
            -
            return  | 
| 1645 | 
            +
            return smalltalk.send(self, "_tag_", ["output"]);
         | 
| 716 1646 | 
             
            return self;}
         | 
| 717 1647 | 
             
            }),
         | 
| 718 | 
            -
            smalltalk.HTMLCanvas | 
| 719 | 
            -
             | 
| 1648 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 720 1649 |  | 
| 721 | 
            -
            smalltalk.addClass('TagBrush', smalltalk.Object, ['canvas', 'element'], 'Canvas');
         | 
| 722 1650 | 
             
            smalltalk.addMethod(
         | 
| 723 | 
            -
            ' | 
| 1651 | 
            +
            unescape('_optgroup'),
         | 
| 724 1652 | 
             
            smalltalk.method({
         | 
| 725 | 
            -
            selector: ' | 
| 1653 | 
            +
            selector: unescape('optgroup'),
         | 
| 726 1654 | 
             
            fn: function (){
         | 
| 727 1655 | 
             
            var self=this;
         | 
| 728 | 
            -
            return self[ | 
| 1656 | 
            +
            return smalltalk.send(self, "_tag_", ["optgroup"]);
         | 
| 729 1657 | 
             
            return self;}
         | 
| 730 1658 | 
             
            }),
         | 
| 731 | 
            -
            smalltalk. | 
| 1659 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 732 1660 |  | 
| 733 1661 | 
             
            smalltalk.addMethod(
         | 
| 734 | 
            -
            ' | 
| 1662 | 
            +
            unescape('_object'),
         | 
| 735 1663 | 
             
            smalltalk.method({
         | 
| 736 | 
            -
            selector: ' | 
| 737 | 
            -
            fn: function ( | 
| 1664 | 
            +
            selector: unescape('object'),
         | 
| 1665 | 
            +
            fn: function (){
         | 
| 738 1666 | 
             
            var self=this;
         | 
| 739 | 
            -
             | 
| 1667 | 
            +
            return smalltalk.send(self, "_tag_", ["object"]);
         | 
| 740 1668 | 
             
            return self;}
         | 
| 741 1669 | 
             
            }),
         | 
| 742 | 
            -
            smalltalk. | 
| 1670 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 743 1671 |  | 
| 744 1672 | 
             
            smalltalk.addMethod(
         | 
| 745 | 
            -
            ' | 
| 1673 | 
            +
            unescape('_noscript'),
         | 
| 746 1674 | 
             
            smalltalk.method({
         | 
| 747 | 
            -
            selector: ' | 
| 748 | 
            -
            fn: function ( | 
| 1675 | 
            +
            selector: unescape('noscript'),
         | 
| 1676 | 
            +
            fn: function (){
         | 
| 749 1677 | 
             
            var self=this;
         | 
| 750 | 
            -
            smalltalk.send(self, " | 
| 751 | 
            -
            return aTagBrush;
         | 
| 1678 | 
            +
            return smalltalk.send(self, "_tag_", ["noscript"]);
         | 
| 752 1679 | 
             
            return self;}
         | 
| 753 1680 | 
             
            }),
         | 
| 754 | 
            -
            smalltalk. | 
| 1681 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 755 1682 |  | 
| 756 1683 | 
             
            smalltalk.addMethod(
         | 
| 757 | 
            -
            ' | 
| 1684 | 
            +
            unescape('_nav'),
         | 
| 758 1685 | 
             
            smalltalk.method({
         | 
| 759 | 
            -
            selector: ' | 
| 760 | 
            -
            fn: function ( | 
| 1686 | 
            +
            selector: unescape('nav'),
         | 
| 1687 | 
            +
            fn: function (){
         | 
| 761 1688 | 
             
            var self=this;
         | 
| 762 | 
            -
            smalltalk.send(self, " | 
| 1689 | 
            +
            return smalltalk.send(self, "_tag_", ["nav"]);
         | 
| 763 1690 | 
             
            return self;}
         | 
| 764 1691 | 
             
            }),
         | 
| 765 | 
            -
            smalltalk. | 
| 1692 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 766 1693 |  | 
| 767 1694 | 
             
            smalltalk.addMethod(
         | 
| 768 | 
            -
            ' | 
| 1695 | 
            +
            unescape('_meta'),
         | 
| 769 1696 | 
             
            smalltalk.method({
         | 
| 770 | 
            -
            selector: ' | 
| 771 | 
            -
            fn: function ( | 
| 1697 | 
            +
            selector: unescape('meta'),
         | 
| 1698 | 
            +
            fn: function (){
         | 
| 772 1699 | 
             
            var self=this;
         | 
| 773 | 
            -
            smalltalk.send( | 
| 1700 | 
            +
            return smalltalk.send(self, "_tag_", ["meta"]);
         | 
| 774 1701 | 
             
            return self;}
         | 
| 775 1702 | 
             
            }),
         | 
| 776 | 
            -
            smalltalk. | 
| 1703 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 777 1704 |  | 
| 778 1705 | 
             
            smalltalk.addMethod(
         | 
| 779 | 
            -
            ' | 
| 1706 | 
            +
            unescape('_menu'),
         | 
| 780 1707 | 
             
            smalltalk.method({
         | 
| 781 | 
            -
            selector: ' | 
| 782 | 
            -
            fn: function ( | 
| 1708 | 
            +
            selector: unescape('menu'),
         | 
| 1709 | 
            +
            fn: function (){
         | 
| 783 1710 | 
             
            var self=this;
         | 
| 784 | 
            -
            smalltalk.send( | 
| 1711 | 
            +
            return smalltalk.send(self, "_tag_", ["menu"]);
         | 
| 785 1712 | 
             
            return self;}
         | 
| 786 1713 | 
             
            }),
         | 
| 787 | 
            -
            smalltalk. | 
| 1714 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 788 1715 |  | 
| 789 1716 | 
             
            smalltalk.addMethod(
         | 
| 790 | 
            -
            ' | 
| 1717 | 
            +
            unescape('_mark'),
         | 
| 791 1718 | 
             
            smalltalk.method({
         | 
| 792 | 
            -
            selector: ' | 
| 793 | 
            -
            fn: function ( | 
| 1719 | 
            +
            selector: unescape('mark'),
         | 
| 1720 | 
            +
            fn: function (){
         | 
| 794 1721 | 
             
            var self=this;
         | 
| 795 | 
            -
             | 
| 796 | 
            -
            (root=smalltalk.send(self['@canvas'], "_root", []));
         | 
| 797 | 
            -
            smalltalk.send(self['@canvas'], "_root_", [self]);
         | 
| 798 | 
            -
            smalltalk.send(aBlock, "_value_", [self['@canvas']]);
         | 
| 799 | 
            -
            smalltalk.send(self['@canvas'], "_root_", [root]);
         | 
| 1722 | 
            +
            return smalltalk.send(self, "_tag_", ["mark"]);
         | 
| 800 1723 | 
             
            return self;}
         | 
| 801 1724 | 
             
            }),
         | 
| 802 | 
            -
            smalltalk. | 
| 1725 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 803 1726 |  | 
| 804 1727 | 
             
            smalltalk.addMethod(
         | 
| 805 | 
            -
            ' | 
| 1728 | 
            +
            unescape('_map'),
         | 
| 806 1729 | 
             
            smalltalk.method({
         | 
| 807 | 
            -
            selector: ' | 
| 808 | 
            -
            fn: function ( | 
| 1730 | 
            +
            selector: unescape('map'),
         | 
| 1731 | 
            +
            fn: function (){
         | 
| 809 1732 | 
             
            var self=this;
         | 
| 810 | 
            -
             | 
| 811 | 
            -
             	if (null == element.canHaveChildren || element.canHaveChildren) {
         | 
| 812 | 
            -
            		element.appendChild(anElement);
         | 
| 813 | 
            -
             	} else {
         | 
| 814 | 
            -
             		element.text = String(element.text) +  anElement.innerHTML;
         | 
| 815 | 
            -
             	} ;
         | 
| 1733 | 
            +
            return smalltalk.send(self, "_tag_", ["map"]);
         | 
| 816 1734 | 
             
            return self;}
         | 
| 817 1735 | 
             
            }),
         | 
| 818 | 
            -
            smalltalk. | 
| 1736 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 819 1737 |  | 
| 820 1738 | 
             
            smalltalk.addMethod(
         | 
| 821 | 
            -
            ' | 
| 1739 | 
            +
            unescape('_legend'),
         | 
| 822 1740 | 
             
            smalltalk.method({
         | 
| 823 | 
            -
            selector: ' | 
| 824 | 
            -
            fn: function ( | 
| 1741 | 
            +
            selector: unescape('legend'),
         | 
| 1742 | 
            +
            fn: function (){
         | 
| 825 1743 | 
             
            var self=this;
         | 
| 826 | 
            -
            smalltalk.send(self, " | 
| 1744 | 
            +
            return smalltalk.send(self, "_tag_", ["legend"]);
         | 
| 827 1745 | 
             
            return self;}
         | 
| 828 1746 | 
             
            }),
         | 
| 829 | 
            -
            smalltalk. | 
| 1747 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 830 1748 |  | 
| 831 1749 | 
             
            smalltalk.addMethod(
         | 
| 832 | 
            -
            ' | 
| 1750 | 
            +
            unescape('_html'),
         | 
| 833 1751 | 
             
            smalltalk.method({
         | 
| 834 | 
            -
            selector: ' | 
| 1752 | 
            +
            selector: unescape('html'),
         | 
| 835 1753 | 
             
            fn: function (){
         | 
| 836 1754 | 
             
            var self=this;
         | 
| 837 | 
            -
            smalltalk.send( | 
| 1755 | 
            +
            return smalltalk.send(self, "_tag_", ["html"]);
         | 
| 838 1756 | 
             
            return self;}
         | 
| 839 1757 | 
             
            }),
         | 
| 840 | 
            -
            smalltalk. | 
| 1758 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 841 1759 |  | 
| 842 1760 | 
             
            smalltalk.addMethod(
         | 
| 843 | 
            -
            ' | 
| 1761 | 
            +
            unescape('_hgroup'),
         | 
| 844 1762 | 
             
            smalltalk.method({
         | 
| 845 | 
            -
            selector: ' | 
| 846 | 
            -
            fn: function ( | 
| 1763 | 
            +
            selector: unescape('hgroup'),
         | 
| 1764 | 
            +
            fn: function (){
         | 
| 847 1765 | 
             
            var self=this;
         | 
| 848 | 
            -
             | 
| 1766 | 
            +
            return smalltalk.send(self, "_tag_", ["hgroup"]);
         | 
| 849 1767 | 
             
            return self;}
         | 
| 850 1768 | 
             
            }),
         | 
| 851 | 
            -
            smalltalk. | 
| 1769 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 852 1770 |  | 
| 853 1771 | 
             
            smalltalk.addMethod(
         | 
| 854 | 
            -
            ' | 
| 1772 | 
            +
            unescape('_head'),
         | 
| 855 1773 | 
             
            smalltalk.method({
         | 
| 856 | 
            -
            selector: ' | 
| 857 | 
            -
            fn: function ( | 
| 1774 | 
            +
            selector: unescape('head'),
         | 
| 1775 | 
            +
            fn: function (){
         | 
| 858 1776 | 
             
            var self=this;
         | 
| 859 | 
            -
            self[ | 
| 1777 | 
            +
            return smalltalk.send(self, "_tag_", ["head"]);
         | 
| 860 1778 | 
             
            return self;}
         | 
| 861 1779 | 
             
            }),
         | 
| 862 | 
            -
            smalltalk. | 
| 1780 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 863 1781 |  | 
| 864 1782 | 
             
            smalltalk.addMethod(
         | 
| 865 | 
            -
            ' | 
| 1783 | 
            +
            unescape('_figure'),
         | 
| 866 1784 | 
             
            smalltalk.method({
         | 
| 867 | 
            -
            selector: ' | 
| 868 | 
            -
            fn: function ( | 
| 1785 | 
            +
            selector: unescape('figure'),
         | 
| 1786 | 
            +
            fn: function (){
         | 
| 869 1787 | 
             
            var self=this;
         | 
| 870 | 
            -
            self[ | 
| 1788 | 
            +
            return smalltalk.send(self, "_tag_", ["figure"]);
         | 
| 871 1789 | 
             
            return self;}
         | 
| 872 1790 | 
             
            }),
         | 
| 873 | 
            -
            smalltalk. | 
| 1791 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 874 1792 |  | 
| 875 1793 | 
             
            smalltalk.addMethod(
         | 
| 876 | 
            -
            ' | 
| 1794 | 
            +
            unescape('_figcaption'),
         | 
| 877 1795 | 
             
            smalltalk.method({
         | 
| 878 | 
            -
            selector: ' | 
| 879 | 
            -
            fn: function ( | 
| 1796 | 
            +
            selector: unescape('figcaption'),
         | 
| 1797 | 
            +
            fn: function (){
         | 
| 880 1798 | 
             
            var self=this;
         | 
| 881 | 
            -
            smalltalk.send(self, " | 
| 1799 | 
            +
            return smalltalk.send(self, "_tag_", ["figcaption"]);
         | 
| 882 1800 | 
             
            return self;}
         | 
| 883 1801 | 
             
            }),
         | 
| 884 | 
            -
            smalltalk. | 
| 1802 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 885 1803 |  | 
| 886 1804 | 
             
            smalltalk.addMethod(
         | 
| 887 | 
            -
            ' | 
| 1805 | 
            +
            unescape('_embed'),
         | 
| 888 1806 | 
             
            smalltalk.method({
         | 
| 889 | 
            -
            selector: ' | 
| 890 | 
            -
            fn: function ( | 
| 1807 | 
            +
            selector: unescape('embed'),
         | 
| 1808 | 
            +
            fn: function (){
         | 
| 891 1809 | 
             
            var self=this;
         | 
| 892 | 
            -
            smalltalk.send(self, " | 
| 1810 | 
            +
            return smalltalk.send(self, "_tag_", ["embed"]);
         | 
| 893 1811 | 
             
            return self;}
         | 
| 894 1812 | 
             
            }),
         | 
| 895 | 
            -
            smalltalk. | 
| 1813 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 896 1814 |  | 
| 897 1815 | 
             
            smalltalk.addMethod(
         | 
| 898 | 
            -
            ' | 
| 1816 | 
            +
            unescape('_em'),
         | 
| 899 1817 | 
             
            smalltalk.method({
         | 
| 900 | 
            -
            selector: ' | 
| 901 | 
            -
            fn: function ( | 
| 1818 | 
            +
            selector: unescape('em'),
         | 
| 1819 | 
            +
            fn: function (){
         | 
| 902 1820 | 
             
            var self=this;
         | 
| 903 | 
            -
            smalltalk.send(self, " | 
| 1821 | 
            +
            return smalltalk.send(self, "_tag_", ["em"]);
         | 
| 904 1822 | 
             
            return self;}
         | 
| 905 1823 | 
             
            }),
         | 
| 906 | 
            -
            smalltalk. | 
| 1824 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 907 1825 |  | 
| 908 1826 | 
             
            smalltalk.addMethod(
         | 
| 909 | 
            -
            ' | 
| 1827 | 
            +
            unescape('_dt'),
         | 
| 910 1828 | 
             
            smalltalk.method({
         | 
| 911 | 
            -
            selector: ' | 
| 912 | 
            -
            fn: function ( | 
| 1829 | 
            +
            selector: unescape('dt'),
         | 
| 1830 | 
            +
            fn: function (){
         | 
| 913 1831 | 
             
            var self=this;
         | 
| 914 | 
            -
            smalltalk.send(self, " | 
| 1832 | 
            +
            return smalltalk.send(self, "_tag_", ["dt"]);
         | 
| 915 1833 | 
             
            return self;}
         | 
| 916 1834 | 
             
            }),
         | 
| 917 | 
            -
            smalltalk. | 
| 1835 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 918 1836 |  | 
| 919 1837 | 
             
            smalltalk.addMethod(
         | 
| 920 | 
            -
            ' | 
| 1838 | 
            +
            unescape('_dl'),
         | 
| 921 1839 | 
             
            smalltalk.method({
         | 
| 922 | 
            -
            selector: ' | 
| 923 | 
            -
            fn: function ( | 
| 1840 | 
            +
            selector: unescape('dl'),
         | 
| 1841 | 
            +
            fn: function (){
         | 
| 924 1842 | 
             
            var self=this;
         | 
| 925 | 
            -
            smalltalk.send(self, " | 
| 1843 | 
            +
            return smalltalk.send(self, "_tag_", ["dl"]);
         | 
| 926 1844 | 
             
            return self;}
         | 
| 927 1845 | 
             
            }),
         | 
| 928 | 
            -
            smalltalk. | 
| 1846 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 929 1847 |  | 
| 930 1848 | 
             
            smalltalk.addMethod(
         | 
| 931 | 
            -
            ' | 
| 1849 | 
            +
            unescape('_details'),
         | 
| 932 1850 | 
             
            smalltalk.method({
         | 
| 933 | 
            -
            selector: ' | 
| 934 | 
            -
            fn: function ( | 
| 1851 | 
            +
            selector: unescape('details'),
         | 
| 1852 | 
            +
            fn: function (){
         | 
| 935 1853 | 
             
            var self=this;
         | 
| 936 | 
            -
            smalltalk.send(self, " | 
| 1854 | 
            +
            return smalltalk.send(self, "_tag_", ["details"]);
         | 
| 937 1855 | 
             
            return self;}
         | 
| 938 1856 | 
             
            }),
         | 
| 939 | 
            -
            smalltalk. | 
| 1857 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 940 1858 |  | 
| 941 1859 | 
             
            smalltalk.addMethod(
         | 
| 942 | 
            -
            ' | 
| 1860 | 
            +
            unescape('_del'),
         | 
| 943 1861 | 
             
            smalltalk.method({
         | 
| 944 | 
            -
            selector: ' | 
| 945 | 
            -
            fn: function ( | 
| 1862 | 
            +
            selector: unescape('del'),
         | 
| 1863 | 
            +
            fn: function (){
         | 
| 946 1864 | 
             
            var self=this;
         | 
| 947 | 
            -
            smalltalk.send(self, " | 
| 1865 | 
            +
            return smalltalk.send(self, "_tag_", ["del"]);
         | 
| 948 1866 | 
             
            return self;}
         | 
| 949 1867 | 
             
            }),
         | 
| 950 | 
            -
            smalltalk. | 
| 1868 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 951 1869 |  | 
| 952 1870 | 
             
            smalltalk.addMethod(
         | 
| 953 | 
            -
            ' | 
| 1871 | 
            +
            unescape('_dd'),
         | 
| 954 1872 | 
             
            smalltalk.method({
         | 
| 955 | 
            -
            selector: ' | 
| 956 | 
            -
            fn: function ( | 
| 1873 | 
            +
            selector: unescape('dd'),
         | 
| 1874 | 
            +
            fn: function (){
         | 
| 957 1875 | 
             
            var self=this;
         | 
| 958 | 
            -
            smalltalk.send(self, " | 
| 1876 | 
            +
            return smalltalk.send(self, "_tag_", ["dd"]);
         | 
| 959 1877 | 
             
            return self;}
         | 
| 960 1878 | 
             
            }),
         | 
| 961 | 
            -
            smalltalk. | 
| 1879 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 962 1880 |  | 
| 963 1881 | 
             
            smalltalk.addMethod(
         | 
| 964 | 
            -
            ' | 
| 1882 | 
            +
            unescape('_datalist'),
         | 
| 965 1883 | 
             
            smalltalk.method({
         | 
| 966 | 
            -
            selector: ' | 
| 967 | 
            -
            fn: function ( | 
| 1884 | 
            +
            selector: unescape('datalist'),
         | 
| 1885 | 
            +
            fn: function (){
         | 
| 968 1886 | 
             
            var self=this;
         | 
| 969 | 
            -
            smalltalk.send(self, " | 
| 1887 | 
            +
            return smalltalk.send(self, "_tag_", ["datalist"]);
         | 
| 970 1888 | 
             
            return self;}
         | 
| 971 1889 | 
             
            }),
         | 
| 972 | 
            -
            smalltalk. | 
| 1890 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 973 1891 |  | 
| 974 1892 | 
             
            smalltalk.addMethod(
         | 
| 975 | 
            -
            ' | 
| 1893 | 
            +
            unescape('_command'),
         | 
| 976 1894 | 
             
            smalltalk.method({
         | 
| 977 | 
            -
            selector: ' | 
| 978 | 
            -
            fn: function ( | 
| 1895 | 
            +
            selector: unescape('command'),
         | 
| 1896 | 
            +
            fn: function (){
         | 
| 979 1897 | 
             
            var self=this;
         | 
| 980 | 
            -
            smalltalk.send(self, " | 
| 1898 | 
            +
            return smalltalk.send(self, "_tag_", ["command"]);
         | 
| 981 1899 | 
             
            return self;}
         | 
| 982 1900 | 
             
            }),
         | 
| 983 | 
            -
            smalltalk. | 
| 1901 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 984 1902 |  | 
| 985 1903 | 
             
            smalltalk.addMethod(
         | 
| 986 | 
            -
            ' | 
| 1904 | 
            +
            unescape('_colgroup'),
         | 
| 987 1905 | 
             
            smalltalk.method({
         | 
| 988 | 
            -
            selector: ' | 
| 989 | 
            -
            fn: function ( | 
| 1906 | 
            +
            selector: unescape('colgroup'),
         | 
| 1907 | 
            +
            fn: function (){
         | 
| 990 1908 | 
             
            var self=this;
         | 
| 991 | 
            -
            smalltalk.send(self, " | 
| 1909 | 
            +
            return smalltalk.send(self, "_tag_", ["colgroup"]);
         | 
| 992 1910 | 
             
            return self;}
         | 
| 993 1911 | 
             
            }),
         | 
| 994 | 
            -
            smalltalk. | 
| 1912 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 995 1913 |  | 
| 996 1914 | 
             
            smalltalk.addMethod(
         | 
| 997 | 
            -
            ' | 
| 1915 | 
            +
            unescape('_col'),
         | 
| 998 1916 | 
             
            smalltalk.method({
         | 
| 999 | 
            -
            selector: ' | 
| 1917 | 
            +
            selector: unescape('col'),
         | 
| 1000 1918 | 
             
            fn: function (){
         | 
| 1001 1919 | 
             
            var self=this;
         | 
| 1002 | 
            -
            return smalltalk.send( | 
| 1920 | 
            +
            return smalltalk.send(self, "_tag_", ["col"]);
         | 
| 1003 1921 | 
             
            return self;}
         | 
| 1004 1922 | 
             
            }),
         | 
| 1005 | 
            -
            smalltalk. | 
| 1923 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1006 1924 |  | 
| 1007 1925 | 
             
            smalltalk.addMethod(
         | 
| 1008 | 
            -
            ' | 
| 1926 | 
            +
            unescape('_cite'),
         | 
| 1009 1927 | 
             
            smalltalk.method({
         | 
| 1010 | 
            -
            selector: ' | 
| 1011 | 
            -
            fn: function ( | 
| 1928 | 
            +
            selector: unescape('cite'),
         | 
| 1929 | 
            +
            fn: function (){
         | 
| 1012 1930 | 
             
            var self=this;
         | 
| 1013 | 
            -
            smalltalk.send( | 
| 1931 | 
            +
            return smalltalk.send(self, "_tag_", ["cite"]);
         | 
| 1014 1932 | 
             
            return self;}
         | 
| 1015 1933 | 
             
            }),
         | 
| 1016 | 
            -
            smalltalk. | 
| 1934 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1017 1935 |  | 
| 1018 1936 | 
             
            smalltalk.addMethod(
         | 
| 1019 | 
            -
            ' | 
| 1937 | 
            +
            unescape('_caption'),
         | 
| 1020 1938 | 
             
            smalltalk.method({
         | 
| 1021 | 
            -
            selector: ' | 
| 1022 | 
            -
            fn: function ( | 
| 1939 | 
            +
            selector: unescape('caption'),
         | 
| 1940 | 
            +
            fn: function (){
         | 
| 1023 1941 | 
             
            var self=this;
         | 
| 1024 | 
            -
            smalltalk.send( | 
| 1942 | 
            +
            return smalltalk.send(self, "_tag_", ["caption"]);
         | 
| 1025 1943 | 
             
            return self;}
         | 
| 1026 1944 | 
             
            }),
         | 
| 1027 | 
            -
            smalltalk. | 
| 1945 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1028 1946 |  | 
| 1029 1947 | 
             
            smalltalk.addMethod(
         | 
| 1030 | 
            -
            ' | 
| 1948 | 
            +
            unescape('_body'),
         | 
| 1031 1949 | 
             
            smalltalk.method({
         | 
| 1032 | 
            -
            selector: ' | 
| 1033 | 
            -
            fn: function ( | 
| 1950 | 
            +
            selector: unescape('body'),
         | 
| 1951 | 
            +
            fn: function (){
         | 
| 1034 1952 | 
             
            var self=this;
         | 
| 1035 | 
            -
            smalltalk.send( | 
| 1953 | 
            +
            return smalltalk.send(self, "_tag_", ["body"]);
         | 
| 1036 1954 | 
             
            return self;}
         | 
| 1037 1955 | 
             
            }),
         | 
| 1038 | 
            -
            smalltalk. | 
| 1956 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1039 1957 |  | 
| 1040 1958 | 
             
            smalltalk.addMethod(
         | 
| 1041 | 
            -
            ' | 
| 1959 | 
            +
            unescape('_blockquote'),
         | 
| 1042 1960 | 
             
            smalltalk.method({
         | 
| 1043 | 
            -
            selector: ' | 
| 1044 | 
            -
            fn: function ( | 
| 1961 | 
            +
            selector: unescape('blockquote'),
         | 
| 1962 | 
            +
            fn: function (){
         | 
| 1045 1963 | 
             
            var self=this;
         | 
| 1046 | 
            -
            smalltalk.send( | 
| 1964 | 
            +
            return smalltalk.send(self, "_tag_", ["blockquote"]);
         | 
| 1047 1965 | 
             
            return self;}
         | 
| 1048 1966 | 
             
            }),
         | 
| 1049 | 
            -
            smalltalk. | 
| 1967 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1050 1968 |  | 
| 1051 1969 | 
             
            smalltalk.addMethod(
         | 
| 1052 | 
            -
            ' | 
| 1970 | 
            +
            unescape('_base'),
         | 
| 1053 1971 | 
             
            smalltalk.method({
         | 
| 1054 | 
            -
            selector: ' | 
| 1055 | 
            -
            fn: function ( | 
| 1972 | 
            +
            selector: unescape('base'),
         | 
| 1973 | 
            +
            fn: function (){
         | 
| 1056 1974 | 
             
            var self=this;
         | 
| 1057 | 
            -
            smalltalk.send( | 
| 1975 | 
            +
            return smalltalk.send(self, "_tag_", ["base"]);
         | 
| 1058 1976 | 
             
            return self;}
         | 
| 1059 1977 | 
             
            }),
         | 
| 1060 | 
            -
            smalltalk. | 
| 1978 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1061 1979 |  | 
| 1062 1980 | 
             
            smalltalk.addMethod(
         | 
| 1063 | 
            -
            ' | 
| 1981 | 
            +
            unescape('_aside'),
         | 
| 1064 1982 | 
             
            smalltalk.method({
         | 
| 1065 | 
            -
            selector: ' | 
| 1066 | 
            -
            fn: function ( | 
| 1983 | 
            +
            selector: unescape('aside'),
         | 
| 1984 | 
            +
            fn: function (){
         | 
| 1067 1985 | 
             
            var self=this;
         | 
| 1068 | 
            -
            smalltalk.send( | 
| 1986 | 
            +
            return smalltalk.send(self, "_tag_", ["aside"]);
         | 
| 1069 1987 | 
             
            return self;}
         | 
| 1070 1988 | 
             
            }),
         | 
| 1071 | 
            -
            smalltalk. | 
| 1989 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1072 1990 |  | 
| 1073 1991 | 
             
            smalltalk.addMethod(
         | 
| 1074 | 
            -
            ' | 
| 1992 | 
            +
            unescape('_article'),
         | 
| 1075 1993 | 
             
            smalltalk.method({
         | 
| 1076 | 
            -
            selector: ' | 
| 1077 | 
            -
            fn: function ( | 
| 1994 | 
            +
            selector: unescape('article'),
         | 
| 1995 | 
            +
            fn: function (){
         | 
| 1078 1996 | 
             
            var self=this;
         | 
| 1079 | 
            -
            smalltalk.send( | 
| 1997 | 
            +
            return smalltalk.send(self, "_tag_", ["article"]);
         | 
| 1080 1998 | 
             
            return self;}
         | 
| 1081 1999 | 
             
            }),
         | 
| 1082 | 
            -
            smalltalk. | 
| 2000 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1083 2001 |  | 
| 1084 2002 | 
             
            smalltalk.addMethod(
         | 
| 1085 | 
            -
            ' | 
| 2003 | 
            +
            unescape('_area'),
         | 
| 1086 2004 | 
             
            smalltalk.method({
         | 
| 1087 | 
            -
            selector: ' | 
| 1088 | 
            -
            fn: function ( | 
| 2005 | 
            +
            selector: unescape('area'),
         | 
| 2006 | 
            +
            fn: function (){
         | 
| 1089 2007 | 
             
            var self=this;
         | 
| 1090 | 
            -
             | 
| 1091 | 
            -
            (self['@canvas']=aCanvas);
         | 
| 2008 | 
            +
            return smalltalk.send(self, "_tag_", ["area"]);
         | 
| 1092 2009 | 
             
            return self;}
         | 
| 1093 2010 | 
             
            }),
         | 
| 1094 | 
            -
            smalltalk. | 
| 2011 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1095 2012 |  | 
| 1096 2013 | 
             
            smalltalk.addMethod(
         | 
| 1097 | 
            -
            ' | 
| 2014 | 
            +
            unescape('_address'),
         | 
| 1098 2015 | 
             
            smalltalk.method({
         | 
| 1099 | 
            -
            selector: ' | 
| 1100 | 
            -
            fn: function ( | 
| 2016 | 
            +
            selector: unescape('address'),
         | 
| 2017 | 
            +
            fn: function (){
         | 
| 1101 2018 | 
             
            var self=this;
         | 
| 1102 | 
            -
             | 
| 1103 | 
            -
            (self['@canvas']=aCanvas);
         | 
| 2019 | 
            +
            return smalltalk.send(self, "_tag_", ["address"]);
         | 
| 1104 2020 | 
             
            return self;}
         | 
| 1105 2021 | 
             
            }),
         | 
| 1106 | 
            -
            smalltalk. | 
| 2022 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1107 2023 |  | 
| 1108 2024 | 
             
            smalltalk.addMethod(
         | 
| 1109 | 
            -
            ' | 
| 2025 | 
            +
            unescape('_abbr'),
         | 
| 1110 2026 | 
             
            smalltalk.method({
         | 
| 1111 | 
            -
            selector: ' | 
| 1112 | 
            -
            fn: function ( | 
| 2027 | 
            +
            selector: unescape('abbr'),
         | 
| 2028 | 
            +
            fn: function (){
         | 
| 1113 2029 | 
             
            var self=this;
         | 
| 1114 | 
            -
            return  | 
| 2030 | 
            +
            return smalltalk.send(self, "_tag_", ["abbr"]);
         | 
| 1115 2031 | 
             
            return self;}
         | 
| 1116 2032 | 
             
            }),
         | 
| 1117 | 
            -
            smalltalk. | 
| 2033 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1118 2034 |  | 
| 1119 2035 | 
             
            smalltalk.addMethod(
         | 
| 1120 | 
            -
            ' | 
| 2036 | 
            +
            unescape('_div_'),
         | 
| 1121 2037 | 
             
            smalltalk.method({
         | 
| 1122 | 
            -
            selector: ' | 
| 1123 | 
            -
            fn: function ( | 
| 2038 | 
            +
            selector: unescape('div%3A'),
         | 
| 2039 | 
            +
            fn: function (aBlock){
         | 
| 1124 2040 | 
             
            var self=this;
         | 
| 1125 | 
            -
            return  | 
| 2041 | 
            +
            return smalltalk.send(smalltalk.send(self, "_div", []), "_with_", [aBlock]);
         | 
| 1126 2042 | 
             
            return self;}
         | 
| 1127 2043 | 
             
            }),
         | 
| 1128 | 
            -
            smalltalk. | 
| 2044 | 
            +
            smalltalk.HTMLCanvas);
         | 
| 1129 2045 |  | 
| 1130 2046 |  | 
| 1131 2047 | 
             
            smalltalk.addMethod(
         | 
| 1132 | 
            -
            ' | 
| 2048 | 
            +
            unescape('_onJQuery_'),
         | 
| 1133 2049 | 
             
            smalltalk.method({
         | 
| 1134 | 
            -
            selector: ' | 
| 1135 | 
            -
            fn: function ( | 
| 2050 | 
            +
            selector: unescape('onJQuery%3A'),
         | 
| 2051 | 
            +
            fn: function (aJQuery){
         | 
| 1136 2052 | 
             
            var self=this;
         | 
| 1137 | 
            -
            return (function($rec){smalltalk.send($rec, " | 
| 2053 | 
            +
            return (function($rec){smalltalk.send($rec, "_initializeFromJQuery_", [aJQuery]);smalltalk.send($rec, "_initialize", []);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_basicNew", []));
         | 
| 1138 2054 | 
             
            return self;}
         | 
| 1139 2055 | 
             
            }),
         | 
| 1140 | 
            -
            smalltalk. | 
| 2056 | 
            +
            smalltalk.HTMLCanvas.klass);
         | 
| 1141 2057 |  | 
| 1142 2058 | 
             
            smalltalk.addMethod(
         | 
| 1143 | 
            -
            ' | 
| 2059 | 
            +
            unescape('_isMSIE'),
         | 
| 1144 2060 | 
             
            smalltalk.method({
         | 
| 1145 | 
            -
            selector: ' | 
| 1146 | 
            -
            fn: function ( | 
| 2061 | 
            +
            selector: unescape('isMSIE'),
         | 
| 2062 | 
            +
            fn: function (){
         | 
| 1147 2063 | 
             
            var self=this;
         | 
| 1148 | 
            -
            return ( | 
| 2064 | 
            +
            return smalltalk.send(smalltalk.send(smalltalk.send((typeof jQuery == 'undefined' ? nil : jQuery), "_at_", [smalltalk.symbolFor("browser")]), "_at_", [smalltalk.symbolFor("msie")]), "_notNil", []);
         | 
| 1149 2065 | 
             
            return self;}
         | 
| 1150 2066 | 
             
            }),
         | 
| 1151 | 
            -
            smalltalk. | 
| 1152 | 
            -
             | 
| 2067 | 
            +
            smalltalk.HTMLCanvas.klass);
         | 
| 1153 2068 |  | 
| 1154 | 
            -
            smalltalk.addClass('Widget', smalltalk.Object, [], 'Canvas');
         | 
| 1155 2069 | 
             
            smalltalk.addMethod(
         | 
| 1156 | 
            -
            ' | 
| 2070 | 
            +
            unescape('_isOpera'),
         | 
| 1157 2071 | 
             
            smalltalk.method({
         | 
| 1158 | 
            -
            selector: ' | 
| 1159 | 
            -
            fn: function ( | 
| 2072 | 
            +
            selector: unescape('isOpera'),
         | 
| 2073 | 
            +
            fn: function (){
         | 
| 1160 2074 | 
             
            var self=this;
         | 
| 1161 | 
            -
            smalltalk.send( | 
| 2075 | 
            +
            return smalltalk.send(smalltalk.send(smalltalk.send((typeof jQuery == 'undefined' ? nil : jQuery), "_at_", [smalltalk.symbolFor("browser")]), "_at_", [smalltalk.symbolFor("opera")]), "_notNil", []);
         | 
| 1162 2076 | 
             
            return self;}
         | 
| 1163 2077 | 
             
            }),
         | 
| 1164 | 
            -
            smalltalk. | 
| 2078 | 
            +
            smalltalk.HTMLCanvas.klass);
         | 
| 1165 2079 |  | 
| 1166 2080 | 
             
            smalltalk.addMethod(
         | 
| 1167 | 
            -
            ' | 
| 2081 | 
            +
            unescape('_isMozilla'),
         | 
| 1168 2082 | 
             
            smalltalk.method({
         | 
| 1169 | 
            -
            selector: ' | 
| 1170 | 
            -
            fn: function ( | 
| 2083 | 
            +
            selector: unescape('isMozilla'),
         | 
| 2084 | 
            +
            fn: function (){
         | 
| 1171 2085 | 
             
            var self=this;
         | 
| 1172 | 
            -
            smalltalk.send( | 
| 2086 | 
            +
            return smalltalk.send(smalltalk.send(smalltalk.send((typeof jQuery == 'undefined' ? nil : jQuery), "_at_", [smalltalk.symbolFor("browser")]), "_at_", [smalltalk.symbolFor("mozilla")]), "_notNil", []);
         | 
| 1173 2087 | 
             
            return self;}
         | 
| 1174 2088 | 
             
            }),
         | 
| 1175 | 
            -
            smalltalk. | 
| 2089 | 
            +
            smalltalk.HTMLCanvas.klass);
         | 
| 1176 2090 |  | 
| 1177 2091 | 
             
            smalltalk.addMethod(
         | 
| 1178 | 
            -
            ' | 
| 2092 | 
            +
            unescape('_isWebkit'),
         | 
| 1179 2093 | 
             
            smalltalk.method({
         | 
| 1180 | 
            -
            selector: ' | 
| 1181 | 
            -
            fn: function ( | 
| 2094 | 
            +
            selector: unescape('isWebkit'),
         | 
| 2095 | 
            +
            fn: function (){
         | 
| 1182 2096 | 
             
            var self=this;
         | 
| 1183 | 
            -
             | 
| 2097 | 
            +
            return smalltalk.send(smalltalk.send(smalltalk.send((typeof jQuery == 'undefined' ? nil : jQuery), "_at_", [smalltalk.symbolFor("browser")]), "_at_", [smalltalk.symbolFor("webkit")]), "_notNil", []);
         | 
| 1184 2098 | 
             
            return self;}
         | 
| 1185 2099 | 
             
            }),
         | 
| 1186 | 
            -
            smalltalk. | 
| 1187 | 
            -
             | 
| 1188 | 
            -
             | 
| 2100 | 
            +
            smalltalk.HTMLCanvas.klass);
         | 
| 1189 2101 |  | 
| 1190 | 
            -
            smalltalk.addClass('StyleTag', smalltalk.TagBrush, ['canvas', 'element'], 'Canvas');
         | 
| 1191 2102 | 
             
            smalltalk.addMethod(
         | 
| 1192 | 
            -
            ' | 
| 2103 | 
            +
            unescape('_browserVersion'),
         | 
| 1193 2104 | 
             
            smalltalk.method({
         | 
| 1194 | 
            -
            selector: ' | 
| 1195 | 
            -
            fn: function ( | 
| 2105 | 
            +
            selector: unescape('browserVersion'),
         | 
| 2106 | 
            +
            fn: function (){
         | 
| 1196 2107 | 
             
            var self=this;
         | 
| 1197 | 
            -
             | 
| 2108 | 
            +
            return smalltalk.send(smalltalk.send((typeof jQuery == 'undefined' ? nil : jQuery), "_at_", [smalltalk.symbolFor("browser")]), "_version", []);
         | 
| 1198 2109 | 
             
            return self;}
         | 
| 1199 2110 | 
             
            }),
         | 
| 1200 | 
            -
            smalltalk. | 
| 2111 | 
            +
            smalltalk.HTMLCanvas.klass);
         | 
| 1201 2112 |  | 
| 2113 | 
            +
             | 
| 2114 | 
            +
            smalltalk.addClass('StyleTag', smalltalk.TagBrush, ['canvas', 'element'], 'Canvas');
         | 
| 1202 2115 | 
             
            smalltalk.addMethod(
         | 
| 1203 | 
            -
            ' | 
| 2116 | 
            +
            unescape('_with_'),
         | 
| 1204 2117 | 
             
            smalltalk.method({
         | 
| 1205 | 
            -
            selector: ' | 
| 1206 | 
            -
            fn: function (){
         | 
| 2118 | 
            +
            selector: unescape('with%3A'),
         | 
| 2119 | 
            +
            fn: function (aString){
         | 
| 1207 2120 | 
             
            var self=this;
         | 
| 1208 | 
            -
             | 
| 1209 | 
            -
            (ie=jQuery.browser.msie);
         | 
| 1210 | 
            -
            return smalltalk.send(ie, "_notNil", []);
         | 
| 2121 | 
            +
            ((($receiver = smalltalk.send((smalltalk.HTMLCanvas || HTMLCanvas), "_isMSIE", [])).klass === smalltalk.Boolean) ? ($receiver ? (function(){return smalltalk.send(smalltalk.send(smalltalk.send(self, "_element", []), "_styleSheet", []), "_cssText_", [aString]);})() : (function(){return smalltalk.send(self, "_with_", [aString], smalltalk.TagBrush);})()) : smalltalk.send($receiver, "_ifTrue_ifFalse_", [(function(){return smalltalk.send(smalltalk.send(smalltalk.send(self, "_element", []), "_styleSheet", []), "_cssText_", [aString]);}), (function(){return smalltalk.send(self, "_with_", [aString], smalltalk.TagBrush);})]));
         | 
| 1211 2122 | 
             
            return self;}
         | 
| 1212 2123 | 
             
            }),
         | 
| 1213 2124 | 
             
            smalltalk.StyleTag);
         | 
| 1214 2125 |  | 
| 1215 2126 |  | 
| 1216 2127 | 
             
            smalltalk.addMethod(
         | 
| 1217 | 
            -
            '_canvas_',
         | 
| 2128 | 
            +
            unescape('_canvas_'),
         | 
| 1218 2129 | 
             
            smalltalk.method({
         | 
| 1219 | 
            -
            selector: 'canvas | 
| 2130 | 
            +
            selector: unescape('canvas%3A'),
         | 
| 1220 2131 | 
             
            fn: function (aCanvas){
         | 
| 1221 2132 | 
             
            var self=this;
         | 
| 1222 2133 | 
             
            return (function($rec){smalltalk.send($rec, "_initializeFromString_canvas_", ["style", aCanvas]);return smalltalk.send($rec, "_yourself", []);})(smalltalk.send(self, "_new", []));
         | 
| @@ -1226,9 +2137,9 @@ smalltalk.StyleTag.klass); | |
| 1226 2137 |  | 
| 1227 2138 |  | 
| 1228 2139 | 
             
            smalltalk.addMethod(
         | 
| 1229 | 
            -
            '_appendToJQuery_',
         | 
| 2140 | 
            +
            unescape('_appendToJQuery_'),
         | 
| 1230 2141 | 
             
            smalltalk.method({
         | 
| 1231 | 
            -
            selector: 'appendToJQuery | 
| 2142 | 
            +
            selector: unescape('appendToJQuery%3A'),
         | 
| 1232 2143 | 
             
            fn: function (aJQuery){
         | 
| 1233 2144 | 
             
            var self=this;
         | 
| 1234 2145 | 
             
            smalltalk.send(aJQuery, "_append_", [smalltalk.send(self, "_asString", [])]);
         | 
| @@ -1237,9 +2148,9 @@ return self;} | |
| 1237 2148 | 
             
            smalltalk.Object);
         | 
| 1238 2149 |  | 
| 1239 2150 | 
             
            smalltalk.addMethod(
         | 
| 1240 | 
            -
            '_appendToBrush_',
         | 
| 2151 | 
            +
            unescape('_appendToBrush_'),
         | 
| 1241 2152 | 
             
            smalltalk.method({
         | 
| 1242 | 
            -
            selector: 'appendToBrush | 
| 2153 | 
            +
            selector: unescape('appendToBrush%3A'),
         | 
| 1243 2154 | 
             
            fn: function (aTagBrush){
         | 
| 1244 2155 | 
             
            var self=this;
         | 
| 1245 2156 | 
             
            smalltalk.send(aTagBrush, "_append_", [smalltalk.send(self, "_asString", [])]);
         | 
| @@ -1248,9 +2159,9 @@ return self;} | |
| 1248 2159 | 
             
            smalltalk.Object);
         | 
| 1249 2160 |  | 
| 1250 2161 | 
             
            smalltalk.addMethod(
         | 
| 1251 | 
            -
            '_appendToJQuery_',
         | 
| 2162 | 
            +
            unescape('_appendToJQuery_'),
         | 
| 1252 2163 | 
             
            smalltalk.method({
         | 
| 1253 | 
            -
            selector: 'appendToJQuery | 
| 2164 | 
            +
            selector: unescape('appendToJQuery%3A'),
         | 
| 1254 2165 | 
             
            fn: function (aJQuery){
         | 
| 1255 2166 | 
             
            var self=this;
         | 
| 1256 2167 | 
             
            smalltalk.send(self, "_value_", [smalltalk.send((smalltalk.HTMLCanvas || HTMLCanvas), "_onJQuery_", [aJQuery])]);
         | 
| @@ -1259,9 +2170,9 @@ return self;} | |
| 1259 2170 | 
             
            smalltalk.BlockClosure);
         | 
| 1260 2171 |  | 
| 1261 2172 | 
             
            smalltalk.addMethod(
         | 
| 1262 | 
            -
            '_appendToBrush_',
         | 
| 2173 | 
            +
            unescape('_appendToBrush_'),
         | 
| 1263 2174 | 
             
            smalltalk.method({
         | 
| 1264 | 
            -
            selector: 'appendToBrush | 
| 2175 | 
            +
            selector: unescape('appendToBrush%3A'),
         | 
| 1265 2176 | 
             
            fn: function (aTagBrush){
         | 
| 1266 2177 | 
             
            var self=this;
         | 
| 1267 2178 | 
             
            smalltalk.send(aTagBrush, "_appendBlock_", [self]);
         | 
| @@ -1270,9 +2181,9 @@ return self;} | |
| 1270 2181 | 
             
            smalltalk.BlockClosure);
         | 
| 1271 2182 |  | 
| 1272 2183 | 
             
            smalltalk.addMethod(
         | 
| 1273 | 
            -
            '_asJQuery',
         | 
| 2184 | 
            +
            unescape('_asJQuery'),
         | 
| 1274 2185 | 
             
            smalltalk.method({
         | 
| 1275 | 
            -
            selector: 'asJQuery',
         | 
| 2186 | 
            +
            selector: unescape('asJQuery'),
         | 
| 1276 2187 | 
             
            fn: function (){
         | 
| 1277 2188 | 
             
            var self=this;
         | 
| 1278 2189 | 
             
            return jQuery(String(self));
         | 
| @@ -1281,9 +2192,9 @@ return self;} | |
| 1281 2192 | 
             
            smalltalk.String);
         | 
| 1282 2193 |  | 
| 1283 2194 | 
             
            smalltalk.addMethod(
         | 
| 1284 | 
            -
            '_appendToJQuery_',
         | 
| 2195 | 
            +
            unescape('_appendToJQuery_'),
         | 
| 1285 2196 | 
             
            smalltalk.method({
         | 
| 1286 | 
            -
            selector: 'appendToJQuery | 
| 2197 | 
            +
            selector: unescape('appendToJQuery%3A'),
         | 
| 1287 2198 | 
             
            fn: function (aJQuery){
         | 
| 1288 2199 | 
             
            var self=this;
         | 
| 1289 2200 | 
             
            smalltalk.send(aJQuery, "_append_", [self]);
         | 
| @@ -1292,9 +2203,9 @@ return self;} | |
| 1292 2203 | 
             
            smalltalk.String);
         | 
| 1293 2204 |  | 
| 1294 2205 | 
             
            smalltalk.addMethod(
         | 
| 1295 | 
            -
            '_appendToBrush_',
         | 
| 2206 | 
            +
            unescape('_appendToBrush_'),
         | 
| 1296 2207 | 
             
            smalltalk.method({
         | 
| 1297 | 
            -
            selector: 'appendToBrush | 
| 2208 | 
            +
            selector: unescape('appendToBrush%3A'),
         | 
| 1298 2209 | 
             
            fn: function (aTagBrush){
         | 
| 1299 2210 | 
             
            var self=this;
         | 
| 1300 2211 | 
             
            smalltalk.send(aTagBrush, "_appendString_", [self]);
         |