!
function(win, doc) {

  var nes = {version: "0.0.5"},
    locals = {} //存放local属性...被global坑死了

  var ap = Array.prototype,
    op = Object.prototype,
    sp = String.prototype,
    fp = Function.prototype,
    slice = ap.slice,
    body = doc.body,
    testNode = doc.createElement("div"),

    toArray = function(arr) {
      return slice.call(arr)
    },

    typeOf = function(o) {
      return o == null ? String(o) : op.toString.call(o).slice(8, -1).toLowerCase()
    },

    extend = function(o1, o2, override) {
      for (var i in o2) {
        if (o1[i] == null || override) o1[i] = o2[i]
      }
    },

    createCache = function(max) {
      var keys = [],
        cache = {}
      return {
        set: function(key, value) {
          if (keys.length > this.length) {
            delete cache[keys.shift()]
          }
          cache[key] = value
          keys.push(key)
          return value
        },
        get: function(key) {
          if (typeof key === "undefined") return cache
          return cache[key]
        },
        length: max
      }
    },

    autoSet = function(fn) {
      return function(key, value) {
        if (typeOf(key) == "object") {
          for (var i in key) {
            fn.call(this, i, key[i])
          }
        } else {
          fn.call(this, key, value)
        }
        return this;
      }
    },
    assert = function(fn) {
      try {
        return fn()
      } catch (e) {
        return false
      } finally {
        testNode = document.createElement("div");
      }
    }

  try {
    slice.call(doc.getElementsByTagName("body"))
  } catch (e) {
    toArray = function(arr) {
      var result = [],
        len = arr.length
      for (var i = 0; i < len; i++) {
        result.push(arr[i])
      }
      return result
    }
  }

  var trimReg = /^\s+|\s+$/g
  sp.trim = sp.trim || function() {
    return this.replace(trimReg, "")
  }

  fp.bind = fp.bind || function(context, args) {
    args = slice.call(arguments, 1);
    var fn = this;
    return function() {
      fn.apply(context, args.concat(slice.call(arguments)));
    }
  }

  ap.indexOf = ap.indexOf ||
  function(a) {
    for (var i = 0, len = this.length; i < len; i++) {
      if (a === this[i]) return i
    }
    return -1
  }

  var

    ignoredRef = /\(\?\!|\(\?\:/,
    extractRefNum = function(regStr) {
      var left = right = 0,
        len = regStr.length,
        ignored = regStr.split(ignoredRef).length - 1 //忽略非捕获匹配
      for (; len--;) {
        var letter = regStr.charAt(len)
        if (len == 0 || regStr.charAt(len - 1) !== "\\") { //不包括转义括号
          if (letter === "(") left++
          if (letter === ")") right++
        }
      }
      if (left !== right) throw regStr + "中的括号不匹配"
      else return left - ignored
    },

    refIndexReg = /\\(\d+)/g,
    extractRefIndex = function(regStr, curIndex) {
      return regStr.replace(refIndexReg, function(a, b) {
        return "\\" + (parseInt(b) + curIndex)
      })
    },

    keys = Object.keys || function(obj) {
      var result = [];
      for (var prop in obj) {
        if (obj.hasOwnProperty(prop)) result.push(prop);
      }
      return result
    },

    cleanRule = function(rule) {
      var reg = rule.reg

      if (typeOf(reg) === "regexp") reg = reg.toString().slice(1, -1)

      rule.regexp = reg.replace(replaceReg, function(a, b) {
        if (b in macros) return macros[b]
        else throw new Error('can"t replace undefined macros:' + b)
      })
      return rule
    }, 
    cleanRules = function(rules) {
      for (var i in rules) {
        if (rules.hasOwnProperty(i)) cleanRule(rules[i])
      }
      return rules
    }

  function Parser(opts) {
      opts = opts || {}
      if (opts.macros) this._macros = opts.macros
      this._links = {} //symbol link map
      this._rules = {} //symbol def
      this.TRUNK = null
      this.cache = createCache(opts.maxCache || 200)
      this.cache.set("", [[]]) //输入空字符串返回空数组
    }

  extend(Parser.prototype, {

    parse: function(input) {

      input = clean(input)

      if (parsed = this.cache.get(input)) return parsed

      var parsed = this.parsed = [
        [null]
      ],
        remain = this.input = input,
        TRUNK = this.TRUNK

      while (remain != (remain = remain.replace(TRUNK, this._process.bind(this)))) {}

      if (remain !== '') this.error(remain)

      return this.cache.set(input, parsed)
    },

    on: function(rules) {
      if (typeOf(rules) === "string") { //当不是hash传入时
        var tmp = {}
        tmp[rules] = arguments[1]
        rules = tmp
      }

      for (var i in rules) {
        var rule = rules[i]
        if (typeOf(rule) !== "object") {
          rule = {
            regexp: rule
          }
        }
        var reg = rule.regexp
        if (typeOf(reg) === "regexp") {
          rule.regexp = reg.toString().slice(1, -1)
        }

        if (rule.order === undefined) rule.order = 1
        this._rules[i] = rule
      }

      this.setup()
      return this
    },

    off: function(name) {
      if (typeOf(name) === "array") {
        for (var i = name.length; i--;) {
          this.off(name[i])
        }
      } else {
        if (this._rules[name]) {
          delete this._rules[name]
        }
      }
      return this
    },

    current: function() {
      var data = this.parsed
      var piece = data[data.length - 1],
        len = piece.length
      return piece[len - 1] || (piece[len - 1] = {
        tag: "*"
      })
    },
    error: function(info) {
      throw Error("输入  " + this.input + "  含有未识别语句:" + info || "")
    },

    clone: function(parser) {
      return new Parser().on(this._rules)
    },

    _process: function() {
      var links = this._links,
        rules = this._rules,
        args = slice.call(arguments)

        for (var i in links) {
          var link = links[i],
            retain = link[1],
            index = parseInt(link[0])
          if (args[index] && (rule = rules[i])) {
            rule.action.apply(this, args.slice(index, index + retain))
            return ""
          }
        }
      return ""
    },

    setup: function() {
      cleanRules(this._rules)
      var curIndex = 1,

        splits = [],
        rules = this._rules,
        links = this._links,
        ruleNames = keys(rules).sort(function(a, b) {
          return rules[a].order >= rules[b].order
        }),
        len = ruleNames.length;

      for (; len--;) {
        var i = ruleNames[len],
          rule = rules[i],
          retain = extractRefNum(rule.regexp) + 1 // 1就是那个all
        if(rule.filter && !filters[i]){ 
          filters[i] = rule.filter
          console.log(i)
          } //将filter转移到filters下

        links[i] = [curIndex, retain] //分别是rule名，参数数量
        var regexp = extractRefIndex(rule.regexp, curIndex - 1);
        curIndex += retain;
        splits.push(regexp)
      }
      this.TRUNK = new RegExp("^(?:(" + splits.join(")|(") + "))")
      return this
    }
  })

  var
    replaceReg = /\{\{([^\}]*)\}\}/g,

    nthValueReg = /^(?:(\d+)|([+-]?\d*)?n([+-]\d+)?)$/,

    posPesudoReg = /^(nth)[\w-]*(-of-type|-child)/,

    nthCache = createCache(100),

    extractNthValue = function(param) {
      var step, start, res

      if (!param || !(param = param.replace(/\s+/g, ""))) {
        return {
          start: 1,
          step: 0
        }
      }
      if (res = nthCache.get(param)) return res

      if (param == "even") {
        start = 2
        step = 2
      } else if (param == "odd") {
        step = 2
        start = 1
      } else {
        res = param.match(nthValueReg)

        if (!res) step = null // 无论其他参数，如果step为null，则永远为false
        else {
          if (res[1]) {
            step = 0
            start = parseInt(res[1])
          } else {
            if (res[2] == "-") res[2] = "-1"
            step = res[2] ? parseInt(res[2]) : 1
            start = res[3] ? parseInt(res[3]) : 0
          }
        }
      }
      if (start < 1) {
        if (step < 1) {
          step = null //标志false
        } else {
          start = -(-start) % step + step
        }
      }
      return nthCache.set(param, {
        start: start,
        step: step
      })
    }

  var

    macros = {
      split: "\\s*,\\s*",

      operator: "[*^$|~!]?=",

      combo: "[>\\s+~](?!=)",

      word: "[\\\\\\w\\u4e00-\\u9fbf-]"
    },

    rules = {
      split: {

        reg: "{{split}}",
        action: function(all) {
          this.parsed.push([null])
        },
        order: 0
      },

      id: {
        reg: "#({{word}}+)",
        action: function(all, id) {
          this.current().id = id
        }
      },

      tag: {
        reg: "\\*|[a-zA-Z-]\\w*",

        action: function(tag) {
          this.current().tag = tag.toLowerCase()
        }
      },

      classList: {
        reg: "\\.({{word}}+)",
        action: function(all, className) {
          var current = this.current(),
            classList = current.classList || (current.classList = [])
            classList.push(className)
        }
      },

      pesudos: {
        reg: ":({{word}}+)" + //伪类名
        "(?:\\(" + //括号开始
        "([^\\(\\)]*" + //第一种无括号
        "|(?:" + //有括号(即伪类中仍有伪类并且是带括号的)
        "\\([^\\)]+\\)" + //括号部分
        "|[^\\(\\)]*" + ")+)" + //关闭有括号
        "\\))?",

        action: function(all, name, param) {
          var current = this.current(),
            pesudos = current.pesudos || (current.pesudos = [])
            name = name.toLowerCase()

            if (param) param = param.trim()
            if (posPesudoReg.test(name)) {

              param = extractNthValue(param)
            }
          pesudos.push({
            name: name,
            param: param
          })
        }
      },

      attributes: {
        reg: "\\[\\s*({{word}}+)(?:({{operator}})[\'\"]?([^\'\"\\[]+)[\'\"]?)?\\s*\\]",
        action: function(all, key, operator, value) {
          var current = this.current(),
            attributes = current.attributes || (current.attributes = [])
            attributes.push({
              key: key,
              operator: operator,
              value: value
            })
        }
      },

      combo: {
        reg: "\\s*({{combo}})\\s*",
        action: function(all, combo) {
          var data = this.parsed,
            cur = data[data.length - 1]
            this.current().combo = combo
            cur.push(null)
        },
        order: 0
      }
    }

  var cleanReg = new RegExp("\\s*(,|" + macros.combo + "|" + macros.operator + ")\\s*", "g")
  clean = function(sl) {
      return sl.trim().replace(/\s+/g, " ").replace(cleanReg, "$1")
    }

  var parser = new Parser()
  parser.on(rules) //生成规则

  function parse(sl) {
      return parser.parse(sl)
    }

  var root = doc.documentElement || doc;
  var attrMap = {
    'for': "htmlFor",
    "href": function(node) {
      return "href" in node ? node.getAttribute("href", 2) : node.getAttribute("href")
    },
    "type": function(node){
      return "type" in node ? node.getAttribute("type"):node.type
    }
  };
  var checkTagName = assert(function() {
    testNode.appendChild(doc.createComment(""));

    return !testNode.getElementsByTagName("*").length || 

      typeof doc.getElementsByTagName("input").length !== "number"
  });

  var checkAttributes = assert(function() {
    testNode.innerHTML = "<select></select>";
    var type = typeOf(testNode.lastChild.getAttribute("multiple"))

    return type !== "boolean" && type !== "string";
  });

  function checkNth(node, type) {
      if (type) return node.nodeName === type
      else return node.nodeType === 1
    }

  function nthChild(node, n, type) {
      var node = node.firstChild
      if (!node) return
      if (checkNth(node, type)) n--
      return nthNext(node, n, type)
    };

  function nthLastChild(node, n, type) {
      var node = node.lastChild
      if (!node) return
      if (checkNth(node, type)) n--
      return nthPrev(node, n, type)
    };

  function nthPrev(node, n, type) {
      while (n && (node = node.previousSibling)) {
        if (checkNth(node, type)) n--
      }
      return node
    };

  function nthNext(node, n, type) {
      while (n && (node = node.nextSibling)) {
        if (checkNth(node, type)) n--
      }
      return node
    };

  function getAttribute(node, key) {
      var map = attrMap[key]
      if (map) return typeof map === "function" ? map(node) : node[map]
      if(checkAttributes){return node.getAttribute(key);}
      var attrNode = node.getAttributeNode(key);

      return typeof node[key] === "boolean" ? 

          node[key] ? key : null :   
          attrNode && attrNode.specified && attrNode.value || null
    };

  function distinct(array) {
      for (var i = array.length; i--;) {
        var n = array[i]

        array.splice(i, 1, null)
        if (~array.indexOf(n)) {
          array.splice(i, 1); //不清白
        } else {
          array.splice(i, 1, n); //不清白
        }
      }
      return array
    }

  var sortor = (doc.compareDocumentPosition) ?
    function(a, b) {
      if (!a.compareDocumentPosition || !b.compareDocumentPosition) return 0;
      return a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
    } : ('sourceIndex' in doc) ?
    function(a, b) {
      if (!a.sourceIndex || !b.sourceIndex) return 0;
      return a.sourceIndex - b.sourceIndex;
    } : function(a, b) {
      var i = 0,
        ap = [a],
        bp = [b],
        aup = a.parentNode,
        bup = b.parentNode,
        cur = aup;

      if (a === doc) {
        return -1;
      } else if (b === doc) {
        return 1;
      } else if (!aup && !bup) {
        return 0;
      } else if (!bup) {
        return -1;
      } else if (!aup) {
        return 1;
      } else if (aup === bup) {
        return siblingCheck(a, b);
      }
      while (cur) {
        ap.unshift(cur);
        cur = cur.parentNode;
      }
      cur = bup;
      while (cur) {
        bp.unshift(cur);
        cur = cur.parentNode;
      }
      while (ap[i] === bp[i]) {
        i++;
      }
      return siblingCheck(ap[i], bp[i]);
    };
  function siblingCheck(a, b) {
      if (a && b) {
        var cur = a.nextSibling;
        while (cur) {
          if (cur === b) {
            return -1;
          }
          cur = cur.nextSibling;
        }
      }
      return a ? 1 : -1;
    };

  var getUid = (function(token) {
    var _uid = 0
    return function(node) {
      return node._uid || (node._uid = token + _uid++)
    }
  })("nes_" + (+new Date).toString(36));

  function createNthFilter(isNext, isType) {
    var next, prev, cacheKey, getStart
    if (isNext) {
      cacheKey =isType ? "type" : "child"
      next = nthNext
      prev = nthPrev
      getStart = nthChild
    } else {

      cacheKey ="last" + (isType ? "type" : "child")
      prev = nthNext
      next = nthPrev
      getStart = nthLastChild
    }

    return function(node, param) {
      var cache = nthPositionCache[cacheKey]
      if (node === root) return false // 如果是html直接返回false 坑爹啊
      var _uid = getUid(node),
        parent = node.parentNode,
        traverse = param.step > 0 ? next : prev,
        step = param.step,
        start = param.start,
        type = isType && node.nodeName

      if (step === null) return false //means always false
      if (!cache[_uid]) {
        var startNode = getStart(parent, 1, type),
          index = 0
          do {
            cache[getUid(startNode)] = ++index
            nthPositionCache.length++
            
          } while (startNode = next(startNode, 1, type))
      }
      var position = cache[_uid]
      if (step === 0) return position === start
      if ((position - start) / step >= 0 && (position - start) % step == 0) {
        return true
      }
    }
  }
  var nthPositionCache = {
    length: 1
  }
  function clearNthPositionCache() {
    if(nthPositionCache.length){
      nthPositionCache = {
        child:{},
        lastchild:{},
        type:{},
        lasttype:{},
        length:0
      }
    } 
  }

  clearNthPositionCache()

 
  var finders = {
    byId: function(id) {
      var node = doc.getElementById(id)
      return node ? [node] : []
    },
    byClassName: doc.getElementsByClassName ?
    function(classList, node) {
      classList = classList.join(" ")
      return toArray((node || doc).getElementsByClassName(classList))
    } : null,
    byTagName: checkTagName ?
    function(tagName, node) {
      var results = (node || doc).getElementsByTagName(tagName)
      return toArray(results)
    } : function(tagName, node) {
      var results = (node || doc).getElementsByTagName(tagName)
      var elem, tmp = [],
        i = 0;
      for (;(elem = results[i]); i++) {
        if (elem.nodeType === 1) tmp.push(elem);
      }
      return tmp;
    }
  }

  var filters = {
    id: function(node, id) {
      return node.id === id
    },
    classList: function(node, classList) {
      var len = classList.length,
        className = " " + node.className + " "
      for (; len--;) {
        if (className.indexOf(" " + classList[len] + " ") === -1) {
          return false
        }
      }
      return true
    },
    tag: function(node, tag) {
      if (tag == "*") return true
      return node.tagName.toLowerCase() === tag
    },

    pesudos: function(node, pesudos) {
      var len = pesudos.length,
        pesudoFilters = expandFilters["pesudos"]

      for (; len--;) {
        var pesudo = pesudos[len],
          name = pesudo.name,
          filter = pesudoFilters[name]

        if (!filter) throw Error("不支持的伪类:" + name)
        if (!filter(node, pesudo.param)) return false
      }
      return true
    },

    attributes: function(node, attributes) {
      var len = attributes.length,
        operatorFilters = expandFilters["operators"]

      for (; len--;) {
        var attribute = attributes[len],
          operator = attribute["operator"],
          filter = operatorFilters[operator],
          nodeValue = getAttribute(node, attribute.key)

        if(nodeValue === null){
          if(operator !== "!=" ) return false
          continue
        }
        if(!operator) continue
        if (!filter) throw Error("不支持的操作符:" + operator)
        if (!filter(attribute.value, nodeValue+"")) return false
      }
      return true
    }
  }

  var expandFilters = {

    combos: {
      ">": function(node, match) {
        var parent = node.parentNode
        if (match(parent)) return parent
      },
      "~": function(node, match) {
        var prev = nthPrev(node, 1)
        while (prev) {
          if (match(prev)) return prev
          prev = nthPrev(prev, 1)
        }
      },
      " ": function(node, match) {
        var parent = node.parentNode
        while (parent) {
          var pass = match(parent)
          if (pass) return parent
          if (pass === null) return null
          parent = parent.parentNode
        }
        return null
      },
      "+": function(node, match) {
        var prev = nthPrev(node, 1)
        if (prev && match(prev)) return prev
      }
    },

    operators: {
      "^=": function(value, nodeValue) {
        if (nodeValue == null) return false
        return nodeValue.indexOf(value) === 0
      },
      "=": function(value, nodeValue) {
        return nodeValue === value
      },
      "~=": function(value, nodeValue) {
        if (nodeValue == null) return false
        return ~(" " + nodeValue + " ").indexOf(value)
      },
      "$=": function(value, nodeValue) { //以value结尾
        return nodeValue.substr(nodeValue.length - value.length) === value
      },
      "|=": function(value, nodeValue) { // 连接符
        return ~("-" + nodeValue + "-").indexOf("-" + value + "-")
      },
      "*=": function(value, nodeValue) { //出现在nodeValue的任意位置
        return ~(nodeValue).indexOf(value)
      },
      "!=": function(value, nodeValue) {
        return nodeValue !== value
      }
    },

    pesudos: {

      "not": function(node, sl) {
        return !matches(node, sl)
      },
      "matches": function(node, sl) {
        return matches(node, sl)
      },

      "nth-child": createNthFilter(1, 0),
      "nth-last-child": createNthFilter(0, 0),
      "nth-of-type": createNthFilter(1, 1),
      "nth-last-of-type": createNthFilter(0, 1),
      "nth-match": function(node, param) {
        var tmp = param.split(/\s+of\s+/),
          nth = parseInt(tmp[0]),
          sl = tmp[1],
          start = node.parentNode.firstChild

          do {
            if (start.nodeType === 1 && nes.matches(start, sl)) nth--
          } while (nth && (start = start.nextSibling))

          return !nth && node === start
      },
      "first-child": function(node) {
        return !nthPrev(node, 1)
      },
      "last-child": function(node) {
        return !nthNext(node, 1)
      },
      "last-of-type": function(node) {
        return !nthNext(node, 1, node.nodeName)
      },
      "first-of-type": function(node) {
        return !nthPrev(node, 1, node.nodeName)
      },
      "only-child": function(node) {
        return !nthPrev(node, 1) && !nthNext(node, 1)
      },
      "only-of-type": function(node) {
        return !nthPrev(node, 1, node.nodeName) && !nthNext(node, 1, node.nodeName)
      },

      "contains": function(node, param) {
        return ~ (node.innerText || node.textContent || '').indexOf(param)
      },
      "checked": function(node) {
        return !!node.checked || !! node.selected
      },
      "selected": function(node) {
        return node.selected
      },
      "enabled": function(node) {
        return node.disabled === false
      },
      "disabled": function(node) {
        return node.disabled === true
      },
      "empty": function(node) {
        var nodeType;
        node = node.firstChild;
        while (node) {
          if (node.nodeName > "@" || (nodeType = node.nodeType) === 3 || nodeType === 4) {
            return false;
          }
          node = node.nextSibling;
        }
        return true;
      },
      "focus": function(node) {
        return node === doc.activeElement && (!doc.hasFocus || doc.hasFocus()) && !! (node.type || node.href || ~node.tabIndex);
      },
      "target": function(node, param) {
        var id = node.id || node.name
        if (!id) return false
        return ("#" + id) === location.hash
      }
    }
  }

  function matchDatum(node, datum, ignored) {
      var subFilter
      for (var i in datum) {
        if (ignored !== i && (subFilter = filters[i]) && !subFilter(node, datum[i])) {
          return false
        }
      }
      return true
    };

  var matchesCache = null; //保存那些matches函数
  function matchData(node, data, ignored) { // 稍后再看存入step
      var len = data.length,
        datum = data[len - 1]

      if (!matchDatum(node, datum, ignored)) return false
      else {
        if (len == 1) return true
        var nextDatum = data[len - 2],
          getNext = expandFilters.combos[nextDatum.combo],
          match = matchesCache[len - 2],
          next = getNext(node, match)

          if (next) return true
          else return false
      }
    };

  function createMatch(data) {
      return function(node) {
        if (node == root || node == null || node == doc) return null //null 相当于休止符
        return matchData(node, data)
      }
    };
  function createMatches(data) {
      var matches = []
      for (var i = 0, len = data.length; i < len; i++) {
        matches.push(createMatch(data.slice(0, i + 1)))
      }
      return matches
    };

  function filter(results, data, ignored) {
      if (!data.length) return results;

      var preMatchesCache = matchesCache
      matchesCache = createMatches(data)
      for (var i = results.length; i--;) {
        if (!matchData(results[i], data, ignored)) {
          results.splice(i, 1)
        }
      }

      matchesCache = preMatchesCache; // warning :以后写全局变量一定当心
      return results;
    }

  function getTargets(data, context) {
      var results, ignored, lastPiece = data[data.length - 1]
      if (lastPiece.id) {
        results = finders.byId(lastPiece.id);
        ignored = "id";
      } else if (lastPiece.classList && lastPiece.classList.length && finders.byClassName) {
        results = finders.byClassName(lastPiece.classList, context);
        ignored = "classList";
      } else {
        results = finders.byTagName(lastPiece.tag || "*", context);
        ignored = "tag";
      }
      if (!results.length) return results;
      return filter(results, data, ignored);
    }

  function find(datas, context) {
      if (!datas[0][0]) return []
      var results = []
      for (var i = 0, len = datas.length; i < len; i++) {
        var data = datas[i],
          dlen = data.length,
          last = data[dlen - 1]
          results = results.concat(getTargets(data, context))
      }
      clearNthPositionCache()
      if (!results.length) return results
      if (len > 1){
        distinct(results)
        results.sort(sortor)
      }
      return results
    }

  function get(sl, context) {
      var data = parse(sl);
      var result = find(data, context || doc);
      return result;
    }

  var supportQuerySelector = !! doc.querySelector

  function one(sl, context) {
      var node
      if (supportQuerySelector && !nes.debug) {
        try {
          node = (context || doc).querySelector(sl);
        } catch (e) {
          node = get(sl, context)[0];
        }
      } else {
        node = get(sl, context)[0];
      }
      return node
    }

  function all(sl, context) {
      var nodeList
      if (supportQuerySelector && !nes.debug) {
        try {
          nodeList = (context || doc).querySelectorAll(sl);
        } catch (e) {
          nodeList = get(sl, context);
        }
      } else {
        nodeList = get(sl, context);
      }
      return nodeList
    }

  function matches(node, sl) {
      var datas = parse(sl),
        len = datas.length
      if (!datas[len - 1][0]) return false
      for (; len--;) {
        if (matchOneData(node, datas[len])) return true
      }
      return false
    }

  function matchOneData(node, data) {
      var len = data.length
      if (!matchDatum(node, data[len - 1])) {
        return false
      } else {
        return filter([node], data.slice(0)).length === 1
      }
    }

  ;(function createExpand(host, beforeAssign) {
    for (var i in host) {
      nes[i] = (function(i) {
        var container = host[i];

        return autoSet(function(key, value) {

          container[key] = value.bind(container);
          if (i in beforeAssign) {
            beforeAssign[i](key, value);
          }
        })
      })(i)
    }

  })(expandFilters, {
    "operators": function(key, value) {
      var befores = macros.operator.split("]");
      befores.splice(1, 0, key.charAt(0) + "]");
      macros.operator = befores.join("");
      parser.setup();
    },
    "combos": function(key, value) {
      var befores = macros.combo.split("]");
      befores.splice(1, 0, key + "]");
      macros.combo = befores.join("");
      parser.setup();
    }
  })

  extend(nes, {

    debug:false,

    parser:parser,

    parse: parse,

    _find: find,  

    _get: get,

    one: one,
    all: all,
    matches: matches

  })

  if (typeof exports === 'object') {
    module.exports = nes;

  } else if (typeof define === 'function' && define.amd) {
    define(function() {return nes });
  } else {

    win.nes = nes;
  }
}(window, document)