als-document 0.12.0 → 1.0.0-beta

package/document.js

@@ -1,590 +1,42 @@
-class Document {
-   static singlTags = ['comment','area','base','br','col','command','embed','hr','img','input','keygen','link','meta','param','source','track','wbr']
-   constructor(htmlText) {
-      if(typeof htmlText !== 'string') return
-      this.types = {}
-      this.domTree = []
-      this.added = []
-      this.domList = []
-      this.comments = []
-      this.scripts = {}
-      this.events = {}
-      this.htmlText = htmlText
-      this.doctype = ''
-      this.getDoctype()
-      this.removeComments()
-      this.removeScripts()
-      this.removeEvents()
-      this.parseTags()
-      this.addScripts()
-      this.addEvents()
-      this.addComments()
-      this.getPairs()
-   }
-// Get domList
-   getDoctype() {
-      let doctype = this.htmlText.match(/\<\!DOCTYPE([\S\s]*?)\>/gm,'')
-      if(doctype !== null) {
-         this.doctype = doctype[0]
-         this.htmlText = this.htmlText.replace(/\<\!DOCTYPE([\S\s]*?)\>/gm,'')
-      }
-   }
-
-   removeComments() {
-      let comments = this.htmlText.match(/\<\!\-\-([\S\s]*?)\-\-\>/gm,'')
-      if(comments !== null) comments.forEach((comment,i) => {
-         let commentTag = `<comment comment-id="${i}">`
-         this.comments.push(comment)
-         this.htmlText = this.htmlText.replace(comment,commentTag)
-      });
-   }
-
-   addComments() {
-      this.domList.forEach((element,i) => {
-         if(element.tagName == 'comment') {
-            let id = this.domList[i].attributes['comment-id']
-            let comment = this.comments[id]
-            if(comment !== undefined) {
-               this.domList[i].comment = comment
-               delete this.comments[i]
-            }
-         }
-      });
-   }
-
-   removeScripts() {
-      let scripts = this.htmlText.match(/\<script(.*?)\>[\S\s]*?\<\/script\>/gm)
-      if(scripts !== null) scripts.forEach((script,i) => {
-         let scriptContent = script.replace(/\<script(.*?)\>/,'').replace('</script>','')
-         if(scriptContent.trim() !== '') {
-            let scriptName = `{script${i}}`
-            let newScript = script.replace(scriptContent,scriptName)
-            this.scripts[scriptName] = scriptContent
-            this.htmlText = this.htmlText.replace(script,newScript)
-         }
-      });
-   }
-
-   removeEvents() {
-      let events = ['abort','afterprint','animationend','animationiteration','animationstart','beforeprint','beforeunload','blur','canplay','canplaythrough','change','click','contextmenu','copy','cut','dblclick','drag','dragend','dragenter','dragleave','dragover','dragstart','drop','durationchange','ended','error','focus','focusin','focusout','fullscreenchange','fullscreenerror','hashchange','input','invalid','keydown','keypress','keyup','load','loadeddata','loadedmetadata','loadstart','message','mousedown','mouseenter','mouseleave','mousemove','mouseover','mouseout','mouseup','mousewheel','offline','online','open','pagehide','pageshow','paste','pause','play','playing','popstate','progress','ratechange','resize','reset','scroll','search','seeked','seeking','select','show','stalled','storage','submit','suspend','timeupdate','toggle','touchcancel','touchend','touchmove','touchstart','transitionend','unload','volumechange','waiting','wheel']
-      events.forEach(event => {
-         let r = new RegExp(`on${event}\\s?\\=\\s?"[\\S\\s]*?\\"`,'g')
-         let scripts = this.htmlText.match(r)
-         if(scripts !== null) scripts.forEach((script,i) => {
-            let scriptContent = script.replace(`on${event}`,'').replace('=','').replace(/\"/g,'')
-            if(scriptContent.trim() !== '') {
-               let index = Object.keys(this.events).length
-               let scriptName = `{event${index}}`
-               let newScript = script.replace(scriptContent,scriptName)
-               this.events[scriptName] = scriptContent
-               this.htmlText = this.htmlText.replace(script,newScript)
-            }
-         });
-      });
-   }
-
-   addScripts() {
-      this.domList.forEach((element,i) => {
-         if(element.tagName == 'script' && !element.close) {
-            let text = this.domList[i+1].text
-            if(this.scripts[text] !== undefined) {
-               this.domList[i+1].text = this.scripts[text]
-               delete this.scripts[text]
-            }
-         }
-      });
-   }
-
-   addEvents() {
-      this.domList.forEach((element,i) => {
-         if(element.attributes !== undefined) {
-            for(let attName in element.attributes) {
-               let attValue = element.attributes[attName]
-               if(this.events[attValue] !== undefined) {
-                  if(this.domList[i].attributes[attName] == attValue) {
-                     this.domList[i].attributes[attName] = this.events[attValue]
-                     delete this.events[attValue]
-                  }
-               }
-            }
-         }
-      });
-   }
-
-   parseTags() {
-      let outerHTML = this.htmlText
-      let outerHtmlForCut = outerHTML
-      let tags = outerHTML.match(/\<(\w*-?)*?(.*?)?([\S\s]*?)\>/gm)
-      let index = 0
-      if(tags !== null) tags.forEach((tag,i) => {
-         let node = outerHtmlForCut.split(tag)[0]
-         if(node.trim() !== '') {
-            this.domList.push({text:node,index})
-            index++
-         }
-         let obj = this.buildElementObj(tag)
-         let objName = obj.tagName+obj.order
-         obj.index = index
-         if(obj.order.length == 0) { // single tag
-            this.domList.push(obj)
-         } else this.domList.push({[objName]:obj,name:objName,index})
-         if(obj.close) {
-            let j = this.findOpen(objName)
-            if(j >=0) {
-               let closeTag = index
-               let openTagObj = this.domList[j][this.domList[j].name]
-               this.domList[j] = {...openTagObj,closeTag}
-            }
-            this.domList[obj.index] = obj
-         }
-         outerHtmlForCut = outerHtmlForCut.replace(node+tag,'')
-         index++
-      });
-   }
-// Build element
-   buildElementObj(string,obj={}) {
-      let singlTags = Document.singlTags
-      if(string.match(/\<\/(\w*-?)*/) !== null) obj.close = true
-      else obj.close = false
-      obj.tagName = string.match(/\<\/?(\w*-?)*/,'gm')[0].replace(/\<\/?/,'')
-      if(!singlTags.includes(obj.tagName)) {
-         obj.tagName = obj.tagName.replace('/','')
-         let tagName = obj.tagName
-         this.getType(tagName,obj)
-         obj.order = this.types[tagName].count
-      } else obj.order = ''
-      obj.attributes = this.getAttributes(string)
-      obj.getAttribute = (attName) => obj.attributes[attName]
-      obj.setAttribute = (attName,attValue) => {obj.attributes[attName] = attValue}
-      obj = this.buildClass(obj)
-      if(obj.attributes.id !== undefined) {
-         obj.id = obj.attributes.id
-         delete obj.attributes.id
-      }
-      return obj
-   }
-
-   getType(tagName,obj) {
-      if(this.types[tagName] == undefined) 
-         this.types[tagName] = {count:0,lastOperation:1}
-      else if(obj.close && this.types[tagName].lastOperation == 1) 
-         this.types[tagName].lastOperation = 0
-      else if(obj.close && this.types[tagName].lastOperation == 0) 
-         this.types[tagName].count--
-      else if(!obj.close && this.types[tagName].lastOperation == 0) 
-         this.types[tagName].lastOperation = 1
-      else if(!obj.close && this.types[tagName].lastOperation == 1) 
-         this.types[tagName].count++
-   }
-
-   getAttributes(string,attributes = {}) {
-      let matches = string.match(/\s(\/?\w*\-?)*((\S)*?\s?=[\S\s]*?\"[\S\s]*?\")?/g)
-      if(matches !== null) matches.forEach(attribute => {
-            attribute = attribute.trim()
-            if(attribute !== '') {
-               let attName = attribute.split('=')[0]
-               let attValue = attribute.replace(attName,'').replace('=','').replace(/\"/g,'')
-               if(attName !== '/') attributes[attName] = attValue.trim()
-            }
-         })
-      return attributes
-   }
-
-   buildClass(obj) {
-      if(obj.attributes.class !== undefined) {
-         obj.classList = obj.attributes.class.split(' ')
-      } else obj.classList = []
-      obj.classList.add = newClass => {
-         obj.classList.push(newClass)
-         obj.attributes.class += ' '+newClass
-         return obj
-      }
-      obj.classList.remove = clas => {
-         let index = obj.classList.indexOf(clas)
-         if(index >=0) {
-            obj.attributes.class = obj.attributes.class.replace(obj.classList[index],'')
-            obj.classList.splice(index,1)
-         }
-         return obj
-      }
-      return obj
-   }
-// Build dom tree   
-   getPairs(start=0,end=this.domList.length,domTree=this.domTree) {
-      for(let index=start; index<end; index++) {
-         let node = this.domList[index]
-         if(node.closeTag !== undefined && !this.added.includes(index)) { 
-            if(this.firstTag == undefined) this.firstTag = index
-            this.buildTag(index,domTree)
-            break;
-         } 
-      }
-   }
-
-   buildTag(openIndex,domTree,parent=this.domTree) {
-      this.added.push(openIndex)
-      let content = this.domList[openIndex]
-      content.children = []
-      content.innerText = ''
-      this.getChildNodes(openIndex,content.closeTag,content)
-      content.$ = (selector) => this.$(selector,content)
-      content.$$ = (selector) => this.$$(selector,content)
-      content.parent = parent
-      content = Document.buildMethods(content)
-      this.buildOperations(content)
-      if(content.innerText !== '') {
-         if(parent.innerText == undefined) parent.innerText = ''
-         parent.innerText += '|'+content.innerText
-      }
-      content.json = () => Document.removeMethods(content)
-      delete content.closeTag
-      delete content.close
-      delete content.index
-      delete content.order
-      domTree.push(content)
-   }
-
-   static buildMethods(content) {
-      content.children.forEach((child,index) => { // prev and next
-         if(index == 0) child.prev = null
-         else child.prev = content.children[index-1]
-         if(index == content.children.length-1) child.next = null
-         else child.next = content.children[index+1]
-      });
-      return content
-   }
-   
-   static changeByIndex(array,value,item,before = true) {
-      let index = array.indexOf(value);
-      if(index > -1) {
-         if(item == undefined) array.splice(index, 1); // remove value
-         else if(item !== undefined) {
-            if(before) array.splice(index, 0, item);  // add item before value
-            else array.splice(index+1, 0, item);  // add item after value
-         }
-      }
-   }
-
-   static buildInnerText(element) {
-      element.innerText = ''
-      if(element.children !== undefined) element.children.forEach(child => {
-         if(child.text !== undefined && child.text !== '') element.innerText += child.text
-         if(child.innerText !== undefined && child.innerText !== '') element.innerText += '|'+child.innerText
-      });
-   }
-
-   buildOperations(content) {
-      content.remove = function() {
-         Document.changeByIndex(content.parent.children,content)
-         Document.buildInnerText(content.parent)
-      }
-      content.add = function(element,place) {
-         if(typeof element == 'string') element = Document.newElement(element)
-         else element.remove()
-         if(place == 1) content.children.unshift(element)
-         if(place == 2) content.children.push(element)
-         if(place == 1 || place == 2) build(content)
-         
-         if(place == 0) Document.changeByIndex(content.parent.children,content,element,true)
-         if(place == 3) Document.changeByIndex(content.parent.children,content,element,false)
-         if(place == 0 || place == 3) build(content.parent)
-         
-         function build(parent) {
-            element.parent = parent
-            element = Document.buildMethods(parent)
-            Document.buildInnerText(parent)
-         }
-         return element
-      }
-      content.add0 = element => content.add(element,0)
-      content.add1 = element => content.add(element,1)
-      content.add2 = element => content.add(element,2)
-      content.add3 = element => content.add(element,3)
-   }
- 
-   static newElement(outerHtml) {
-      let document = new Document(outerHtml)
-      return document.domTree[0].json()
-   }
-
-   build(filePath,array=this.domTree,html = '',space='') {
-      let extraSpace = space+'    '
-      let nl = `
-`
-      array.forEach(element => {
-         if(element.text !== undefined) html += space+element.text+nl
-         else if(element.tagName == 'comment' ) {
-            html += space+element.comment + nl
-         } else {
-            let attributes = ''
-            for(let propName in element.attributes) {
-               let value = element.attributes[propName]
-               let attribute = ` ${propName}="${value}"`
-               if(attribute.length + attributes.length > 80) attribute = nl+space+attribute
-               attributes += attribute
-            }
-            let id = ''
-            if(element.id !== undefined) id = ` id="${element.id}"`
-            html += `${space}<${element.tagName}${id}${attributes}>${nl}`
-            if(element.children !== undefined)
-               if(element.children.length >0) html = this.build(filePath,element.children,html,extraSpace)
-            if(element.tagName !== undefined && !Document.singlTags.includes(element.tagName)) 
-               html += `${space}</${element.tagName}>${nl}`
-         }
-      });
-      if(array == this.domTree) {
-         html = this.doctype+nl+html
-         if(filePath !== undefined) Document.writeFile(filePath,html)
-      } 
-      return html
-   }
-
-   getChildNodes(openIndex,closeIndex,content) {
-      for(let i = openIndex+1; i<closeIndex; i++) {
-         let node = this.domList[i]
-         if(!this.added.includes(i)) {
-            if(!node.close && node.text == undefined) this.buildTag(node.index,content.children,content)
-            else if(!node.close && node.text !== undefined) {
-               content.innerText += node.text
-               content.children.push(node);
-               delete node.index
-            }
-            this.added.push(i)
-         }
-      }
-   }
- 
-   findOpen(key,array=this.domList) {
-      return array.findIndex(function(obj, index) {
-         if(obj[key] !== undefined && obj[key].close == false && obj[key].closeTag == undefined)
-            return true;
-      });
-   }
-// querySelector
-   $(selector,obj) {return this.$$(selector,obj,true)}
-
-   $$(selector='',obj=this.domTree[0],first=false) {
-      if(typeof selector !== 'string') return
-      this.selector = selector
-      this.selectors = []
-      this.getSelectors(selector)
-      let array = this.findElements(obj)
-      if(first) return array[0]
-      else return this.buildCollection(array)
-   }
-
-   getSelectors() {
-      this.getPropSelctors() // remove all attributes from selector, build them, replace as [i] and put into selectors.attributes[]
-      let groups = this.selector.split(',')
-      groups.forEach(group => {
-         let result = {}
-         group = group.trim()
-         let family = group.split('>')
-         let prevBrother = group.split('+')
-         let nextBrother = group.split('~')
-         if(family.length > 1) {
-            result.parent = this.buildSingleSelector(family[0])
-            result.element = this.buildSingleSelector(family[1])
-         } else if(prevBrother.length > 1) {
-            result.prev = this.buildSingleSelector(prevBrother[0])
-            result.element = this.buildSingleSelector(prevBrother[1])
-         } else if(nextBrother.length > 1) {
-            result.next = this.buildSingleSelector(nextBrother[0])
-            result.element = this.buildSingleSelector(nextBrother[1])
-         } else result.element = this.buildSingleSelector(group)
-         this.selectors.push(result)
-      });
-   }
-
-   getPropSelctors() {
-      let signs = ['~','|','^','$','*']
-      let props = this.selector.match(/\[.*\]/g)
-      this.attributes = []
-      if(props !== null) props.forEach((prop,i) => {
-         this.selector = this.selector.replace(prop,`[${i}]`)
-         let attribute = prop.replace('[','').replace(']','')
-         let array = attribute.split('=')
-         let propName = array[0]
-         let propValue = (array[1] == undefined) ? '' : array[1].replace(/"/g,'')
-         let sign
-         if(signs.includes(propName.slice(-1))) {
-            sign = propName.slice(-1)
-            propName = propName.slice(0, -1)
-         }
-         this.attributes.push({propName,propValue,sign})
-      });
-   }
-
-   buildSingleSelector(selector,result={}) {
-      selector = selector.trim()
-      let props = selector.match(/\[.*\]/g)
-      if(props !== null) props.forEach(prop => {
-         selector = selector.replace(prop,'')
-         let index = prop.replace('[','').replace(']','')
-         result.attributes = this.attributes[index]
-      });
-      let id = selector.match(/#(\w*-?)*/)
-      if(id !== null) {
-         result.id = id[0].replace('#','')
-         selector = selector.replace(id[0],'')
-      }
-      let classes = selector.match(/\.(\w*-?)*/g)
-      if(classes !== null) {
-         result.classes = []
-         classes.forEach(clas => {
-            result.classes.push(clas.replace('.',''))
-            selector = selector.replace(clas,'')
-         });
-      }
-      let tag = selector.match(/(\w*-?)*/)
-      if(tag !== null) {
-         if(tag[0] !== '') {
-            result.tag = tag[0]
-            selector = selector.replace(tag[0],'')
-         }
-      }
-      return result
-   }
-
-   findElements(obj,array = []) {
-      array = this.checkSelectors(obj,array)
-      if(obj.children !== undefined) {
-         obj.children.forEach(element => {
-            this.findElements(element,array)
-         });
-      }
-      return array
-   }
-
-   checkSelectors(element,array) {
-      this.selectors.forEach(group => {
-         let addIt = 0
-         if(group.parent !== undefined) addIt += this.checkElement(element.parent,group.parent)
-         if(group.prev !== undefined) addIt += this.checkElement(element.prev,group.prev)
-         if(group.next !== undefined) addIt += this.checkElement(element.next,group.next)
-         if(group.element !== undefined) addIt += this.checkElement(element,group.element)
-         if(addIt == 0) array.push(element)
-      });
-      return array
-   }
-
-   checkElement(element,selectors,addIt = 0) {
-      if(element == undefined) return -1
-      if(selectors.tag !== undefined)
-         if(element.tagName !== selectors.tag) addIt--
-      if(selectors.id !== undefined)
-         if(element.id !== selectors.id) addIt--
-      if(selectors.classes !== undefined ) {
-         if(element.classList !== undefined) selectors.classes.forEach(clas => {
-            if(!element.classList.includes(clas)) addIt--
-         });
-         else addIt--
-      }
-      if(selectors.attributes !== undefined) addIt += this.checkAttributes(
-         element.attributes,
-         selectors.attributes.propName,
-         selectors.attributes.propValue,
-         selectors.attributes.sign
-      )
-      return addIt
-   }
-
-   checkAttributes(props,propName,propValue,sign,addIt = 0) {
-      if(props == undefined) return -1
-      else {
-         if(props[propName] == undefined) addIt--
-         if(propValue == '' && props[propName] == undefined) addIt--
-         if(propValue.length>0 && props[propName] !== undefined) {
-            if(sign == undefined) {
-               if(props[propName] !== propValue) addIt--
-            } else if(sign == '~') { 
-               let r = new RegExp(`\\b${propValue}`)
-               if(props[propName].match(r) == null) addIt--
-            } else if(sign == '|') {
-               if(!props[propName].startsWith(propValue) || props[propName] !== propValue) addIt--
-            } else if(sign == '^') {
-               if(!props[propName].startsWith(propValue)) addIt--
-            } else if(sign == '$') {
-               if(!props[propName].endsWith(propValue)) addIt--
-            } else if(sign == '*') {
-               if(!props[propName].includes(propValue)) addIt--
-            }
-         }
-      }
-      return addIt
-   }
-
-// Collection array
-   buildCollection(collection) {
-      collection.each = function(fn) {return Document.each(this,fn)}
-      collection.parse = function(part,fn) {return Document.parse(this,part,fn)}
-      return collection
-   }
-
-   static each(collection,fn) {
-      for(let i = 0; i<collection.length; i++) {
-         fn(collection[i],i,collection)
-      }
-      return collection
-   }
-
-   static parse(collection,part,fn,array=[]) {
-      if(part !== undefined) {
-         collection.each((element,index,collection) => {
-            let content
-            if(element[part] !== undefined) content = element[part]
-            else if(element.attributes !== undefined)
-               if(element.attributes[part] !== undefined) 
-                  content = element.attributes[part]
-            
-            if(content !== undefined) {
-               if(typeof content == 'string')
-                  content = content.replace(/&nbsp;/g,' ')
-               if(fn !== undefined) {
-                  if(fn(content)) array.push(content)
-               } else array.push(content)
-            } 
-         })
-      } else {
-         collection.forEach(element => {
-            array.push(Document.removeMethods(element))
-         });
-      }
-      return array
-   }
-
-   static removeMethods(element) {
-      element = {...element}
-      let deleteThis = ['parent','next','prev','classList','json','$','$$','remove','add','add0','add1','add2','add3','getAttribute','setAttribute']
-      deleteThis.forEach(item => {
-         delete element[item]
-      });
-      if(element.children !== undefined) element.children.forEach((child,i) => {
-         element.children[i] = Document.removeMethods(child)
-      });
-      return element
-   }
-
-   static writeFile(path,obj,encoding = 'utf-8') {
-      let {writeFileSync} = require('fs')
-      path = Document.path(path)
-      if(typeof obj !== 'string') try {
-         obj = JSON.stringify(obj,null,4)
-         writeFileSync(path,obj,encoding)
-      } catch(e) {console.log(e)}
-      else writeFileSync(path,obj,encoding)
-   }
-
-   static readFile(path,encoding = 'utf-8') {
-      path = Document.path(path)
-      let {readFileSync} = require('fs')
-      return readFileSync(path,encoding)
-   }
-
-   static path(path) {
-      let {join} = require('path')
-      if(Array.isArray(path)) return join(...path)
-      else return path
-   }
+const alsDocument = (function(){
+class Query{
   static get(query){
      let q=new Query(query)
      return q.selectors
   }
    constructor(query){
      this.query=query
      this.selectors=[]
      this.stringValues=[];
      this.parseSelectors(query.split(','))
   }
    parseSelectors(selectors){
      selectors.forEach(selector=>{
         let originalSelector=selector.trim()
         selector=this.removeSpaces(selector)
         this.stringValues=[]
         selector=selector.replace(/\[.*?\]/g,(value)=>{
            this.stringValues.push(value)
            return `[${this.stringValues.length-1}]`
         })
         let [element,ancestors]=this.splitAndCutLast(selector,' ')
         element=this.getFamily(element)
         if (ancestors.length>0)
            element.ancestors=ancestors.map(ancestor=>this.getFamily(ancestor))
         element.group=originalSelector
         this.selectors.push(element)
      });
   }
    splitAndCutLast(string,splitBy){
      const array=string.split(splitBy);
      const last=array.pop();
      return [last,array];
   }
    getFamily(group,element,prev,prevAny,sign){
      if (group.match(/\~|\+/)!==null){
         let [last,prevBrothers]=this.splitAndCutLast(group,/\~|\+/)
         let signs=group.replace(last,'')
         prevBrothers.forEach(el=>signs=signs.replace(el,''))
         signs=signs.match(/\~|\+/g)
         if (signs.length==1){
            sign=signs[0]
         } else if (signs.length>1){
            sign=signs.splice(signs.length-1,signs.length-1)[0]
            prevBrothers[0]=prevBrothers.map((b,i)=>{
               if (i< prevBrothers.length-1) b+=signs[i]
               return b
            }).join('')
            prevBrothers[0]=this.getFamily(prevBrothers[0])
         }
         if (sign=='~') prevAny=prevBrothers[0]
         else if (sign=='+') prev=prevBrothers[0]
         element=last
      } else element=group
      let family
      if (prev || prevAny){
         family=this.getParents(element)
         if (prev) family.prev=this.getParents(prev)
         if (prevAny) family.prevAny=this.getParents(prevAny)
      } else family=this.getParents(element)
      if (family.query!==group) family.group=group
      return family
   }
    getParents(selector){
      if (typeof selector=='string'){
         let [element,parents]=this.splitAndCutLast(selector,'>')
         element=this.buildElement(element)
         parents=parents.map(parent=>this.buildElement(parent))
         if (parents.length>0) element.parents=parents
         return element
      } else return selector
   }
    buildElement(element,id=null,tag=null,classList=[]){
      let query=element
      element=element.replace(/\#(\w-?)*/,$id=>{
         id=$id.replace(/^\#/,''); return ''
      })
      element=element.replace(/\.(\w-?)*/,$class=>{
         classList.push($class.replace(/^\./,'')); return ''
      })
      element=element.replace(/(\w\:?-?)*/,$tag=>{
         tag=$tag=='' ? null : $tag; return ''
      })
      let attribs=this.getAttributes(element)
      element={ query }
      if (id) element.id=id
      if (tag) element.tag=tag
      if (classList.length>0) element.classList=classList
      if (attribs.length>0) element.attribs=attribs
      return element
   }
    getAttributes(element){
      let attribs=this.stringValues.filter((value,index)=>{
         let searchValue=`[${index}]`
         if (element.match(searchValue)) return true
         else return false
      })
      attribs=attribs.map(attrib=>{
         let query=attrib
         attrib=attrib.replace('[','').replace(']','')
         let [name,value]=attrib.split(/[\~\|\^\$\*]?\=/)
         let sign=attrib.replace(name,'').replace(value,'')
         attrib={ query }
         if (name) attrib.name=name
         if (value) attrib.value=value.trim().replace(/^\"/,'').replace(/\"$/,'')
         if (sign){
            attrib.sign=sign
            attrib.check=this.getAttribFn(sign).bind(attrib)
         }
         return attrib
      });
      return attribs
   }
    getAttribFn(sign){
      if (sign=='=') return function (value){ return value===this.value }
      if (sign=='*=') return function (value){ return value.includes(this.value) }
      if (sign=='^=') return function (value){ return value.startsWith(this.value) }
      if (sign=='$=') return function (value){ return value.endsWith(this.value) }
      if (sign=='|=') return function (value){
         return value.trim().split(' ').length==1
            && (value.startsWith(this.value) || value.startsWith(this.value+'-'))
            ? true : false
      }
      if (sign=='~=') return function (value){
         return this.value.trim().split(' ').length==1 && value.includes(this.value) ? true : false
      }
   }
    removeSpaces(selector){
      selector=selector.replace(/\s{2}/g,' ')
      selector=selector.replace(/\s?\^?\$?\|?\~?\*?\=\s*/g,(m)=>m.trim())
      selector=selector.replace(/\s?(\+|\~|\>)\s?/g,(m)=>m.trim())
      return selector
   }
+}
+function checkElement(el,selector){
   if(selector==undefined) return true
   if(el==null) return false
   let{tag,classList,attribs:attributes,id,prev,ancestors,parents,prevAny}=selector
   if(typeof el==='string') return false
   if(id!==undefined && el.id===null) return false
   if(id && id!==el.id) return false
   if(tag && el.tagName===undefined) return false
   else if(tag && tag!==el.tagName) return false
   const clas=el.attributes.class
   if(classList!==undefined && (clas===undefined || clas==='')) return false
   else if(classList!==undefined){
      if(classList.every(e=>el.classList.contains(e))===false) return false
   }
   if(checkattributes(attributes,el)===false) return false
   if(checkElement(el.prev,prev)===false) return false
   if(checkAncestors(el.ancestors,ancestors)===false) return false
   if(checkParents(el.ancestors,parents)===false) return false
   if(el.parent){
      if(checkPrevAny(el.parent.children,el.childIndex,prevAny)==false) return false
   }
   return true
+}
  function checkattributes(attributes=[],el){
   let elattributes=el.attributes
   let names=Object.keys(elattributes)
   let passedTests=0
   if(attributes) for(let i=0; i<attributes.length; i++){
      let{name,value,check}=attributes[i]
      if(name=='inner' && value!==undefined && check && el.inner){
         if(check(el.inner)) passedTests++
      }
       if(!names.includes(name)) continue
      else if(value==undefined) passedTests++
      else if(value && elattributes[name]){
         if(check(elattributes[name])==false) continue
         else passedTests++
      }
   }
   if(passedTests==attributes.length) return true
   else return false
+}
  function checkPrevAny(children=[],index,prevAny){
   let size=children.length
   if((size==0 || index==0) && prevAny) return false
   for(let i=index; i>=0; i--){
      if(checkElement(children[i],prevAny)) return true
   }
   return false
+}
  function checkAncestors(ancestors=[],selectorAncestors=[]){
   let count=0
   if(selectorAncestors.length==0) return true
   let endIndex=ancestors.length-1
   let selectorIndex=selectorAncestors.length-1
   while(selectorIndex>=0){
      for(let i=endIndex; i>=0; i--){
         endIndex=i-1
         if(checkElement(ancestors[i],selectorAncestors[selectorIndex])==true){
            count++
            break
         }
      }
      selectorIndex--
   }
   if(count==selectorAncestors.length) return true
   else return false
+}
  function checkParents(ancestors=[],selectorParents=[]){
   if(selectorParents.length===0) return true
   if(ancestors.length< selectorParents.length) return false
   let index=ancestors.length-1
   for(let i=selectorParents.length-1; i>=0; i--){
      if(checkElement(ancestors[index],selectorParents[i])===false) return false
      index--
   }
   return true
+}
+const getDataName=prop=>'data-'+prop.toLowerCase()
+function getDataset(element){
   return new Proxy(element.attributes,{
       get: (target,prop)=>{return target[getDataName(prop)]},set: (target,prop,value)=>{target[getDataName(prop)]=value; return true},deleteProperty: (target,prop)=>{
           const dataAttr=getDataName(prop)
           if (dataAttr in target){
               delete target[dataAttr];
               return true;
           }
           return false;
       }
   });
 }
-module.exports = Document
+
+function find(selectors,element,collection,first=false,firstTime=true){
   for(let selector of selectors){
      if(checkElement(element,selector)) collection.add(element)
   }
   if(element.children)
   element.children.forEach(child=>{
      if(first && collection.size>0) return
      find(selectors,child,collection,first,false)
   })
    return firstTime ? [...collection] : collection
+}
+class TextNode{
   constructor(data){
      this.nodeName='#text';
      this.parent=null;
      this.textContent=data;
   }
   get nodeValue(){return this.textContent}
   get parentNode(){return this.parent}
+}
+
+function buildStyle(attributes){
   const styles=attributes.style || "";
    const camelToKebab=str=>str.replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g,'$1-$2').toLowerCase();
   const kebabToCamel=str=>str.replace(/-([a-z])/g,g=>g[1].toUpperCase());
    const baseStyleObj=styles.split(";").reduce((acc,style)=>{
      const [key,value]=style.split(":").map(s=>s.trim());
      if (key && value) acc[kebabToCamel(key)]=value;
      return acc;
   },{});
    return new Proxy(baseStyleObj,{
      get: (obj,prop)=>obj[camelToKebab(prop)] || obj[prop],set: (obj,prop,value)=>{
         obj[camelToKebab(prop)]=value;
         attributes.style=Object.entries(obj).map(([k,v])=>`${camelToKebab(k)}: ${v}`).join("; ");
         return true;
      },deleteProperty: (obj,prop)=>{
         delete obj[camelToKebab(prop)];
         attributes.style=Object.entries(obj).map(([k,v])=>`${camelToKebab(k)}: ${v}`).join("; ");
         return true;
      }
   });
+}
+
+class NodeClassList{
   constructor(node){ this.node=node }
   get classes(){ return (this.node.attributes.class || "").split(" ").filter(Boolean) }
   set classes(val){ this.node.attributes.class=val.join(" ") }
   contains(className){ return this.classes.includes(className) }
    add(className){
      const currentClasses=this.classes;
      if (!currentClasses.includes(className)) this.classes=[...currentClasses,className];
   }
    remove(className){ this.classes=this.classes.filter(cls=>cls!==className); }
    toggle(className){
      if (this.classes.includes(className)) this.remove(className);
      else this.add(className);
   }
    replace(oldClass,newClass){
      if (this.classes.includes(oldClass)){
         this.remove(oldClass);
         this.add(newClass);
      }
   }
+}
+function insertBefore(arr,index,newItem){
   const existingIndex=arr.indexOf(newItem);
   if (existingIndex!==-1) arr.splice(existingIndex,1);
   arr.splice(index,0,newItem);
+}
  class Node{
   constructor(tagName,attributes={},parent=null){
      this.isSingle=false;
      this.tagName=tagName;
      this.attributes=attributes;
      this.childNodes=[];
      if (parent!==null) parent.childNodes.push(this)
      this.parent=parent;
      this._classList=null;
      this.__style=null;
      this._dataset=null
   }
    get id(){ return this.attributes.id ? this.attributes.id : null; }
   set id(newValue){ this.attributes.id=newValue; }
   get className(){return this.attributes.class || null}
   get parentNode(){ return this.parent }
   get ancestors(){
      if(!this.parent) return []
      const ancestors=[]
      let element=this.parent
      while (element.tagName!=='ROOT'){
         ancestors.push(element)
         element=element.parent
      }
      return ancestors.reverse()
   }
    get childNodeIndex(){
      if(!this.parent) return null
      return this.parent.childNodes ? this.parent.childNodes.indexOf(this) : null
   }
    get childIndex(){
      if(!this.parent) return null
      return this.parent.children ? this.parent.children.indexOf(this) : null
   }
   get previousElementSibling(){ return this.prev }
   get prev(){
      if (!this.childIndex) return null
      return this.parent.children[this.childIndex-1]
   }
    get nextElementSibling(){ return this.next }
   get next(){
      if (!this.childIndex) return null
      return this.parent.children[this.childIndex+1] || null
   }
    get dataset(){
      if (!this._dataset) this._dataset=getDataset(this);
      return this._dataset;
   }
    get classList(){
      if (!this._classList) this._classList=new NodeClassList(this);
      return this._classList;
   }
    get style(){
      if (!this.__style) this.__style=buildStyle(this.attributes)
      return this.__style
   }
    get outerHTML(){
      const attrs=Object.entries(this.attributes).map(([key,val])=>val.length ? `${key}="${val}"` : key).join(" ");
      return `<${this.tagName}${attrs ? ' '+attrs : ''}>${this.innerHTML}</${this.tagName}>`;
   }
    getAttribute(attrName){ return this.attributes[attrName] || null }
   setAttribute(attrName,value){ this.attributes[attrName]=value }
   removeAttribute(attrName){ delete this.attributes[attrName] }
    remove(){
      if (!this.parent) return
      const index=this.childNodeIndex;
      if (index!==null) this.parent.childNodes.splice(index,1);
   }
    get innerHTML(){
      return this.childNodes.map(child=>{
         if (child instanceof Node || child instanceof SingleNode) return child.outerHTML;
         else if (child instanceof TextNode) return child.textContent;
         else return child
      }).join("");
   }
    $$(query){return this.querySelectorAll(query)}
   querySelectorAll(query){
      const selectors=Query.get(query)
      return find(selectors,this,new Set())
   }
   $(query){return this.querySelector(query)}
   querySelector(query){
      const selectors=Query.get(query)
      return find(selectors,this,new Set(),true)[0] || null
   }
    getElementsByClassName(query){ return this.querySelectorAll('.'+query) }
   getElementsByTagName(query){ return this.querySelectorAll(query) }
   getElementById(query){ return this.querySelector('#'+query) }
    get children(){
      return this.childNodes.filter(child=>{
         if (!(child instanceof Node)) return false
         if (child.tagName==='#comment') return false
         return true
      });
   }
    insertAdjacentElement(position,newElement){
      if(newElement.tagName==='ROOT' && newElement.childNodes.length>0) newElement=newElement.childNodes[0]
      const pos=position.toLowerCase();
      if (pos==="afterbegin") this.childNodes.unshift(newElement);
      else if (pos==="beforeend") this.childNodes.push(newElement);
      newElement.parent=this
      if (!this.parent) return newElement
      if (pos==="beforebegin") insertBefore(this.parent.childNodes,this.childNodeIndex,newElement)
      else if (pos==="afterend") this.parent.childNodes.splice(this.childNodeIndex+1,0,newElement);
      newElement.parent=this.parent
      return newElement
   }
    insertAdjacentHTML(position,html){
      const newNode=parseHTML(html);
      newNode.childNodes.reverse().forEach(node=>{
         this.insertAdjacentElement(position,node);
      });
      return newNode
   }
    insertAdjacentText(position,text){
      return this.insertAdjacentElement(position,new TextNode(text));
   }
    insert(position,element){
      const positions=['beforebegin','afterbegin','beforeend','afterend']
      if(positions[position]) position=positions[position]
      if(typeof element==='string'){
         element=element.trim()
         if(element.startsWith('<') && element.endsWith('>')){
            return this.insertAdjacentHTML(position,element)
         }
         return this.insertAdjacentText(position,element)
      }
      return this.insertAdjacentElement(position,element)
   }
    set innerHTML(html){
      const parsed=parseHTML(html);
      this.childNodes=parsed.childNodes;
   }
    set outerHTML(html){
      const parsed=parseHTML(html);
      if (!this.parent) return console.log('element has no parent node')
      const index=this.childIndex
      if (index!==null) this.parent.childNodes.splice(index,1,...parsed.childNodes);
   }
    appendChild(newChild){
      if (newChild instanceof Node || newChild instanceof TextNode || newChild instanceof SingleNode){
         if (newChild.parent) newChild.parent.childNodes=newChild.parent.childNodes.filter(child=>child!==newChild);
      } else if(typeof newChild==='string') newChild=new TextNode(newChild)
      else return newChild
      this.childNodes.push(newChild);
      newChild.parent=this;
      return newChild;
   }
    get textContent(){
      if (this.childNodes.length===0) return this.nodeName==='#text' ? this.nodeValue : '';
      return this.childNodes.map(child=>{
         if(child instanceof SingleNode) return ''
         if(child instanceof TextNode) return child.nodeValue
         if(child instanceof Node) return child.textContent;
         else return child;
      }).join(" ");
   }
    set textContent(value){
      this.childNodes=[];
      if (value!==null && value!==undefined){
         this.childNodes.push(value.toString());
      }
   }
+}
+class SingleNode extends Node{
   constructor(tagName,attributes={},parent=null){
      if(attributes['?'] && tagName==='?xml') delete attributes['?']
      super(tagName,attributes,parent);
      this.isSingle=true
   }
    get outerHTML(){
      if (this.tagName==="#cdata-section") return `<![CDATA[${this.nodeValue}]]>`;
      const attrs=Object.entries(this.attributes).map(([key,val])=>val.length ? `${key}="${val}"` : key).join(" ");
      return `<${this.tagName} ${attrs}${this.tagName==='?xml' ? '?' : ''}>`;
   }
    get innerHTML(){ return ""; }
   set innerHTML(_){ }
   $(_){return null}
   $$(_){return []}
   querySelectorAll(_){ return []; }
   querySelector(_){ return null; }
   getElementsByClassName(_){ return []; }
   getElementsByTagName(_){ return []; }
   getElementById(_){ return null; }
   get children(){ return []; }
   insertAdjacentElement(_,__){ }
   insertAdjacentHTML(_,__){ }
   insertAdjacentText(_,__){ }
   appendChild(_){ }
   insert(_,__){ }
   get textContent(){ return ""; }
   set textContent(_){ }
+}
+
+class Root extends Node{
   constructor(){
      super('ROOT',{},null);
      this.isSingle=false
   }
    get body(){return this.$('body')}
   get head(){return this.$('head')}
   get title(){return this.$('title')}
   set title(title){return this.$('title').innerHTML=title}
+}
+function parseAttributes(str){
   const attrs={};
   let key="";
   let value="";
   let isKey=true;
   let quoteChar=null;
    for (let i=0; i< str.length; i++){
      const char=str[i];
       if (isKey && (char==='=' || char===' ')){
         if (char==='=') isKey=false;
         else if (key.trim()){
            attrs[key.trim()]=true;
            key="";
         }
         continue;
      }
       if (!quoteChar && (char==='"' || char==="'")){
         quoteChar=char;
         continue;
      } else if (quoteChar && char===quoteChar){
         quoteChar=null;
         attrs[key.trim()]=value.trim();
         key=""; value=""; isKey=true;
         continue;
      }
       if (isKey) key+=char;
      else value+=char;
   }
    if (key.trim() &&!value) attrs[key.trim()]='';
   return attrs;
+}
+const VOID_TAGS=new Set(["area","base","br","col","command","embed","hr","img","input","keygen","link","meta","param","source","track","wbr","!doctype",'?xml']);
+function parseHTML(html){
   const root=new Root();
   const stack=[root];
   let currentText="",i=0;
   let max=0
    function parseScript(){
      if (!html.startsWith("<script",i)) return false;
      const openTagEnd=html.indexOf(">",i);
      if (openTagEnd===-1) return false;
       const attributesString=html.substring(i+7,openTagEnd).trim();
      const attributes=parseAttributes(attributesString);
       let closeTagStart=html.indexOf("</script>",openTagEnd);
      if (closeTagStart===-1) return false;
      const content=html.substring(openTagEnd+1,closeTagStart);
       const scriptNode=new Node('script',attributes,stack[stack.length-1]);
      if(content.length>0) scriptNode.childNodes.push(content);
         i=closeTagStart+9;
      return true;
   }
    function parseSpecial(startStr,endStr,n1,n2,tag){
      if (!html.startsWith(startStr,i)) return false
      const end=html.indexOf(endStr,i+n1);
      const strNode=new Node(tag,{},stack[stack.length-1]);
      strNode.childNodes.push(html.substring(i+n1,end));
      i=end+n2;
      return true
   }
    while (i< html.length){
      if(i>=max) max=i;
      else break;
      if (parseScript()) continue
      if (parseSpecial("<!--","-->",4,3,'#comment')) continue
      if (parseSpecial("<style","</style>",7,8,'style')) continue
       if (html.startsWith("<![CDATA[",i)){
         const end=html.indexOf("]]>",i+9);
         if (end===-1) break;
         const content=html.substring(i+9,end);
         const cdataNode=new SingleNode("#cdata-section",{},stack[stack.length-1]);
         cdataNode.nodeValue=content;
         i=end+3;
         continue;
      }
       if (html.startsWith("<",i)){
         if (currentText && stack[stack.length-1]){
            const textNode=new TextNode(currentText)
            stack[stack.length-1].childNodes.push(textNode);
            textNode.parent=stack[stack.length-1]
            currentText="";
         }
          let tagEnd=i+1;
         let insideQuotes=false;
         let quoteChar=null;
          while (tagEnd< html.length){
            const char=html[tagEnd];
            if (!insideQuotes && (char==='"' || char==="'")){
               insideQuotes=true;
               quoteChar=char;
            } else if (insideQuotes && char===quoteChar){
               insideQuotes=false;
               quoteChar=null;
            }
             if (!insideQuotes && char==='>') break;
            tagEnd++;
         }
          const tagContent=html.substring(i+1,tagEnd);
         if (tagContent.startsWith("/")) stack.pop();
         else{
            let isSelfClosing=tagContent.endsWith('/');
            const tagNameEnd=tagContent.search(/\s|>|\//);
            const tagName=tagContent.substring(0,tagNameEnd>0 ? tagNameEnd : tagEnd-i-1);
            const attributesString=tagContent.substring(tagName.length,isSelfClosing ? tagContent.length-1 : tagContent.length).trim();
            const attributes=parseAttributes(attributesString);
            if (VOID_TAGS.has(tagName.toLowerCase()) || isSelfClosing) new SingleNode(tagName,attributes,stack[stack.length-1])
            else stack.push(new Node(tagName,attributes,stack[stack.length-1]));
         }
         i=tagEnd+1;
      } else{
         currentText+=html[i];
         i++;
      }
   }
   if (currentText.trim() && stack[stack.length-1]) stack[stack.length-1].childNodes.push(new TextNode(currentText));
   return root;
+}
+function buildFromCache(cached){
   function buildNode(cache,parent=null){
      if(typeof cache==='string') return parent.childNodes.push(cache)
      const{isSingle,tagName,attributes,childNodes,textContent}=cache
      if(textContent) return parent.childNodes.push(new TextNode(textContent))
      if(isSingle) return parent.childNodes.push(new SingleNode(tagName,attributes))
      const newDoc=tagName==='ROOT' ? new Root() : new Node(tagName,attributes,parent)
      childNodes.forEach(childNode=>{
         buildNode(childNode,newDoc)
      });
      return newDoc
   }
   return buildNode(cached)
+}
  
+function cacheDoc(doc){
   const props=['isSingle','tagName','attributes']
   function addToCache(element,cache={}){
      if(typeof element==='string') return element
      if(element.nodeName==='#text') return{textContent:element.textContent}
      props.forEach(prop=>{
         if(element[prop]) cache[prop]=element[prop]
      });
      if(!element.childNodes) return cache
      cache.childNodes=[]
      element.childNodes.forEach(childNode=>{
         cache.childNodes.push(addToCache(childNode))
      });
      return cache
   }
   return addToCache(doc)
+}
+return { parseHTML, Node, Query, TextNode, SingleNode, buildFromCache, cacheDoc, Root }
+})()