define(["amber/boot", "require", "amber/core/Kernel-Collections", "amber/core/Kernel-Infrastructure", "amber/core/Kernel-Methods", "amber/core/Kernel-Objects"], function($boot,requirejs){"use strict";
var $core=$boot.api,nil=$boot.nilAsValue,$nil=$boot.nilAsReceiver,$recv=$boot.asReceiver,$globals=$boot.globals;
var $pkg = $core.addPackage("Web");
$pkg.innerEval = function (expr) { return eval(expr); };
$pkg.imports = ["amber/core/Platform-DOM", "amber/web/Web-JQuery"];
//>>excludeStart("imports", pragmas.excludeImports);
$pkg.isReady = new Promise(function (resolve, reject) { requirejs(["amber/core/Platform-DOM", "amber/web/Web-JQuery"], function () {resolve();}, reject); });
//>>excludeEnd("imports");
$pkg.transport = {"type":"amd","amdNamespace":"amber/web"};

$core.addClass("HTMLCanvas", $globals.Object, ["root"], "Web");
//>>excludeStart("ide", pragmas.excludeIdeData);
$globals.HTMLCanvas.comment="I am a canvas for building HTML.\x0a\x0aI provide the `#tag:` method to create a `TagBrush` (wrapping a DOM element) and convenience methods in the `tags` protocol.\x0a\x0a## API\x0a\x0aMy instances are used as the argument of the `#renderOn:` method of `Widget` objects.\x0a\x0aThe `#with:` method is used to compose HTML, nesting tags. `#with:` can take a `TagBrush`, a `String`, a `BlockClosure` or a `Widget` as argument.\x0a\x0a## Usage example:\x0a\x0a    aCanvas a \x0a        with: [ aCanvas span with: 'click me' ];\x0a        onClick: [ window alert: 'clicked!' ]";
//>>excludeEnd("ide");
$core.addMethod(
$core.method({
selector: "a",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("a");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"a",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "a\x0a\x09^ self tag: 'a'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "abbr",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("abbr");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"abbr",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "abbr\x0a\x09^ self tag: 'abbr'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "address",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("address");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"address",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "address\x0a\x09^ self tag: 'address'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "area",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("area");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"area",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "area\x0a\x09^ self tag: 'area'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "article",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("article");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"article",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "article\x0a\x09^ self tag: 'article'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "aside",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("aside");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"aside",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "aside\x0a\x09^ self tag: 'aside'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "audio",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("audio");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"audio",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "audio\x0a\x09^ self tag: 'audio'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "base",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("base");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"base",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "base\x0a\x09^ self tag: 'base'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "blockquote",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("blockquote");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"blockquote",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "blockquote\x0a\x09^ self tag: 'blockquote'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "body",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("body");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"body",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "body\x0a\x09^ self tag: 'body'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "br",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("br");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"br",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "br\x0a\x09^ self tag: 'br'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "button",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("button");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"button",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "button\x0a\x09^ self tag: 'button'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "canvas",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("canvas");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"canvas",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "canvas\x0a\x09^ self tag: 'canvas'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "caption",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("caption");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"caption",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "caption\x0a\x09^ self tag: 'caption'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "cite",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("cite");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"cite",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "cite\x0a\x09^ self tag: 'cite'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "code",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("code");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"code",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "code\x0a\x09^ self tag: 'code'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "col",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("col");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"col",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "col\x0a\x09^ self tag: 'col'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "colgroup",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("colgroup");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"colgroup",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "colgroup\x0a\x09^ self tag: 'colgroup'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "command",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("command");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"command",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "command\x0a\x09^ self tag: 'command'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "datalist",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("datalist");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"datalist",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "datalist\x0a\x09^ self tag: 'datalist'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "dd",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("dd");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"dd",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "dd\x0a\x09^ self tag: 'dd'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "del",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("del");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"del",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "del\x0a\x09^ self tag: 'del'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "details",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("details");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"details",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "details\x0a\x09^ self tag: 'details'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "div",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("div");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"div",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "div\x0a\x09^ self tag: 'div'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "div:",
protocol: "tags",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._div())._with_(aBlock);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"div:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "div: aBlock\x0a\x09^ self div with: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["with:", "div"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "dl",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("dl");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"dl",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "dl\x0a\x09^ self tag: 'dl'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "dt",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("dt");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"dt",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "dt\x0a\x09^ self tag: 'dt'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "em",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("em");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"em",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "em\x0a\x09^ self tag: 'em'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "embed",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("embed");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"embed",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "embed\x0a\x09^ self tag: 'embed'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "entity:",
protocol: "adding",
fn: function (aString){
var self=this,$self=this;
var result;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1,$3,$2,$4;
$1=$recv($recv($globals.TagBrush)._fromString_("span"))._asDomNode();
$3="&".__comma(aString);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx1.sendIdx[","]=2;
//>>excludeEnd("ctx");
$2=$recv($3).__comma(";");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx1.sendIdx[","]=1;
//>>excludeEnd("ctx");
$recv($1)._innerHTML_($2);
result=$recv($1)._textContent();
$4=$recv($recv(result)._size()).__eq((1));
if(!$core.assert($4)){
$self._error_("Not an HTML entity: ".__comma(aString));
}
$self._with_(result);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"entity:",{aString:aString,result:result})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "entity: aString\x0a\x09\x22Adds a character representing html entity, eg.\x0a\x09html entity: 'copy'\x0a\x09adds a copyright sign.\x0a\x09If a name does not represent valid HTML entity, error is raised.\x22\x0a\x09| result |\x0a\x09result := (TagBrush fromString: 'span') asDomNode innerHTML: '&', aString, ';'; textContent.\x0a\x09result size = 1 ifFalse: [ self error: 'Not an HTML entity: ', aString ].\x0a\x09self with: result",
referencedClasses: ["TagBrush"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["innerHTML:", "asDomNode", "fromString:", ",", "textContent", "ifFalse:", "=", "size", "error:", "with:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "fieldset",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("fieldset");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"fieldset",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "fieldset\x0a\x09^ self tag: 'fieldset'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "figcaption",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("figcaption");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"figcaption",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "figcaption\x0a\x09^ self tag: 'figcaption'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "figure",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("figure");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"figure",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "figure\x0a\x09^ self tag: 'figure'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "footer",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("footer");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"footer",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "footer\x0a\x09^ self tag: 'footer'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "form",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("form");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"form",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "form\x0a\x09^ self tag: 'form'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "h1",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("h1");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"h1",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "h1\x0a\x09^ self tag: 'h1'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "h1:",
protocol: "tags",
fn: function (anObject){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._h1())._with_(anObject);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"h1:",{anObject:anObject})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "h1: anObject\x0a\x09^ self h1 with: anObject",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["with:", "h1"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "h2",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("h2");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"h2",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "h2\x0a\x09^ self tag: 'h2'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "h2:",
protocol: "tags",
fn: function (anObject){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._h2())._with_(anObject);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"h2:",{anObject:anObject})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "h2: anObject\x0a\x09^ self h2 with: anObject",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["with:", "h2"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "h3",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("h3");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"h3",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "h3\x0a\x09^ self tag: 'h3'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "h3:",
protocol: "tags",
fn: function (anObject){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._h3())._with_(anObject);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"h3:",{anObject:anObject})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "h3: anObject\x0a\x09^ self h3 with: anObject",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["with:", "h3"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "h4",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("h4");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"h4",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "h4\x0a\x09^ self tag: 'h4'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "h4:",
protocol: "tags",
fn: function (anObject){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._h4())._with_(anObject);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"h4:",{anObject:anObject})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "h4: anObject\x0a\x09^ self h4 with: anObject",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["with:", "h4"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "h5",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("h5");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"h5",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "h5\x0a\x09^ self tag: 'h5'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "h5:",
protocol: "tags",
fn: function (anObject){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._h5())._with_(anObject);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"h5:",{anObject:anObject})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "h5: anObject\x0a\x09^ self h5 with: anObject",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["with:", "h5"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "h6",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("h6");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"h6",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "h6\x0a\x09^ self tag: 'h6'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "h6:",
protocol: "tags",
fn: function (anObject){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._h6())._with_(anObject);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"h6:",{anObject:anObject})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "h6: anObject\x0a\x09^ self h6 with: anObject",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["with:", "h6"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "head",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("head");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"head",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "head\x0a\x09^ self tag: 'head'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "header",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("header");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"header",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "header\x0a\x09^ self tag: 'header'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "hgroup",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("hgroup");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"hgroup",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "hgroup\x0a\x09^ self tag: 'hgroup'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "hr",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("hr");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"hr",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "hr\x0a\x09^ self tag: 'hr'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "html",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("html");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"html",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "html\x0a\x09^ self tag: 'html'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "iframe",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("iframe");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"iframe",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "iframe\x0a\x09^ self tag: 'iframe'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "iframe:",
protocol: "tags",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._iframe())._src_(aString);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"iframe:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "iframe: aString\x0a\x09^ self iframe src: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["src:", "iframe"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "img",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("img");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"img",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "img\x0a\x09^ self tag: 'img'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "img:",
protocol: "tags",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._img())._src_(aString);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"img:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "img: aString\x0a\x09^ self img src: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["src:", "img"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "input",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("input");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"input",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "input\x0a\x09^ self tag: 'input'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "label",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("label");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"label",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "label\x0a\x09^ self tag: 'label'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "legend",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("legend");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"legend",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "legend\x0a\x09^ self tag: 'legend'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "li",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("li");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"li",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "li\x0a\x09^ self tag: 'li'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "li:",
protocol: "tags",
fn: function (anObject){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._li())._with_(anObject);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"li:",{anObject:anObject})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "li: anObject\x0a\x09^ self li with: anObject",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["with:", "li"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "link",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("link");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"link",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "link\x0a\x09^ self tag: 'link'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "map",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("map");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"map",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "map\x0a\x09^ self tag: 'map'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "mark",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("mark");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"mark",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "mark\x0a\x09^ self tag: 'mark'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "menu",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("menu");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"menu",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "menu\x0a\x09^ self tag: 'menu'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "meta",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("meta");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"meta",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "meta\x0a\x09^ self tag: 'meta'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "nav",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("nav");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"nav",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "nav\x0a\x09^ self tag: 'nav'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "newTag:",
protocol: "tags",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($globals.TagBrush)._fromString_canvas_(aString,self);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"newTag:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "newTag: aString\x0a\x09^ TagBrush fromString: aString canvas: self",
referencedClasses: ["TagBrush"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["fromString:canvas:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "noscript",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("noscript");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"noscript",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "noscript\x0a\x09^ self tag: 'noscript'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "object",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("object");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"object",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "object\x0a\x09^ self tag: 'object'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "ol",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("ol");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"ol",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "ol\x0a\x09^ self tag: 'ol'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "ol:",
protocol: "tags",
fn: function (anObject){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._ol())._with_(anObject);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"ol:",{anObject:anObject})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "ol: anObject\x0a\x09^ self ol with: anObject",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["with:", "ol"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "optgroup",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("optgroup");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"optgroup",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "optgroup\x0a\x09^ self tag: 'optgroup'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "option",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("option");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"option",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "option\x0a\x09^ self tag: 'option'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "output",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("output");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"output",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "output\x0a\x09^ self tag: 'output'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "p",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("p");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"p",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "p\x0a\x09^ self tag: 'p'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "p:",
protocol: "tags",
fn: function (anObject){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._p())._with_(anObject);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"p:",{anObject:anObject})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "p: anObject\x0a\x09^ self p with: anObject",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["with:", "p"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "param",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("param");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"param",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "param\x0a\x09^ self tag: 'param'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "pre",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("pre");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"pre",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "pre\x0a\x09^ self tag: 'pre'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "progress",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("progress");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"progress",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "progress\x0a\x09^ self tag: 'progress'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "root",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1,$receiver;
$1=$self.root;
if(($receiver = $1) == null || $receiver.a$nil){
$self.root=$recv($globals.TagBrush)._fromString_canvas_("div",self);
return $self.root;
} else {
return $1;
}
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"root",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "root\x0a\x09^ root ifNil: [ root := TagBrush fromString: 'div' canvas: self ]",
referencedClasses: ["TagBrush"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["ifNil:", "fromString:canvas:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "root:",
protocol: "accessing",
fn: function (aTagBrush){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._deprecatedAPI();
$self.root=aTagBrush;
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"root:",{aTagBrush:aTagBrush})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aTagBrush"],
source: "root: aTagBrush\x0a\x09self deprecatedAPI.\x0a\x09root := aTagBrush",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["deprecatedAPI"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "root:do:",
protocol: "adding",
fn: function (aTagBrush,aBlock){
var self=this,$self=this;
var old;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
old=$self.root;
$self.root=aTagBrush;
$recv(aBlock)._value_(self);
$self.root=old;
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"root:do:",{aTagBrush:aTagBrush,aBlock:aBlock,old:old})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aTagBrush", "aBlock"],
source: "root: aTagBrush do: aBlock\x0a\x09| old |\x0a\x09old := root.\x0a\x09root := aTagBrush.\x0a\x09aBlock value: self.\x0a\x09root := old",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["value:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "script",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("script");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"script",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "script\x0a\x09^ self tag: 'script'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "section",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("section");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"section",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "section\x0a\x09^ self tag: 'section'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "select",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("select");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"select",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "select\x0a\x09^ self tag: 'select'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "small",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("small");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"small",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "small\x0a\x09^ self tag: 'small'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "source",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("source");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"source",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "source\x0a\x09^ self tag: 'source'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "span",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("span");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"span",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "span\x0a\x09^ self tag: 'span'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "span:",
protocol: "tags",
fn: function (anObject){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._span())._with_(anObject);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"span:",{anObject:anObject})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "span: anObject\x0a\x09^ self span with: anObject",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["with:", "span"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "strong",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("strong");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"strong",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "strong\x0a\x09^ self tag: 'strong'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "strong:",
protocol: "tags",
fn: function (anObject){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._strong())._with_(anObject);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"strong:",{anObject:anObject})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "strong: anObject\x0a\x09^ self strong with: anObject",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["with:", "strong"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "style",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("style");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"style",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "style\x0a\x09^ self tag: 'style'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "style:",
protocol: "tags",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$self._style();
$recv($1)._with_(aString);
return $recv($1)._yourself();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"style:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "style: aString\x0a\x09^ self style with: aString; yourself",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["with:", "style", "yourself"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "sub",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("sub");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"sub",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "sub\x0a\x09^ self tag: 'sub'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "summary",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("summary");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"summary",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "summary\x0a\x09^ self tag: 'summary'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "sup",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("sup");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"sup",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "sup\x0a\x09^ self tag: 'sup'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "table",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("table");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"table",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "table\x0a\x09^ self tag: 'table'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "tag:",
protocol: "tags",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._root())._addBrush_($self._newTag_(aString));
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"tag:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "tag: aString\x0a\x09^ self root addBrush: (self newTag: aString)",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["addBrush:", "root", "newTag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "tbody",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("tbody");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"tbody",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "tbody\x0a\x09^ self tag: 'tbody'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "td",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("td");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"td",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "td\x0a\x09^ self tag: 'td'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "textarea",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("textarea");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"textarea",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "textarea\x0a\x09^ self tag: 'textarea'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "tfoot",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("tfoot");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"tfoot",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "tfoot\x0a\x09^ self tag: 'tfoot'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "th",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("th");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"th",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "th\x0a\x09^ self tag: 'th'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "thead",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("thead");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"thead",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "thead\x0a\x09^ self tag: 'thead'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "time",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("time");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"time",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "time\x0a\x09^ self tag: 'time'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "title",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("title");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"title",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "title\x0a\x09^ self tag: 'title'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "tr",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("tr");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"tr",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "tr\x0a\x09^ self tag: 'tr'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "ul",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("ul");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"ul",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "ul\x0a\x09^ self tag: 'ul'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "ul:",
protocol: "tags",
fn: function (anObject){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._ul())._with_(anObject);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"ul:",{anObject:anObject})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "ul: anObject\x0a\x09^ self ul with: anObject",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["with:", "ul"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "video",
protocol: "tags",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._tag_("video");
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"video",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "video\x0a\x09^ self tag: 'video'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["tag:"]
}),
$globals.HTMLCanvas);

$core.addMethod(
$core.method({
selector: "with:",
protocol: "adding",
fn: function (anObject){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($self._root())._with_(anObject);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"with:",{anObject:anObject})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "with: anObject\x0a\x09^ self root with: anObject",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["with:", "root"]
}),
$globals.HTMLCanvas);



$core.addClass("TagBrush", $globals.Object, ["canvas", "element"], "Web");
//>>excludeStart("ide", pragmas.excludeIdeData);
$globals.TagBrush.comment="I am a brush for building a single DOM element (which I hold onto).\x0a\x0a## API\x0a\x0a1. Nesting\x0a\x0a    Use `#with:` to nest tags. `#with:` can take aString, `TagBrush` instance, a `Widget` or block closure as parameter.\x0a\x0a    Example: `aTag with: aString with: aCanvas div`\x0a\x0a2. Events\x0a\x0a    The `events` protocol contains all methods related to events.\x0a\x0a    Example: `aTag onClick: [ window alert: 'clicked' ]`\x0a\x0a3. Attributes\x0a\x0a    The `attribute` protocol contains methods for attribute manipulation.\x0a\x0a    Example: `aTag at: 'value' put: 'hello world'`\x0a\x0a4. Raw access and jQuery\x0a\x0a    The `#asDomNode` method can be used to access to JavaScript DOM element object.\x0a\x0a    Example: `aTag asDomNode cssStyle`\x0a\x0a    With 'Web-JQuery' package there is `#asJQuery` to access to the receiver converted into a jQuery object.\x0a\x0a    Example: `aTag asJQuery css: 'color' value: 'red'`";
//>>excludeEnd("ide");
$core.addMethod(
$core.method({
selector: "accesskey:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("accesskey",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"accesskey:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "accesskey: aString\x0a\x09self at: 'accesskey' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "action:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("action",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"action:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "action: aString\x0a\x09self at: 'action' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "addBrush:",
protocol: "adding",
fn: function (aTagBrush){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._appendChild_($recv(aTagBrush)._asDomNode());
return aTagBrush;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"addBrush:",{aTagBrush:aTagBrush})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aTagBrush"],
source: "addBrush: aTagBrush\x0a\x09self appendChild: aTagBrush asDomNode.\x0a\x09^ aTagBrush",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["appendChild:", "asDomNode"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "align:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("align",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"align:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "align: aString\x0a\x09self at: 'align' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "alt:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("alt",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"alt:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "alt: aString\x0a\x09self at: 'alt' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "append:",
protocol: "adding",
fn: function (anObject){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv(anObject)._appendToBrush_(self);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"append:",{anObject:anObject})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "append: anObject\x0a\x09anObject appendToBrush: self",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["appendToBrush:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "appendBlock:",
protocol: "adding",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv($self.canvas)._root_do_(self,aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"appendBlock:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "appendBlock: aBlock\x0a\x09canvas root: self do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["root:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "appendChild:",
protocol: "adding",
fn: function (anElement){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv($self.element)._appendChild_(anElement);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"appendChild:",{anElement:anElement})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anElement"],
source: "appendChild: anElement\x0a\x09element appendChild: anElement",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["appendChild:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "appendString:",
protocol: "adding",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._appendChild_($recv(aString)._asDomNode());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"appendString:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "appendString: aString\x0a\x09self appendChild: aString asDomNode",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["appendChild:", "asDomNode"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "appendToBrush:",
protocol: "adding",
fn: function (aTagBrush){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv(aTagBrush)._addBrush_(self);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"appendToBrush:",{aTagBrush:aTagBrush})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aTagBrush"],
source: "appendToBrush: aTagBrush\x0a\x09aTagBrush addBrush: self",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["addBrush:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "asDomNode",
protocol: "converting",
fn: function (){
var self=this,$self=this;
return $self.element;

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "asDomNode\x0a\x09^ element",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: []
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "at:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._at_ifAbsent_(aString,(function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
return $recv($recv($globals.Collection)._new())._errorNotFound();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
//>>excludeEnd("ctx");
}));
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"at:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "at: aString\x0a\x09^ self at: aString ifAbsent: [ Collection new errorNotFound ]",
referencedClasses: ["Collection"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:ifAbsent:", "errorNotFound", "new"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "at:ifAbsent:",
protocol: "attributes",
fn: function (aString,aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self.element.hasAttribute(aString) ? $self.element.getAttribute(aString) : aBlock._value();
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"at:ifAbsent:",{aString:aString,aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString", "aBlock"],
source: "at: aString ifAbsent: aBlock\x0a\x09<inlineJS: 'return $self.element.hasAttribute(aString) ? $self.element.getAttribute(aString) : aBlock._value()'>",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [["inlineJS:", ["return $self.element.hasAttribute(aString) ? $self.element.getAttribute(aString) : aBlock._value()"]]],
messageSends: []
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "at:put:",
protocol: "attributes",
fn: function (aString,aValue){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self.element.setAttribute(aString, aValue); return aValue;
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"at:put:",{aString:aString,aValue:aValue})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString", "aValue"],
source: "at: aString put: aValue\x0a\x09<inlineJS: '$self.element.setAttribute(aString, aValue); return aValue'>",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [["inlineJS:", ["$self.element.setAttribute(aString, aValue); return aValue"]]],
messageSends: []
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "class:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self.element.className = aString;
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"class:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "class: aString\x0a\x09<inlineJS: '$self.element.className = aString'>",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [["inlineJS:", ["$self.element.className = aString"]]],
messageSends: []
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "cols:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("cols",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"cols:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "cols: aString\x0a\x09self at: 'cols' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "contenteditable:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("contenteditable",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"contenteditable:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "contenteditable: aString\x0a\x09self at: 'contenteditable' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "contents:",
protocol: "adding",
fn: function (anObject){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._empty();
$self._append_(anObject);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"contents:",{anObject:anObject})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "contents: anObject\x0a\x09self\x0a\x09empty;\x0a\x09append: anObject",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["empty", "append:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "contextmenu:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("contextmenu",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"contextmenu:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "contextmenu: aString\x0a\x09self at: 'contextmenu' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "draggable:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("draggable",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"draggable:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "draggable: aString\x0a\x09self at: 'draggable' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "element",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return $self.element;

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "element\x0a\x09^ element",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: []
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "empty",
protocol: "adding",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");

	var element = $self.element, child;
	while (child = element.firstChild) element.removeChild(child);;
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"empty",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "empty\x0a<inlineJS: '\x0a\x09var element = $self.element, child;\x0a\x09while (child = element.firstChild) element.removeChild(child);\x0a'>",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [["inlineJS:", ["\x0a\x09var element = $self.element, child;\x0a\x09while (child = element.firstChild) element.removeChild(child);"]]],
messageSends: []
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "for:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("for",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"for:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "for: aString\x0a\x09self at: 'for' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "height:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("height",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"height:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "height: aString\x0a\x09self at: 'height' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "hidden",
protocol: "attributes",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("hidden","hidden");
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"hidden",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "hidden\x0a\x09self at: 'hidden' put: 'hidden'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "href:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("href",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"href:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "href: aString\x0a\x09self at: 'href' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "id:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("id",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"id:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "id: aString\x0a\x09self at: 'id' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "initializeFromCssSelector:canvas:",
protocol: "initialization",
fn: function (aString,aCanvas){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self.element=$recv(document)._querySelector_(aString);
$self.canvas=aCanvas;
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"initializeFromCssSelector:canvas:",{aString:aString,aCanvas:aCanvas})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString", "aCanvas"],
source: "initializeFromCssSelector: aString canvas: aCanvas\x0a\x09element := document querySelector: aString.\x0a\x09canvas := aCanvas",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["querySelector:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "initializeFromString:canvas:",
protocol: "initialization",
fn: function (aString,aCanvas){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self.element=$recv(document)._createElement_(aString);
$self.canvas=aCanvas;
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"initializeFromString:canvas:",{aString:aString,aCanvas:aCanvas})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString", "aCanvas"],
source: "initializeFromString: aString canvas: aCanvas\x0a\x09element := document createElement: aString.\x0a\x09canvas := aCanvas",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["createElement:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "media:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("media",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"media:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "media: aString\x0a\x09self at: 'media' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "method:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("method",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"method:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "method: aString\x0a\x09self at: 'method' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "name:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("name",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"name:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "name: aString\x0a\x09self at: 'name' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onBlur:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("blur",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onBlur:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onBlur: aBlock\x0a\x09self onEvent: 'blur' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onChange:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("change",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onChange:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onChange: aBlock\x0a\x09self onEvent: 'change' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onClick:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("click",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onClick:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onClick: aBlock\x0a\x09self onEvent: 'click' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onDblClick:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("dblclick",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onDblClick:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onDblClick: aBlock\x0a\x09self onEvent: 'dblclick' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onEvent:do:",
protocol: "events",
fn: function (aString,aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv($self._asDomNode())._addEventListener_block_useCapture_(aString,aBlock,false);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onEvent:do:",{aString:aString,aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString", "aBlock"],
source: "onEvent: aString do: aBlock\x0a\x09self asDomNode addEventListener: aString block: aBlock useCapture: false",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["addEventListener:block:useCapture:", "asDomNode"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onFocus:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("focus",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onFocus:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onFocus: aBlock\x0a\x09self onEvent: 'focus' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onFocusIn:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("focusin",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onFocusIn:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onFocusIn: aBlock\x0a\x09self onEvent: 'focusin' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onFocusOut:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("focusout",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onFocusOut:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onFocusOut: aBlock\x0a\x09self onEvent: 'focusout' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onKeyDown:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("keydown",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onKeyDown:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onKeyDown: aBlock\x0a\x09self onEvent: 'keydown' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onKeyPress:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("keypress",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onKeyPress:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onKeyPress: aBlock\x0a\x09self onEvent: 'keypress' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onKeyUp:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("keyup",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onKeyUp:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onKeyUp: aBlock\x0a\x09self onEvent: 'keyup' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onMouseDown:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("mousedown",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onMouseDown:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onMouseDown: aBlock\x0a\x09self onEvent: 'mousedown' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onMouseEnter:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("mouseenter",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onMouseEnter:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onMouseEnter: aBlock\x0a\x09self onEvent: 'mouseenter' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onMouseLeave:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("mouseleave",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onMouseLeave:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onMouseLeave: aBlock\x0a\x09self onEvent: 'mouseleave' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onMouseMove:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("mousemove",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onMouseMove:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onMouseMove: aBlock\x0a\x09self onEvent: 'mousemove' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onMouseOut:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("mouseout",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onMouseOut:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onMouseOut: aBlock\x0a\x09self onEvent: 'mouseout' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onMouseOver:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("mouseover",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onMouseOver:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onMouseOver: aBlock\x0a\x09self onEvent: 'mouseover' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onMouseUp:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("mouseup",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onMouseUp:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onMouseUp: aBlock\x0a\x09self onEvent: 'mouseup' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onSelect:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("select",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onSelect:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onSelect: aBlock\x0a\x09self onEvent: 'select' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onSubmit:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("submit",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onSubmit:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onSubmit: aBlock\x0a\x09self onEvent: 'submit' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "onUnload:",
protocol: "events",
fn: function (aBlock){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._onEvent_do_("unload",aBlock);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"onUnload:",{aBlock:aBlock})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aBlock"],
source: "onUnload: aBlock\x0a\x09self onEvent: 'unload' do: aBlock",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["onEvent:do:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "placeholder:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("placeholder",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"placeholder:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "placeholder: aString\x0a\x09self at: 'placeholder' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "rel:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("rel",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"rel:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "rel: aString\x0a\x09self at: 'rel' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "removeAt:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self.element.removeAttribute(aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"removeAt:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "removeAt: aString\x0a\x09<inlineJS: '$self.element.removeAttribute(aString)'>",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [["inlineJS:", ["$self.element.removeAttribute(aString)"]]],
messageSends: []
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "rows:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("rows",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"rows:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "rows: aString\x0a\x09self at: 'rows' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "src:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("src",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"src:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "src: aString\x0a\x09self at: 'src' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "style:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("style",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"style:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "style: aString\x0a\x09self at: 'style' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "tabindex:",
protocol: "attributes",
fn: function (aNumber){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("tabindex",aNumber);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"tabindex:",{aNumber:aNumber})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aNumber"],
source: "tabindex: aNumber\x0a\x09self at: 'tabindex' put: aNumber",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "target:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("target",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"target:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "target: aString\x0a\x09self at: 'target' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "title:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("title",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"title:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "title: aString\x0a\x09self at: 'title' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "type:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("type",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"type:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "type: aString\x0a\x09self at: 'type' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "valign:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("valign",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"valign:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "valign: aString\x0a\x09self at: 'valign' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "value:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("value",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"value:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "value: aString\x0a\x09self at: 'value' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "width:",
protocol: "attributes",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._at_put_("width",aString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"width:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "width: aString\x0a\x09self at: 'width' put: aString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:"]
}),
$globals.TagBrush);

$core.addMethod(
$core.method({
selector: "with:",
protocol: "adding",
fn: function (anObject){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._append_(anObject);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"with:",{anObject:anObject})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "with: anObject\x0a\x09self append: anObject",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["append:"]
}),
$globals.TagBrush);


$core.addMethod(
$core.method({
selector: "fromCssSelector:",
protocol: "instance creation",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._fromCssSelector_canvas_(aString,$recv($globals.HTMLCanvas)._new());
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"fromCssSelector:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "fromCssSelector: aString\x0a\x09^ self fromCssSelector: aString canvas: HTMLCanvas new",
referencedClasses: ["HTMLCanvas"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["fromCssSelector:canvas:", "new"]
}),
$globals.TagBrush.a$cls);

$core.addMethod(
$core.method({
selector: "fromCssSelector:canvas:",
protocol: "instance creation",
fn: function (aString,aCanvas){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$self._new();
$recv($1)._initializeFromCssSelector_canvas_(aString,aCanvas);
return $recv($1)._yourself();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"fromCssSelector:canvas:",{aString:aString,aCanvas:aCanvas})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString", "aCanvas"],
source: "fromCssSelector: aString canvas: aCanvas\x0a\x09^ self new\x0a\x09\x09initializeFromCssSelector: aString canvas: aCanvas;\x0a\x09\x09yourself",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["initializeFromCssSelector:canvas:", "new", "yourself"]
}),
$globals.TagBrush.a$cls);

$core.addMethod(
$core.method({
selector: "fromString:",
protocol: "instance creation",
fn: function (aString){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $self._fromString_canvas_(aString,$recv($globals.HTMLCanvas)._new());
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"fromString:",{aString:aString})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "fromString: aString\x0a\x09^ self fromString: aString canvas: HTMLCanvas new",
referencedClasses: ["HTMLCanvas"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["fromString:canvas:", "new"]
}),
$globals.TagBrush.a$cls);

$core.addMethod(
$core.method({
selector: "fromString:canvas:",
protocol: "instance creation",
fn: function (aString,aCanvas){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$self._new();
$recv($1)._initializeFromString_canvas_(aString,aCanvas);
return $recv($1)._yourself();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"fromString:canvas:",{aString:aString,aCanvas:aCanvas})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString", "aCanvas"],
source: "fromString: aString canvas: aCanvas\x0a\x09^ self new\x0a\x09initializeFromString: aString canvas: aCanvas;\x0a\x09yourself",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["initializeFromString:canvas:", "new", "yourself"]
}),
$globals.TagBrush.a$cls);


$core.addClass("Widget", $globals.Object, [], "Web");
//>>excludeStart("ide", pragmas.excludeIdeData);
$globals.Widget.comment="I am a presenter building HTML. Subclasses are typically reusable components.\x0a\x0a## API\x0a\x0aUse `#renderOn:` to build HTML. (See `HTMLCanvas` and `TagBrush` classes for more about building HTML).\x0a\x0aTo add a widget to the page, the convenience method `#appendToBrush:` is very useful.\x0a\x0aExemple: \x0a\x0a    Counter new appendToBrush: 'body' asBrush";
//>>excludeEnd("ide");
$core.addMethod(
$core.method({
selector: "appendToBrush:",
protocol: "adding",
fn: function (aTagBrush){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv((function(html){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
return $self._renderOn_(html);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({html:html},$ctx1,1)});
//>>excludeEnd("ctx");
}))._appendToBrush_(aTagBrush);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"appendToBrush:",{aTagBrush:aTagBrush})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aTagBrush"],
source: "appendToBrush: aTagBrush\x0a\x09[ :html | self renderOn: html ] appendToBrush: aTagBrush",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["appendToBrush:", "renderOn:"]
}),
$globals.Widget);

$core.addMethod(
$core.method({
selector: "renderOn:",
protocol: "rendering",
fn: function (html){
var self=this,$self=this;
return self;

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["html"],
source: "renderOn: html\x0a\x09self",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: []
}),
$globals.Widget);


$core.addMethod(
$core.method({
selector: "classTag",
protocol: "accessing",
fn: function (){
var self=this,$self=this;
return "widget";

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "classTag\x0a\x09\x22Returns a tag or general category for this class.\x0a\x09Typically used to help tools do some reflection.\x0a\x09Helios, for example, uses this to decide what icon the class should display.\x22\x0a\x09\x0a\x09^ 'widget'",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: []
}),
$globals.Widget.a$cls);

$core.addMethod(
$core.method({
selector: "appendToBrush:",
protocol: "*Web",
fn: function (aTagBrush){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv(aTagBrush)._at_put_($self._key(),$self._value());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"appendToBrush:",{aTagBrush:aTagBrush})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aTagBrush"],
source: "appendToBrush: aTagBrush\x0a\x09aTagBrush at: self key put: self value",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["at:put:", "key", "value"]
}),
$globals.Association);

$core.addMethod(
$core.method({
selector: "appendToBrush:",
protocol: "*Web",
fn: function (aTagBrush){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv(aTagBrush)._appendBlock_(self);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"appendToBrush:",{aTagBrush:aTagBrush})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aTagBrush"],
source: "appendToBrush: aTagBrush\x0a\x09aTagBrush appendBlock: self",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["appendBlock:"]
}),
$globals.BlockClosure);

$core.addMethod(
$core.method({
selector: "appendToBrush:",
protocol: "*Web",
fn: function (aTagBrush){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$self._do_((function(each){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
return $recv(aTagBrush)._append_(each);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)});
//>>excludeEnd("ctx");
}));
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"appendToBrush:",{aTagBrush:aTagBrush})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aTagBrush"],
source: "appendToBrush: aTagBrush\x0a\x09self do: [ :each | aTagBrush append: each ]",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["do:", "append:"]
}),
$globals.Collection);

$core.addMethod(
$core.method({
selector: "appendToBrush:",
protocol: "*Web",
fn: function (aTagBrush){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$recv($globals.PlatformDom)._isDomNode_($self.jsObject);
if($core.assert($1)){
$recv(aTagBrush)._appendChild_($self.jsObject);
} else {
$recv(aTagBrush)._append_($self._asString());
}
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"appendToBrush:",{aTagBrush:aTagBrush})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aTagBrush"],
source: "appendToBrush: aTagBrush\x0a\x09(PlatformDom isDomNode: jsObject)\x0a\x09\x09ifTrue: [ aTagBrush appendChild: jsObject ]\x0a\x09\x09ifFalse: [ aTagBrush append: self asString ]",
referencedClasses: ["PlatformDom"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["ifTrue:ifFalse:", "isDomNode:", "appendChild:", "append:", "asString"]
}),
$globals.JSObjectProxy);

$core.addMethod(
$core.method({
selector: "appendToBrush:",
protocol: "*Web",
fn: function (aTagBrush){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv(aTagBrush)._append_($self._asString());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"appendToBrush:",{aTagBrush:aTagBrush})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aTagBrush"],
source: "appendToBrush: aTagBrush\x0a\x09aTagBrush append: self asString",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["append:", "asString"]
}),
$globals.Object);

$core.addMethod(
$core.method({
selector: "appendToBrush:",
protocol: "*Web",
fn: function (aTagBrush){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv(aTagBrush)._appendString_(self);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"appendToBrush:",{aTagBrush:aTagBrush})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aTagBrush"],
source: "appendToBrush: aTagBrush\x0a\x09aTagBrush appendString: self",
referencedClasses: [],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["appendString:"]
}),
$globals.String);

$core.addMethod(
$core.method({
selector: "asBrush",
protocol: "*Web",
fn: function (){
var self=this,$self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return $recv($globals.TagBrush)._fromCssSelector_(self);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"asBrush",{})});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "asBrush\x0a\x09^ TagBrush fromCssSelector: self",
referencedClasses: ["TagBrush"],
//>>excludeEnd("ide");
pragmas: [],
messageSends: ["fromCssSelector:"]
}),
$globals.String);

});