@slyte/html-parser 2.0.0-alpha

package/src/nodeStructClass.js

@@ -0,0 +1,986 @@
+import htmlToJsObjectLyteRendered from "./htmlToJsObjectLyteRendered.js";
+const MAX_DEPTH = 512;
+let dNegateItems = {
+    '__events__':true,
+    'errorInfo':true,
+    'attr':true,
+    'node':true,
+    'text':true,
+    'attrType':true,
+    // 'parent':true,
+    // 'prev':true,
+    // 'next':true,
+    'cont':true,
+    '_parent':true,
+    'child':true
+  }
+
+// Skip keys that can pollute Object.prototype when copied via defineProperty
+let dangerousCloneKeys = {
+	'__proto__': true,
+	'constructor': true,
+	'prototype': true
+};
+
+function setNodeCompile(node, compile) {
+	if (!node || !compile) {
+		return;
+	}
+	Object.defineProperty(node, 'Compile', {
+		value: compile,
+		writable: true,
+		configurable: true,
+		enumerable: false
+	});
+}
+
+function getNodeCompile(node) {
+	if (!node || !Object.prototype.hasOwnProperty.call(node, 'Compile')) {
+		return undefined;
+	}
+	return node.Compile;
+}
+
+/**
+ * Parse HTML for public DOM-like setters (innerHTML / outerHTML).
+ * Inherits the host node's strict policy from `_opt` (same as toObject: default true).
+ */
+function resolveNodeStrict(node) {
+	return node && node._opt && node._opt.strict;
+}
+
+function parseHtmlFromSetter(hostNode, html) {
+	const tagName = hostNode.tagName;
+	return htmlToJsObjectLyteRendered.toObject(String(html == null ? "" : html), {
+		fromInternal: true,
+		enhanced: true,
+		withoutTableProcessing: true,
+		withoutTemplateConversion: true,
+		hasParentSvg: tagName == tagName.toLowerCase(),
+		fromSub: true,
+		Compile: getNodeCompile(hostNode),
+		strict: resolveNodeStrict(hostNode)
+	}).childNodes;
+}
+
+function inheritNodeOpt(fromNode, toNode) {
+	if (fromNode && toNode && fromNode._opt && Object.keys(fromNode._opt).length) {
+		toNode._opt = { ...fromNode._opt };
+	}
+}
+
+function deepCopyObject( obj )  {
+    let current, copies = [{source : obj, target : Object.create(Object.getPrototypeOf(obj))}], keys, propertyIndex, descriptor, nextSource, sourceReferences = [obj];
+    let cloneObject = copies[0].target, targetReferences = [cloneObject];
+	let referenceChecker = new WeakMap();
+    while(current = copies.shift()){
+        keys = Object.getOwnPropertyNames(current.source);
+        for(propertyIndex = 0; propertyIndex < keys.length; propertyIndex++){
+			if (dangerousCloneKeys[keys[propertyIndex]]) {
+				continue;
+			}
+            descriptor = Object.getOwnPropertyDescriptor(current.source, keys[propertyIndex]);
+            if(!descriptor.value || typeof descriptor.value != "object"){
+                Object.defineProperty(current.target, keys[propertyIndex], descriptor);
+                continue;
+            }
+			nextSource = descriptor.value;
+			descriptor.value = Array.isArray(nextSource) ? [] : Object.create(Object.getPrototypeOf(nextSource));
+			let indexOf = referenceChecker.get(nextSource);
+			if(indexOf){
+				descriptor.value = targetReferences[indexOf];
+				Object.defineProperty(current.target, keys[propertyIndex], descriptor);
+				continue;
+			}
+			sourceReferences.push(nextSource);
+			referenceChecker.set(nextSource,sourceReferences.length-1);
+			targetReferences.push(descriptor.value);
+			Object.defineProperty(current.target, keys[propertyIndex], descriptor);
+			let res = {source : nextSource, target : descriptor.value};
+			if(keys[propertyIndex] == "child"){
+				res._parent = current.source;
+			}
+			if(current._parent){
+				res.parent = current._parent;
+			}
+			if(current.parent){
+				current.source.parent = current.parent;
+			}
+			if (dNegateItems[keys[propertyIndex]] || !(current.source instanceof Node)) {
+				copies.push(res);
+			}
+		}
+    }
+    return cloneObject;
+}
+function getSelectorType(selector){
+	let index;
+	if(selector[0]=='.') { return {_attr:"class",_attrVal:selector.substring(1),single:1}; }
+	else if(selector[0]=='#') { return {_attr:"id",_attrVal:selector.substring(1),single:1}; }
+	else if((index = selector.search('\\[')) != -1){
+		let tagName;
+		if(index != 0){
+			[tagName,selector] = selector.split('[');
+			tagName = tagName.trim();
+			selector = "["+selector;
+		}
+		let res;
+		if(selector.search('=')!=-1){
+			let searchItem = selector.substring(1,selector.length-1).split("=");
+			let attr = searchItem[0];
+			let attrVal = searchItem[1].replace(/^"+|"+$/g, '');
+			attrVal = attrVal.replace(/^'+|'+$/g, '');
+			res = {_attr:attr,_attrVal:attrVal,single:1};
+		}
+		else {
+			let attr = selector.substring(1,selector.length-1);
+			res = {_attr:attr,_attrVal:null,single:2};
+		}
+		if(tagName){
+			res.tagName = tagName;
+		}
+		return res;
+	};	
+	return {tagName:selector,_attrVal:null,single:3};
+}
+function deepCopyNode(obj,hasSeenSvg){
+	if(!obj){return}
+	obj = new Node(obj);
+	if(hasSeenSvg && obj.tag == "template" && obj.cont){
+		let temp = obj.content.childNodes,ls = obj.child = [];
+		obj.child = temp;
+		delete obj.cont;
+	}
+	if(!hasSeenSvg && obj.tag == "template" && obj.child ){
+		let temp = obj.child;
+		obj.content = obj.createDocumentFragment();
+		obj.cont.child=temp;
+		delete obj.child;
+	}
+	if(obj.tag == "svg"){
+		hasSeenSvg = hasSeenSvg || true;
+	}
+	let prev;
+	if(obj.content){
+		obj.content = new Node(obj.content);
+		let ls = [];
+		for(let i in obj.content.child){
+			let ref = obj.content.child[i] = deepCopyNode(obj.content.child[i],hasSeenSvg);
+			if(prev){
+				prev.next = ref;
+			}
+			ref.parent = obj.content;
+			ref.prev = prev;
+			prev = ref;
+			ls.push(ref);
+		}
+		obj.content.child = ls;
+		
+	}
+	else if (obj.childNodes){
+		let ls = [];
+		for(let i in obj.child){
+			let ref = obj.child[i] = deepCopyNode(obj.child[i],hasSeenSvg);
+			if(prev){
+				prev.next = ref;
+			}
+			ref.parent = obj;
+			ref.prev = prev;
+			prev = ref;
+			ls.push(ref);
+		}
+		obj.child = ls;
+	}
+	return obj;
+}
+class Node{
+	_opt = {};
+    constructor(obj) {
+		this.node = obj.node;
+		(obj.hasOwnProperty("parent")) ? this.parent = obj.parent : this.parent = null;
+		(obj.hasOwnProperty("prev")) ? this.prev = obj.prev : this.prev = null;
+		(obj.hasOwnProperty("next")) ? this.next = obj.next : this.next = null;
+		if (obj.hasOwnProperty("tag")) { this.tag = obj.tag; }
+		if(obj.hasOwnProperty("text")) { this.text = obj.text; }
+		if(obj.hasOwnProperty("attr")) { this.attr = Object.assign({},obj.attr); }
+		if(obj.hasOwnProperty("child")) { this.child = obj.child; }
+		if(obj.hasOwnProperty("attrType")) { this.attrType = Object.assign({},obj.attrType) }
+		else if(obj.node == "#element"){
+			this.attrType = {};
+		}
+		{
+			const compile = getNodeCompile(obj);
+			if (compile) {
+				setNodeCompile(this, compile);
+			}
+		}
+		if(obj.check){
+			this._opt = {...obj.check};
+		}
+		if(obj.hasOwnProperty("errorInfo")){ this.errorInfo = obj.errorInfo}
+		if(obj.hasOwnProperty("cont")){this.cont = obj.content}
+    }
+	/**
+	 * @param {{}} check
+	 */
+	set setOpt(opt){
+		if(opt){
+			this._opt = {...opt};
+		}
+	}
+	refreshNode(NodeStruct = false){
+		let nodes = this.querySelectorAll("tbody",true);
+		let ds = {};
+		let value = null;
+        for(let node of nodes){
+            let parent = node.parent || node._parent
+            let index = parent.child.indexOf(node);
+            let temp = null;
+            let count = 0;
+            if (parent.tag != "table"){
+                parent.child.splice(parent.child.indexOf(node), 1);
+				let ptr = parent;
+                while(parent){
+                    if (parent.tag == "table" && temp) {
+                        let ls = []
+                        index = parent.child.indexOf(temp);
+                        if (parent.hasAttribute("haveChangesInTbody")) {
+                            value = parent.attr.haveChangesInTbody;
+                        }
+                        else {
+                            count++;
+                            parent.setAttribute("haveChangesInTbody", count.toString());
+                            value = count.toString();
+                        }
+                        if(ds[value]){
+                            ds[value].push({ node: node, index: index});
+                        }
+                        else{
+                            ds[value] = [{ node: node, index: index}]
+                        }
+						if(node.next && node.next.node == "#text"){
+							ds[value].push({ node: node.next, index: index});
+							ptr.child.splice(ptr.child.indexOf(node.next), 1);
+						}
+                        break;
+                    };
+                    temp = parent;
+                    parent = parent.parent
+                }
+            }
+        }
+		let ls = [];
+		for(let i in ds){
+			let parent = this.querySelector("[haveChangesInTbody=" + i + "]",true);
+			let key = parent.attr.haveChangesInTbody;
+			let childToAdd = []
+			let index = null
+			for(let j of ds[i]){
+				childToAdd.push(j.node);
+				index = j.index
+			}
+			let child = parent.child
+			if (index == child.length - 1) {
+				ls = child.concat(childToAdd);
+			}
+			else{
+				ls = (child.slice(0,index)).concat(childToAdd).concat(child.slice(index));
+			}
+			parent.child = []
+			for (let j = 0; j < ls.length;j++){
+				parent.appendChild(ls[j]);
+			}
+			parent.removeAttribute("haveChangesInTbody");
+		}
+		htmlToJsObjectLyteRendered.processTable(this);
+		if (NodeStruct) {
+			let list = [];
+			list.push(this);
+			while (list.length > 0) {
+				let obj = list.splice(0, 1);
+				if (obj.child) {
+					for (let child of obj.child) {
+						child = new Node(child);
+						list.push(child);
+					}
+				}
+			}
+		}
+	}
+	
+	get content(){
+		return this.cont;
+	}
+	
+	set content(docFag){
+		this.cont = docFag;
+		docFag._parent = this;
+	}
+	
+    get children(){
+		if(this.child){
+			let obj = this.child;
+			let res = [];
+			for(let i=0; i<obj.length; i++){
+				if(obj[i].node== "#element") { res.push(obj[i]) }
+			}
+			return res;
+		}
+		return [];
+	}
+	
+	//.childNodes
+	get childNodes(){
+		return this.child;
+	}
+	//.outerObj()
+	get outerObj(){
+		return (this.node!= "#document-fragment")?/*deepCopyNode(*/this/*)*/:undefined;
+	}
+
+	set outerObj(obj){
+		if(obj){
+			let tagName = this.tagName;
+			obj = obj.childNodes;
+			// let obj = htmlToJsObjectLyteRendered.toObject(html, { fromInternal:true, enhanced: true,withoutTableProcessing:true,withoutTemplateConversion:true,hasParentSvg:(tagName == tagName.toLowerCase()),fromSub:true ,Compile: this.__proto__.Compile}).childNodes;
+			if (this.node != "#document-fragment") {
+				let child = this.parent.childNodes;
+				let index = child.indexOf(this);
+				// child = [child.slice(0, index+1),...obj,child.slice(index+1)];
+				let secondHalf = child.slice(index + 1);
+				this.parent.child = child.slice(0, index);
+				for(let i of obj){
+					this.parent.appendChild(deepCopyNode(i,(tagName == tagName.toLowerCase())));
+				}
+				for(let i of secondHalf){
+					this.parent.appendChild(i);
+				}
+			}
+		}
+	}
+	//.outerHTML()
+	get outerHTML(){
+		return (this.node!= "#document-fragment")?htmlToJsObjectLyteRendered.toHtml(this):undefined;
+	}
+
+	set outerHTML(html){
+		let obj = parseHtmlFromSetter(this, html);
+		if (this.node != "#document-fragment") {
+			let child = this.parent.childNodes;
+			let index = child.indexOf(this);
+			// child = [child.slice(0, index+1),...obj,child.slice(index+1)];
+			let secondHalf = child.slice(index + 1);
+			this.parent.child = child.slice(0, index);
+			for(let i of obj){
+				this.parent.appendChild(i);
+			}
+			for(let i of secondHalf){
+				this.parent.appendChild(i);
+			}
+		}
+	}
+
+	//.innerObj()
+	get innerObj(){
+		let obj = this;
+		obj = (!obj.content) ? obj.childNodes : obj.content.childNodes;
+		return obj;
+	}
+
+	set innerObj(obj){
+		let tagName = this.tagName;
+		if (tagName == "TEMPLATE") {
+			this.content.child = [];
+			if(obj.length != undefined){
+				for(let i of obj){
+					this.content.appendChild(deepCopyNode(i,(tagName == tagName.toLowerCase())));
+				}
+			}
+			else{
+				this.content.appendChild(deepCopyNode(obj,(tagName == tagName.toLowerCase())));
+			}
+		}
+		else {
+			this.child = []
+			if(obj.length != undefined){
+				for(let i of obj){
+					this.appendChild(deepCopyNode(i,(tagName == tagName.toLowerCase())));
+				}
+			}
+			else{
+				this.appendChild(deepCopyNode(obj,(tagName == tagName.toLowerCase())));
+			}
+		}
+	}
+
+	//.innerHTML()
+	get innerHTML(){
+		let res = "";
+		let obj = this;
+		obj = (!obj.content) ? obj.childNodes : obj.content.childNodes;
+		for(let i=0; i<obj.length; i++){
+			res += htmlToJsObjectLyteRendered.toHtml(obj[i]);
+		}
+		return res;
+	}
+	
+	set innerHTML(html){
+		let tagName = this.tagName
+		let obj = parseHtmlFromSetter(this, html);
+		if (tagName == "TEMPLATE" && this.content) {
+			this.content.child = [];
+			this.content.appendChildArr(obj);
+		}
+		else {
+			this.child = []
+			this.appendChildArr(obj);
+		}
+	}
+	prepend(child,deleteInPreviousParent){
+		if (child.parent && child.parent.child && deleteInPreviousParent) {
+			child.remove();
+		}
+		if(child.node == "#document-fragment"){
+			return this.appendChildArr(child.child);
+		}
+		if (this.child && this.child.length) {
+			for(let i of this.child){
+				if(i==child){
+					i.remove();
+					break;
+				}
+			}
+			let next = this.child[0];
+			next.prev = child;
+			child.parent = this;
+			child.prev = null;
+			child.next = next;
+		}
+		else {
+			this.child = [];
+			child.parent = this;
+			child.prev = null;
+			child.next = null;
+		}
+		this.child.unshift(child);
+		if(child){
+			child.setOpt = this._opt;
+		}
+		return this;
+	}
+	//replaceChild()
+	replaceChild(newChild){
+		let oldChild=this;
+		newChild.parent=this.parent;
+		newChild.prev=this.prev;
+		newChild.next=this.next;
+		let index=this.parent.child.indexOf(this);
+		this.parent.child.splice(index,1,newChild);
+		if(this.next)
+				{ this.next.prev = newChild; }
+			if(this.prev)
+				{ this.prev.next = newChild; }
+		
+		newChild.content.appendChild(oldChild);
+			return newChild;
+	}
+	//.appendChild()
+	appendChild(child,deleteInPreviousParent){
+		if (child.parent && child.parent.child && deleteInPreviousParent) {
+			child.remove();
+		}
+		if(child.node == "#document-fragment"){
+			return this.appendChildArr(child.child);
+		}
+		if (this.child && this.child.length) {
+			for(let i of this.child){
+				if(i==child){
+					i.remove();
+					break;
+				}
+			}
+			let prev = this.child[this.child.length-1];
+			child.parent = this;
+			child.prev = prev;
+			child.next = null;
+			prev.next = child;
+		}
+		else {
+			this.child = [];
+			child.parent = this;
+			child.prev = null;
+			child.next = null;
+		}
+		this.child.push(child);
+		if(child){
+			child.setOpt = this._opt;
+		}
+		return this;
+	}
+	
+	appendChildArr(childArr){
+        for(let i=0; i<childArr.length;i++){
+          this.appendChild(childArr[i]);
+        }
+        return this;
+      }
+
+	//.hasAttribute()
+	hasAttribute(attr){
+		return (this.attr && this.attr[attr] != undefined)? true : false;
+	}
+	
+	//.hasAttributes()
+	hasAttributes(){
+		return (this.attr && Object.keys(this.attr).length > 0) ? true : false;
+	}
+	//.getAttribute()
+	getAttribute(attr){
+		return (this.attr && this.attr[attr] != undefined) ? this.attr[attr] : null;
+	}
+	
+	//.hasChildNodes()
+	hasChildNodes(){
+		return (this.childNodes && this.childNodes.length > 0) ? true : false;
+	}
+	
+	get firstChild(){
+		return (this.child[0]) ? this.child[0] : null;
+	}
+	
+	//.setAttribute()
+	setAttribute(attr,value){
+		if(!this.attr) { this.attr = {}; }
+		if(this._opt && !this._opt.fromInternal && this._opt.withoutTemplateConversion && typeof value == "string"){
+			let singleQuot = value.indexOf("'");
+			let doubleQuot = value.indexOf('"');
+			if (!this.attrType) {
+				this.attrType = { ___attrStart___: {},___nullCheck___:{} };
+			} else if (!this.attrType.___attrStart___) {
+				this.attrType.___attrStart___ = {};
+			}
+			else if(!this.attrType.___nullCheck___){
+				this.attrType.___nullCheck___ = {};
+			}
+			this.attrType.___attrStart___[attr] = singleQuot!=-1 && doubleQuot!=-1 ? undefined : singleQuot!=-1 ? '"' : doubleQuot!=-1 ? "'" : undefined;
+		}
+		if (typeof value == "string" || typeof value == "number") {
+			this.attr[attr] = value.toString();
+		}
+		else{
+			this.attr[attr] =JSON.stringify(value);
+		}
+		return;
+	}
+
+	//.tagName()
+	get tagName(){
+		if(this.tag){
+			let tag = this.tag;
+			if(tag == "svg"){
+				return tag.toLowerCase();
+			}
+			let obj = this;
+			if(!obj.replacedNode){
+				while(obj){
+					if(obj.tag == "svg" || obj.hasParentSvg) { return tag.toLowerCase(); }
+					if(obj.tag =="foreignObject"){
+						break;
+					}
+					obj = obj.parent;
+				}
+			}
+			return tag.toUpperCase();
+		}
+		return null;
+	}
+
+	//.nextSibling()
+	get nextSibling(){
+		return this.next;
+	}
+
+	//.nextElementSibling()
+	get nextElementSibling(){
+		let obj = this.next;
+		while (obj) {
+			if(obj.node == "#element") { return obj; }
+			obj = obj.next;
+		}
+		return null;
+	}
+
+	//.previousSibling()
+	get previousSibling(){
+		return this.prev;
+	}
+
+	//.previousElementSibling()
+	get previousElementSibling(){
+		let obj = this.prev;
+		while(obj){
+			if(obj.node == "#element") { return obj; }
+			obj = obj.prev;
+		}
+		return null;
+	}
+	updateNode(newNode){
+		let parent = this.parent
+		let ind = parent.child.indexOf(this);
+		newNode.prev = this.prev;
+		newNode.next = this.next;
+		newNode.parent = parent;
+		if(this.prev){
+			this.prev.next = newNode;
+		}
+		parent.child.splice(ind,1,newNode)
+	}
+	//.parentElement()
+	get parentElement(){
+		return (this.parent && this.parent.node=="#element")? this.parent : null;
+	}
+
+	//.parentNode()
+	get parentNode(){
+		return this.parent;
+	}
+
+	nodeParentHasSvg() {
+		let obj = this
+		while(obj){
+			if(this.tag == "svg") { return true; }
+			obj = obj.parent;
+		}
+		return false;
+	}
+	
+	deepCopyObject(){
+		return new Node(this);
+	}
+	//.nodeName()
+	get nodeName() {
+		let obj = this;
+		if(this.nodeType==2 || this.nodeType == 3){
+			return this.node;		
+		}
+		if(obj.node && obj.node!="#document-fragment" && obj.tagName){
+			let node = obj.tagName.toUpperCase();
+			while(obj){
+				if(obj.tag == "svg") { return node.toLowerCase(); }
+				obj = obj.parent;
+			}
+			return node.toUpperCase();
+		}
+		return null;
+	}
+
+	//.nodeType()
+	get nodeType(){
+		let check = {"#element":1,'#text':3,'#comment':8,attr:2,'#document-fragment':11};
+		return check[this.node] || ((this.ownerElement)? 2:undefined);
+	}
+
+	//.nodeValue()
+	get nodeValue(){
+		if(this.nodeType==8 || this.nodeType==3) { return this.text; }
+		if(this.nodeType==2){
+			return this.value;
+		}
+		return null;
+	}
+	
+	set nodeValue(textValue){
+		if(this.nodeType == 8 || this.nodeType == 3){
+			this.text = textValue;
+		}
+		if(this.nodeType == 2){
+			this.ownerElement.setAttribute(this.nodeName, textValue);
+		}
+	}
+	//.remove()
+	remove(){
+		let index = this.parent.child.indexOf(this);
+		if(this.prev) {
+			this.prev.next = this.next;
+		}
+		if(this.next) {
+			this.next.prev = this.prev;
+		}
+		this.parent.child.splice(index,1);
+	}
+	get firstElementSibling(){
+		for (let i = 0; i < this.child.length;i++){
+			if(this.child[i].node == "#element"){
+				return this.child[i];
+			}
+		}
+		return undefined;
+	}
+	//.removeAttribute()
+	removeAttribute(attr){
+		if (this.attr) {
+			delete this.attr[attr];
+		}
+		if(this.attr && Object.keys(this.attr).length==0) { delete this.attr; }
+	}
+	//.replaceWith()
+	replaceWith(newNode) {
+		newNode.parent = this.parent;
+		newNode.prev = this.prev;
+		newNode.next = this.next;
+		this.replacedNode = true;
+		newNode.replacedNode = true;
+		let index = this.parent.child.indexOf(this);
+		this.parent.child.splice(index,1,newNode)
+		if(this.next)
+			{ this.next.prev = newNode; }
+		if(this.prev)
+			{ this.prev.next = newNode; }
+	}
+
+	//.attributes()
+	get attributes(){
+		let attr = this.attr;
+		let res = [];
+		for(let i in attr){
+			res[i] = this.createAttribute(i);
+			res[i].value = (attr[i]) ? attr[i] : "";
+			res.push(res[i]);
+		}
+		return (this.attr)?res:[];
+	}
+
+	//.localName()
+	get localName(){
+		return this.tag?this.tag:null;
+	}
+
+	//.cloneNode()
+	cloneNode(flag){
+		let res={}
+		res = new Node((flag)?deepCopyObject(this):this);
+		
+		if(this.attr)
+			{ res.attr = Object.assign({},this.attr )};
+		if(this.parent)
+			{ res.parent = null; }
+		if(this.prev)
+			{ res.prev = null; }
+		if(this.next)
+			{ res.next = null; }
+		if(res.tagName == "TEMPLATE" && !flag){
+			res.content = this.createDocumentFragment();
+		}
+		return res;
+	}
+	
+	createAttribute(nodeName){
+		let temp = new Node({node:nodeName});
+		temp.value = "";
+		temp.name = nodeName;
+		temp.ownerElement = this
+		return temp;
+	}
+	
+	createDocumentFragment(){
+		let node = new Node({ node: "#document-fragment", child: [], cont: [] });
+		setNodeCompile(node, getNodeCompile(this));
+		inheritNodeOpt(this, node);
+		return node;
+	}
+	
+	//.createElement()
+	createElement(tag,options = {next:null,prev:null,parent:null,attr:{}}){
+
+		let node = {};
+		if (options.attr)
+			{ node = { node: "#element", tag: tag.toLowerCase(),  prev: options.prev, next: options.next, parent: options.parent, attr: options.attr }; }
+		else
+			{ node = { node: "#element", tag: tag.toLowerCase(),  prev: options.prev, next: options.next, parent: options.parent, attr: {}  }; }
+		
+		if(options.attrType){
+			node.attrType = options.attrType
+		}
+		if (options.errorInfo) { 
+			node.errorInfo = options.errorInfo;
+		}
+		node = new Node(node);
+		setNodeCompile(node, getNodeCompile(this));
+		inheritNodeOpt(this, node);
+		if(node.tag == "template"){
+			node.content = this.createDocumentFragment();
+		}else{
+			node.child = [];
+		}
+		return node;
+	}
+	//.createTextNode()
+	createTextNode(text,options = {next:null,prev:null,parent:null}){
+		let node = new Node({node:"#text",prev:options.prev,next:options.next,parent:options.parent,text:text});
+		setNodeCompile(node, getNodeCompile(this));
+		inheritNodeOpt(this, node);
+		node.attrType = options.attrType
+		if(options.lineIndex){
+            node.lineIndex = options.lineIndex;
+        }
+        if(options.colIndex){
+            node.colIndex = options.colIndex;
+        }
+		return node;
+	}
+
+	//.querySelector()
+	findItem(dontCheckTemplate,obj,attr,attrVal,single = 1,tag = undefined){
+		if (dontCheckTemplate && obj.tag == "template" && obj.tagName == "TEMPLATE") {
+			obj = obj.content.child;
+		}
+		else {
+			obj = obj.child;
+		}
+		if (!obj || (obj.attr && obj.attr.dontConsiderForDefault == "true")) { return null; }
+		let res = null;
+		for(let i=0; i<obj.length; i++){
+			if (obj[i].attr && obj[i].attr.dontConsiderForDefault == "true") { continue; }
+			if(single==1 && obj[i].attr && obj[i].attr[attr]==attrVal) 
+				{ return obj[i]; }
+			if(single==2 && obj[i].attr && this.find(obj[i].attr, attr))
+				{ return obj[i]; }
+			if(single==3 && obj[i].tag == attr)
+				{ return obj[i]; }
+			if(single==4 && obj[i].attr && obj[i].attr[attr]==attrVal && obj[i].tag == tag)
+				{ return obj[i]; }
+			else {
+				res = this.findItem(dontCheckTemplate, obj[i], attr, attrVal, single, tag);
+			}
+			if(res) { break; }
+		}
+		return res;
+	}
+
+	querySelector(selector,dontCheckTemplate=false) {
+		if(selector[0]=='.') { return this.findItem(dontCheckTemplate,this,"class",selector.substring(1)); }
+		else if(selector[0]=='#') { return this.findItem(dontCheckTemplate,this,"id",selector.substring(1)); }
+		else if(selector[0]=='['){
+			if(selector.search('=')!=-1){
+				let searchItem = selector.substring(1,selector.length-1).split("=");
+				let attr = searchItem[0];
+				let attrVal = searchItem[1].replace(/^"+|"+$/g, '');
+				attrVal = attrVal.replace(/^'+|'+$/g, '');
+				return this.findItem(dontCheckTemplate,this,attr,attrVal);
+			}
+			else {
+				let attr = selector.substring(1, selector.length - 1);
+				return this.findItem(dontCheckTemplate,this, attr, null, 2);
+			}
+		}
+		else if(selector.match(/^\w+\[.+=.+]$/gm)){
+			selector = selector.split("[");
+			let tag = selector[0];
+			selector = selector[1].split("=");
+			let attr = selector[0].replace(/^"+|"+$/g, '').replace(/^'+|'+$/g, '');
+			let attrVal = selector[1].substring(0,selector[1].length-1).replace(/^"+|"+$/g, '').replace(/^'+|'+$/g, '');
+
+			return this.findItem(dontCheckTemplate,this, attr, attrVal, 4, tag);
+        }
+		return this.findItem(dontCheckTemplate,this,selector,null,3);
+	}
+
+	find(obj, find){
+		if (obj) {
+		  for (let i in obj) {
+			if (i == find) {
+			  return true;
+			}
+		  }
+		}
+		return false;
+	}
+
+	//.querySelectorAll()
+	findAll(obj,listToCheck,dontCheckTemplate,result = [],depth = 0){
+		if (depth > MAX_DEPTH) {
+			throw new Error("Parse Error: HTML nesting depth exceeds the maximum allowed (" + MAX_DEPTH + ").");
+		}
+		obj = ((obj.tag == "template" && dontCheckTemplate && obj.tagName == "TEMPLATE") ? obj.content.child : obj.child);
+		if(!obj){ return result;}
+		for (let i=0; i<obj.length; i++){
+			for(let lsItem of listToCheck){
+				let {single,_attr,_attrVal,tagName} = lsItem;
+				let tagNameCheck = (tagName==undefined || obj[i].tag==tagName);
+				if(single == 1 && obj[i].attr && obj[i].attr[_attr] == _attrVal && tagNameCheck)
+					{ result.push(obj[i]); break; }
+				else if (single == 2 && obj[i].attr && this.find(obj[i].attr, _attr) && tagNameCheck) 
+					{ result.push(obj[i]); break; }
+				else if(single == 3 && obj[i].tag == tagName)
+					{ result.push(obj[i]); break; }
+			}
+			this.findAll(obj[i],listToCheck,dontCheckTemplate,result,depth + 1);
+		}
+		return result;
+	}
+	querySelectorAll(selector,dontCheckTemplate){
+		let multiList = [];
+		if((multiList = selector.split(',')).length>1){
+			for(let index in multiList){
+				multiList[index]  = getSelectorType(multiList[index].trim());
+			}
+			return this.findAll(this,multiList,dontCheckTemplate);
+		}
+		return this.findAll(this,[getSelectorType(selector)],dontCheckTemplate);
+	}
+
+	//Cases
+	// let defaultCase = node.querySelectorChildren("[default]")
+	// let isBreak = currentCase.querySelectorChildren("template[is=break]");
+	// let isBreak = dCaseTemplate.querySelectorChildren("template[is=break]");
+
+	querySelectorChildren(string){
+		let children = this.child;
+		if(string.startsWith("#")){
+			return;
+		}else if(string.startsWith("[")){
+			let attrString = string.slice(1,string.length-1)
+			for(let i=0; i<children.length; i++){
+				if(children[i].attr && children[i].attr.hasOwnProperty(attrString)){
+					return children[i];
+				}
+			}
+		}else if(string.indexOf("[") != -1){
+			let arr = string.split("[");
+			let tagName = arr[0];
+			let attrString = arr[1].slice(0,arr[1].length-1);
+			let attrStringArr = attrString.split("=");
+			let attrName = attrStringArr[0];
+			let attrVal = attrStringArr[1];
+			for(let i=0; i<children.length; i++){
+				if(children[i].tag && children[i].tag == tagName){
+					if(children[i].attr[attrName] && children[i].attr[attrName] == attrVal){
+						return children[i];
+					}
+				}
+			}
+		}
+	}
+
+	// Cases
+	// let cases = node.querySelectorAllChildren("[case]")
+	querySelectorAllChildren(string){
+		let children = this.child,
+			output = [];
+		if(string.startsWith("#")){
+			return output;
+		}else if(string.startsWith("[")){
+			let attrString = string.slice(1,string.length-1)
+			for(let i=0; i<children.length; i++){
+				if(children[i].attr && children[i].attr[attrString]){
+					output.push(children[i])
+				}
+			}
+		}
+		return output;
+	}
+	json2html(obj) { return htmlToJsObjectLyteRendered.toHtml(obj) }
+}
+
+export { setNodeCompile, getNodeCompile };
+export default Node;