herby
/
domite


			
							1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285
							define("domite/DOMite", ["amber/boot", "amber_core/Kernel-Collections"], function($boot){
var $core=$boot.api,nil=$boot.nil,$recv=$boot.asReceiver,$globals=$boot.globals;
$core.addPackage('DOMite');
$core.packages["DOMite"].innerEval = function (expr) { return eval(expr); };
$core.packages["DOMite"].transport = {"type":"amd","amdNamespace":"domite"};

$core.addClass('Domite', $globals.ProtoStream, ['element', 'reference'], 'DOMite');
//>>excludeStart("ide", pragmas.excludeIdeData);
$globals.Domite.comment="I am (hopefully thin) wrapper around the notion of \x22cursor in a page\x22.\x0aI represent a DOM node _and_ a point where\x0ato insert new content into it.\x0a\x0aSo I play both the role of a container that inserts\x0aas well as the role of an element being inserted.\x0a\x0aI inherit from `ProtoStream`.\x0a\x0aCreation API:\x0a\x0a - `Domite new` creates an insertion point at the bottom of `<body>`.\x0a - `Domite newStream` is unique way to create pieces of content. It creates an instance \x22floating in thin air\x22 (wrapper around DOM DocumentFragment) that can be filled with any contents and then inserted in a page.\x0a - `Domite fromElement: aDomElement` wraps an element and set the cursor to its end.\x0a\x0aCSS selector API:\x0a\x0a - `Domite at: aSelector` wraps an element found by `document.querySelector(aSelector)`.\x0a - `aDomite at: aSelector` wraps an element found by `element.querySelector(aSelector)`.\x0a - `Domite allAt: aSelector` return collection of wrapped results of `document.querySelectorAll(aSelector)`.\x0a - `aDomite allAt: aSelector` return collection of wrapped results of `element.querySelectorAll(aSelector)`.\x0a\x0aManipulation API:\x0a\x0a - `aDomite << obj` inserts obj at the insertion point.\x0a - `aDomite resetContents` deletes contents of the wrapped element.\x0a - `aDomite cutUpTo: anotherDomite` removes contents between the two cursors (or up to the end of the receiver) and returns it collected in a wrapped DocumentFragment (IOW, you can `anotherPlace << theResult` to move the contents in the specified range).\x0a\x0aCursor moving API:\x0a\x0aTake this sample HTML, where `[n]` are just markers, not real content:\x0a\x0a```\x0a<body>\x0a  <h1>header</h1>\x0a  [4]<p>[2]Hello[1]world[3]</p>[5]\x0a  <small>footer</small>\x0a</body>\x0a```\x0a\x0aIf `d` is a `Domite` representing `[1]`, then:\x0a\x0a - `d setToStart` would move `d` to be at `[2]`,\x0a - `d setToEnd` would move `d` to be at `[3]`,\x0a - `d setToBefore` would move `d` to be at `[4]`, and\x0a - `d setToAfter` would move `d` to be at `[5]`.\x0a\x0aIt is not presumed one would use `setToXxx`\x0ato actually move around in a single instance.\x0aIt is envisioned this API will be used mostly\x0ain combination with `copy`, like\x0a`afterMe := self copy setToAfter`.";
//>>excludeEnd("ide");
$core.addMethod(
$core.method({
selector: "=",
protocol: 'comparing',
fn: function (aDomite){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $3,$2,$5,$4,$6,$1;
$3=self._class();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx1.sendIdx["class"]=1;
//>>excludeEnd("ctx");
$2=$recv($3).__eq($recv(aDomite)._class());
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx1.sendIdx["="]=1;
//>>excludeEnd("ctx");
$1=$recv($2)._and_((function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
$5=self._element();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx2.sendIdx["element"]=1;
//>>excludeEnd("ctx");
$4=$recv($5).__eq($recv(aDomite)._element());
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx2.sendIdx["="]=2;
//>>excludeEnd("ctx");
return $recv($4)._and_((function(){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx3) {
//>>excludeEnd("ctx");
$6=self._reference();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx3.sendIdx["reference"]=1;
//>>excludeEnd("ctx");
return $recv($6).__eq($recv(aDomite)._reference());
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)});
//>>excludeEnd("ctx");
}));
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
//>>excludeEnd("ctx");
}));
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx1.sendIdx["and:"]=1;
//>>excludeEnd("ctx");
return $1;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"=",{aDomite:aDomite},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aDomite"],
source: "= aDomite\x0a\x09^ self class = aDomite class and: [\x0a\x09\x09self element = aDomite element and: [\x0a\x09\x09\x09self reference = aDomite reference ]]",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["and:", "=", "class", "element", "reference"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "allAt:",
protocol: 'accessing',
fn: function (aString){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $2,$1;
$2=self._class();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx1.sendIdx["class"]=1;
//>>excludeEnd("ctx");
$1=$recv($2)._wrap_($recv(self._class())._domListAsArray_($recv(self._element())._querySelectorAll_(aString)));
return $1;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"allAt:",{aString:aString},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "allAt: aString\x0a\x09^ self class wrap: (self class domListAsArray: (self element querySelectorAll: aString))",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["wrap:", "class", "domListAsArray:", "querySelectorAll:", "element"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "asJQuery",
protocol: 'converting',
fn: function (){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$recv(self._element())._asJQuery();
return $1;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"asJQuery",{},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "asJQuery\x0a\x09^ self element asJQuery",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["asJQuery", "element"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "at:",
protocol: 'accessing',
fn: function (aString){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$recv(self._class())._fromElement_($recv(self._element())._querySelector_(aString));
return $1;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"at:",{aString:aString},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "at: aString\x0a\x09^ self class fromElement: (self element querySelector: aString)",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["fromElement:", "class", "querySelector:", "element"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "atEnd",
protocol: 'testing',
fn: function (){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$recv(self._reference())._isNil();
return $1;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"atEnd",{},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "atEnd\x0a\x09^ self reference isNil",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["isNil", "reference"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "atStart",
protocol: 'testing',
fn: function (){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$recv(self._reference()).__eq($recv(self._element())._firstChild());
return $1;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"atStart",{},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "atStart\x0a\x09^ self reference = self element firstChild",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["=", "reference", "firstChild", "element"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "attrAt:",
protocol: 'accessing',
fn: function (aString){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1,$2;
$1=$recv(self["@element"])._hasAttribute_(aString);
if($core.assert($1)){
$2=$recv(self["@element"])._getAttribute_(aString);
return $2;
} else {
return nil;
};
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"attrAt:",{aString:aString},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "attrAt: aString\x0a\x09(element hasAttribute: aString)\x0a\x09\x09ifTrue: [ ^ element getAttribute: aString ]\x0a\x09\x09ifFalse: [ ^ nil ]",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["ifTrue:ifFalse:", "hasAttribute:", "getAttribute:"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "attrAt:put:",
protocol: 'accessing',
fn: function (aString,anotherString){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv(self["@element"])._setAttribute_to_(aString,anotherString);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"attrAt:put:",{aString:aString,anotherString:anotherString},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString", "anotherString"],
source: "attrAt: aString put: anotherString\x0a\x09element setAttribute: aString to: anotherString",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["setAttribute:to:"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "canSetToUpperLevel",
protocol: 'testing',
fn: function (){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$recv($recv(self._element())._parentNode())._notNil();
return $1;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"canSetToUpperLevel",{},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "canSetToUpperLevel\x0a\x09^ self element parentNode notNil",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["notNil", "parentNode", "element"]
}),
$globals.Domite);

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

	var result = document.createDocumentFragment(),
		start = self['@reference'],
		end = aDomite['@reference'],
		tmp;
	while (start && start != end) {
		tmp = start;
		start = start.nextSibling;
		result.appendChild(tmp);
	}
	self['@reference'] = start;
	return self._class()._fromElement_(result);;
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"cutUpTo:",{aDomite:aDomite},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aDomite"],
source: "cutUpTo: aDomite\x0a<\x0a\x09var result = document.createDocumentFragment(),\x0a\x09\x09start = self['@reference'],\x0a\x09\x09end = aDomite['@reference'],\x0a\x09\x09tmp;\x0a\x09while (start && start != end) {\x0a\x09\x09tmp = start;\x0a\x09\x09start = start.nextSibling;\x0a\x09\x09result.appendChild(tmp);\x0a\x09}\x0a\x09self['@reference'] = start;\x0a\x09return self._class()._fromElement_(result);\x0a>",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.Domite);

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

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

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

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "element: anObject\x0a\x09element := anObject",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "initialize",
protocol: 'initialization',
fn: function (){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
(
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx1.supercall = true, 
//>>excludeEnd("ctx");
$globals.Domite.superclass.fn.prototype._initialize.apply($recv(self), []));
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx1.supercall = false;
//>>excludeEnd("ctx");;
self["@element"]=$recv(document)._body();
self["@reference"]=nil._asJSON();
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"initialize",{},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "initialize\x0a\x09super initialize.\x0a\x09element := document body.\x0a\x09reference := nil asJSON",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["initialize", "body", "asJSON"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "isInvalid",
protocol: 'testing',
fn: function (){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$recv(self._element())._isNil();
return $1;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"isInvalid",{},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "isInvalid\x0a\x09^ self element isNil",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["isNil", "element"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "next",
protocol: 'reading',
fn: function (){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1,$2;
$1=self._atEnd();
if($core.assert($1)){
return nil;
} else {
var result;
result=self._peek();
result;
self._setToNext();
$2=result;
return $2;
};
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"next",{},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "next\x0a\x09self atEnd\x0a\x09\x09ifTrue: [ ^ nil ]\x0a\x09\x09ifFalse: [ | result |\x0a\x09\x09\x09result := self peek.\x0a\x09\x09\x09self setToNext.\x0a\x09\x09\x09^ result ]",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["ifTrue:ifFalse:", "atEnd", "peek", "setToNext"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "nextPut:",
protocol: 'insertion',
fn: function (anObject){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
self._nextPutString_($recv(anObject)._printString());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"nextPut:",{anObject:anObject},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "nextPut: anObject\x0a\x09self nextPutString: anObject printString",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["nextPutString:", "printString"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "nextPutDomNode:",
protocol: 'insertion',
fn: function (aDomElement){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv(self._element())._insertBefore_reference_(aDomElement,self._reference());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"nextPutDomNode:",{aDomElement:aDomElement},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aDomElement"],
source: "nextPutDomNode: aDomElement\x0a\x09self element\x0a\x09\x09insertBefore: aDomElement\x0a\x09\x09reference: self reference",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["insertBefore:reference:", "element", "reference"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "nextPutJSObject:",
protocol: 'insertion',
fn: function (aJSObject){
var self=this;
function $Domite(){return $globals.Domite||(typeof Domite=="undefined"?nil:Domite)}
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$recv($Domite())._isDomNode_(aJSObject);
if($core.assert($1)){
self._nextPutDomNode_(aJSObject);
} else {
self._nextPut_(aJSObject);
};
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"nextPutJSObject:",{aJSObject:aJSObject},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aJSObject"],
source: "nextPutJSObject: aJSObject\x0a\x09(Domite isDomNode: aJSObject)\x0a\x09\x09ifTrue: [ self nextPutDomNode: aJSObject ]\x0a\x09\x09ifFalse: [ self nextPut: aJSObject ]",
referencedClasses: ["Domite"],
//>>excludeEnd("ide");
messageSends: ["ifTrue:ifFalse:", "isDomNode:", "nextPutDomNode:", "nextPut:"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "nextPutString:",
protocol: 'insertion',
fn: function (aString){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
self._nextPutDomNode_($recv(document)._createTextNode_($recv(aString)._asString()));
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"nextPutString:",{aString:aString},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "nextPutString: aString\x0a\x09self nextPutDomNode: (\x0a\x09\x09document createTextNode: aString asString )",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["nextPutDomNode:", "createTextNode:", "asString"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "off:unbind:",
protocol: 'events',
fn: function (aString,aBlock){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv(self._element())._removeEventListener_block_useCapture_(aString,aBlock,false);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"off:unbind:",{aString:aString,aBlock:aBlock},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString", "aBlock"],
source: "off: aString unbind: aBlock\x0a\x09self element removeEventListener: aString block: aBlock useCapture: false",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["removeEventListener:block:useCapture:", "element"]
}),
$globals.Domite);

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

$core.addMethod(
$core.method({
selector: "peek",
protocol: 'reading',
fn: function (){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $2,$1,$receiver;
$2=self._reference();
if(($receiver = $2) == null || $receiver.isNil){
$1=$2;
} else {
var ref;
ref=$receiver;
$1=$recv(self._class())._fromElement_(ref);
};
return $1;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"peek",{},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "peek\x0a\x09^ self reference\x0a\x09\x09ifNotNil: [ :ref | self class fromElement: ref ]",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["ifNotNil:", "reference", "fromElement:", "class"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "prev",
protocol: 'reading',
fn: function (){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1,$2;
$1=self._atStart();
if($core.assert($1)){
return nil;
} else {
self._setToPrev();
$2=self._peek();
return $2;
};
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"prev",{},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "prev\x0a\x09self atStart\x0a\x09\x09ifTrue: [ ^ nil ]\x0a\x09\x09ifFalse: [ self setToPrev. ^ self peek ]",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["ifTrue:ifFalse:", "atStart", "setToPrev", "peek"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "propAt:",
protocol: 'accessing',
fn: function (aString){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$recv(self["@element"])._at_(aString);
return $1;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"propAt:",{aString:aString},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "propAt: aString\x0a\x09^ element at: aString",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["at:"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "propAt:put:",
protocol: 'accessing',
fn: function (aString,anObject){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$recv(self["@element"])._at_put_(aString,anObject);
return $1;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"propAt:put:",{aString:aString,anObject:anObject},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString", "anObject"],
source: "propAt: aString put: anObject\x0a\x09^ element at: aString put: anObject",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["at:put:"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "putOn:",
protocol: 'streaming',
fn: function (aStream){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
$recv(aStream)._nextPutDomNode_(self._element());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"putOn:",{aStream:aStream},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aStream"],
source: "putOn: aStream\x0a\x09aStream nextPutDomNode: self element",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["nextPutDomNode:", "element"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "reference",
protocol: 'accessing',
fn: function (){
var self=this;
var $1;
$1=self["@reference"];
return $1;

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

$core.addMethod(
$core.method({
selector: "reference:",
protocol: 'accessing',
fn: function (anObject){
var self=this;
self["@reference"]=anObject;
return self;

},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "reference: anObject\x0a\x09reference := anObject",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "reset",
protocol: 'positioning',
fn: function (){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
self._reference_($recv(self._element())._firstChild());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"reset",{},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "reset\x0a\x09self reference: self element firstChild",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["reference:", "firstChild", "element"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "resetContents",
protocol: 'deletion',
fn: function (){
var 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);
	self['@reference'] = null;;
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"resetContents",{},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "resetContents\x0a<\x0a\x09var element = self['@element'], child;\x0a\x09while (child = element.firstChild) element.removeChild(child);\x0a\x09self['@reference'] = null;\x0a>",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "setToAfter",
protocol: 'positioning',
fn: function (){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $2,$1,$3;
$2=self._element();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx1.sendIdx["element"]=1;
//>>excludeEnd("ctx");
$1=$recv($2)._nextSibling();
self._reference_($1);
$3=self._element_($recv(self._element())._parentNode());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"setToAfter",{},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "setToAfter\x0a\x09self\x0a\x09\x09reference: self element nextSibling;\x0a\x09\x09element: self element parentNode",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["reference:", "nextSibling", "element", "element:", "parentNode"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "setToBefore",
protocol: 'positioning',
fn: function (){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1,$2;
$1=self._element();
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
$ctx1.sendIdx["element"]=1;
//>>excludeEnd("ctx");
self._reference_($1);
$2=self._element_($recv(self._element())._parentNode());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"setToBefore",{},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "setToBefore\x0a\x09self\x0a\x09\x09reference: self element;\x0a\x09\x09element: self element parentNode",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["reference:", "element", "element:", "parentNode"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "setToEnd",
protocol: 'positioning',
fn: function (){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
self._reference_(nil._asJSON());
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"setToEnd",{},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "setToEnd\x0a\x09self reference: nil asJSON \x22null\x22",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["reference:", "asJSON"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "setToNext",
protocol: 'positioning',
fn: function (){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=self._atEnd();
if(!$core.assert($1)){
self._reference_($recv(self._reference())._nextSibling());
};
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"setToNext",{},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "setToNext\x0a\x09self atEnd ifFalse: [\x0a\x09\x09self reference: self reference nextSibling ]",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["ifFalse:", "atEnd", "reference:", "nextSibling", "reference"]
}),
$globals.Domite);

$core.addMethod(
$core.method({
selector: "setToPrev",
protocol: 'positioning',
fn: function (){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1,$3,$2,$receiver;
$1=self._atStart();
if(!$core.assert($1)){
$3=self._reference();
if(($receiver = $3) == null || $receiver.isNil){
$2=$recv(self._element())._lastChild();
} else {
var ref;
ref=$receiver;
$2=$recv(ref)._previousSibling();
};
self._reference_($2);
};
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"setToPrev",{},$globals.Domite)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "setToPrev\x0a\x09self atStart ifFalse: [\x0a\x09\x09self reference: (self reference\x0a\x09\x09\x09ifNil: [ self element lastChild ]\x0a\x09\x09\x09ifNotNil: [ :ref | ref previousSibling ])]",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["ifFalse:", "atStart", "reference:", "ifNil:ifNotNil:", "reference", "lastChild", "element", "previousSibling"]
}),
$globals.Domite);


$core.addMethod(
$core.method({
selector: "allAt:",
protocol: 'instance creation',
fn: function (aString){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=self._wrap_(self._domListAsArray_($recv(document)._querySelectorAll_(aString)));
return $1;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"allAt:",{aString:aString},$globals.Domite.klass)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "allAt: aString\x0a\x09^ self wrap: (self domListAsArray: (document querySelectorAll: aString))",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["wrap:", "domListAsArray:", "querySelectorAll:"]
}),
$globals.Domite.klass);

$core.addMethod(
$core.method({
selector: "at:",
protocol: 'instance creation',
fn: function (aString){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=self._fromElement_($recv(document)._querySelector_(aString));
return $1;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"at:",{aString:aString},$globals.Domite.klass)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "at: aString\x0a\x09^ self fromElement: (document querySelector: aString)",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["fromElement:", "querySelector:"]
}),
$globals.Domite.klass);

$core.addMethod(
$core.method({
selector: "domListAsArray:",
protocol: 'converting',
fn: function (aDomList){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
return Array.prototype.slice.call(aDomList);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"domListAsArray:",{aDomList:aDomList},$globals.Domite.klass)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aDomList"],
source: "domListAsArray: aDomList\x0a<return Array.prototype.slice.call(aDomList)>\x0a\x09",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.Domite.klass);

$core.addMethod(
$core.method({
selector: "fromElement:",
protocol: 'instance creation',
fn: function (aDomElement){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1,$3,$4,$2,$receiver;
if(($receiver = aDomElement) == null || $receiver.isNil){
aDomElement;
} else {
$1=self._isDomNode_(aDomElement);
if(!$core.assert($1)){
self._error_($recv(self._name()).__comma(": Need a DOM node"));
};
};
$3=self._new();
$recv($3)._element_(aDomElement);
$4=$recv($3)._yourself();
$2=$4;
return $2;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"fromElement:",{aDomElement:aDomElement},$globals.Domite.klass)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aDomElement"],
source: "fromElement: aDomElement\x0a\x09aDomElement ifNotNil: [\x0a\x09\x09(self isDomNode: aDomElement) ifFalse: [\x0a\x09\x09\x09self error: self name, ': Need a DOM node' ]].\x0a\x09^ self new\x0a\x09\x09element: aDomElement;\x0a\x09\x09yourself",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["ifNotNil:", "ifFalse:", "isDomNode:", "error:", ",", "name", "element:", "new", "yourself"]
}),
$globals.Domite.klass);

$core.addMethod(
$core.method({
selector: "fromElement:cursorBefore:",
protocol: 'instance creation',
fn: function (aDomElement,anotherDomElement){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1,$3,$4,$2,$receiver;
if(($receiver = aDomElement) == null || $receiver.isNil){
aDomElement;
} else {
$1=self._isDomNode_(aDomElement);
if(!$core.assert($1)){
self._error_($recv(self._name()).__comma(": Need a DOM node"));
};
};
$3=self._new();
$recv($3)._element_(aDomElement);
$recv($3)._referenceElement_(anotherDomElement);
$4=$recv($3)._yourself();
$2=$4;
return $2;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"fromElement:cursorBefore:",{aDomElement:aDomElement,anotherDomElement:anotherDomElement},$globals.Domite.klass)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aDomElement", "anotherDomElement"],
source: "fromElement: aDomElement cursorBefore: anotherDomElement\x0a\x09aDomElement ifNotNil: [\x0a\x09\x09(self isDomNode: aDomElement) ifFalse: [\x0a\x09\x09\x09self error: self name, ': Need a DOM node' ]].\x0a\x09^ self new\x0a\x09\x09element: aDomElement;\x0a\x09\x09referenceElement: anotherDomElement;\x0a\x09\x09yourself",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["ifNotNil:", "ifFalse:", "isDomNode:", "error:", ",", "name", "element:", "new", "referenceElement:", "yourself"]
}),
$globals.Domite.klass);

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

	return anObject.nodeType > 0 &&
		Object.prototype.toString.call(anObject) !== "[object Object]";
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"isDomNode:",{anObject:anObject},$globals.Domite.klass)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["anObject"],
source: "isDomNode: anObject\x0a<\x0a\x09return anObject.nodeType >> 0 &&\x0a\x09\x09Object.prototype.toString.call(anObject) !== \x22[object Object]\x22\x0a>",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: []
}),
$globals.Domite.klass);

$core.addMethod(
$core.method({
selector: "newElement:",
protocol: 'instance creation',
fn: function (aString){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=self._fromElement_($recv(document)._createElement_(aString));
return $1;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"newElement:",{aString:aString},$globals.Domite.klass)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "newElement: aString\x0a\x09^ self fromElement: (document createElement: aString)",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["fromElement:", "createElement:"]
}),
$globals.Domite.klass);

$core.addMethod(
$core.method({
selector: "newElement:xmlns:",
protocol: 'instance creation',
fn: function (aString,anotherString){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=self._fromElement_($recv(document)._createElementNS_tagName_(anotherString,aString));
return $1;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"newElement:xmlns:",{aString:aString,anotherString:anotherString},$globals.Domite.klass)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString", "anotherString"],
source: "newElement: aString xmlns: anotherString \x0a\x0a\x09^ self fromElement: (document createElementNS: anotherString tagName: aString)",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["fromElement:", "createElementNS:tagName:"]
}),
$globals.Domite.klass);

$core.addMethod(
$core.method({
selector: "newStream",
protocol: 'instance creation',
fn: function (){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=self._fromElement_($recv(document)._createDocumentFragment());
return $1;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"newStream",{},$globals.Domite.klass)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: [],
source: "newStream\x0a\x09^ self fromElement: document createDocumentFragment",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["fromElement:", "createDocumentFragment"]
}),
$globals.Domite.klass);

$core.addMethod(
$core.method({
selector: "wrap:",
protocol: 'converting',
fn: function (aCollection){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $1;
$1=$recv(aCollection)._collect_((function(each){
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx2) {
//>>excludeEnd("ctx");
return self._fromElement_(each);
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)});
//>>excludeEnd("ctx");
}));
return $1;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"wrap:",{aCollection:aCollection},$globals.Domite.klass)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aCollection"],
source: "wrap: aCollection\x0a\x09^ aCollection collect: [ :each | self fromElement: each ]",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["collect:", "fromElement:"]
}),
$globals.Domite.klass);

$core.addMethod(
$core.method({
selector: "nextPutDomNode:",
protocol: '*DOMite',
fn: function (aNode){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
self._nextPut_(aNode);
return self;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
}, function($ctx1) {$ctx1.fill(self,"nextPutDomNode:",{aNode:aNode},$globals.ProtoStream)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aNode"],
source: "nextPutDomNode: aNode\x0a\x09self nextPut: aNode",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["nextPut:"]
}),
$globals.ProtoStream);

});