herby
/
domite


			
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714
							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\x0aCreation API:\x0a\x0a - `Domite new` creates an insertion point at the bottom of `<body>`.\x0a - `Domite open` 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\x0aManipulation API:\x0a\x0a - `aDomite insertDomite:` and `aDomite insertString:` insert either a Domite or a text content at the insertion point.\x0a - `aDomite clearHere` deletes contents of the wrapped element.\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 seekHereStart` would move `d` to be at `[2]`,\x0a - `d seekHereEnd` would move `d` to be at `[3]`,\x0a - `d seekBeforeHere` would move `d` to be at `[4]`, and\x0a - `d seekAfterHere` would move `d` to be at `[5]`.\x0a\x0aIt is not presumed one would use `seekXxx`\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 seekAfterHere`.";
//>>excludeEnd("ide");
$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: "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: "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: "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");
self._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 removeEventListener: aString block: aBlock useCapture: false",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["removeEventListener:block:useCapture:"]
}),
$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");
self._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 addEventListener: aString block: aBlock useCapture: false",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["addEventListener:block:useCapture:"]
}),
$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: "fromElement:",
protocol: 'instance creation',
fn: function (aDomElement){
var self=this;
//>>excludeStart("ctx", pragmas.excludeDebugContexts);
return $core.withContext(function($ctx1) {
//>>excludeEnd("ctx");
var $2,$3,$1;
$2=self._new();
$recv($2)._element_(aDomElement);
$3=$recv($2)._yourself();
$1=$3;
return $1;
//>>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\x09^ self new\x0a\x09\x09element: aDomElement;\x0a\x09\x09yourself",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["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 $2,$3,$1;
$2=self._new();
$recv($2)._element_(aDomElement);
$recv($2)._referenceElement_(anotherDomElement);
$3=$recv($2)._yourself();
$1=$3;
return $1;
//>>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\x09^ self new\x0a\x09\x09element: aDomElement;\x0a\x09\x09referenceElement: anotherDomElement;\x0a\x09\x09yourself",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["element:", "new", "referenceElement:", "yourself"]
}),
$globals.Domite.klass);

$core.addMethod(
$core.method({
selector: "fromSelector:",
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,"fromSelector:",{aString:aString},$globals.Domite.klass)});
//>>excludeEnd("ctx");
},
//>>excludeStart("ide", pragmas.excludeIdeData);
args: ["aString"],
source: "fromSelector: aString\x0a\x09^ self fromElement: (document querySelector: aString)",
referencedClasses: [],
//>>excludeEnd("ide");
messageSends: ["fromElement:", "querySelector:"]
}),
$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: "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: "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);

});