optimal-select.js

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define([], factory);
	else if(typeof exports === 'object')
		exports["OptimalSelect"] = factory();
	else
		root["OptimalSelect"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;
/******/
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// identity function for calling harmony imports with the correct context
/******/ 	__webpack_require__.i = function(value) { return value; };
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 8);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

/**
 * # Utilities
 *
 * Convenience helpers.
 */

/**
 * Create an array with the DOM nodes of the list
 *
 * @param  {NodeList}             nodes - [description]
 * @return {Array.<HTMLElement>}        - [description]
 */
var convertNodeList = exports.convertNodeList = function convertNodeList(nodes) {
  var length = nodes.length;

  var arr = new Array(length);
  for (var i = 0; i < length; i++) {
    arr[i] = nodes[i];
  }
  return arr;
};

/**
 * Escape special characters and line breaks as a simplified version of 'CSS.escape()'
 *
 * Description of valid characters: https://mathiasbynens.be/notes/css-escapes
 *
 * @param  {String?} value - [description]
 * @return {String}        - [description]
 */
var escapeValue = exports.escapeValue = function escapeValue(value) {
  return value && value.replace(/['"`\\/:?&!#$%^()[\]{|}*+;,.<=>@~]/g, '\\$&').replace(/\n/g, '\xA0');
};

/**
 * Partition array into two groups determined by predicate
 */
var partition = exports.partition = function partition(array, predicate) {
  return array.reduce(function (_ref, item) {
    var _ref2 = _slicedToArray(_ref, 2),
        inner = _ref2[0],
        outer = _ref2[1];

    return predicate(item) ? [inner.concat(item), outer] : [inner, outer.concat(item)];
  }, [[], []]);
};

/**
 * Determine if string is valid CSS identifier
 * 
 * In CSS, identifiers (including element names, classes, and IDs in selectors) can contain
 * only the characters [a-zA-Z0-9] and ISO 10646 characters U+00A0 and higher, plus the hyphen (-)
 * and the underscore (_); they cannot start with a digit, two hyphens, or a hyphen followed by
 * a digit.
 * 
 * Identifiers can also contain escaped characters and any ISO 10646 character as a numeric
 * code (see next item). For instance, the identifier "B&W?" may be written as "B\&W\?" or "B\26 W\3F".
 * @param {String} value 
 * @return {Boolean}
 */
var isValidCSSIdentifier = exports.isValidCSSIdentifier = function isValidCSSIdentifier(value) {
  return !!value && !/(^\d)|(^--)|(^-\d)/.test(value) && !/([^\\]|^)['"`/:?&!#$%^()[\]{|}*+;,.<=>@~]/.test(value);
};

/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.checkIgnore = exports.combinations = exports.initOptions = exports.defaultIgnore = undefined;

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; /**
                                                                                                                                                                                                                                                                   * # Match
                                                                                                                                                                                                                                                                   *
                                                                                                                                                                                                                                                                   * Retrieve selector for a node.
                                                                                                                                                                                                                                                                   */

exports.default = match;

var _pattern = __webpack_require__(2);

var _selector = __webpack_require__(3);

var _utilities = __webpack_require__(0);

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

/**
 * @typedef {import('./select').Options} Options
 * @typedef {import('./pattern').Pattern} Pattern
 * @typedef {import('./pattern').ToStringApi} Pattern
 */

var defaultIgnore = exports.defaultIgnore = {
  attribute: function attribute(attributeName) {
    return ['style', 'data-reactid', 'data-react-checksum'].indexOf(attributeName) > -1;
  },

  contains: function contains() {
    return true;
  }
};

var initOptions = exports.initOptions = function initOptions() {
  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return _extends({}, options, {
    root: options.root || document,
    skip: options.skip || null,
    priority: options.priority || ['id', 'class', 'href', 'src'],
    ignore: options.ignore || {}
  });
};

/**
 * Get the path of the element
 *
 * @param  {HTMLElement} node      - [description]
 * @param  {Options}     [options] - [description]
 * @return {Array.<Pattern>}       - [description]
 */
function match(node) {
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var nested = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

  options = initOptions(options);
  var _options = options,
      root = _options.root,
      skip = _options.skip,
      ignore = _options.ignore,
      format = _options.format;


  var path = [];
  var element = node;
  var length = path.length;
  var select = (0, _selector.getSelect)(options);
  var toString = (0, _pattern.getToString)(options);

  var skipCompare = skip && (Array.isArray(skip) ? skip : [skip]).map(function (entry) {
    if (typeof entry !== 'function') {
      return function (element) {
        return element === entry;
      };
    }
    return entry;
  });

  var skipChecks = function skipChecks(element) {
    return skip && skipCompare.some(function (compare) {
      return compare(element);
    });
  };

  Object.keys(ignore).forEach(function (type) {
    var predicate = ignore[type];
    if (typeof predicate === 'function') return;
    if (typeof predicate === 'number') {
      predicate = predicate.toString();
    }
    if (typeof predicate === 'string') {
      predicate = new RegExp((0, _utilities.escapeValue)(predicate).replace(/\\/g, '\\\\'));
    }
    if (typeof predicate === 'boolean') {
      predicate = predicate ? /(?:)/ : /.^/;
    }
    // check class-/attributename for regex
    ignore[type] = function (name, value) {
      return predicate.test(value);
    };
  });

  while (element !== root && element.nodeType !== 11) {
    if (skipChecks(element) !== true) {
      // ~ global
      if (checkAttributes(element, path, options, select, toString, root)) break;
      if (checkTag(element, path, options, select, toString, root)) break;

      // ~ local
      checkAttributes(element, path, options, select, toString);
      if (path.length === length) {
        checkTag(element, path, options, select, toString);
      }

      if (path.length === length && [1, 'xpath'].includes(format) && !nested && element === node) {
        checkRecursiveDescendants(element, path, options, select, toString);
      }

      if (path.length === length && [1, 'xpath', 'jquery'].includes(format)) {
        checkText(element, path, options, select, toString, format === 'jquery');
      }

      if (path.length === length) {
        checkNthChild(element, path, options);
      }
    }

    element = element.parentNode;
    length = path.length;
  }

  if (element === root) {
    var pattern = findPattern(element, options, select, toString);
    path.unshift(pattern);
  }

  return path;
}

/**
 * Extend path with attribute identifier
 *
 * @param  {HTMLElement}     element  - [description]
 * @param  {Array.<Pattern>} path     - [description]
 * @param  {Options}         options  - [description]
 * @param  {function}        select   - [description]
 * @param  {ToStringApi}     toString - [description]
 * @param  {HTMLElement}     parent   - [description]
 * @return {boolean}                  - [description]
 */
var checkAttributes = function checkAttributes(element, path, _ref, select, toString) {
  var priority = _ref.priority,
      ignore = _ref.ignore;
  var parent = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : element.parentNode;

  var pattern = findAttributesPattern(priority, element, ignore, select, toString, parent);
  if (pattern) {
    path.unshift(pattern);
    return true;
  }
  return false;
};

/**
 * Calculates array of combinations of items in input array.
 * @param  {Array.<any>} values   - array of values
 * @param  {Object} options       - options: min - minimum subset size; max - maximum subset size
 * @return {Array.<Array.<any>>?}   array of subsets
 */
var combinations = exports.combinations = function combinations(values, options) {
  var _ref2 = options || {},
      min = _ref2.min,
      max = _ref2.max;

  var result = [[]];

  values.forEach(function (v) {
    result.forEach(function (r) {
      if (!max || r.length < max) {
        result.push(r.concat(v));
      }
    });
  });

  result.shift();
  return min ? result.filter(function (r) {
    return r.length >= min;
  }) : result;
};

// limit subset size to increase performance
var maxSubsetSize = [{ items: 13, max: 1 }, { items: 10, max: 2 }, { items: 8, max: 3 }, { items: 5, max: 4 }];

/**
 * Get class selector
 *
 * @param  {Array.<string>} classes - [description]
 * @param  {function}       select  - [description]
 * @param  {ToStringApi}    toString - [description]
 * @param  {HTMLElement}    parent  - [description]
 * @param  {Pattern}        base    - [description]
 * @return {Array.<string>?}        - [description]
 */
var getClassSelector = function getClassSelector() {
  var classes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
  var select = arguments[1];
  var toString = arguments[2];
  var parent = arguments[3];
  var base = arguments[4];

  var _ref3 = maxSubsetSize.find(function (_ref4) {
    var items = _ref4.items;
    return classes.length > items;
  }) || { max: classes.length },
      max = _ref3.max;

  var result = combinations(classes, { max: max });

  for (var i = 0; i < result.length; i++) {
    var pattern = toString.pattern(_extends({}, base, { classes: result[i] }));
    var matches = select(pattern, parent);
    if (matches.length === 1) {
      return result[i];
    }
  }

  return null;
};

/**
 * Lookup attribute identifier
 *
 * @param  {Array.<string>} priority  - [description]
 * @param  {HTMLElement}    element   - [description]
 * @param  {Object}         ignore    - [description]
 * @param  {function}       select    - [description]
 * @param  {ToStringApi}    toString  - [description]
 * @param  {ParentNode}     parent    - [description]
 * @return {Pattern?}                 - [description]
 */
var findAttributesPattern = function findAttributesPattern(priority, element, ignore, select, toString) {
  var parent = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : element.parentNode;

  var attributes = element.attributes;
  var attributeNames = Object.keys(attributes).map(function (val) {
    return attributes[val].name;
  }).filter(function (a) {
    return priority.indexOf(a) < 0;
  });

  var sortedKeys = [].concat(_toConsumableArray(priority), _toConsumableArray(attributeNames));
  var pattern = (0, _pattern.createPattern)();
  pattern.tag = element.tagName.toLowerCase();

  var isOptimal = function isOptimal(pattern) {
    return select(toString.pattern(pattern), parent).length === 1;
  };

  for (var i = 0, l = sortedKeys.length; i < l; i++) {
    var key = sortedKeys[i];
    var attribute = attributes[key];
    var attributeName = (0, _utilities.escapeValue)(attribute && attribute.name);
    var attributeValue = (0, _utilities.escapeValue)(attribute && attribute.value);
    var useNamedIgnore = attributeName !== 'class';

    var currentIgnore = useNamedIgnore && ignore[attributeName] || ignore.attribute;
    var currentDefaultIgnore = useNamedIgnore && defaultIgnore[attributeName] || defaultIgnore.attribute;
    if (checkIgnore(currentIgnore, attributeName, attributeValue, currentDefaultIgnore)) {
      continue;
    }

    switch (attributeName) {
      case 'class':
        {
          var _ret = function () {
            var classNames = attributeValue.trim().split(/\s+/g);
            if (!classNames[0]) {
              // empty string
              return 'break';
            }
            var classIgnore = ignore.class || defaultIgnore.class;
            if (classIgnore) {
              classNames = classNames.filter(function (className) {
                return !classIgnore(className);
              });
            }
            if (classNames.length > 0) {
              var classes = getClassSelector(classNames, select, toString, parent, pattern);
              if (classes) {
                pattern.classes = classes;
                if (isOptimal(pattern)) {
                  return {
                    v: pattern
                  };
                }
              }
            }
          }();

          switch (_ret) {
            case 'break':
              break;

            default:
              if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v;
          }
        }
        break;

      default:
        pattern.attributes.push({ name: attributeName, value: attributeValue });
        if (isOptimal(pattern)) {
          return pattern;
        }
    }
  }

  return null;
};

/**
 * Extend path with tag identifier
 *
 * @param  {HTMLElement}     element - [description]
 * @param  {Options}         options  - [description]
 * @param  {Array.<Pattern>} path    - [description]
 * @param  {function}        select  - [description]
 * @param  {ToStringApi}     toString - [description]
 * @param  {HTMLElement}     parent  - [description]
 * @return {boolean}                 - [description]
 */
var checkTag = function checkTag(element, path, _ref5, select, toString) {
  var ignore = _ref5.ignore;
  var parent = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : element.parentNode;

  var pattern = findTagPattern(element, ignore);
  if (pattern) {
    var matches = [];
    matches = select(toString.pattern(pattern), parent);
    if (matches.length === 1) {
      path.unshift(pattern);
      if (pattern.tag === 'iframe') {
        return false;
      }
      return true;
    }
  }
  return false;
};

/**
 * Lookup tag identifier
 *
 * @param  {HTMLElement} element - [description]
 * @param  {Object}      ignore  - [description]
 * @return {Pattern?}            - [description]
 */
var findTagPattern = function findTagPattern(element, ignore) {
  var tagName = element.tagName.toLowerCase();
  if (checkIgnore(ignore.tag, null, tagName)) {
    return null;
  }
  var pattern = (0, _pattern.createPattern)();
  pattern.tag = tagName;
  return pattern;
};

/**
 * Extend path with specific child identifier
 *
 * @param  {HTMLElement}     element - [description]
 * @param  {Options}         options - [description]
 * @param  {Array.<Pattern>} path    - [description]
 * @return {boolean}                 - [description]
 */
var checkNthChild = function checkNthChild(element, path, _ref6) {
  var ignore = _ref6.ignore;

  var parent = element.parentNode;
  var children = parent.children;
  for (var i = 0, l = children.length; i < l; i++) {
    var child = children[i];
    if (child === element) {
      var childPattern = findTagPattern(child, ignore);
      if (!childPattern) {
        return console.warn('\n          Element couldn\'t be matched through strict ignore pattern!\n        ', child, ignore, childPattern);
      }
      childPattern.relates = 'child';
      childPattern.pseudo = ['nth-child(' + (i + 1) + ')'];
      path.unshift(childPattern);
      return true;
    }
  }
  return false;
};

/**
 * Extend path with contains
 *
 * @param  {HTMLElement}     element  - [description]
 * @param  {Array.<Pattern>} path     - [description]
 * @param  {Options}         options  - [description]
 * @param  {function}        select   - [description]
 * @param  {ToStringApi}     toString - [description]
 * @param  {boolean}         nested   - [description]
 * @return {boolean}                  - [description]
 */
var checkText = function checkText(element, path, _ref7, select, toString, nested) {
  var ignore = _ref7.ignore;

  var pattern = findTagPattern(element, ignore);
  if (!pattern) {
    return false;
  }
  var textContent = nested ? element.textContent : element.firstChild && element.firstChild.nodeValue || '';
  if (!textContent) {
    return false;
  }

  pattern.relates = 'child';
  var parent = element.parentNode;
  var texts = textContent.replace(/\n+/g, '\n').split('\n').map(function (text) {
    return text.trim();
  }).filter(function (text) {
    return text.length > 0;
  });

  var contains = [];

  while (texts.length > 0) {
    var text = texts.shift();
    if (checkIgnore(ignore.contains, null, text, defaultIgnore.contains)) {
      break;
    }
    contains.push('contains("' + text + '")');

    var matches = select(toString.pattern(_extends({}, pattern, { pseudo: contains })), parent);
    if (matches.length === 1) {
      pattern.pseudo = contains;
      path.unshift(pattern);
      return true;
    }
    if (matches.length === 0) {
      return false;
    }
  }
  return false;
};

/**
 * Extend path with descendant tag
 *
 * @param  {HTMLElement}     element  - [description]
 * @param  {Array.<Pattern>} path     - [description]
 * @param  {Options}         options  - [description]
 * @param  {function}        select   - [description]
 * @param  {ToStringApi}     toString - [description]
 * @return {boolean}                  - [description]
 */
var checkRecursiveDescendants = function checkRecursiveDescendants(element, path, options, select, toString) {
  var pattern = findTagPattern(element, options.ignore);
  if (!pattern) {
    return false;
  }

  var descendants = Array.from(element.querySelectorAll('*'));
  while (descendants.length > 0) {
    var descendantPath = match(descendants.shift(), _extends({}, options, { root: element }), true);
    // avoid descendant selectors with nth-child
    if (!descendantPath.some(function (pattern) {
      return pattern.pseudo.some(function (p) {
        return p.startsWith('nth-child');
      });
    })) {
      var parent = element.parentElement;
      var matches = select(toString.pattern(_extends({}, pattern, { descendants: [descendantPath] })), parent);
      if (matches.length === 1) {
        pattern.descendants = [descendantPath];
        path.unshift(pattern);
        return true;
      }
    }
  }

  return false;
};

/**
 * Lookup identifier
 *
 * @param  {HTMLElement}    element  - [description]
 * @param  {Options}        options   - [description]
 * @param  {function}       select   - [description]
 * @param  {ToStringApi}    toString - [description]
 * @return {Pattern}                 - [description]
 */
var findPattern = function findPattern(element, _ref8, select, toString) {
  var priority = _ref8.priority,
      ignore = _ref8.ignore;

  var pattern = findAttributesPattern(priority, element, ignore, select, toString);
  if (!pattern) {
    pattern = findTagPattern(element, ignore);
  }
  return pattern;
};

/**
 * Validate with custom and default functions
 *
 * @param  {Function} predicate        - [description]
 * @param  {string?}  name             - [description]
 * @param  {string}   value            - [description]
 * @param  {Function} defaultPredicate - [description]
 * @return {boolean}                   - [description]
 */
var checkIgnore = exports.checkIgnore = function checkIgnore(predicate, name, value, defaultPredicate) {
  if (!value) {
    return true;
  }
  var check = predicate || defaultPredicate;
  if (!check) {
    return false;
  }
  return check(name, value, defaultPredicate);
};

/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getToString = exports.descendantsToXPath = exports.pathToXPath = exports.patternToXPath = exports.pseudoToXPath = exports.classesToXPath = exports.attributesToXPath = exports.pathToSelector = exports.patternToSelector = exports.pseudoToSelector = exports.classesToSelector = exports.attributesToSelector = exports.createPattern = undefined;

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _utilities = __webpack_require__(0);

/**
 * @typedef  {Object} Pattern
 * @property {('descendant' | 'child')}                  [relates]
 * @property {string}                                    [tag]
 * @property {Array.<{ name: string, value: string? }>}  attributes
 * @property {Array.<string>}                            classes
 * @property {Array.<string>}                            pseudo
 * @property {Array.<Array.<Pattern>>}                   descendants
 */

/**
 * Creates a new pattern structure
 * 
 * @param {Partial<Pattern>} pattern
 * @returns {Pattern}
 */
var createPattern = exports.createPattern = function createPattern() {
  var base = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return _extends({ attributes: [], classes: [], pseudo: [], descendants: [] }, base);
};

/**
 * Convert attributes to CSS selector
 * 
 * @param {Array.<{ name: string, value: string? }>} attributes 
 * @returns {string}
 */
var attributesToSelector = exports.attributesToSelector = function attributesToSelector(attributes) {
  return attributes.map(function (_ref) {
    var name = _ref.name,
        value = _ref.value;

    if (value === null) {
      return '[' + name + ']';
    }
    if (name === 'id' && (0, _utilities.isValidCSSIdentifier)(value)) {
      return '#' + value;
    }
    return '[' + name + '="' + value + '"]';
  }).join('');
};

/**
 * Convert classes to CSS selector
 * 
 * @param {Array.<string>} classes 
 * @returns {string}
 */
var classesToSelector = exports.classesToSelector = function classesToSelector(classes) {
  return classes.map(function (c) {
    return (0, _utilities.isValidCSSIdentifier)(c) ? '.' + c : '[class~="' + c + '"]';
  }).join('');
};

/**
 * Convert pseudo selectors to CSS selector
 * 
 * @param {Array.<string>} pseudo 
 * @returns {string}
 */
var pseudoToSelector = exports.pseudoToSelector = function pseudoToSelector(pseudo) {
  return pseudo.length ? ':' + pseudo.join(':') : '';
};

/**
 * Convert pattern to CSS selector
 * 
 * @param {Pattern} pattern 
 * @returns {string}
 */
var patternToSelector = exports.patternToSelector = function patternToSelector(pattern) {
  var relates = pattern.relates,
      tag = pattern.tag,
      attributes = pattern.attributes,
      classes = pattern.classes,
      pseudo = pattern.pseudo;

  var value = '' + (relates === 'child' ? '> ' : '') + (tag || '') + attributesToSelector(attributes) + classesToSelector(classes) + pseudoToSelector(pseudo);
  return value;
};

/**
 * Converts path to string
 *
 * @param {Array.<Pattern>} path 
 * @returns {string}
 */
var pathToSelector = exports.pathToSelector = function pathToSelector(path) {
  return path.map(patternToSelector).join(' ');
};

var convertEscaping = function convertEscaping(value) {
  return value && value.replace(/\\([`\\/:?&!#$%^()[\]{|}*+;,.<=>@~])/g, '$1').replace(/\\(['"])/g, '$1$1').replace(/\\A /g, '\n');
};

/**
* Convert attributes to XPath string
* 
* @param {Array.<{ name: string, value: string? }>} attributes 
* @returns {string}
*/
var attributesToXPath = exports.attributesToXPath = function attributesToXPath(attributes) {
  return attributes.map(function (_ref2) {
    var name = _ref2.name,
        value = _ref2.value;

    if (value === null) {
      return '[@' + name + ']';
    }
    return '[@' + name + '="' + convertEscaping(value) + '"]';
  }).join('');
};

/**
* Convert classes to XPath string
* 
* @param {Array.<string>} classes 
* @returns {string}
*/
var classesToXPath = exports.classesToXPath = function classesToXPath(classes) {
  return classes.map(function (c) {
    return '[contains(concat(" ",normalize-space(@class)," ")," ' + c + ' ")]';
  }).join('');
};

/**
* Convert pseudo selectors to XPath string
* 
* @param {Array.<string>} pseudo 
* @returns {string}
*/
var pseudoToXPath = exports.pseudoToXPath = function pseudoToXPath(pseudo) {
  return pseudo.map(function (p) {
    var match = p.match(/^(nth-child|nth-of-type|contains)\((.+)\)$/);
    if (!match) {
      return '';
    }

    switch (match[1]) {
      case 'nth-child':
        return '[(count(preceding-sibling::*)+1) = ' + match[2] + ']';

      case 'nth-of-type':
        return '[' + match[2] + ']';

      case 'contains':
        return '[contains(text(),' + match[2] + ')]';

      default:
        return '';
    }
  }).join('');
};

/**
* Convert pattern to XPath string
* 
* @param {Pattern} pattern 
* @returns {string}
*/
var patternToXPath = exports.patternToXPath = function patternToXPath(pattern) {
  var relates = pattern.relates,
      tag = pattern.tag,
      attributes = pattern.attributes,
      classes = pattern.classes,
      pseudo = pattern.pseudo,
      descendants = pattern.descendants;

  var value = '' + (relates === 'child' ? '/' : '//') + (tag || '*') + attributesToXPath(attributes) + classesToXPath(classes) + pseudoToXPath(pseudo) + descendantsToXPath(descendants);
  return value;
};

/**
* Converts path to XPath string
*
* @param {Array.<Pattern>} path 
* @returns {string}
*/
var pathToXPath = exports.pathToXPath = function pathToXPath(path) {
  return '.' + path.map(patternToXPath).join('');
};

/**
* Convert child selectors to XPath string
* 
* @param {Array.<Array.<Pattern>>} children 
* @returns {string}
*/
var descendantsToXPath = exports.descendantsToXPath = function descendantsToXPath(children) {
  return children.length ? '[' + children.map(pathToXPath).join('][') + ']' : '';
};

var toString = {
  'css': {
    attributes: attributesToSelector,
    classes: classesToSelector,
    pseudo: pseudoToSelector,
    pattern: patternToSelector,
    path: pathToSelector
  },
  'xpath': {
    attributes: attributesToXPath,
    classes: classesToXPath,
    pseudo: pseudoToXPath,
    pattern: patternToXPath,
    path: pathToXPath
  },
  'jquery': {}
};

toString.jquery = toString.css;
toString[0] = toString.css;
toString[1] = toString.xpath;

/**
 * @typedef  {Object} ToStringApi
 * @property {(attributes: Array.<{ name: string, value: string? }>) => string} attributes
 * @property {(classes: Array.<string>) => string}  classes
 * @property {(pseudo: Array.<string>) => string}   pseudo
 * @property {(pattern: Pattern) => string}         pattern
 * @property {(path: Array.<Pattern>) => string}    path
 */

/**
 * 
 * @param {Options} options 
 * @returns {ToStringApi}
 */
var getToString = exports.getToString = function getToString() {
  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return toString[options.format || 'css'];
};

/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
// import Sizzle from 'sizzle'
var Sizzle = void 0;

/**
 * Select element using jQuery
 * @param  {string}         selector
 * @param  {HTMLElement}    parent
 * @return Array.<HTMLElement>
 */
var selectJQuery = function selectJQuery(selector) {
  var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

  if (!Sizzle) {
    Sizzle = __webpack_require__(7);
  }
  return Sizzle(selector, parent || document);
};

/**
 * Select element using XPath
 * @param  {string}         selector
 * @param  {HTMLElement}    parent
 * @return Array.<HTMLElement>
 */
var selectXPath = function selectXPath(selector) {
  var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;

  parent = parent || document;
  var doc = parent;
  while (doc.parentNode) {
    doc = doc.parentNode;
  }
  if (doc !== parent && !selector.startsWith('.')) {
    selector = '.' + selector;
  }
  var iterator = doc.evaluate(selector, parent, null, 0);
  var elements = [];
  var element;
  while (element = iterator.iterateNext()) {
    elements.push(element);
  }
  return elements;
};

/**
 * Select element using CSS
 * @param  {string}         selector
 * @param  {HTMLElement}    parent
 * @return Array.<HTMLElement>
 */
var selectCSS = function selectCSS(selector) {
  var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
  return (parent || document).querySelectorAll(selector);
};

var select = {
  'css': selectCSS,
  'xpath': selectXPath,
  'jquery': selectJQuery
};

select[0] = select.css;
select[1] = select.xpath;

/**
* 
* @param {Options} options 
* @returns {(selector: string, parent: HTMLElement) => Array.<HTMLElement>}
*/
var getSelect = exports.getSelect = function getSelect() {
  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return function (selector, parent) {
    try {
      return select[options.format || 'css'](selector, parent || options.root);
    } catch (err) {
      return [];
    }
  };
};

/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getCommonProperties = exports.getCommonAncestor = undefined;

var _match = __webpack_require__(1);

var _utilities = __webpack_require__(0);

/**
 * # Common
 *
 * Process collections for similarities.
 */

/**
 * @typedef {import('./select').Options} Options
 */

/**
 * Find the last common ancestor of elements
 *
 * @param  {Array.<HTMLElement>} elements  - [description]
 * @param  {Options}              options  - [description]
 * @return {HTMLElement}                   - [description]
 */
var getCommonAncestor = exports.getCommonAncestor = function getCommonAncestor(elements) {
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var _options$root = options.root,
      root = _options$root === undefined ? document : _options$root;


  var ancestors = [];

  elements.forEach(function (element, index) {
    var parents = [];
    while (element !== root) {
      element = element.parentNode;
      parents.unshift(element);
    }
    ancestors[index] = parents;
  });

  ancestors.sort(function (curr, next) {
    return curr.length - next.length;
  });

  var shallowAncestor = ancestors.shift();

  var ancestor = null;

  var _loop = function _loop() {
    var parent = shallowAncestor[i];
    var missing = ancestors.some(function (otherParents) {
      return !otherParents.some(function (otherParent) {
        return otherParent === parent;
      });
    });

    if (missing) {
      // TODO: find similar sub-parents, not the top root, e.g. sharing a class selector
      return 'break';
    }

    ancestor = parent;
  };

  for (var i = 0, l = shallowAncestor.length; i < l; i++) {
    var _ret = _loop();

    if (_ret === 'break') break;
  }

  return ancestor;
};

/**
 * Get a set of common properties of elements
 *
 * @param  {Array.<HTMLElement>} elements - [description]
 * @return {Object}                       - [description]
 */
var getCommonProperties = exports.getCommonProperties = function getCommonProperties(elements) {
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var _options$ignore = options.ignore,
      ignore = _options$ignore === undefined ? {} : _options$ignore;


  var commonProperties = {
    classes: [],
    attributes: {},
    tag: null
  };

  elements.forEach(function (element) {
    var commonClasses = commonProperties.classes,
        commonAttributes = commonProperties.attributes,
        commonTag = commonProperties.tag;

    // ~ classes

    if (commonClasses !== undefined) {
      var classes = element.getAttribute('class');
      if (classes) {
        classes = classes.trim().split(' ').filter(function (cls) {
          return !ignore.class || !ignore.class(cls);
        });
        if (!commonClasses.length) {
          commonProperties.classes = classes;
        } else {
          commonClasses = commonClasses.filter(function (entry) {
            return classes.some(function (name) {
              return name === entry;
            });
          });
          if (commonClasses.length) {
            commonProperties.classes = commonClasses;
          } else {
            delete commonProperties.classes;
          }
        }
      } else {
        delete commonProperties.classes;
      }
    }

    // ~ attributes
    if (commonAttributes !== undefined) {
      var elementAttributes = element.attributes;
      var attributes = Object.keys(elementAttributes).reduce(function (attributes, key) {
        var attribute = elementAttributes[key];
        var attributeName = (0, _utilities.escapeValue)(attribute && attribute.name);
        var attributeValue = (0, _utilities.escapeValue)(attribute && attribute.value);
        var useNamedIgnore = attributeName !== 'class';
        var currentIgnore = useNamedIgnore && ignore[attributeName] || ignore.attribute;
        var currentDefaultIgnore = useNamedIgnore && _match.defaultIgnore[attributeName] || _match.defaultIgnore.attribute;
        if (attribute && attributeName !== 'class' && !(0, _match.checkIgnore)(currentIgnore, attributeName, attributeValue, currentDefaultIgnore)) {
          attributes[attributeName] = attribute.value;
        }
        return attributes;
      }, {});

      var attributesNames = Object.keys(attributes);
      var commonAttributesNames = Object.keys(commonAttributes);

      if (attributesNames.length) {
        if (!commonAttributesNames.length) {
          commonProperties.attributes = attributes;
        } else {
          commonAttributes = commonAttributesNames.reduce(function (nextCommonAttributes, name) {
            var value = commonAttributes[name];
            if (value === attributes[name]) {
              nextCommonAttributes[name] = value;
            }
            return nextCommonAttributes;
          }, {});
          if (Object.keys(commonAttributes).length) {
            commonProperties.attributes = commonAttributes;
          } else {
            delete commonProperties.attributes;
          }
        }
      } else {
        delete commonProperties.attributes;
      }
    }

    // ~ tag
    if (commonTag !== undefined) {
      var tag = element.tagName.toLowerCase();
      if (!commonTag) {
        commonProperties.tag = tag;
      } else if (tag !== commonTag) {
        delete commonProperties.tag;
      }
    }
  });

  return commonProperties;
};

/***/ },
/* 5 */
/***/ function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.compareResults = undefined;

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

exports.default = optimize;

var _selector = __webpack_require__(3);

var _pattern2 = __webpack_require__(2);

var _utilities = __webpack_require__(0);

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } /**
                                                                                                                                                                                                     * # Optimize
                                                                                                                                                                                                     *
                                                                                                                                                                                                     * 1.) Improve efficiency through shorter selectors by removing redundancy
                                                                                                                                                                                                     * 2.) Improve robustness through selector transformation
                                                                                                                                                                                                     */

/**
 * @typedef {import('./select').Options} Options
 * @typedef {import('./pattern').Pattern} Pattern
 * @typedef {import('./pattern').ToStringApi} Pattern
 */

/**
 * Apply different optimization techniques
 *
 * @param  {Array.<Pattern>}                 path   - [description]
 * @param  {HTMLElement|Array.<HTMLElement>} element    - [description]
 * @param  {Options}                         [options]  - [description]
 * @return {Array.<Pattern>}                            - [description]
 */
function optimize(path, elements) {
  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

  if (path.length === 0) {
    return [];
  }

  if (path[0].relates === 'child') {
    path[0].relates = undefined;
  }

  // convert single entry and NodeList
  if (!Array.isArray(elements)) {
    elements = !elements.length ? [elements] : (0, _utilities.convertNodeList)(elements);
  }

  if (!elements.length || elements.some(function (element) {
    return element.nodeType !== 1;
  })) {
    throw new Error('Invalid input - to compare HTMLElements its necessary to provide a reference of the selected node(s)! (missing "elements")');
  }

  var select = (0, _selector.getSelect)(options);
  var toString = (0, _pattern2.getToString)(options);

  if (path.length === 1) {
    return [optimizePart([], path[0], [], elements, select, toString)];
  }

  var endOptimized = false;
  if (path[path.length - 1].relates === 'child') {
    path[path.length - 1] = optimizePart(path.slice(0, -1), path[path.length - 1], [], elements, select, toString);
    endOptimized = true;
  }

  path = [].concat(_toConsumableArray(path));
  var shortened = [path.pop()];

  var _loop = function _loop() {
    var current = path.pop();
    var matches = select(toString.path([].concat(_toConsumableArray(path), shortened)));
    var hasSameResult = matches.length === elements.length && elements.every(function (element, i) {
      return element === matches[i];
    });
    if (!hasSameResult) {
      shortened.unshift(optimizePart(path, current, shortened, elements, select, toString));
    }
  };

  while (path.length > 1) {
    _loop();
  }
  shortened.unshift(path[0]);
  path = shortened;

  // optimize start + end
  path[0] = optimizePart([], path[0], path.slice(1), elements, select, toString);
  if (!endOptimized) {
    path[path.length - 1] = optimizePart(path.slice(0, -1), path[path.length - 1], [], elements, select, toString);
  }

  return path;
}

/**
 * Optimize :contains
 *
 * @param  {Array.<Pattern>}     pre      - [description]
 * @param  {Pattern}             current  - [description]
 * @param  {Array.<Pattern>}     post     - [description]
 * @param  {Array.<HTMLElement>} elements - [description]
 * @param  {function}            select   - [description]
 * @param  {ToStringApi}         toString - [description]
 * @return {Pattern}                      - [description]
 */
var optimizeText = function optimizeText(pre, current, post, elements, select, toString) {
  var _partition = (0, _utilities.partition)(current.pseudo, function (item) {
    return item.startsWith('contains');
  }),
      _partition2 = _slicedToArray(_partition, 2),
      contains = _partition2[0],
      other = _partition2[1];

  if (contains.length > 0 && post.length) {
    var base = _extends({}, current, { pseudo: [].concat(_toConsumableArray(other), _toConsumableArray(contains)) });
    while (base.pseudo.length > other.length) {
      var optimized = base.pseudo.slice(0, -1);
      if (!compareResults(select(toString.path([].concat(_toConsumableArray(pre), [_extends({}, base, { pseudo: optimized })], _toConsumableArray(post)))), elements)) {
        break;
      }
      base.pseudo = optimized;
    }
    return base;
  }
  return current;
};

/**
 * Optimize attributes
 *
 * @param  {Array.<Pattern>}     pre      - [description]
 * @param  {Pattern}             current  - [description]
 * @param  {Array.<Pattern>}     post     - [description]
 * @param  {Array.<HTMLElement>} elements - [description]
 * @param  {function}            select   - [description]
 * @param  {ToStringApi}         toString - [description]
 * @return {Pattern}                      - [description]
 */
var optimizeAttributes = function optimizeAttributes(pre, current, post, elements, select, toString) {
  // reduce attributes: first try without value, then removing completely
  if (current.attributes.length > 0) {
    var attributes = [].concat(_toConsumableArray(current.attributes));

    var simplify = function simplify(original, getSimplified) {
      var i = original.length - 1;
      while (i >= 0) {
        var _attributes = getSimplified(original, i);
        if (!compareResults(select(toString.path([].concat(_toConsumableArray(pre), [_extends({}, current, { attributes: _attributes })], _toConsumableArray(post)))), elements)) {
          break;
        }
        i--;
        original = _attributes;
      }
      return original;
    };

    var simplified = simplify(attributes, function (attributes, i) {
      var name = attributes[i].name;

      if (name === 'id') {
        return attributes;
      }
      return [].concat(_toConsumableArray(attributes.slice(0, i)), [{ name: name, value: null }], _toConsumableArray(attributes.slice(i + 1)));
    });
    return _extends({}, current, { attributes: simplify(simplified, function (attributes) {
        return attributes.slice(0, -1);
      }) });
  }
  return current;
};

/**
 * Optimize descendant
 *
 * @param  {Array.<Pattern>}     pre      - [description]
 * @param  {Pattern}             current  - [description]
 * @param  {Array.<Pattern>}     post     - [description]
 * @param  {Array.<HTMLElement>} elements - [description]
 * @param  {function}            select   - [description]
 * @param  {ToStringApi}         toString - [description]
 * @return {Pattern}                      - [description]
 */
var optimizeDescendant = function optimizeDescendant(pre, current, post, elements, select, toString) {
  // robustness: descendant instead child (heuristic)
  if (current.relates === 'child') {
    var descendant = _extends({}, current, { relates: undefined });
    var _matches = select(toString.path([].concat(_toConsumableArray(pre), [descendant], _toConsumableArray(post))));
    if (compareResults(_matches, elements)) {
      return descendant;
    }
  }
  return current;
};

/**
 * Optimize recursive descendants
 * 
 * @param  {Array.<Pattern>}     pre      - [description]
 * @param  {Pattern}             current  - [description]
 * @param  {Array.<Pattern>}     post     - [description]
 * @param  {Array.<HTMLElement>} elements - [description]
 * @param  {function}            select   - [description]
 * @param  {ToStringApi}         toString - [description]
 * @return {Pattern}                      - [description]
 */
var optimizeRecursiveDescendants = function optimizeRecursiveDescendants(pre, current, post, elements, select, toString) {
  if (current.descendants.length > 0 && post.length) {
    var base = _extends({}, current, { descendants: [].concat(_toConsumableArray(current.descendants)) });
    while (base.descendants.length > 0) {
      var optimized = base.descendants.slice(0, -1);
      if (!compareResults(select(toString.path([].concat(_toConsumableArray(pre), [_extends({}, base, { descendants: optimized })], _toConsumableArray(post)))), elements)) {
        break;
      }
      base.descendants = optimized;
    }
    return base;
  }
  return current;
};

/**
 * Optimize nth of type
 *
 * @param  {Array.<Pattern>}     pre      - [description]
 * @param  {Pattern}             current  - [description]
 * @param  {Array.<Pattern>}     post     - [description]
 * @param  {Array.<HTMLElement>} elements - [description]
 * @param  {function}            select   - [description]
 * @param  {ToStringApi}         toString - [description]
 * @return {Pattern}                      - [description]
 */
var optimizeNthOfType = function optimizeNthOfType(pre, current, post, elements, select, toString) {
  var i = current.pseudo.findIndex(function (item) {
    return item.startsWith('nth-child');
  });
  // robustness: 'nth-of-type' instead 'nth-child' (heuristic)
  if (i >= 0) {
    // TODO: consider complete coverage of 'nth-of-type' replacement
    var type = current.pseudo[i].replace(/^nth-child/, 'nth-of-type');
    var nthOfType = _extends({}, current, { pseudo: [].concat(_toConsumableArray(current.pseudo.slice(0, i)), [type], _toConsumableArray(current.pseudo.slice(i + 1))) });
    var pattern = toString.path([].concat(_toConsumableArray(pre), [nthOfType], _toConsumableArray(post)));
    var _matches2 = select(pattern);
    if (compareResults(_matches2, elements)) {
      return nthOfType;
    }
  }
  return current;
};

/**
 * Optimize classes
 *
 * @param  {Array.<Pattern>}     pre      - [description]
 * @param  {Pattern}             current  - [description]
 * @param  {Array.<Pattern>}     post     - [description]
 * @param  {Array.<HTMLElement>} elements - [description]
 * @param  {function}            select   - [description]
 * @param  {ToStringApi}         toString - [description]
 * @return {Pattern}                      - [description]
 */
var optimizeClasses = function optimizeClasses(pre, current, post, elements, select, toString) {
  // efficiency: combinations of classname (partial permutations)
  if (current.classes.length > 1) {
    var optimized = current.classes.slice().sort(function (curr, next) {
      return curr.length - next.length;
    });

    while (optimized.length > 1) {
      optimized.shift();
      var _pattern = toString.path([].concat(_toConsumableArray(pre), [_extends({}, current, { classes: optimized })], _toConsumableArray(post)));
      if (!compareResults(select(_pattern), elements)) {
        break;
      }
      current.classes = optimized;
    }

    optimized = current.classes;

    if (optimized.length > 2) {
      var base = (0, _pattern2.createPattern)({ classes: optimized });
      var references = select(toString.path([].concat(_toConsumableArray(pre), [base])));

      var _loop2 = function _loop2() {
        var reference = references[i];
        if (elements.some(function (element) {
          return reference.contains(element);
        })) {
          // TODO:
          // - check using attributes + regard excludes
          var description = (0, _pattern2.createPattern)({ tag: reference.tagName });
          pattern = toString.path([].concat(_toConsumableArray(pre), [description], _toConsumableArray(post)));
          matches = select(pattern);

          if (compareResults(matches, elements)) {
            current = description;
          }
          return 'break';
        }
      };

      for (var i = 0; i < references.length; i++) {
        var pattern;
        var matches;

        var _ret2 = _loop2();

        if (_ret2 === 'break') break;
      }
    }
  }
  return current;
};

var optimizers = [optimizeText, optimizeAttributes, optimizeDescendant, optimizeRecursiveDescendants, optimizeNthOfType, optimizeClasses];

/**
 * Improve a chunk of the selector
 *
 * @param  {Array.<Pattern>}     pre      - [description]
 * @param  {Pattern}             current  - [description]
 * @param  {Array.<Pattern>}     post     - [description]
 * @param  {Array.<HTMLElement>} elements - [description]
 * @param  {function}            select   - [description]
 * @param  {ToStringApi}         toString - [description]
 * @return {Pattern}                      - [description]
 */
var optimizePart = function optimizePart(pre, current, post, elements, select, toString) {
  return optimizers.reduce(function (acc, optimizer) {
    return optimizer(pre, acc, post, elements, select, toString);
  }, current);
};

/**
 * Evaluate matches with expected elements
 *
 * @param  {Array.<HTMLElement>} matches  - [description]
 * @param  {Array.<HTMLElement>} elements - [description]
 * @return {Boolean}                      - [description]
 */
var compareResults = exports.compareResults = function compareResults(matches, elements) {
  var length = matches.length;

  return length === elements.length && elements.every(function (element) {
    for (var i = 0; i < length; i++) {
      if (matches[i] === element) {
        return true;
      }
    }
    return false;
  });
};

/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getMultiSelectorPath = exports.getSingleSelectorPath = undefined;

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; /**
                                                                                                                                                                                                                                                                               * # Select
                                                                                                                                                                                                                                                                               *
                                                                                                                                                                                                                                                                               * Construct a unique CSS query selector to access the selected DOM element(s).
                                                                                                                                                                                                                                                                               * For longevity it applies different matching and optimization strategies.
                                                                                                                                                                                                                                                                               */


exports.default = getQuerySelector;

var _match = __webpack_require__(1);

var _match2 = _interopRequireDefault(_match);

var _optimize = __webpack_require__(5);

var _optimize2 = _interopRequireDefault(_optimize);

var _utilities = __webpack_require__(0);

var _common = __webpack_require__(4);

var _selector = __webpack_require__(3);

var _pattern = __webpack_require__(2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

/**
 * @typedef  {Object} Options
 * @property {HTMLElement} [root]                     Optionally specify the root element
 * @property {function | Array.<HTMLElement>} [skip]  Specify elements to skip
 * @property {Array.<string>} [priority]              Order of attribute processing
 * @property {Object<string, function | number | string | boolean} [ignore] Define patterns which shouldn't be included
 * @property {('css'|'xpath'|'jquery')} [format]      Output format    
 */

/**
 * @typedef {import('./pattern').Pattern} Pattern
 */

/**
 * Get a selector for the provided element
 *
 * @param  {HTMLElement} element   - [description]
 * @param  {Options}     [options] - [description]
 * @return {Array.<Pattern>}       - [description]
 */
var getSingleSelectorPath = exports.getSingleSelectorPath = function getSingleSelectorPath(element) {
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};


  if (element.nodeType === 3) {
    element = element.parentNode;
  }

  if (element.nodeType !== 1) {
    throw new Error('Invalid input - only HTMLElements or representations of them are supported! (not "' + (typeof element === 'undefined' ? 'undefined' : _typeof(element)) + '")');
  }

  var path = (0, _match2.default)(element, options);
  var optimizedPath = (0, _optimize2.default)(path, element, options);

  // debug
  // console.log(`
  //   selector:  ${path}
  //   optimized: ${optimizedPath}
  // `)

  return optimizedPath;
};

/**
 * Get a selector to match multiple descendants from an ancestor
 *
 * @param  {Array.<HTMLElement>|NodeList} elements   - [description]
 * @param  {Options}                      [options]  - [description]
 * @return {Array.<Pattern>}                         - [description]
 */
var getMultiSelectorPath = exports.getMultiSelectorPath = function getMultiSelectorPath(elements) {
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};


  if (!Array.isArray(elements)) {
    elements = (0, _utilities.convertNodeList)(elements);
  }

  if (elements.some(function (element) {
    return element.nodeType !== 1;
  })) {
    throw new Error('Invalid input - only an Array of HTMLElements or representations of them is supported!');
  }

  var select = (0, _selector.getSelect)(options);
  var toString = (0, _pattern.getToString)(options);

  var ancestor = (0, _common.getCommonAncestor)(elements, options);
  var ancestorPath = (0, _match2.default)(ancestor, options);

  // TODO: consider usage of multiple selectors + parent-child relation + check for part redundancy
  var commonPath = getCommonPath(elements, options);
  var descendantPattern = commonPath[0];

  var selectorPath = (0, _optimize2.default)([].concat(_toConsumableArray(ancestorPath), [descendantPattern]), elements, options);
  var selectorMatches = (0, _utilities.convertNodeList)(select(toString.path(selectorPath)));

  if (!elements.every(function (element) {
    return selectorMatches.some(function (entry) {
      return entry === element;
    });
  })) {
    // TODO: cluster matches to split into similar groups for sub selections
    console.warn('\n      The selected elements can\'t be efficiently mapped.\n      Its probably best to use multiple single selectors instead!\n    ');
    return elements;
  }

  return selectorPath;
};

/**
 * Get selectors to describe a set of elements
 *
 * @param  {Array.<HTMLElement>} elements  - [description]
 * @return {Array.<Pattern>}               - [description]
 */
var getCommonPath = function getCommonPath(elements, options) {
  var _getCommonProperties = (0, _common.getCommonProperties)(elements, options),
      classes = _getCommonProperties.classes,
      attributes = _getCommonProperties.attributes,
      tag = _getCommonProperties.tag;

  return [(0, _pattern.createPattern)({
    tag: tag,
    classes: classes || [],
    attributes: attributes ? Object.keys(attributes).map(function (name) {
      return {
        name: (0, _utilities.escapeValue)(name),
        value: (0, _utilities.escapeValue)(attributes[name])
      };
    }) : []
  })];
};

/**
 * Choose action depending on the input (multiple/single)
 *
 * NOTE: extended detection is used for special cases like the <select> element with <options>
 *
 * @param  {HTMLElement|NodeList|Array.<HTMLElement>} input     - [description]
 * @param  {Options}                                  [options] - [description]
 * @return {string}                                             - [description]
 */
function getQuerySelector(input) {
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

  var path = input.length && !input.name ? getMultiSelectorPath(input, options) : getSingleSelectorPath(input, options);

  if (Array.isArray(path) && path.length > 0 && path[0] instanceof HTMLElement) {
    return path.map(function (entry) {
      return getQuerySelector(entry, options);
    }).join(',');
  }
  return (0, _pattern.getToString)(options).path(path);
}

/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {

"use strict";
var __WEBPACK_AMD_DEFINE_RESULT__;

/*!
 * Sizzle CSS Selector Engine v2.3.6
 * https://sizzlejs.com/
 *
 * Copyright JS Foundation and other contributors
 * Released under the MIT license
 * https://js.foundation/
 *
 * Date: 2021-02-16
 */
(function (window) {
	var i,
	    support,
	    Expr,
	    getText,
	    isXML,
	    tokenize,
	    compile,
	    select,
	    outermostContext,
	    sortInput,
	    hasDuplicate,


	// Local document vars
	setDocument,
	    document,
	    docElem,
	    documentIsHTML,
	    rbuggyQSA,
	    rbuggyMatches,
	    matches,
	    contains,


	// Instance-specific data
	expando = "sizzle" + 1 * new Date(),
	    preferredDoc = window.document,
	    dirruns = 0,
	    done = 0,
	    classCache = createCache(),
	    tokenCache = createCache(),
	    compilerCache = createCache(),
	    nonnativeSelectorCache = createCache(),
	    sortOrder = function sortOrder(a, b) {
		if (a === b) {
			hasDuplicate = true;
		}
		return 0;
	},


	// Instance methods
	hasOwn = {}.hasOwnProperty,
	    arr = [],
	    pop = arr.pop,
	    pushNative = arr.push,
	    push = arr.push,
	    slice = arr.slice,


	// Use a stripped-down indexOf as it's faster than native
	// https://jsperf.com/thor-indexof-vs-for/5
	indexOf = function indexOf(list, elem) {
		var i = 0,
		    len = list.length;
		for (; i < len; i++) {
			if (list[i] === elem) {
				return i;
			}
		}
		return -1;
	},
	    booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" + "ismap|loop|multiple|open|readonly|required|scoped",


	// Regular expressions

	// http://www.w3.org/TR/css3-selectors/#whitespace
	whitespace = "[\\x20\\t\\r\\n\\f]",


	// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
	identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",


	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +

	// Operator (capture 2)
	"*([*^$|!~]?=)" + whitespace +

	// "Attribute values must be CSS identifiers [capture 5]
	// or strings [capture 3 or capture 4]"
	"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + "*\\]",
	    pseudos = ":(" + identifier + ")(?:\\((" +

	// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
	// 1. quoted (capture 3; capture 4 or capture 5)
	"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +

	// 2. simple (capture 6)
	"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +

	// 3. anything else (capture 2)
	".*" + ")\\)|)",


	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
	rwhitespace = new RegExp(whitespace + "+", "g"),
	    rtrim = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g"),
	    rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"),
	    rcombinators = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"),
	    rdescend = new RegExp(whitespace + "|>"),
	    rpseudo = new RegExp(pseudos),
	    ridentifier = new RegExp("^" + identifier + "$"),
	    matchExpr = {
		"ID": new RegExp("^#(" + identifier + ")"),
		"CLASS": new RegExp("^\\.(" + identifier + ")"),
		"TAG": new RegExp("^(" + identifier + "|[*])"),
		"ATTR": new RegExp("^" + attributes),
		"PSEUDO": new RegExp("^" + pseudos),
		"CHILD": new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i"),
		"bool": new RegExp("^(?:" + booleans + ")$", "i"),

		// For use in libraries implementing .is()
		// We use this for POS matching in `select`
		"needsContext": new RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i")
	},
	    rhtml = /HTML$/i,
	    rinputs = /^(?:input|select|textarea|button)$/i,
	    rheader = /^h\d$/i,
	    rnative = /^[^{]+\{\s*\[native \w/,


	// Easily-parseable/retrievable ID or TAG or CLASS selectors
	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
	    rsibling = /[+~]/,


	// CSS escapes
	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
	runescape = new RegExp("\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g"),
	    funescape = function funescape(escape, nonHex) {
		var high = "0x" + escape.slice(1) - 0x10000;

		return nonHex ?

		// Strip the backslash prefix from a non-hex escape sequence
		nonHex :

		// Replace a hexadecimal escape sequence with the encoded Unicode code point
		// Support: IE <=11+
		// For values outside the Basic Multilingual Plane (BMP), manually construct a
		// surrogate pair
		high < 0 ? String.fromCharCode(high + 0x10000) : String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00);
	},


	// CSS string/identifier serialization
	// https://drafts.csswg.org/cssom/#common-serializing-idioms
	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
	    fcssescape = function fcssescape(ch, asCodePoint) {
		if (asCodePoint) {

			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
			if (ch === "\0") {
				return "\uFFFD";
			}

			// Control characters and (dependent upon position) numbers get escaped as code points
			return ch.slice(0, -1) + "\\" + ch.charCodeAt(ch.length - 1).toString(16) + " ";
		}

		// Other potentially-special ASCII characters get backslash-escaped
		return "\\" + ch;
	},


	// Used for iframes
	// See setDocument()
	// Removing the function wrapper causes a "Permission Denied"
	// error in IE
	unloadHandler = function unloadHandler() {
		setDocument();
	},
	    inDisabledFieldset = addCombinator(function (elem) {
		return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
	}, { dir: "parentNode", next: "legend" });

	// Optimize for push.apply( _, NodeList )
	try {
		push.apply(arr = slice.call(preferredDoc.childNodes), preferredDoc.childNodes);

		// Support: Android<4.0
		// Detect silently failing push.apply
		// eslint-disable-next-line no-unused-expressions
		arr[preferredDoc.childNodes.length].nodeType;
	} catch (e) {
		push = { apply: arr.length ?

			// Leverage slice if possible
			function (target, els) {
				pushNative.apply(target, slice.call(els));
			} :

			// Support: IE<9
			// Otherwise append directly
			function (target, els) {
				var j = target.length,
				    i = 0;

				// Can't trust NodeList.length
				while (target[j++] = els[i++]) {}
				target.length = j - 1;
			}
		};
	}

	function Sizzle(selector, context, results, seed) {
		var m,
		    i,
		    elem,
		    nid,
		    match,
		    groups,
		    newSelector,
		    newContext = context && context.ownerDocument,


		// nodeType defaults to 9, since context defaults to document
		nodeType = context ? context.nodeType : 9;

		results = results || [];

		// Return early from calls with invalid selector or context
		if (typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11) {

			return results;
		}

		// Try to shortcut find operations (as opposed to filters) in HTML documents
		if (!seed) {
			setDocument(context);
			context = context || document;

			if (documentIsHTML) {

				// If the selector is sufficiently simple, try using a "get*By*" DOM method
				// (excepting DocumentFragment context, where the methods don't exist)
				if (nodeType !== 11 && (match = rquickExpr.exec(selector))) {

					// ID selector
					if (m = match[1]) {

						// Document context
						if (nodeType === 9) {
							if (elem = context.getElementById(m)) {

								// Support: IE, Opera, Webkit
								// TODO: identify versions
								// getElementById can match elements by name instead of ID
								if (elem.id === m) {
									results.push(elem);
									return results;
								}
							} else {
								return results;
							}

							// Element context
						} else {

							// Support: IE, Opera, Webkit
							// TODO: identify versions
							// getElementById can match elements by name instead of ID
							if (newContext && (elem = newContext.getElementById(m)) && contains(context, elem) && elem.id === m) {

								results.push(elem);
								return results;
							}
						}

						// Type selector
					} else if (match[2]) {
						push.apply(results, context.getElementsByTagName(selector));
						return results;

						// Class selector
					} else if ((m = match[3]) && support.getElementsByClassName && context.getElementsByClassName) {

						push.apply(results, context.getElementsByClassName(m));
						return results;
					}
				}

				// Take advantage of querySelectorAll
				if (support.qsa && !nonnativeSelectorCache[selector + " "] && (!rbuggyQSA || !rbuggyQSA.test(selector)) && (

				// Support: IE 8 only
				// Exclude object elements
				nodeType !== 1 || context.nodeName.toLowerCase() !== "object")) {

					newSelector = selector;
					newContext = context;

					// qSA considers elements outside a scoping root when evaluating child or
					// descendant combinators, which is not what we want.
					// In such cases, we work around the behavior by prefixing every selector in the
					// list with an ID selector referencing the scope context.
					// The technique has to be used as well when a leading combinator is used
					// as such selectors are not recognized by querySelectorAll.
					// Thanks to Andrew Dupont for this technique.
					if (nodeType === 1 && (rdescend.test(selector) || rcombinators.test(selector))) {

						// Expand context for sibling selectors
						newContext = rsibling.test(selector) && testContext(context.parentNode) || context;

						// We can use :scope instead of the ID hack if the browser
						// supports it & if we're not changing the context.
						if (newContext !== context || !support.scope) {

							// Capture the context ID, setting it first if necessary
							if (nid = context.getAttribute("id")) {
								nid = nid.replace(rcssescape, fcssescape);
							} else {
								context.setAttribute("id", nid = expando);
							}
						}

						// Prefix every selector in the list
						groups = tokenize(selector);
						i = groups.length;
						while (i--) {
							groups[i] = (nid ? "#" + nid : ":scope") + " " + toSelector(groups[i]);
						}
						newSelector = groups.join(",");
					}

					try {
						push.apply(results, newContext.querySelectorAll(newSelector));
						return results;
					} catch (qsaError) {
						nonnativeSelectorCache(selector, true);
					} finally {
						if (nid === expando) {
							context.removeAttribute("id");
						}
					}
				}
			}
		}

		// All others
		return select(selector.replace(rtrim, "$1"), context, results, seed);
	}

	/**
  * Create key-value caches of limited size
  * @returns {function(string, object)} Returns the Object data after storing it on itself with
  *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
  *	deleting the oldest entry
  */
	function createCache() {
		var keys = [];

		function cache(key, value) {

			// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
			if (keys.push(key + " ") > Expr.cacheLength) {

				// Only keep the most recent entries
				delete cache[keys.shift()];
			}
			return cache[key + " "] = value;
		}
		return cache;
	}

	/**
  * Mark a function for special use by Sizzle
  * @param {Function} fn The function to mark
  */
	function markFunction(fn) {
		fn[expando] = true;
		return fn;
	}

	/**
  * Support testing using an element
  * @param {Function} fn Passed the created element and returns a boolean result
  */
	function assert(fn) {
		var el = document.createElement("fieldset");

		try {
			return !!fn(el);
		} catch (e) {
			return false;
		} finally {

			// Remove from its parent by default
			if (el.parentNode) {
				el.parentNode.removeChild(el);
			}

			// release memory in IE
			el = null;
		}
	}

	/**
  * Adds the same handler for all of the specified attrs
  * @param {String} attrs Pipe-separated list of attributes
  * @param {Function} handler The method that will be applied
  */
	function addHandle(attrs, handler) {
		var arr = attrs.split("|"),
		    i = arr.length;

		while (i--) {
			Expr.attrHandle[arr[i]] = handler;
		}
	}

	/**
  * Checks document order of two siblings
  * @param {Element} a
  * @param {Element} b
  * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
  */
	function siblingCheck(a, b) {
		var cur = b && a,
		    diff = cur && a.nodeType === 1 && b.nodeType === 1 && a.sourceIndex - b.sourceIndex;

		// Use IE sourceIndex if available on both nodes
		if (diff) {
			return diff;
		}

		// Check if b follows a
		if (cur) {
			while (cur = cur.nextSibling) {
				if (cur === b) {
					return -1;
				}
			}
		}

		return a ? 1 : -1;
	}

	/**
  * Returns a function to use in pseudos for input types
  * @param {String} type
  */
	function createInputPseudo(type) {
		return function (elem) {
			var name = elem.nodeName.toLowerCase();
			return name === "input" && elem.type === type;
		};
	}

	/**
  * Returns a function to use in pseudos for buttons
  * @param {String} type
  */
	function createButtonPseudo(type) {
		return function (elem) {
			var name = elem.nodeName.toLowerCase();
			return (name === "input" || name === "button") && elem.type === type;
		};
	}

	/**
  * Returns a function to use in pseudos for :enabled/:disabled
  * @param {Boolean} disabled true for :disabled; false for :enabled
  */
	function createDisabledPseudo(disabled) {

		// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
		return function (elem) {

			// Only certain elements can match :enabled or :disabled
			// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
			// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
			if ("form" in elem) {

				// Check for inherited disabledness on relevant non-disabled elements:
				// * listed form-associated elements in a disabled fieldset
				//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
				//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
				// * option elements in a disabled optgroup
				//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
				// All such elements have a "form" property.
				if (elem.parentNode && elem.disabled === false) {

					// Option elements defer to a parent optgroup if present
					if ("label" in elem) {
						if ("label" in elem.parentNode) {
							return elem.parentNode.disabled === disabled;
						} else {
							return elem.disabled === disabled;
						}
					}

					// Support: IE 6 - 11
					// Use the isDisabled shortcut property to check for disabled fieldset ancestors
					return elem.isDisabled === disabled ||

					// Where there is no isDisabled, check manually
					/* jshint -W018 */
					elem.isDisabled !== !disabled && inDisabledFieldset(elem) === disabled;
				}

				return elem.disabled === disabled;

				// Try to winnow out elements that can't be disabled before trusting the disabled property.
				// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
				// even exist on them, let alone have a boolean value.
			} else if ("label" in elem) {
				return elem.disabled === disabled;
			}

			// Remaining elements are neither :enabled nor :disabled
			return false;
		};
	}

	/**
  * Returns a function to use in pseudos for positionals
  * @param {Function} fn
  */
	function createPositionalPseudo(fn) {
		return markFunction(function (argument) {
			argument = +argument;
			return markFunction(function (seed, matches) {
				var j,
				    matchIndexes = fn([], seed.length, argument),
				    i = matchIndexes.length;

				// Match elements found at the specified indexes
				while (i--) {
					if (seed[j = matchIndexes[i]]) {
						seed[j] = !(matches[j] = seed[j]);
					}
				}
			});
		});
	}

	/**
  * Checks a node for validity as a Sizzle context
  * @param {Element|Object=} context
  * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
  */
	function testContext(context) {
		return context && typeof context.getElementsByTagName !== "undefined" && context;
	}

	// Expose support vars for convenience
	support = Sizzle.support = {};

	/**
  * Detects XML nodes
  * @param {Element|Object} elem An element or a document
  * @returns {Boolean} True iff elem is a non-HTML XML node
  */
	isXML = Sizzle.isXML = function (elem) {
		var namespace = elem && elem.namespaceURI,
		    docElem = elem && (elem.ownerDocument || elem).documentElement;

		// Support: IE <=8
		// Assume HTML when documentElement doesn't yet exist, such as inside loading iframes
		// https://bugs.jquery.com/ticket/4833
		return !rhtml.test(namespace || docElem && docElem.nodeName || "HTML");
	};

	/**
  * Sets document-related variables once based on the current document
  * @param {Element|Object} [doc] An element or document object to use to set the document
  * @returns {Object} Returns the current document
  */
	setDocument = Sizzle.setDocument = function (node) {
		var hasCompare,
		    subWindow,
		    doc = node ? node.ownerDocument || node : preferredDoc;

		// Return early if doc is invalid or already selected
		// Support: IE 11+, Edge 17 - 18+
		// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
		// two documents; shallow comparisons work.
		// eslint-disable-next-line eqeqeq
		if (doc == document || doc.nodeType !== 9 || !doc.documentElement) {
			return document;
		}

		// Update global variables
		document = doc;
		docElem = document.documentElement;
		documentIsHTML = !isXML(document);

		// Support: IE 9 - 11+, Edge 12 - 18+
		// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
		// Support: IE 11+, Edge 17 - 18+
		// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
		// two documents; shallow comparisons work.
		// eslint-disable-next-line eqeqeq
		if (preferredDoc != document && (subWindow = document.defaultView) && subWindow.top !== subWindow) {

			// Support: IE 11, Edge
			if (subWindow.addEventListener) {
				subWindow.addEventListener("unload", unloadHandler, false);

				// Support: IE 9 - 10 only
			} else if (subWindow.attachEvent) {
				subWindow.attachEvent("onunload", unloadHandler);
			}
		}

		// Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,
		// Safari 4 - 5 only, Opera <=11.6 - 12.x only
		// IE/Edge & older browsers don't support the :scope pseudo-class.
		// Support: Safari 6.0 only
		// Safari 6.0 supports :scope but it's an alias of :root there.
		support.scope = assert(function (el) {
			docElem.appendChild(el).appendChild(document.createElement("div"));
			return typeof el.querySelectorAll !== "undefined" && !el.querySelectorAll(":scope fieldset div").length;
		});

		/* Attributes
  ---------------------------------------------------------------------- */

		// Support: IE<8
		// Verify that getAttribute really returns attributes and not properties
		// (excepting IE8 booleans)
		support.attributes = assert(function (el) {
			el.className = "i";
			return !el.getAttribute("className");
		});

		/* getElement(s)By*
  ---------------------------------------------------------------------- */

		// Check if getElementsByTagName("*") returns only elements
		support.getElementsByTagName = assert(function (el) {
			el.appendChild(document.createComment(""));
			return !el.getElementsByTagName("*").length;
		});

		// Support: IE<9
		support.getElementsByClassName = rnative.test(document.getElementsByClassName);

		// Support: IE<10
		// Check if getElementById returns elements by name
		// The broken getElementById methods don't pick up programmatically-set names,
		// so use a roundabout getElementsByName test
		support.getById = assert(function (el) {
			docElem.appendChild(el).id = expando;
			return !document.getElementsByName || !document.getElementsByName(expando).length;
		});

		// ID filter and find
		if (support.getById) {
			Expr.filter["ID"] = function (id) {
				var attrId = id.replace(runescape, funescape);
				return function (elem) {
					return elem.getAttribute("id") === attrId;
				};
			};
			Expr.find["ID"] = function (id, context) {
				if (typeof context.getElementById !== "undefined" && documentIsHTML) {
					var elem = context.getElementById(id);
					return elem ? [elem] : [];
				}
			};
		} else {
			Expr.filter["ID"] = function (id) {
				var attrId = id.replace(runescape, funescape);
				return function (elem) {
					var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
					return node && node.value === attrId;
				};
			};

			// Support: IE 6 - 7 only
			// getElementById is not reliable as a find shortcut
			Expr.find["ID"] = function (id, context) {
				if (typeof context.getElementById !== "undefined" && documentIsHTML) {
					var node,
					    i,
					    elems,
					    elem = context.getElementById(id);

					if (elem) {

						// Verify the id attribute
						node = elem.getAttributeNode("id");
						if (node && node.value === id) {
							return [elem];
						}

						// Fall back on getElementsByName
						elems = context.getElementsByName(id);
						i = 0;
						while (elem = elems[i++]) {
							node = elem.getAttributeNode("id");
							if (node && node.value === id) {
								return [elem];
							}
						}
					}

					return [];
				}
			};
		}

		// Tag
		Expr.find["TAG"] = support.getElementsByTagName ? function (tag, context) {
			if (typeof context.getElementsByTagName !== "undefined") {
				return context.getElementsByTagName(tag);

				// DocumentFragment nodes don't have gEBTN
			} else if (support.qsa) {
				return context.querySelectorAll(tag);
			}
		} : function (tag, context) {
			var elem,
			    tmp = [],
			    i = 0,


			// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
			results = context.getElementsByTagName(tag);

			// Filter out possible comments
			if (tag === "*") {
				while (elem = results[i++]) {
					if (elem.nodeType === 1) {
						tmp.push(elem);
					}
				}

				return tmp;
			}
			return results;
		};

		// Class
		Expr.find["CLASS"] = support.getElementsByClassName && function (className, context) {
			if (typeof context.getElementsByClassName !== "undefined" && documentIsHTML) {
				return context.getElementsByClassName(className);
			}
		};

		/* QSA/matchesSelector
  ---------------------------------------------------------------------- */

		// QSA and matchesSelector support

		// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
		rbuggyMatches = [];

		// qSa(:focus) reports false when true (Chrome 21)
		// We allow this because of a bug in IE8/9 that throws an error
		// whenever `document.activeElement` is accessed on an iframe
		// So, we allow :focus to pass through QSA all the time to avoid the IE error
		// See https://bugs.jquery.com/ticket/13378
		rbuggyQSA = [];

		if (support.qsa = rnative.test(document.querySelectorAll)) {

			// Build QSA regex
			// Regex strategy adopted from Diego Perini
			assert(function (el) {

				var input;

				// Select is set to empty string on purpose
				// This is to test IE's treatment of not explicitly
				// setting a boolean content attribute,
				// since its presence should be enough
				// https://bugs.jquery.com/ticket/12359
				docElem.appendChild(el).innerHTML = "<a id='" + expando + "'></a>" + "<select id='" + expando + "-\r\\' msallowcapture=''>" + "<option selected=''></option></select>";

				// Support: IE8, Opera 11-12.16
				// Nothing should be selected when empty strings follow ^= or $= or *=
				// The test attribute must be unknown in Opera but "safe" for WinRT
				// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
				if (el.querySelectorAll("[msallowcapture^='']").length) {
					rbuggyQSA.push("[*^$]=" + whitespace + "*(?:''|\"\")");
				}

				// Support: IE8
				// Boolean attributes and "value" are not treated correctly
				if (!el.querySelectorAll("[selected]").length) {
					rbuggyQSA.push("\\[" + whitespace + "*(?:value|" + booleans + ")");
				}

				// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
				if (!el.querySelectorAll("[id~=" + expando + "-]").length) {
					rbuggyQSA.push("~=");
				}

				// Support: IE 11+, Edge 15 - 18+
				// IE 11/Edge don't find elements on a `[name='']` query in some cases.
				// Adding a temporary attribute to the document before the selection works
				// around the issue.
				// Interestingly, IE 10 & older don't seem to have the issue.
				input = document.createElement("input");
				input.setAttribute("name", "");
				el.appendChild(input);
				if (!el.querySelectorAll("[name='']").length) {
					rbuggyQSA.push("\\[" + whitespace + "*name" + whitespace + "*=" + whitespace + "*(?:''|\"\")");
				}

				// Webkit/Opera - :checked should return selected option elements
				// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
				// IE8 throws error here and will not see later tests
				if (!el.querySelectorAll(":checked").length) {
					rbuggyQSA.push(":checked");
				}

				// Support: Safari 8+, iOS 8+
				// https://bugs.webkit.org/show_bug.cgi?id=136851
				// In-page `selector#id sibling-combinator selector` fails
				if (!el.querySelectorAll("a#" + expando + "+*").length) {
					rbuggyQSA.push(".#.+[+~]");
				}

				// Support: Firefox <=3.6 - 5 only
				// Old Firefox doesn't throw on a badly-escaped identifier.
				el.querySelectorAll("\\\f");
				rbuggyQSA.push("[\\r\\n\\f]");
			});

			assert(function (el) {
				el.innerHTML = "<a href='' disabled='disabled'></a>" + "<select disabled='disabled'><option/></select>";

				// Support: Windows 8 Native Apps
				// The type and name attributes are restricted during .innerHTML assignment
				var input = document.createElement("input");
				input.setAttribute("type", "hidden");
				el.appendChild(input).setAttribute("name", "D");

				// Support: IE8
				// Enforce case-sensitivity of name attribute
				if (el.querySelectorAll("[name=d]").length) {
					rbuggyQSA.push("name" + whitespace + "*[*^$|!~]?=");
				}

				// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
				// IE8 throws error here and will not see later tests
				if (el.querySelectorAll(":enabled").length !== 2) {
					rbuggyQSA.push(":enabled", ":disabled");
				}

				// Support: IE9-11+
				// IE's :disabled selector does not pick up the children of disabled fieldsets
				docElem.appendChild(el).disabled = true;
				if (el.querySelectorAll(":disabled").length !== 2) {
					rbuggyQSA.push(":enabled", ":disabled");
				}

				// Support: Opera 10 - 11 only
				// Opera 10-11 does not throw on post-comma invalid pseudos
				el.querySelectorAll("*,:x");
				rbuggyQSA.push(",.*:");
			});
		}

		if (support.matchesSelector = rnative.test(matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector)) {

			assert(function (el) {

				// Check to see if it's possible to do matchesSelector
				// on a disconnected node (IE 9)
				support.disconnectedMatch = matches.call(el, "*");

				// This should fail with an exception
				// Gecko does not error, returns false instead
				matches.call(el, "[s!='']:x");
				rbuggyMatches.push("!=", pseudos);
			});
		}

		rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|"));
		rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join("|"));

		/* Contains
  ---------------------------------------------------------------------- */
		hasCompare = rnative.test(docElem.compareDocumentPosition);

		// Element contains another
		// Purposefully self-exclusive
		// As in, an element does not contain itself
		contains = hasCompare || rnative.test(docElem.contains) ? function (a, b) {
			var adown = a.nodeType === 9 ? a.documentElement : a,
			    bup = b && b.parentNode;
			return a === bup || !!(bup && bup.nodeType === 1 && (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16));
		} : function (a, b) {
			if (b) {
				while (b = b.parentNode) {
					if (b === a) {
						return true;
					}
				}
			}
			return false;
		};

		/* Sorting
  ---------------------------------------------------------------------- */

		// Document order sorting
		sortOrder = hasCompare ? function (a, b) {

			// Flag for duplicate removal
			if (a === b) {
				hasDuplicate = true;
				return 0;
			}

			// Sort on method existence if only one input has compareDocumentPosition
			var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
			if (compare) {
				return compare;
			}

			// Calculate position if both inputs belong to the same document
			// Support: IE 11+, Edge 17 - 18+
			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
			// two documents; shallow comparisons work.
			// eslint-disable-next-line eqeqeq
			compare = (a.ownerDocument || a) == (b.ownerDocument || b) ? a.compareDocumentPosition(b) :

			// Otherwise we know they are disconnected
			1;

			// Disconnected nodes
			if (compare & 1 || !support.sortDetached && b.compareDocumentPosition(a) === compare) {

				// Choose the first element that is related to our preferred document
				// Support: IE 11+, Edge 17 - 18+
				// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
				// two documents; shallow comparisons work.
				// eslint-disable-next-line eqeqeq
				if (a == document || a.ownerDocument == preferredDoc && contains(preferredDoc, a)) {
					return -1;
				}

				// Support: IE 11+, Edge 17 - 18+
				// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
				// two documents; shallow comparisons work.
				// eslint-disable-next-line eqeqeq
				if (b == document || b.ownerDocument == preferredDoc && contains(preferredDoc, b)) {
					return 1;
				}

				// Maintain original order
				return sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;
			}

			return compare & 4 ? -1 : 1;
		} : function (a, b) {

			// Exit early if the nodes are identical
			if (a === b) {
				hasDuplicate = true;
				return 0;
			}

			var cur,
			    i = 0,
			    aup = a.parentNode,
			    bup = b.parentNode,
			    ap = [a],
			    bp = [b];

			// Parentless nodes are either documents or disconnected
			if (!aup || !bup) {

				// Support: IE 11+, Edge 17 - 18+
				// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
				// two documents; shallow comparisons work.
				/* eslint-disable eqeqeq */
				return a == document ? -1 : b == document ? 1 :
				/* eslint-enable eqeqeq */
				aup ? -1 : bup ? 1 : sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;

				// If the nodes are siblings, we can do a quick check
			} else if (aup === bup) {
				return siblingCheck(a, b);
			}

			// Otherwise we need full lists of their ancestors for comparison
			cur = a;
			while (cur = cur.parentNode) {
				ap.unshift(cur);
			}
			cur = b;
			while (cur = cur.parentNode) {
				bp.unshift(cur);
			}

			// Walk down the tree looking for a discrepancy
			while (ap[i] === bp[i]) {
				i++;
			}

			return i ?

			// Do a sibling check if the nodes have a common ancestor
			siblingCheck(ap[i], bp[i]) :

			// Otherwise nodes in our document sort first
			// Support: IE 11+, Edge 17 - 18+
			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
			// two documents; shallow comparisons work.
			/* eslint-disable eqeqeq */
			ap[i] == preferredDoc ? -1 : bp[i] == preferredDoc ? 1 :
			/* eslint-enable eqeqeq */
			0;
		};

		return document;
	};

	Sizzle.matches = function (expr, elements) {
		return Sizzle(expr, null, null, elements);
	};

	Sizzle.matchesSelector = function (elem, expr) {
		setDocument(elem);

		if (support.matchesSelector && documentIsHTML && !nonnativeSelectorCache[expr + " "] && (!rbuggyMatches || !rbuggyMatches.test(expr)) && (!rbuggyQSA || !rbuggyQSA.test(expr))) {

			try {
				var ret = matches.call(elem, expr);

				// IE 9's matchesSelector returns false on disconnected nodes
				if (ret || support.disconnectedMatch ||

				// As well, disconnected nodes are said to be in a document
				// fragment in IE 9
				elem.document && elem.document.nodeType !== 11) {
					return ret;
				}
			} catch (e) {
				nonnativeSelectorCache(expr, true);
			}
		}

		return Sizzle(expr, document, null, [elem]).length > 0;
	};

	Sizzle.contains = function (context, elem) {

		// Set document vars if needed
		// Support: IE 11+, Edge 17 - 18+
		// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
		// two documents; shallow comparisons work.
		// eslint-disable-next-line eqeqeq
		if ((context.ownerDocument || context) != document) {
			setDocument(context);
		}
		return contains(context, elem);
	};

	Sizzle.attr = function (elem, name) {

		// Set document vars if needed
		// Support: IE 11+, Edge 17 - 18+
		// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
		// two documents; shallow comparisons work.
		// eslint-disable-next-line eqeqeq
		if ((elem.ownerDocument || elem) != document) {
			setDocument(elem);
		}

		var fn = Expr.attrHandle[name.toLowerCase()],


		// Don't get fooled by Object.prototype properties (jQuery #13807)
		val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : undefined;

		return val !== undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
	};

	Sizzle.escape = function (sel) {
		return (sel + "").replace(rcssescape, fcssescape);
	};

	Sizzle.error = function (msg) {
		throw new Error("Syntax error, unrecognized expression: " + msg);
	};

	/**
  * Document sorting and removing duplicates
  * @param {ArrayLike} results
  */
	Sizzle.uniqueSort = function (results) {
		var elem,
		    duplicates = [],
		    j = 0,
		    i = 0;

		// Unless we *know* we can detect duplicates, assume their presence
		hasDuplicate = !support.detectDuplicates;
		sortInput = !support.sortStable && results.slice(0);
		results.sort(sortOrder);

		if (hasDuplicate) {
			while (elem = results[i++]) {
				if (elem === results[i]) {
					j = duplicates.push(i);
				}
			}
			while (j--) {
				results.splice(duplicates[j], 1);
			}
		}

		// Clear input after sorting to release objects
		// See https://github.com/jquery/sizzle/pull/225
		sortInput = null;

		return results;
	};

	/**
  * Utility function for retrieving the text value of an array of DOM nodes
  * @param {Array|Element} elem
  */
	getText = Sizzle.getText = function (elem) {
		var node,
		    ret = "",
		    i = 0,
		    nodeType = elem.nodeType;

		if (!nodeType) {

			// If no nodeType, this is expected to be an array
			while (node = elem[i++]) {

				// Do not traverse comment nodes
				ret += getText(node);
			}
		} else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {

			// Use textContent for elements
			// innerText usage removed for consistency of new lines (jQuery #11153)
			if (typeof elem.textContent === "string") {
				return elem.textContent;
			} else {

				// Traverse its children
				for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
					ret += getText(elem);
				}
			}
		} else if (nodeType === 3 || nodeType === 4) {
			return elem.nodeValue;
		}

		// Do not include comment or processing instruction nodes

		return ret;
	};

	Expr = Sizzle.selectors = {

		// Can be adjusted by the user
		cacheLength: 50,

		createPseudo: markFunction,

		match: matchExpr,

		attrHandle: {},

		find: {},

		relative: {
			">": { dir: "parentNode", first: true },
			" ": { dir: "parentNode" },
			"+": { dir: "previousSibling", first: true },
			"~": { dir: "previousSibling" }
		},

		preFilter: {
			"ATTR": function ATTR(match) {
				match[1] = match[1].replace(runescape, funescape);

				// Move the given value to match[3] whether quoted or unquoted
				match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape);

				if (match[2] === "~=") {
					match[3] = " " + match[3] + " ";
				}

				return match.slice(0, 4);
			},

			"CHILD": function CHILD(match) {

				/* matches from matchExpr["CHILD"]
    	1 type (only|nth|...)
    	2 what (child|of-type)
    	3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
    	4 xn-component of xn+y argument ([+-]?\d*n|)
    	5 sign of xn-component
    	6 x of xn-component
    	7 sign of y-component
    	8 y of y-component
    */
				match[1] = match[1].toLowerCase();

				if (match[1].slice(0, 3) === "nth") {

					// nth-* requires argument
					if (!match[3]) {
						Sizzle.error(match[0]);
					}

					// numeric x and y parameters for Expr.filter.CHILD
					// remember that false/true cast respectively to 0/1
					match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === "even" || match[3] === "odd"));
					match[5] = +(match[7] + match[8] || match[3] === "odd");

					// other types prohibit arguments
				} else if (match[3]) {
					Sizzle.error(match[0]);
				}

				return match;
			},

			"PSEUDO": function PSEUDO(match) {
				var excess,
				    unquoted = !match[6] && match[2];

				if (matchExpr["CHILD"].test(match[0])) {
					return null;
				}

				// Accept quoted arguments as-is
				if (match[3]) {
					match[2] = match[4] || match[5] || "";

					// Strip excess characters from unquoted arguments
				} else if (unquoted && rpseudo.test(unquoted) && (

				// Get excess from tokenize (recursively)
				excess = tokenize(unquoted, true)) && (

				// advance to the next closing parenthesis
				excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) {

					// excess is a negative index
					match[0] = match[0].slice(0, excess);
					match[2] = unquoted.slice(0, excess);
				}

				// Return only captures needed by the pseudo filter method (type and argument)
				return match.slice(0, 3);
			}
		},

		filter: {

			"TAG": function TAG(nodeNameSelector) {
				var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();
				return nodeNameSelector === "*" ? function () {
					return true;
				} : function (elem) {
					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
				};
			},

			"CLASS": function CLASS(className) {
				var pattern = classCache[className + " "];

				return pattern || (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)")) && classCache(className, function (elem) {
					return pattern.test(typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "");
				});
			},

			"ATTR": function ATTR(name, operator, check) {
				return function (elem) {
					var result = Sizzle.attr(elem, name);

					if (result == null) {
						return operator === "!=";
					}
					if (!operator) {
						return true;
					}

					result += "";

					/* eslint-disable max-len */

					return operator === "=" ? result === check : operator === "!=" ? result !== check : operator === "^=" ? check && result.indexOf(check) === 0 : operator === "*=" ? check && result.indexOf(check) > -1 : operator === "$=" ? check && result.slice(-check.length) === check : operator === "~=" ? (" " + result.replace(rwhitespace, " ") + " ").indexOf(check) > -1 : operator === "|=" ? result === check || result.slice(0, check.length + 1) === check + "-" : false;
					/* eslint-enable max-len */
				};
			},

			"CHILD": function CHILD(type, what, _argument, first, last) {
				var simple = type.slice(0, 3) !== "nth",
				    forward = type.slice(-4) !== "last",
				    ofType = what === "of-type";

				return first === 1 && last === 0 ?

				// Shortcut for :nth-*(n)
				function (elem) {
					return !!elem.parentNode;
				} : function (elem, _context, xml) {
					var cache,
					    uniqueCache,
					    outerCache,
					    node,
					    nodeIndex,
					    start,
					    dir = simple !== forward ? "nextSibling" : "previousSibling",
					    parent = elem.parentNode,
					    name = ofType && elem.nodeName.toLowerCase(),
					    useCache = !xml && !ofType,
					    diff = false;

					if (parent) {

						// :(first|last|only)-(child|of-type)
						if (simple) {
							while (dir) {
								node = elem;
								while (node = node[dir]) {
									if (ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) {

										return false;
									}
								}

								// Reverse direction for :only-* (if we haven't yet done so)
								start = dir = type === "only" && !start && "nextSibling";
							}
							return true;
						}

						start = [forward ? parent.firstChild : parent.lastChild];

						// non-xml :nth-child(...) stores cache data on `parent`
						if (forward && useCache) {

							// Seek `elem` from a previously-cached index

							// ...in a gzip-friendly way
							node = parent;
							outerCache = node[expando] || (node[expando] = {});

							// Support: IE <9 only
							// Defend against cloned attroperties (jQuery gh-1709)
							uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});

							cache = uniqueCache[type] || [];
							nodeIndex = cache[0] === dirruns && cache[1];
							diff = nodeIndex && cache[2];
							node = nodeIndex && parent.childNodes[nodeIndex];

							while (node = ++nodeIndex && node && node[dir] || (

							// Fallback to seeking `elem` from the start
							diff = nodeIndex = 0) || start.pop()) {

								// When found, cache indexes on `parent` and break
								if (node.nodeType === 1 && ++diff && node === elem) {
									uniqueCache[type] = [dirruns, nodeIndex, diff];
									break;
								}
							}
						} else {

							// Use previously-cached element index if available
							if (useCache) {

								// ...in a gzip-friendly way
								node = elem;
								outerCache = node[expando] || (node[expando] = {});

								// Support: IE <9 only
								// Defend against cloned attroperties (jQuery gh-1709)
								uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});

								cache = uniqueCache[type] || [];
								nodeIndex = cache[0] === dirruns && cache[1];
								diff = nodeIndex;
							}

							// xml :nth-child(...)
							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
							if (diff === false) {

								// Use the same loop as above to seek `elem` from the start
								while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) {

									if ((ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) && ++diff) {

										// Cache the index of each encountered element
										if (useCache) {
											outerCache = node[expando] || (node[expando] = {});

											// Support: IE <9 only
											// Defend against cloned attroperties (jQuery gh-1709)
											uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});

											uniqueCache[type] = [dirruns, diff];
										}

										if (node === elem) {
											break;
										}
									}
								}
							}
						}

						// Incorporate the offset, then check against cycle size
						diff -= last;
						return diff === first || diff % first === 0 && diff / first >= 0;
					}
				};
			},

			"PSEUDO": function PSEUDO(pseudo, argument) {

				// pseudo-class names are case-insensitive
				// http://www.w3.org/TR/selectors/#pseudo-classes
				// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
				// Remember that setFilters inherits from pseudos
				var args,
				    fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error("unsupported pseudo: " + pseudo);

				// The user may use createPseudo to indicate that
				// arguments are needed to create the filter function
				// just as Sizzle does
				if (fn[expando]) {
					return fn(argument);
				}

				// But maintain support for old signatures
				if (fn.length > 1) {
					args = [pseudo, pseudo, "", argument];
					return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function (seed, matches) {
						var idx,
						    matched = fn(seed, argument),
						    i = matched.length;
						while (i--) {
							idx = indexOf(seed, matched[i]);
							seed[idx] = !(matches[idx] = matched[i]);
						}
					}) : function (elem) {
						return fn(elem, 0, args);
					};
				}

				return fn;
			}
		},

		pseudos: {

			// Potentially complex pseudos
			"not": markFunction(function (selector) {

				// Trim the selector passed to compile
				// to avoid treating leading and trailing
				// spaces as combinators
				var input = [],
				    results = [],
				    matcher = compile(selector.replace(rtrim, "$1"));

				return matcher[expando] ? markFunction(function (seed, matches, _context, xml) {
					var elem,
					    unmatched = matcher(seed, null, xml, []),
					    i = seed.length;

					// Match elements unmatched by `matcher`
					while (i--) {
						if (elem = unmatched[i]) {
							seed[i] = !(matches[i] = elem);
						}
					}
				}) : function (elem, _context, xml) {
					input[0] = elem;
					matcher(input, null, xml, results);

					// Don't keep the element (issue #299)
					input[0] = null;
					return !results.pop();
				};
			}),

			"has": markFunction(function (selector) {
				return function (elem) {
					return Sizzle(selector, elem).length > 0;
				};
			}),

			"contains": markFunction(function (text) {
				text = text.replace(runescape, funescape);
				return function (elem) {
					return (elem.textContent || getText(elem)).indexOf(text) > -1;
				};
			}),

			// "Whether an element is represented by a :lang() selector
			// is based solely on the element's language value
			// being equal to the identifier C,
			// or beginning with the identifier C immediately followed by "-".
			// The matching of C against the element's language value is performed case-insensitively.
			// The identifier C does not have to be a valid language name."
			// http://www.w3.org/TR/selectors/#lang-pseudo
			"lang": markFunction(function (lang) {

				// lang value must be a valid identifier
				if (!ridentifier.test(lang || "")) {
					Sizzle.error("unsupported lang: " + lang);
				}
				lang = lang.replace(runescape, funescape).toLowerCase();
				return function (elem) {
					var elemLang;
					do {
						if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) {

							elemLang = elemLang.toLowerCase();
							return elemLang === lang || elemLang.indexOf(lang + "-") === 0;
						}
					} while ((elem = elem.parentNode) && elem.nodeType === 1);
					return false;
				};
			}),

			// Miscellaneous
			"target": function target(elem) {
				var hash = window.location && window.location.hash;
				return hash && hash.slice(1) === elem.id;
			},

			"root": function root(elem) {
				return elem === docElem;
			},

			"focus": function focus(elem) {
				return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
			},

			// Boolean properties
			"enabled": createDisabledPseudo(false),
			"disabled": createDisabledPseudo(true),

			"checked": function checked(elem) {

				// In CSS3, :checked should return both checked and selected elements
				// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
				var nodeName = elem.nodeName.toLowerCase();
				return nodeName === "input" && !!elem.checked || nodeName === "option" && !!elem.selected;
			},

			"selected": function selected(elem) {

				// Accessing this property makes selected-by-default
				// options in Safari work properly
				if (elem.parentNode) {
					// eslint-disable-next-line no-unused-expressions
					elem.parentNode.selectedIndex;
				}

				return elem.selected === true;
			},

			// Contents
			"empty": function empty(elem) {

				// http://www.w3.org/TR/selectors/#empty-pseudo
				// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
				//   but not by others (comment: 8; processing instruction: 7; etc.)
				// nodeType < 6 works because attributes (2) do not appear as children
				for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
					if (elem.nodeType < 6) {
						return false;
					}
				}
				return true;
			},

			"parent": function parent(elem) {
				return !Expr.pseudos["empty"](elem);
			},

			// Element/input types
			"header": function header(elem) {
				return rheader.test(elem.nodeName);
			},

			"input": function input(elem) {
				return rinputs.test(elem.nodeName);
			},

			"button": function button(elem) {
				var name = elem.nodeName.toLowerCase();
				return name === "input" && elem.type === "button" || name === "button";
			},

			"text": function text(elem) {
				var attr;
				return elem.nodeName.toLowerCase() === "input" && elem.type === "text" && (

				// Support: IE<8
				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
				(attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text");
			},

			// Position-in-collection
			"first": createPositionalPseudo(function () {
				return [0];
			}),

			"last": createPositionalPseudo(function (_matchIndexes, length) {
				return [length - 1];
			}),

			"eq": createPositionalPseudo(function (_matchIndexes, length, argument) {
				return [argument < 0 ? argument + length : argument];
			}),

			"even": createPositionalPseudo(function (matchIndexes, length) {
				var i = 0;
				for (; i < length; i += 2) {
					matchIndexes.push(i);
				}
				return matchIndexes;
			}),

			"odd": createPositionalPseudo(function (matchIndexes, length) {
				var i = 1;
				for (; i < length; i += 2) {
					matchIndexes.push(i);
				}
				return matchIndexes;
			}),

			"lt": createPositionalPseudo(function (matchIndexes, length, argument) {
				var i = argument < 0 ? argument + length : argument > length ? length : argument;
				for (; --i >= 0;) {
					matchIndexes.push(i);
				}
				return matchIndexes;
			}),

			"gt": createPositionalPseudo(function (matchIndexes, length, argument) {
				var i = argument < 0 ? argument + length : argument;
				for (; ++i < length;) {
					matchIndexes.push(i);
				}
				return matchIndexes;
			})
		}
	};

	Expr.pseudos["nth"] = Expr.pseudos["eq"];

	// Add button/input type pseudos
	for (i in { radio: true, checkbox: true, file: true, password: true, image: true }) {
		Expr.pseudos[i] = createInputPseudo(i);
	}
	for (i in { submit: true, reset: true }) {
		Expr.pseudos[i] = createButtonPseudo(i);
	}

	// Easy API for creating new setFilters
	function setFilters() {}
	setFilters.prototype = Expr.filters = Expr.pseudos;
	Expr.setFilters = new setFilters();

	tokenize = Sizzle.tokenize = function (selector, parseOnly) {
		var matched,
		    match,
		    tokens,
		    type,
		    soFar,
		    groups,
		    preFilters,
		    cached = tokenCache[selector + " "];

		if (cached) {
			return parseOnly ? 0 : cached.slice(0);
		}

		soFar = selector;
		groups = [];
		preFilters = Expr.preFilter;

		while (soFar) {

			// Comma and first run
			if (!matched || (match = rcomma.exec(soFar))) {
				if (match) {

					// Don't consume trailing commas as valid
					soFar = soFar.slice(match[0].length) || soFar;
				}
				groups.push(tokens = []);
			}

			matched = false;

			// Combinators
			if (match = rcombinators.exec(soFar)) {
				matched = match.shift();
				tokens.push({
					value: matched,

					// Cast descendant combinators to space
					type: match[0].replace(rtrim, " ")
				});
				soFar = soFar.slice(matched.length);
			}

			// Filters
			for (type in Expr.filter) {
				if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match)))) {
					matched = match.shift();
					tokens.push({
						value: matched,
						type: type,
						matches: match
					});
					soFar = soFar.slice(matched.length);
				}
			}

			if (!matched) {
				break;
			}
		}

		// Return the length of the invalid excess
		// if we're just parsing
		// Otherwise, throw an error or return tokens
		return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) :

		// Cache the tokens
		tokenCache(selector, groups).slice(0);
	};

	function toSelector(tokens) {
		var i = 0,
		    len = tokens.length,
		    selector = "";
		for (; i < len; i++) {
			selector += tokens[i].value;
		}
		return selector;
	}

	function addCombinator(matcher, combinator, base) {
		var dir = combinator.dir,
		    skip = combinator.next,
		    key = skip || dir,
		    checkNonElements = base && key === "parentNode",
		    doneName = done++;

		return combinator.first ?

		// Check against closest ancestor/preceding element
		function (elem, context, xml) {
			while (elem = elem[dir]) {
				if (elem.nodeType === 1 || checkNonElements) {
					return matcher(elem, context, xml);
				}
			}
			return false;
		} :

		// Check against all ancestor/preceding elements
		function (elem, context, xml) {
			var oldCache,
			    uniqueCache,
			    outerCache,
			    newCache = [dirruns, doneName];

			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
			if (xml) {
				while (elem = elem[dir]) {
					if (elem.nodeType === 1 || checkNonElements) {
						if (matcher(elem, context, xml)) {
							return true;
						}
					}
				}
			} else {
				while (elem = elem[dir]) {
					if (elem.nodeType === 1 || checkNonElements) {
						outerCache = elem[expando] || (elem[expando] = {});

						// Support: IE <9 only
						// Defend against cloned attroperties (jQuery gh-1709)
						uniqueCache = outerCache[elem.uniqueID] || (outerCache[elem.uniqueID] = {});

						if (skip && skip === elem.nodeName.toLowerCase()) {
							elem = elem[dir] || elem;
						} else if ((oldCache = uniqueCache[key]) && oldCache[0] === dirruns && oldCache[1] === doneName) {

							// Assign to newCache so results back-propagate to previous elements
							return newCache[2] = oldCache[2];
						} else {

							// Reuse newcache so results back-propagate to previous elements
							uniqueCache[key] = newCache;

							// A match means we're done; a fail means we have to keep checking
							if (newCache[2] = matcher(elem, context, xml)) {
								return true;
							}
						}
					}
				}
			}
			return false;
		};
	}

	function elementMatcher(matchers) {
		return matchers.length > 1 ? function (elem, context, xml) {
			var i = matchers.length;
			while (i--) {
				if (!matchers[i](elem, context, xml)) {
					return false;
				}
			}
			return true;
		} : matchers[0];
	}

	function multipleContexts(selector, contexts, results) {
		var i = 0,
		    len = contexts.length;
		for (; i < len; i++) {
			Sizzle(selector, contexts[i], results);
		}
		return results;
	}

	function condense(unmatched, map, filter, context, xml) {
		var elem,
		    newUnmatched = [],
		    i = 0,
		    len = unmatched.length,
		    mapped = map != null;

		for (; i < len; i++) {
			if (elem = unmatched[i]) {
				if (!filter || filter(elem, context, xml)) {
					newUnmatched.push(elem);
					if (mapped) {
						map.push(i);
					}
				}
			}
		}

		return newUnmatched;
	}

	function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
		if (postFilter && !postFilter[expando]) {
			postFilter = setMatcher(postFilter);
		}
		if (postFinder && !postFinder[expando]) {
			postFinder = setMatcher(postFinder, postSelector);
		}
		return markFunction(function (seed, results, context, xml) {
			var temp,
			    i,
			    elem,
			    preMap = [],
			    postMap = [],
			    preexisting = results.length,


			// Get initial elements from seed or context
			elems = seed || multipleContexts(selector || "*", context.nodeType ? [context] : context, []),


			// Prefilter to get matcher input, preserving a map for seed-results synchronization
			matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems,
			    matcherOut = matcher ?

			// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
			postFinder || (seed ? preFilter : preexisting || postFilter) ?

			// ...intermediate processing is necessary
			[] :

			// ...otherwise use results directly
			results : matcherIn;

			// Find primary matches
			if (matcher) {
				matcher(matcherIn, matcherOut, context, xml);
			}

			// Apply postFilter
			if (postFilter) {
				temp = condense(matcherOut, postMap);
				postFilter(temp, [], context, xml);

				// Un-match failing elements by moving them back to matcherIn
				i = temp.length;
				while (i--) {
					if (elem = temp[i]) {
						matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);
					}
				}
			}

			if (seed) {
				if (postFinder || preFilter) {
					if (postFinder) {

						// Get the final matcherOut by condensing this intermediate into postFinder contexts
						temp = [];
						i = matcherOut.length;
						while (i--) {
							if (elem = matcherOut[i]) {

								// Restore matcherIn since elem is not yet a final match
								temp.push(matcherIn[i] = elem);
							}
						}
						postFinder(null, matcherOut = [], temp, xml);
					}

					// Move matched elements from seed to results to keep them synchronized
					i = matcherOut.length;
					while (i--) {
						if ((elem = matcherOut[i]) && (temp = postFinder ? indexOf(seed, elem) : preMap[i]) > -1) {

							seed[temp] = !(results[temp] = elem);
						}
					}
				}

				// Add elements to results, through postFinder if defined
			} else {
				matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut);
				if (postFinder) {
					postFinder(null, results, matcherOut, xml);
				} else {
					push.apply(results, matcherOut);
				}
			}
		});
	}

	function matcherFromTokens(tokens) {
		var checkContext,
		    matcher,
		    j,
		    len = tokens.length,
		    leadingRelative = Expr.relative[tokens[0].type],
		    implicitRelative = leadingRelative || Expr.relative[" "],
		    i = leadingRelative ? 1 : 0,


		// The foundational matcher ensures that elements are reachable from top-level context(s)
		matchContext = addCombinator(function (elem) {
			return elem === checkContext;
		}, implicitRelative, true),
		    matchAnyContext = addCombinator(function (elem) {
			return indexOf(checkContext, elem) > -1;
		}, implicitRelative, true),
		    matchers = [function (elem, context, xml) {
			var ret = !leadingRelative && (xml || context !== outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml));

			// Avoid hanging onto element (issue #299)
			checkContext = null;
			return ret;
		}];

		for (; i < len; i++) {
			if (matcher = Expr.relative[tokens[i].type]) {
				matchers = [addCombinator(elementMatcher(matchers), matcher)];
			} else {
				matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches);

				// Return special upon seeing a positional matcher
				if (matcher[expando]) {

					// Find the next relative operator (if any) for proper handling
					j = ++i;
					for (; j < len; j++) {
						if (Expr.relative[tokens[j].type]) {
							break;
						}
					}
					return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector(

					// If the preceding token was a descendant combinator, insert an implicit any-element `*`
					tokens.slice(0, i - 1).concat({ value: tokens[i - 2].type === " " ? "*" : "" })).replace(rtrim, "$1"), matcher, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens(tokens = tokens.slice(j)), j < len && toSelector(tokens));
				}
				matchers.push(matcher);
			}
		}

		return elementMatcher(matchers);
	}

	function matcherFromGroupMatchers(elementMatchers, setMatchers) {
		var bySet = setMatchers.length > 0,
		    byElement = elementMatchers.length > 0,
		    superMatcher = function superMatcher(seed, context, xml, results, outermost) {
			var elem,
			    j,
			    matcher,
			    matchedCount = 0,
			    i = "0",
			    unmatched = seed && [],
			    setMatched = [],
			    contextBackup = outermostContext,


			// We must always have either seed elements or outermost context
			elems = seed || byElement && Expr.find["TAG"]("*", outermost),


			// Use integer dirruns iff this is the outermost matcher
			dirrunsUnique = dirruns += contextBackup == null ? 1 : Math.random() || 0.1,
			    len = elems.length;

			if (outermost) {

				// Support: IE 11+, Edge 17 - 18+
				// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
				// two documents; shallow comparisons work.
				// eslint-disable-next-line eqeqeq
				outermostContext = context == document || context || outermost;
			}

			// Add elements passing elementMatchers directly to results
			// Support: IE<9, Safari
			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
			for (; i !== len && (elem = elems[i]) != null; i++) {
				if (byElement && elem) {
					j = 0;

					// Support: IE 11+, Edge 17 - 18+
					// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
					// two documents; shallow comparisons work.
					// eslint-disable-next-line eqeqeq
					if (!context && elem.ownerDocument != document) {
						setDocument(elem);
						xml = !documentIsHTML;
					}
					while (matcher = elementMatchers[j++]) {
						if (matcher(elem, context || document, xml)) {
							results.push(elem);
							break;
						}
					}
					if (outermost) {
						dirruns = dirrunsUnique;
					}
				}

				// Track unmatched elements for set filters
				if (bySet) {

					// They will have gone through all possible matchers
					if (elem = !matcher && elem) {
						matchedCount--;
					}

					// Lengthen the array for every element, matched or not
					if (seed) {
						unmatched.push(elem);
					}
				}
			}

			// `i` is now the count of elements visited above, and adding it to `matchedCount`
			// makes the latter nonnegative.
			matchedCount += i;

			// Apply set filters to unmatched elements
			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
			// no element matchers and no seed.
			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
			// numerically zero.
			if (bySet && i !== matchedCount) {
				j = 0;
				while (matcher = setMatchers[j++]) {
					matcher(unmatched, setMatched, context, xml);
				}

				if (seed) {

					// Reintegrate element matches to eliminate the need for sorting
					if (matchedCount > 0) {
						while (i--) {
							if (!(unmatched[i] || setMatched[i])) {
								setMatched[i] = pop.call(results);
							}
						}
					}

					// Discard index placeholder values to get only actual matches
					setMatched = condense(setMatched);
				}

				// Add matches to results
				push.apply(results, setMatched);

				// Seedless set matches succeeding multiple successful matchers stipulate sorting
				if (outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1) {

					Sizzle.uniqueSort(results);
				}
			}

			// Override manipulation of globals by nested matchers
			if (outermost) {
				dirruns = dirrunsUnique;
				outermostContext = contextBackup;
			}

			return unmatched;
		};

		return bySet ? markFunction(superMatcher) : superMatcher;
	}

	compile = Sizzle.compile = function (selector, match /* Internal Use Only */) {
		var i,
		    setMatchers = [],
		    elementMatchers = [],
		    cached = compilerCache[selector + " "];

		if (!cached) {

			// Generate a function of recursive functions that can be used to check each element
			if (!match) {
				match = tokenize(selector);
			}
			i = match.length;
			while (i--) {
				cached = matcherFromTokens(match[i]);
				if (cached[expando]) {
					setMatchers.push(cached);
				} else {
					elementMatchers.push(cached);
				}
			}

			// Cache the compiled function
			cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers));

			// Save selector and tokenization
			cached.selector = selector;
		}
		return cached;
	};

	/**
  * A low-level selection function that works with Sizzle's compiled
  *  selector functions
  * @param {String|Function} selector A selector or a pre-compiled
  *  selector function built with Sizzle.compile
  * @param {Element} context
  * @param {Array} [results]
  * @param {Array} [seed] A set of elements to match against
  */
	select = Sizzle.select = function (selector, context, results, seed) {
		var i,
		    tokens,
		    token,
		    type,
		    find,
		    compiled = typeof selector === "function" && selector,
		    match = !seed && tokenize(selector = compiled.selector || selector);

		results = results || [];

		// Try to minimize operations if there is only one selector in the list and no seed
		// (the latter of which guarantees us context)
		if (match.length === 1) {

			// Reduce context if the leading compound selector is an ID
			tokens = match[0] = match[0].slice(0);
			if (tokens.length > 2 && (token = tokens[0]).type === "ID" && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) {

				context = (Expr.find["ID"](token.matches[0].replace(runescape, funescape), context) || [])[0];
				if (!context) {
					return results;

					// Precompiled matchers will still verify ancestry, so step up a level
				} else if (compiled) {
					context = context.parentNode;
				}

				selector = selector.slice(tokens.shift().value.length);
			}

			// Fetch a seed set for right-to-left matching
			i = matchExpr["needsContext"].test(selector) ? 0 : tokens.length;
			while (i--) {
				token = tokens[i];

				// Abort if we hit a combinator
				if (Expr.relative[type = token.type]) {
					break;
				}
				if (find = Expr.find[type]) {

					// Search, expanding context for leading sibling combinators
					if (seed = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && testContext(context.parentNode) || context)) {

						// If seed is empty or no tokens remain, we can return early
						tokens.splice(i, 1);
						selector = seed.length && toSelector(tokens);
						if (!selector) {
							push.apply(results, seed);
							return results;
						}

						break;
					}
				}
			}
		}

		// Compile and execute a filtering function if one is not provided
		// Provide `match` to avoid retokenization if we modified the selector above
		(compiled || compile(selector, match))(seed, context, !documentIsHTML, results, !context || rsibling.test(selector) && testContext(context.parentNode) || context);
		return results;
	};

	// One-time assignments

	// Sort stability
	support.sortStable = expando.split("").sort(sortOrder).join("") === expando;

	// Support: Chrome 14-35+
	// Always assume duplicates if they aren't passed to the comparison function
	support.detectDuplicates = !!hasDuplicate;

	// Initialize against the default document
	setDocument();

	// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
	// Detached nodes confoundingly follow *each other*
	support.sortDetached = assert(function (el) {

		// Should return 1, but returns 4 (following)
		return el.compareDocumentPosition(document.createElement("fieldset")) & 1;
	});

	// Support: IE<8
	// Prevent attribute/property "interpolation"
	// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
	if (!assert(function (el) {
		el.innerHTML = "<a href='#'></a>";
		return el.firstChild.getAttribute("href") === "#";
	})) {
		addHandle("type|href|height|width", function (elem, name, isXML) {
			if (!isXML) {
				return elem.getAttribute(name, name.toLowerCase() === "type" ? 1 : 2);
			}
		});
	}

	// Support: IE<9
	// Use defaultValue in place of getAttribute("value")
	if (!support.attributes || !assert(function (el) {
		el.innerHTML = "<input/>";
		el.firstChild.setAttribute("value", "");
		return el.firstChild.getAttribute("value") === "";
	})) {
		addHandle("value", function (elem, _name, isXML) {
			if (!isXML && elem.nodeName.toLowerCase() === "input") {
				return elem.defaultValue;
			}
		});
	}

	// Support: IE<9
	// Use getAttributeNode to fetch booleans when getAttribute lies
	if (!assert(function (el) {
		return el.getAttribute("disabled") == null;
	})) {
		addHandle(booleans, function (elem, name, isXML) {
			var val;
			if (!isXML) {
				return elem[name] === true ? name.toLowerCase() : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
			}
		});
	}

	// EXPOSE
	var _sizzle = window.Sizzle;

	Sizzle.noConflict = function () {
		if (window.Sizzle === Sizzle) {
			window.Sizzle = _sizzle;
		}

		return Sizzle;
	};

	if (true) {
		!(__WEBPACK_AMD_DEFINE_RESULT__ = function () {
			return Sizzle;
		}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

		// Sizzle requires that there be a global window in Common-JS like environments
	} else if (typeof module !== "undefined" && module.exports) {
		module.exports = Sizzle;
	} else {
		window.Sizzle = Sizzle;
	}

	// EXPOSE
})(window);

/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.common = exports.optimize = exports.initOptions = exports.match = exports.getMultiSelector = exports.getSingleSelector = exports.select = undefined;

var _select = __webpack_require__(6);

Object.defineProperty(exports, 'select', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_select).default;
  }
});
Object.defineProperty(exports, 'getSingleSelector', {
  enumerable: true,
  get: function get() {
    return _select.getSingleSelector;
  }
});
Object.defineProperty(exports, 'getMultiSelector', {
  enumerable: true,
  get: function get() {
    return _select.getMultiSelector;
  }
});

var _match = __webpack_require__(1);

Object.defineProperty(exports, 'match', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_match).default;
  }
});
Object.defineProperty(exports, 'initOptions', {
  enumerable: true,
  get: function get() {
    return _match.initOptions;
  }
});

var _optimize = __webpack_require__(5);

Object.defineProperty(exports, 'optimize', {
  enumerable: true,
  get: function get() {
    return _interopRequireDefault(_optimize).default;
  }
});

var _common2 = __webpack_require__(4);

var _common = _interopRequireWildcard(_common2);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.common = _common;

/***/ }
/******/ ]);
});
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///webpack/bootstrap 8b5e1de494d207a1fcb4","webpack:///./src/utilities.js","webpack:///./src/match.js","webpack:///./src/pattern.js","webpack:///./src/selector.js","webpack:///./src/common.js","webpack:///./src/optimize.js","webpack:///./src/select.js","webpack:///./~/sizzle/dist/sizzle.js","webpack:///./src/index.js"],"names":["convertNodeList","nodes","length","arr","Array","i","escapeValue","value","replace","partition","array","predicate","reduce","item","inner","outer","concat","isValidCSSIdentifier","test","match","defaultIgnore","attribute","attributeName","indexOf","contains","initOptions","options","root","document","skip","priority","ignore","node","nested","format","path","element","select","toString","skipCompare","isArray","map","entry","skipChecks","some","compare","Object","keys","forEach","type","RegExp","name","nodeType","checkAttributes","checkTag","includes","checkRecursiveDescendants","checkText","checkNthChild","parentNode","pattern","findPattern","unshift","parent","findAttributesPattern","combinations","values","min","max","result","r","push","v","shift","filter","maxSubsetSize","items","getClassSelector","classes","base","find","matches","attributes","attributeNames","val","a","sortedKeys","tag","tagName","toLowerCase","isOptimal","l","key","attributeValue","useNamedIgnore","currentIgnore","currentDefaultIgnore","checkIgnore","classNames","trim","split","classIgnore","class","className","findTagPattern","children","child","childPattern","console","warn","relates","pseudo","textContent","firstChild","nodeValue","texts","text","descendants","from","querySelectorAll","descendantPath","p","startsWith","parentElement","defaultPredicate","check","createPattern","attributesToSelector","join","classesToSelector","c","pseudoToSelector","patternToSelector","pathToSelector","convertEscaping","attributesToXPath","classesToXPath","pseudoToXPath","patternToXPath","descendantsToXPath","pathToXPath","jquery","css","xpath","getToString","Sizzle","selectJQuery","selector","require","selectXPath","doc","iterator","evaluate","elements","iterateNext","selectCSS","getSelect","err","getCommonAncestor","ancestors","index","parents","sort","curr","next","shallowAncestor","ancestor","missing","otherParents","otherParent","getCommonProperties","commonProperties","commonClasses","commonAttributes","commonTag","undefined","getAttribute","cls","elementAttributes","attributesNames","commonAttributesNames","nextCommonAttributes","optimize","Error","optimizePart","endOptimized","slice","shortened","pop","current","hasSameResult","every","optimizeText","pre","post","other","optimized","compareResults","optimizeAttributes","simplify","original","getSimplified","simplified","optimizeDescendant","descendant","optimizeRecursiveDescendants","optimizeNthOfType","findIndex","nthOfType","optimizeClasses","references","reference","description","optimizers","acc","optimizer","getQuerySelector","getSingleSelectorPath","optimizedPath","getMultiSelectorPath","ancestorPath","commonPath","getCommonPath","descendantPattern","selectorPath","selectorMatches","input","HTMLElement","window","support","Expr","getText","isXML","tokenize","compile","outermostContext","sortInput","hasDuplicate","setDocument","docElem","documentIsHTML","rbuggyQSA","rbuggyMatches","expando","Date","preferredDoc","dirruns","done","classCache","createCache","tokenCache","compilerCache","nonnativeSelectorCache","sortOrder","b","hasOwn","hasOwnProperty","pushNative","list","elem","len","booleans","whitespace","identifier","pseudos","rwhitespace","rtrim","rcomma","rcombinators","rdescend","rpseudo","ridentifier","matchExpr","rhtml","rinputs","rheader","rnative","rquickExpr","rsibling","runescape","funescape","escape","nonHex","high","String","fromCharCode","rcssescape","fcssescape","ch","asCodePoint","charCodeAt","unloadHandler","inDisabledFieldset","addCombinator","disabled","nodeName","dir","apply","call","childNodes","e","target","els","j","context","results","seed","m","nid","groups","newSelector","newContext","ownerDocument","exec","getElementById","id","getElementsByTagName","getElementsByClassName","qsa","testContext","scope","setAttribute","toSelector","qsaError","removeAttribute","cache","cacheLength","markFunction","fn","assert","el","createElement","removeChild","addHandle","attrs","handler","attrHandle","siblingCheck","cur","diff","sourceIndex","nextSibling","createInputPseudo","createButtonPseudo","createDisabledPseudo","isDisabled","createPositionalPseudo","argument","matchIndexes","namespace","namespaceURI","documentElement","hasCompare","subWindow","defaultView","top","addEventListener","attachEvent","appendChild","createComment","getById","getElementsByName","attrId","getAttributeNode","elems","tmp","innerHTML","matchesSelector","webkitMatchesSelector","mozMatchesSelector","oMatchesSelector","msMatchesSelector","disconnectedMatch","compareDocumentPosition","adown","bup","sortDetached","aup","ap","bp","expr","ret","attr","specified","sel","error","msg","uniqueSort","duplicates","detectDuplicates","sortStable","splice","selectors","createPseudo","relative","first","preFilter","excess","unquoted","nodeNameSelector","operator","what","_argument","last","simple","forward","ofType","_context","xml","uniqueCache","outerCache","nodeIndex","start","useCache","lastChild","uniqueID","args","setFilters","idx","matched","matcher","unmatched","lang","elemLang","hash","location","activeElement","hasFocus","href","tabIndex","checked","selected","selectedIndex","_matchIndexes","radio","checkbox","file","password","image","submit","reset","prototype","filters","parseOnly","tokens","soFar","preFilters","cached","combinator","checkNonElements","doneName","oldCache","newCache","elementMatcher","matchers","multipleContexts","contexts","condense","newUnmatched","mapped","setMatcher","postFilter","postFinder","postSelector","temp","preMap","postMap","preexisting","matcherIn","matcherOut","matcherFromTokens","checkContext","leadingRelative","implicitRelative","matchContext","matchAnyContext","matcherFromGroupMatchers","elementMatchers","setMatchers","bySet","byElement","superMatcher","outermost","matchedCount","setMatched","contextBackup","dirrunsUnique","Math","random","token","compiled","_name","defaultValue","_sizzle","noConflict","define","module","exports","default","getSingleSelector","getMultiSelector","common"],"mappings":"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","file":"optimal-select.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"OptimalSelect\"] = factory();\n\telse\n\t\troot[\"OptimalSelect\"] = factory();\n})(this, function() {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// identity function for calling harmony imports with the correct context\n \t__webpack_require__.i = function(value) { return value; };\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 8);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 8b5e1de494d207a1fcb4","/**\n * # Utilities\n *\n * Convenience helpers.\n */\n\n/**\n * Create an array with the DOM nodes of the list\n *\n * @param  {NodeList}             nodes - [description]\n * @return {Array.<HTMLElement>}        - [description]\n */\nexport const convertNodeList = (nodes) => {\n  const { length } = nodes\n  const arr = new Array(length)\n  for (var i = 0; i < length; i++) {\n    arr[i] = nodes[i]\n  }\n  return arr\n}\n\n/**\n * Escape special characters and line breaks as a simplified version of 'CSS.escape()'\n *\n * Description of valid characters: https://mathiasbynens.be/notes/css-escapes\n *\n * @param  {String?} value - [description]\n * @return {String}        - [description]\n */\nexport const escapeValue = (value) =>\n  value && value.replace(/['\"`\\\\/:?&!#$%^()[\\]{|}*+;,.<=>@~]/g, '\\\\$&')\n    .replace(/\\n/g, '\\u00a0')\n\n/**\n * Partition array into two groups determined by predicate\n */\nexport const partition = (array, predicate) =>\n  array.reduce(\n    ([inner, outer], item) => predicate(item) ? [inner.concat(item), outer] : [inner, outer.concat(item)],\n    [[], []]\n  )\n\n\n\n/**\n * Determine if string is valid CSS identifier\n * \n * In CSS, identifiers (including element names, classes, and IDs in selectors) can contain\n * only the characters [a-zA-Z0-9] and ISO 10646 characters U+00A0 and higher, plus the hyphen (-)\n * and the underscore (_); they cannot start with a digit, two hyphens, or a hyphen followed by\n * a digit.\n * \n * Identifiers can also contain escaped characters and any ISO 10646 character as a numeric\n * code (see next item). For instance, the identifier \"B&W?\" may be written as \"B\\&W\\?\" or \"B\\26 W\\3F\".\n * @param {String} value \n * @return {Boolean}\n */\nexport const isValidCSSIdentifier = (value) =>\n  !!value && !/(^\\d)|(^--)|(^-\\d)/.test(value) && !/([^\\\\]|^)['\"`/:?&!#$%^()[\\]{|}*+;,.<=>@~]/.test(value)\n\n\n\n\n\n// WEBPACK FOOTER //\n// ./src/utilities.js","/**\n * # Match\n *\n * Retrieve selector for a node.\n */\n\nimport { createPattern, getToString } from './pattern'\nimport { getSelect } from './selector'\nimport { escapeValue } from './utilities'\n\n/**\n * @typedef {import('./select').Options} Options\n * @typedef {import('./pattern').Pattern} Pattern\n * @typedef {import('./pattern').ToStringApi} Pattern\n */\n\nexport const defaultIgnore = {\n  attribute(attributeName) {\n    return [\n      'style',\n      'data-reactid',\n      'data-react-checksum'\n    ].indexOf(attributeName) > -1\n  },\n  contains: () => true\n}\n\nexport const initOptions = (options = {}) => ({\n  ...options,\n  root: options.root || document,\n  skip: options.skip || null,\n  priority: options.priority || ['id', 'class', 'href', 'src'],\n  ignore: options.ignore || {}\n})\n\n/**\n * Get the path of the element\n *\n * @param  {HTMLElement} node      - [description]\n * @param  {Options}     [options] - [description]\n * @return {Array.<Pattern>}       - [description]\n */\nexport default function match(node, options = {}, nested = false) {\n  options = initOptions(options)\n  const { root, skip, ignore, format } = options\n\n  const path = []\n  let element = node\n  let length = path.length\n  const select = getSelect(options)\n  const toString = getToString(options)\n\n  const skipCompare = skip && (Array.isArray(skip) ? skip : [skip]).map((entry) => {\n    if (typeof entry !== 'function') {\n      return (element) => element === entry\n    }\n    return entry\n  })\n\n  const skipChecks = (element) => {\n    return skip && skipCompare.some((compare) => compare(element))\n  }\n\n  Object.keys(ignore).forEach((type) => {\n    var predicate = ignore[type]\n    if (typeof predicate === 'function') return\n    if (typeof predicate === 'number') {\n      predicate = predicate.toString()\n    }\n    if (typeof predicate === 'string') {\n      predicate = new RegExp(escapeValue(predicate).replace(/\\\\/g, '\\\\\\\\'))\n    }\n    if (typeof predicate === 'boolean') {\n      predicate = predicate ? /(?:)/ : /.^/\n    }\n    // check class-/attributename for regex\n    ignore[type] = (name, value) => predicate.test(value)\n  })\n\n  while (element !== root && element.nodeType !== 11) {\n    if (skipChecks(element) !== true) {\n      // ~ global\n      if (checkAttributes(element, path, options, select, toString, root)) break\n      if (checkTag(element, path, options, select, toString, root)) break\n\n      // ~ local\n      checkAttributes(element, path, options, select, toString)\n      if (path.length === length) {\n        checkTag(element, path, options, select, toString)\n      }\n\n      if (path.length === length && [1, 'xpath'].includes(format) && !nested && element === node) {\n        checkRecursiveDescendants(element, path, options, select, toString)\n      }\n\n      if (path.length === length && [1, 'xpath', 'jquery'].includes(format)) {\n        checkText(element, path, options, select, toString, format === 'jquery')\n      }\n\n      if (path.length === length) {\n        checkNthChild(element, path, options)\n      }\n    }\n\n    element = element.parentNode\n    length = path.length\n  }\n\n  if (element === root) {\n    const pattern = findPattern(element, options, select, toString)\n    path.unshift(pattern)\n  }\n\n  return path\n}\n\n/**\n * Extend path with attribute identifier\n *\n * @param  {HTMLElement}     element  - [description]\n * @param  {Array.<Pattern>} path     - [description]\n * @param  {Options}         options  - [description]\n * @param  {function}        select   - [description]\n * @param  {ToStringApi}     toString - [description]\n * @param  {HTMLElement}     parent   - [description]\n * @return {boolean}                  - [description]\n */\nconst checkAttributes = (element, path, { priority, ignore }, select, toString, parent = element.parentNode) => {\n  const pattern = findAttributesPattern(priority, element, ignore, select, toString, parent)\n  if (pattern) {\n    path.unshift(pattern)\n    return true\n  }\n  return false\n}\n\n/**\n * Calculates array of combinations of items in input array.\n * @param  {Array.<any>} values   - array of values\n * @param  {Object} options       - options: min - minimum subset size; max - maximum subset size\n * @return {Array.<Array.<any>>?}   array of subsets\n */\nexport const combinations = (values, options) => {\n  const { min, max } = options || {}\n  const result = [[]]\n\n  values.forEach(v => {\n    result.forEach(r => {\n      if (!max || r.length < max) {\n        result.push(r.concat(v))\n      }\n    })\n  })\n\n  result.shift()\n  return min ? result.filter(r => r.length >= min) : result\n}\n\n// limit subset size to increase performance\nconst maxSubsetSize = [\n  { items: 13, max: 1 },\n  { items: 10, max: 2 },\n  { items: 8, max: 3 },\n  { items: 5, max: 4 }\n]\n\n/**\n * Get class selector\n *\n * @param  {Array.<string>} classes - [description]\n * @param  {function}       select  - [description]\n * @param  {ToStringApi}    toString - [description]\n * @param  {HTMLElement}    parent  - [description]\n * @param  {Pattern}        base    - [description]\n * @return {Array.<string>?}        - [description]\n */\nconst getClassSelector = (classes = [], select, toString, parent, base) => {\n  const { max } =\n    maxSubsetSize.find(({ items }) => classes.length > items) || { max: classes.length }\n\n  let result = combinations(classes, { max })\n\n  for (let i = 0; i < result.length; i++) {\n    const pattern = toString.pattern({ ...base, classes: result[i] })\n    const matches = select(pattern, parent)\n    if (matches.length === 1) {\n      return result[i]\n    }\n  }\n\n  return null\n}\n\n/**\n * Lookup attribute identifier\n *\n * @param  {Array.<string>} priority  - [description]\n * @param  {HTMLElement}    element   - [description]\n * @param  {Object}         ignore    - [description]\n * @param  {function}       select    - [description]\n * @param  {ToStringApi}    toString  - [description]\n * @param  {ParentNode}     parent    - [description]\n * @return {Pattern?}                 - [description]\n */\nconst findAttributesPattern = (priority, element, ignore, select, toString, parent = element.parentNode) => {\n  const attributes = element.attributes\n  var attributeNames = Object.keys(attributes).map((val) => attributes[val].name)\n    .filter((a) => priority.indexOf(a) < 0)\n\n  var sortedKeys = [...priority, ...attributeNames]\n  var pattern = createPattern()\n  pattern.tag = element.tagName.toLowerCase()\n\n  var isOptimal = (pattern) => (select(toString.pattern(pattern), parent).length === 1)\n\n  for (var i = 0, l = sortedKeys.length; i < l; i++) {\n    const key = sortedKeys[i]\n    const attribute = attributes[key]\n    const attributeName = escapeValue(attribute && attribute.name)\n    const attributeValue = escapeValue(attribute && attribute.value)\n    const useNamedIgnore = attributeName !== 'class'\n\n    const currentIgnore = (useNamedIgnore && ignore[attributeName]) || ignore.attribute\n    const currentDefaultIgnore = (useNamedIgnore && defaultIgnore[attributeName]) || defaultIgnore.attribute\n    if (checkIgnore(currentIgnore, attributeName, attributeValue, currentDefaultIgnore)) {\n      continue\n    }\n\n    switch (attributeName) {\n      case 'class': {\n        let classNames = attributeValue.trim().split(/\\s+/g)\n        if (!classNames[0]) { // empty string\n          break\n        }\n        const classIgnore = ignore.class || defaultIgnore.class\n        if (classIgnore) {\n          classNames = classNames.filter(className => !classIgnore(className))\n        }\n        if (classNames.length > 0) {\n          const classes = getClassSelector(classNames, select, toString, parent, pattern)\n          if (classes) {\n            pattern.classes = classes\n            if (isOptimal(pattern)) {\n              return pattern\n            }\n          }\n        }\n      }\n        break\n\n      default:\n        pattern.attributes.push({ name: attributeName, value: attributeValue })\n        if (isOptimal(pattern)) {\n          return pattern\n        }\n    }\n  }\n\n  return null\n}\n\n\n/**\n * Extend path with tag identifier\n *\n * @param  {HTMLElement}     element - [description]\n * @param  {Options}         options  - [description]\n * @param  {Array.<Pattern>} path    - [description]\n * @param  {function}        select  - [description]\n * @param  {ToStringApi}     toString - [description]\n * @param  {HTMLElement}     parent  - [description]\n * @return {boolean}                 - [description]\n */\nconst checkTag = (element, path, { ignore }, select, toString, parent = element.parentNode) => {\n  const pattern = findTagPattern(element, ignore)\n  if (pattern) {\n    let matches = []\n    matches = select(toString.pattern(pattern), parent)\n    if (matches.length === 1) {\n      path.unshift(pattern)\n      if (pattern.tag === 'iframe') {\n        return false\n      }\n      return true\n    }\n  }\n  return false\n}\n\n/**\n * Lookup tag identifier\n *\n * @param  {HTMLElement} element - [description]\n * @param  {Object}      ignore  - [description]\n * @return {Pattern?}            - [description]\n */\nconst findTagPattern = (element, ignore) => {\n  const tagName = element.tagName.toLowerCase()\n  if (checkIgnore(ignore.tag, null, tagName)) {\n    return null\n  }\n  const pattern = createPattern()\n  pattern.tag = tagName\n  return pattern\n}\n\n/**\n * Extend path with specific child identifier\n *\n * @param  {HTMLElement}     element - [description]\n * @param  {Options}         options - [description]\n * @param  {Array.<Pattern>} path    - [description]\n * @return {boolean}                 - [description]\n */\nconst checkNthChild = (element, path, { ignore }) => {\n  const parent = element.parentNode\n  const children = parent.children\n  for (var i = 0, l = children.length; i < l; i++) {\n    const child = children[i]\n    if (child === element) {\n      const childPattern = findTagPattern(child, ignore)\n      if (!childPattern) {\n        return console.warn(`\n          Element couldn't be matched through strict ignore pattern!\n        `, child, ignore, childPattern)\n      }\n      childPattern.relates = 'child'\n      childPattern.pseudo = [`nth-child(${i + 1})`]\n      path.unshift(childPattern)\n      return true\n    }\n  }\n  return false\n}\n\n/**\n * Extend path with contains\n *\n * @param  {HTMLElement}     element  - [description]\n * @param  {Array.<Pattern>} path     - [description]\n * @param  {Options}         options  - [description]\n * @param  {function}        select   - [description]\n * @param  {ToStringApi}     toString - [description]\n * @param  {boolean}         nested   - [description]\n * @return {boolean}                  - [description]\n */\nconst checkText = (element, path, { ignore }, select, toString, nested) => {\n  const pattern = findTagPattern(element, ignore)\n  if (!pattern) {\n    return false\n  }\n  const textContent = (nested ? element.textContent : (element.firstChild && element.firstChild.nodeValue) || '')\n  if (!textContent) {\n    return false\n  }\n\n  pattern.relates = 'child'\n  const parent = element.parentNode\n  const texts = textContent\n    .replace(/\\n+/g, '\\n')\n    .split('\\n')\n    .map(text => text.trim())\n    .filter(text => text.length > 0)\n\n  const contains = []\n\n  while (texts.length > 0) {\n    const text = texts.shift()\n    if (checkIgnore(ignore.contains, null, text, defaultIgnore.contains)) {\n      break\n    }\n    contains.push(`contains(\"${text}\")`)\n\n    const matches = select(toString.pattern({ ...pattern, pseudo: contains }), parent)\n    if (matches.length === 1) {\n      pattern.pseudo = contains\n      path.unshift(pattern)\n      return true\n    }\n    if (matches.length === 0) {\n      return false\n    }\n  }\n  return false\n}\n\n/**\n * Extend path with descendant tag\n *\n * @param  {HTMLElement}     element  - [description]\n * @param  {Array.<Pattern>} path     - [description]\n * @param  {Options}         options  - [description]\n * @param  {function}        select   - [description]\n * @param  {ToStringApi}     toString - [description]\n * @return {boolean}                  - [description]\n */\nconst checkRecursiveDescendants = (element, path, options, select, toString) => {\n  const pattern = findTagPattern(element, options.ignore)\n  if (!pattern) {\n    return false\n  }\n\n  const descendants = Array.from(element.querySelectorAll('*'))\n  while (descendants.length > 0) {\n    const descendantPath = match(descendants.shift(), { ...options, root: element }, true)\n    // avoid descendant selectors with nth-child\n    if (!descendantPath.some(pattern => pattern.pseudo.some(p => p.startsWith('nth-child')))) {\n      const parent = element.parentElement\n      const matches = select(toString.pattern({ ...pattern, descendants: [descendantPath] }), parent)\n      if (matches.length === 1) {\n        pattern.descendants = [descendantPath]\n        path.unshift(pattern)\n        return true\n      }\n    }\n  }\n\n  return false\n}\n\n/**\n * Lookup identifier\n *\n * @param  {HTMLElement}    element  - [description]\n * @param  {Options}        options   - [description]\n * @param  {function}       select   - [description]\n * @param  {ToStringApi}    toString - [description]\n * @return {Pattern}                 - [description]\n */\nconst findPattern = (element, { priority, ignore }, select, toString) => {\n  var pattern = findAttributesPattern(priority, element, ignore, select, toString)\n  if (!pattern) {\n    pattern = findTagPattern(element, ignore)\n  }\n  return pattern\n}\n\n/**\n * Validate with custom and default functions\n *\n * @param  {Function} predicate        - [description]\n * @param  {string?}  name             - [description]\n * @param  {string}   value            - [description]\n * @param  {Function} defaultPredicate - [description]\n * @return {boolean}                   - [description]\n */\nexport const checkIgnore = (predicate, name, value, defaultPredicate) => {\n  if (!value) {\n    return true\n  }\n  const check = predicate || defaultPredicate\n  if (!check) {\n    return false\n  }\n  return check(name, value, defaultPredicate)\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/match.js","import { isValidCSSIdentifier } from './utilities'\n/**\n * @typedef  {Object} Pattern\n * @property {('descendant' | 'child')}                  [relates]\n * @property {string}                                    [tag]\n * @property {Array.<{ name: string, value: string? }>}  attributes\n * @property {Array.<string>}                            classes\n * @property {Array.<string>}                            pseudo\n * @property {Array.<Array.<Pattern>>}                   descendants\n */\n\n/**\n * Creates a new pattern structure\n * \n * @param {Partial<Pattern>} pattern\n * @returns {Pattern}\n */\nexport const createPattern = (base = {}) =>\n  ({ attributes: [], classes: [], pseudo: [], descendants: [], ...base })\n\n/**\n * Convert attributes to CSS selector\n * \n * @param {Array.<{ name: string, value: string? }>} attributes \n * @returns {string}\n */\nexport const attributesToSelector = (attributes) =>\n  attributes.map(({ name, value }) => {\n    if (value === null) {\n      return `[${name}]`\n    }\n    if (name === 'id' && isValidCSSIdentifier(value)) {\n      return `#${value}`\n    }\n    return `[${name}=\"${value}\"]`\n  }).join('')\n\n/**\n * Convert classes to CSS selector\n * \n * @param {Array.<string>} classes \n * @returns {string}\n */\nexport const classesToSelector = (classes) =>\n  classes.map(c => isValidCSSIdentifier(c) ? `.${c}` : `[class~=\"${c}\"]`).join('')\n\n/**\n * Convert pseudo selectors to CSS selector\n * \n * @param {Array.<string>} pseudo \n * @returns {string}\n */\nexport const pseudoToSelector = (pseudo) => pseudo.length ? `:${pseudo.join(':')}` : ''\n\n/**\n * Convert pattern to CSS selector\n * \n * @param {Pattern} pattern \n * @returns {string}\n */\nexport const patternToSelector = (pattern) => {\n  const { relates, tag, attributes, classes, pseudo } = pattern\n  const value = `${\n    relates === 'child' ? '> ' : ''\n  }${\n    tag || ''\n  }${\n    attributesToSelector(attributes)\n  }${\n    classesToSelector(classes)\n  }${\n    pseudoToSelector(pseudo)\n  }`\n  return value\n}\n\n/**\n * Converts path to string\n *\n * @param {Array.<Pattern>} path \n * @returns {string}\n */\nexport const pathToSelector = (path) =>\n  path.map(patternToSelector).join(' ')\n\n\nconst convertEscaping = (value) =>\n  value && value.replace(/\\\\([`\\\\/:?&!#$%^()[\\]{|}*+;,.<=>@~])/g, '$1')\n    .replace(/\\\\(['\"])/g, '$1$1')\n    .replace(/\\\\A /g, '\\n')\n\n/**\n* Convert attributes to XPath string\n* \n* @param {Array.<{ name: string, value: string? }>} attributes \n* @returns {string}\n*/\nexport const attributesToXPath = (attributes) =>\n  attributes.map(({ name, value }) => {\n    if (value === null) {\n      return `[@${name}]`\n    }\n    return `[@${name}=\"${convertEscaping(value)}\"]`\n  }).join('')\n\n/**\n* Convert classes to XPath string\n* \n* @param {Array.<string>} classes \n* @returns {string}\n*/\nexport const classesToXPath = (classes) =>\n  classes.map(c => `[contains(concat(\" \",normalize-space(@class),\" \"),\" ${c} \")]`).join('')\n\n/**\n* Convert pseudo selectors to XPath string\n* \n* @param {Array.<string>} pseudo \n* @returns {string}\n*/\nexport const pseudoToXPath = (pseudo) =>\n  pseudo.map(p => {\n    const match = p.match(/^(nth-child|nth-of-type|contains)\\((.+)\\)$/)\n    if (!match) {\n      return ''\n    }\n\n    switch (match[1]) {\n      case 'nth-child':\n        return `[(count(preceding-sibling::*)+1) = ${match[2]}]`\n\n      case 'nth-of-type':\n        return `[${match[2]}]`\n\n      case 'contains':\n        return `[contains(text(),${match[2]})]`\n\n      default:\n        return ''\n    }\n  }).join('')\n\n/**\n* Convert pattern to XPath string\n* \n* @param {Pattern} pattern \n* @returns {string}\n*/\nexport const patternToXPath = (pattern) => {\n  const { relates, tag, attributes, classes, pseudo, descendants } = pattern\n  const value = `${\n    relates === 'child' ? '/' : '//'\n  }${\n    tag || '*'\n  }${\n    attributesToXPath(attributes)\n  }${\n    classesToXPath(classes)\n  }${\n    pseudoToXPath(pseudo)\n  }${\n    descendantsToXPath(descendants)\n  }`\n  return value\n}\n\n/**\n* Converts path to XPath string\n*\n* @param {Array.<Pattern>} path \n* @returns {string}\n*/\nexport const pathToXPath = (path) => `.${path.map(patternToXPath).join('')}`\n\n/**\n* Convert child selectors to XPath string\n* \n* @param {Array.<Array.<Pattern>>} children \n* @returns {string}\n*/\nexport const descendantsToXPath = (children) =>\n  children.length ? `[${children.map(pathToXPath).join('][')}]` : ''\n\n  \nconst toString = {\n  'css': {\n    attributes: attributesToSelector,\n    classes: classesToSelector,\n    pseudo: pseudoToSelector,\n    pattern: patternToSelector,\n    path: pathToSelector\n  },\n  'xpath': {\n    attributes: attributesToXPath,\n    classes: classesToXPath,\n    pseudo: pseudoToXPath,\n    pattern: patternToXPath,\n    path: pathToXPath\n  },\n  'jquery': {}\n}\n\ntoString.jquery = toString.css\ntoString[0] = toString.css\ntoString[1] = toString.xpath\n  \n/**\n * @typedef  {Object} ToStringApi\n * @property {(attributes: Array.<{ name: string, value: string? }>) => string} attributes\n * @property {(classes: Array.<string>) => string}  classes\n * @property {(pseudo: Array.<string>) => string}   pseudo\n * @property {(pattern: Pattern) => string}         pattern\n * @property {(path: Array.<Pattern>) => string}    path\n */\n\n/**\n * \n * @param {Options} options \n * @returns {ToStringApi}\n */\nexport const getToString = (options = {}) =>\n  toString[options.format || 'css']\n\n\n\n\n\n// WEBPACK FOOTER //\n// ./src/pattern.js","// import Sizzle from 'sizzle'\nlet Sizzle\n\n/**\n * Select element using jQuery\n * @param  {string}         selector\n * @param  {HTMLElement}    parent\n * @return Array.<HTMLElement>\n */\nconst selectJQuery = (selector, parent = null) => {\n  if (!Sizzle) {\n    Sizzle = require('sizzle')\n  }\n  return Sizzle(selector, parent || document)\n}\n  \n/**\n * Select element using XPath\n * @param  {string}         selector\n * @param  {HTMLElement}    parent\n * @return Array.<HTMLElement>\n */\nconst selectXPath = (selector, parent = null) => {\n  parent = (parent || document)\n  var doc = parent\n  while (doc.parentNode) {\n    doc = doc.parentNode\n  }\n  if (doc !== parent && !selector.startsWith('.')) {\n    selector = `.${selector}`\n  }\n  var iterator = doc.evaluate(selector, parent, null, 0)\n  var elements = []\n  var element\n  while ((element = iterator.iterateNext())) {\n    elements.push(element)\n  }\n  return elements\n}\n  \n/**\n * Select element using CSS\n * @param  {string}         selector\n * @param  {HTMLElement}    parent\n * @return Array.<HTMLElement>\n */\nconst selectCSS = (selector, parent = null) =>\n  (parent || document).querySelectorAll(selector)\n\nconst select = {\n  'css': selectCSS,\n  'xpath': selectXPath,\n  'jquery': selectJQuery\n}\n\nselect[0] = select.css\nselect[1] = select.xpath\n\n/**\n* \n* @param {Options} options \n* @returns {(selector: string, parent: HTMLElement) => Array.<HTMLElement>}\n*/\nexport const getSelect = (options = {}) =>\n  (selector, parent) => {\n    try {\n      return select[options.format || 'css'](selector, parent || options.root)\n    } catch (err) {\n      return []\n    }\n  }\n\n\n\n\n// WEBPACK FOOTER //\n// ./src/selector.js","/**\n * # Common\n *\n * Process collections for similarities.\n */\n\n/**\n * @typedef {import('./select').Options} Options\n */\n\n/**\n * Find the last common ancestor of elements\n *\n * @param  {Array.<HTMLElement>} elements  - [description]\n * @param  {Options}              options  - [description]\n * @return {HTMLElement}                   - [description]\n */\nimport { defaultIgnore, checkIgnore } from './match'\nimport { escapeValue } from './utilities'\n\nexport const getCommonAncestor = (elements, options = {}) => {\n\n  const {\n    root = document\n  } = options\n\n  const ancestors = []\n\n  elements.forEach((element, index) => {\n    const parents = []\n    while (element !== root) {\n      element = element.parentNode\n      parents.unshift(element)\n    }\n    ancestors[index] = parents\n  })\n\n  ancestors.sort((curr, next) => curr.length - next.length)\n\n  const shallowAncestor = ancestors.shift()\n\n  var ancestor = null\n\n  for (var i = 0, l = shallowAncestor.length; i < l; i++) {\n    const parent = shallowAncestor[i]\n    const missing = ancestors.some((otherParents) => {\n      return !otherParents.some((otherParent) => otherParent === parent)\n    })\n\n    if (missing) {\n      // TODO: find similar sub-parents, not the top root, e.g. sharing a class selector\n      break\n    }\n\n    ancestor = parent\n  }\n\n  return ancestor\n}\n\n/**\n * Get a set of common properties of elements\n *\n * @param  {Array.<HTMLElement>} elements - [description]\n * @return {Object}                       - [description]\n */\nexport const getCommonProperties = (elements, options = {}) => {\n  const { ignore = {} } = options\n\n  const commonProperties = {\n    classes: [],\n    attributes: {},\n    tag: null\n  }\n\n  elements.forEach((element) => {\n\n    var {\n      classes: commonClasses,\n      attributes: commonAttributes,\n      tag: commonTag\n    } = commonProperties\n\n    // ~ classes\n    if (commonClasses !== undefined) {\n      var classes = element.getAttribute('class')\n      if (classes) {\n        classes = classes.trim().split(' ').filter(cls => !ignore.class || !ignore.class(cls))\n        if (!commonClasses.length) {\n          commonProperties.classes = classes\n        } else {\n          commonClasses = commonClasses.filter((entry) => classes.some((name) => name === entry))\n          if (commonClasses.length) {\n            commonProperties.classes = commonClasses\n          } else {\n            delete commonProperties.classes\n          }\n        }\n      } else {\n        delete commonProperties.classes\n      }\n    }\n\n    // ~ attributes\n    if (commonAttributes !== undefined) {\n      const elementAttributes = element.attributes\n      const attributes = Object.keys(elementAttributes).reduce((attributes, key) => {\n        const attribute = elementAttributes[key]\n        const attributeName = escapeValue(attribute && attribute.name)\n        const attributeValue = escapeValue(attribute && attribute.value)\n        const useNamedIgnore = attributeName !== 'class'\n        const currentIgnore = (useNamedIgnore && ignore[attributeName]) || ignore.attribute\n        const currentDefaultIgnore = (useNamedIgnore && defaultIgnore[attributeName]) || defaultIgnore.attribute\n        if (attribute && attributeName !== 'class' && !checkIgnore(currentIgnore, attributeName, attributeValue, currentDefaultIgnore)) {\n          attributes[attributeName] = attribute.value\n        }\n        return attributes\n      }, {})\n\n      const attributesNames = Object.keys(attributes)\n      const commonAttributesNames = Object.keys(commonAttributes)\n\n      if (attributesNames.length) {\n        if (!commonAttributesNames.length) {\n          commonProperties.attributes = attributes\n        } else {\n          commonAttributes = commonAttributesNames.reduce((nextCommonAttributes, name) => {\n            const value = commonAttributes[name]\n            if (value === attributes[name]) {\n              nextCommonAttributes[name] = value\n            }\n            return nextCommonAttributes\n          }, {})\n          if (Object.keys(commonAttributes).length) {\n            commonProperties.attributes = commonAttributes\n          } else {\n            delete commonProperties.attributes\n          }\n        }\n      } else {\n        delete commonProperties.attributes\n      }\n    }\n\n    // ~ tag\n    if (commonTag !== undefined) {\n      const tag = element.tagName.toLowerCase()\n      if (!commonTag) {\n        commonProperties.tag = tag\n      } else if (tag !== commonTag) {\n        delete commonProperties.tag\n      }\n    }\n  })\n\n  return commonProperties\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/common.js","/**\n * # Optimize\n *\n * 1.) Improve efficiency through shorter selectors by removing redundancy\n * 2.) Improve robustness through selector transformation\n */\n\nimport { getSelect } from './selector'\nimport { createPattern, getToString } from './pattern'\nimport { convertNodeList, partition } from './utilities'\n\n/**\n * @typedef {import('./select').Options} Options\n * @typedef {import('./pattern').Pattern} Pattern\n * @typedef {import('./pattern').ToStringApi} Pattern\n */\n\n/**\n * Apply different optimization techniques\n *\n * @param  {Array.<Pattern>}                 path   - [description]\n * @param  {HTMLElement|Array.<HTMLElement>} element    - [description]\n * @param  {Options}                         [options]  - [description]\n * @return {Array.<Pattern>}                            - [description]\n */\nexport default function optimize (path, elements, options = {}) {\n  if (path.length === 0) {\n    return []\n  }\n\n  if (path[0].relates === 'child') {\n    path[0].relates = undefined\n  }\n\n  // convert single entry and NodeList\n  if (!Array.isArray(elements)) {\n    elements = !elements.length ? [elements] : convertNodeList(elements)\n  }\n\n  if (!elements.length || elements.some((element) => element.nodeType !== 1)) {\n    throw new Error('Invalid input - to compare HTMLElements its necessary to provide a reference of the selected node(s)! (missing \"elements\")')\n  }\n\n  const select = getSelect(options)\n  const toString = getToString(options)\n\n  if (path.length === 1) {\n    return [optimizePart([], path[0], [], elements, select, toString)]\n  }\n\n  var endOptimized = false\n  if (path[path.length-1].relates === 'child') {\n    path[path.length-1] = optimizePart(path.slice(0, -1), path[path.length-1], [], elements, select, toString)\n    endOptimized = true\n  }\n\n  path = [...path]\n  const shortened = [path.pop()]\n  while (path.length > 1) {\n    const current = path.pop()\n    const matches = select(toString.path([...path, ...shortened]))\n    const hasSameResult = matches.length === elements.length && elements.every((element, i) => element === matches[i])\n    if (!hasSameResult) {\n      shortened.unshift(optimizePart(path, current, shortened, elements, select, toString))\n    }\n  }\n  shortened.unshift(path[0])\n  path = shortened\n\n  // optimize start + end\n  path[0] = optimizePart([], path[0], path.slice(1), elements, select, toString)\n  if (!endOptimized) {\n    path[path.length-1] = optimizePart(path.slice(0, -1), path[path.length-1], [], elements, select, toString)\n  }\n\n  return path\n}\n\n/**\n * Optimize :contains\n *\n * @param  {Array.<Pattern>}     pre      - [description]\n * @param  {Pattern}             current  - [description]\n * @param  {Array.<Pattern>}     post     - [description]\n * @param  {Array.<HTMLElement>} elements - [description]\n * @param  {function}            select   - [description]\n * @param  {ToStringApi}         toString - [description]\n * @return {Pattern}                      - [description]\n */\nconst optimizeText = (pre, current, post, elements, select, toString) => {\n  const [contains, other] = partition(current.pseudo, (item) => item.startsWith('contains'))\n\n  if (contains.length > 0 && post.length) {\n    const base = { ...current, pseudo: [...other, ...contains] }\n    while (base.pseudo.length > other.length) {\n      const optimized = base.pseudo.slice(0, -1)\n      if (!compareResults(select(toString.path([...pre, { ...base, pseudo: optimized }, ...post])), elements)) {\n        break\n      }\n      base.pseudo = optimized\n    }\n    return base\n  }\n  return current\n}\n\n/**\n * Optimize attributes\n *\n * @param  {Array.<Pattern>}     pre      - [description]\n * @param  {Pattern}             current  - [description]\n * @param  {Array.<Pattern>}     post     - [description]\n * @param  {Array.<HTMLElement>} elements - [description]\n * @param  {function}            select   - [description]\n * @param  {ToStringApi}         toString - [description]\n * @return {Pattern}                      - [description]\n */\nconst optimizeAttributes = (pre, current, post, elements, select, toString) => {\n  // reduce attributes: first try without value, then removing completely\n  if (current.attributes.length > 0) {\n    let attributes = [...current.attributes]\n\n    const simplify = (original, getSimplified) => {\n      let i = original.length - 1\n      while (i >= 0) {\n        let attributes = getSimplified(original, i)\n        if (!compareResults(\n          select(toString.path([...pre, { ...current, attributes }, ...post])),\n          elements\n        )) {\n          break\n        }\n        i--\n        original = attributes\n      }\n      return original\n    }\n\n    const simplified = simplify(attributes, (attributes, i) => {\n      const { name } = attributes[i]\n      if (name === 'id') {\n        return attributes\n      }\n      return [...attributes.slice(0, i), { name, value: null }, ...attributes.slice(i + 1)]\n    })\n    return { ...current, attributes: simplify(simplified, attributes => attributes.slice(0, -1)) }    \n  }\n  return current\n}\n\n/**\n * Optimize descendant\n *\n * @param  {Array.<Pattern>}     pre      - [description]\n * @param  {Pattern}             current  - [description]\n * @param  {Array.<Pattern>}     post     - [description]\n * @param  {Array.<HTMLElement>} elements - [description]\n * @param  {function}            select   - [description]\n * @param  {ToStringApi}         toString - [description]\n * @return {Pattern}                      - [description]\n */\nconst optimizeDescendant = (pre, current, post, elements, select, toString) => {\n  // robustness: descendant instead child (heuristic)\n  if (current.relates === 'child') {\n    const descendant = { ...current, relates: undefined }\n    let matches = select(toString.path([...pre, descendant, ...post]))\n    if (compareResults(matches, elements)) {\n      return descendant\n    }\n  }\n  return current\n}\n\n/**\n * Optimize recursive descendants\n * \n * @param  {Array.<Pattern>}     pre      - [description]\n * @param  {Pattern}             current  - [description]\n * @param  {Array.<Pattern>}     post     - [description]\n * @param  {Array.<HTMLElement>} elements - [description]\n * @param  {function}            select   - [description]\n * @param  {ToStringApi}         toString - [description]\n * @return {Pattern}                      - [description]\n */\nconst optimizeRecursiveDescendants = (pre, current, post, elements, select, toString) => {\n  if (current.descendants.length > 0 && post.length) {\n    const base = { ...current, descendants: [...current.descendants] }\n    while (base.descendants.length > 0) {\n      const optimized = base.descendants.slice(0, -1)\n      if (!compareResults(select(toString.path([...pre, { ...base, descendants: optimized }, ...post])), elements)) {\n        break\n      }\n      base.descendants = optimized\n    }\n    return base\n  }\n  return current\n}\n\n/**\n * Optimize nth of type\n *\n * @param  {Array.<Pattern>}     pre      - [description]\n * @param  {Pattern}             current  - [description]\n * @param  {Array.<Pattern>}     post     - [description]\n * @param  {Array.<HTMLElement>} elements - [description]\n * @param  {function}            select   - [description]\n * @param  {ToStringApi}         toString - [description]\n * @return {Pattern}                      - [description]\n */\nconst optimizeNthOfType = (pre, current, post, elements, select, toString) => {\n  const i = current.pseudo.findIndex(item => item.startsWith('nth-child'))\n  // robustness: 'nth-of-type' instead 'nth-child' (heuristic)\n  if (i >= 0) {\n    // TODO: consider complete coverage of 'nth-of-type' replacement\n    const type = current.pseudo[i].replace(/^nth-child/, 'nth-of-type')\n    const nthOfType = { ...current, pseudo: [...current.pseudo.slice(0, i), type, ...current.pseudo.slice(i + 1)] }\n    let pattern = toString.path([...pre, nthOfType, ...post])\n    let matches = select(pattern)\n    if (compareResults(matches, elements)) {\n      return nthOfType\n    }\n  }\n  return current\n}\n\n/**\n * Optimize classes\n *\n * @param  {Array.<Pattern>}     pre      - [description]\n * @param  {Pattern}             current  - [description]\n * @param  {Array.<Pattern>}     post     - [description]\n * @param  {Array.<HTMLElement>} elements - [description]\n * @param  {function}            select   - [description]\n * @param  {ToStringApi}         toString - [description]\n * @return {Pattern}                      - [description]\n */\nconst optimizeClasses = (pre, current, post, elements, select, toString) => {\n  // efficiency: combinations of classname (partial permutations)\n  if (current.classes.length > 1) {\n    let optimized = current.classes.slice().sort((curr, next) => curr.length - next.length)\n\n    while (optimized.length > 1) {\n      optimized.shift()\n      const pattern = toString.path([...pre, { ...current, classes: optimized }, ...post])\n      if (!compareResults(select(pattern), elements)) {\n        break\n      }\n      current.classes = optimized\n    }\n\n    optimized = current.classes\n\n    if (optimized.length > 2) {\n      const base = createPattern({ classes: optimized })\n      const references = select(toString.path([...pre, base]))\n      for (var i = 0; i < references.length; i++) {\n        const reference = references[i]\n        if (elements.some((element) => reference.contains(element))) {\n          // TODO:\n          // - check using attributes + regard excludes\n          const description = createPattern({ tag: reference.tagName })\n          var pattern = toString.path([...pre, description, ...post])\n          var matches = select(pattern)\n          if (compareResults(matches, elements)) {\n            current = description\n          }\n          break\n        }\n      }\n    }\n  }\n  return current\n}\n\nconst optimizers = [\n  optimizeText,\n  optimizeAttributes,\n  optimizeDescendant,\n  optimizeRecursiveDescendants,\n  optimizeNthOfType,\n  optimizeClasses,\n]\n\n/**\n * Improve a chunk of the selector\n *\n * @param  {Array.<Pattern>}     pre      - [description]\n * @param  {Pattern}             current  - [description]\n * @param  {Array.<Pattern>}     post     - [description]\n * @param  {Array.<HTMLElement>} elements - [description]\n * @param  {function}            select   - [description]\n * @param  {ToStringApi}         toString - [description]\n * @return {Pattern}                      - [description]\n */\nconst optimizePart = (pre, current, post, elements, select, toString) =>\n  optimizers.reduce((acc, optimizer) => optimizer(pre, acc, post, elements, select, toString), current)\n\n/**\n * Evaluate matches with expected elements\n *\n * @param  {Array.<HTMLElement>} matches  - [description]\n * @param  {Array.<HTMLElement>} elements - [description]\n * @return {Boolean}                      - [description]\n */\nexport const compareResults = (matches, elements) => {\n  const { length } = matches\n  return length === elements.length && elements.every((element) => {\n    for (var i = 0; i < length; i++) {\n      if (matches[i] === element) {\n        return true\n      }\n    }\n    return false\n  })\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/optimize.js","/**\n * # Select\n *\n * Construct a unique CSS query selector to access the selected DOM element(s).\n * For longevity it applies different matching and optimization strategies.\n */\nimport match from './match'\nimport optimize from './optimize'\nimport { convertNodeList, escapeValue } from './utilities'\nimport { getCommonAncestor, getCommonProperties } from './common'\nimport { getSelect } from './selector'\nimport { createPattern, getToString } from './pattern'\n\n/**\n * @typedef  {Object} Options\n * @property {HTMLElement} [root]                     Optionally specify the root element\n * @property {function | Array.<HTMLElement>} [skip]  Specify elements to skip\n * @property {Array.<string>} [priority]              Order of attribute processing\n * @property {Object<string, function | number | string | boolean} [ignore] Define patterns which shouldn't be included\n * @property {('css'|'xpath'|'jquery')} [format]      Output format    \n */\n\n/**\n * @typedef {import('./pattern').Pattern} Pattern\n */\n\n/**\n * Get a selector for the provided element\n *\n * @param  {HTMLElement} element   - [description]\n * @param  {Options}     [options] - [description]\n * @return {Array.<Pattern>}       - [description]\n */\nexport const getSingleSelectorPath = (element, options = {}) => {\n\n  if (element.nodeType === 3) {\n    element = element.parentNode\n  }\n\n  if (element.nodeType !== 1) {\n    throw new Error(`Invalid input - only HTMLElements or representations of them are supported! (not \"${typeof element}\")`)\n  }\n\n  const path = match(element, options)\n  const optimizedPath = optimize(path, element, options)\n\n  // debug\n  // console.log(`\n  //   selector:  ${path}\n  //   optimized: ${optimizedPath}\n  // `)\n\n  return optimizedPath\n}\n\n/**\n * Get a selector to match multiple descendants from an ancestor\n *\n * @param  {Array.<HTMLElement>|NodeList} elements   - [description]\n * @param  {Options}                      [options]  - [description]\n * @return {Array.<Pattern>}                         - [description]\n */\nexport const getMultiSelectorPath = (elements, options = {}) => {\n\n  if (!Array.isArray(elements)) {\n    elements = convertNodeList(elements)\n  }\n\n  if (elements.some((element) => element.nodeType !== 1)) {\n    throw new Error('Invalid input - only an Array of HTMLElements or representations of them is supported!')\n  }\n\n  const select = getSelect(options)\n  const toString = getToString(options)\n\n  const ancestor = getCommonAncestor(elements, options)\n  const ancestorPath = match(ancestor, options)\n\n  // TODO: consider usage of multiple selectors + parent-child relation + check for part redundancy\n  const commonPath = getCommonPath(elements, options)\n  const descendantPattern = commonPath[0]\n\n  const selectorPath = optimize([...ancestorPath, descendantPattern], elements, options)\n  const selectorMatches = convertNodeList(select(toString.path(selectorPath)))\n\n  if (!elements.every((element) => selectorMatches.some((entry) => entry === element))) {\n    // TODO: cluster matches to split into similar groups for sub selections\n    console.warn(`\n      The selected elements can't be efficiently mapped.\n      Its probably best to use multiple single selectors instead!\n    `)\n    return elements\n  }\n\n  return selectorPath\n}\n\n/**\n * Get selectors to describe a set of elements\n *\n * @param  {Array.<HTMLElement>} elements  - [description]\n * @return {Array.<Pattern>}               - [description]\n */\nconst getCommonPath = (elements, options) => {\n  const { classes, attributes, tag } = getCommonProperties(elements, options)\n\n\n  return [\n    createPattern({\n      tag,\n      classes: classes || [],\n      attributes: attributes ? Object.keys(attributes).map((name) => ({\n        name: escapeValue(name),\n        value: escapeValue(attributes[name])\n      })) : []\n    })\n  ]\n}\n\n/**\n * Choose action depending on the input (multiple/single)\n *\n * NOTE: extended detection is used for special cases like the <select> element with <options>\n *\n * @param  {HTMLElement|NodeList|Array.<HTMLElement>} input     - [description]\n * @param  {Options}                                  [options] - [description]\n * @return {string}                                             - [description]\n */\nexport default function getQuerySelector(input, options = {}) {\n  const path = (input.length && !input.name)\n    ? getMultiSelectorPath(input, options)\n    : getSingleSelectorPath(input, options)\n\n  if (Array.isArray(path) && path.length > 0 && path[0] instanceof HTMLElement) {\n    return path.map(entry => getQuerySelector(entry, options)).join(',')\n  }\n  return getToString(options).path(path)\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/select.js","/*!\n * Sizzle CSS Selector Engine v2.3.6\n * https://sizzlejs.com/\n *\n * Copyright JS Foundation and other contributors\n * Released under the MIT license\n * https://js.foundation/\n *\n * Date: 2021-02-16\n */\n( function( window ) {\nvar i,\n\tsupport,\n\tExpr,\n\tgetText,\n\tisXML,\n\ttokenize,\n\tcompile,\n\tselect,\n\toutermostContext,\n\tsortInput,\n\thasDuplicate,\n\n\t// Local document vars\n\tsetDocument,\n\tdocument,\n\tdocElem,\n\tdocumentIsHTML,\n\trbuggyQSA,\n\trbuggyMatches,\n\tmatches,\n\tcontains,\n\n\t// Instance-specific data\n\texpando = \"sizzle\" + 1 * new Date(),\n\tpreferredDoc = window.document,\n\tdirruns = 0,\n\tdone = 0,\n\tclassCache = createCache(),\n\ttokenCache = createCache(),\n\tcompilerCache = createCache(),\n\tnonnativeSelectorCache = createCache(),\n\tsortOrder = function( a, b ) {\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t}\n\t\treturn 0;\n\t},\n\n\t// Instance methods\n\thasOwn = ( {} ).hasOwnProperty,\n\tarr = [],\n\tpop = arr.pop,\n\tpushNative = arr.push,\n\tpush = arr.push,\n\tslice = arr.slice,\n\n\t// Use a stripped-down indexOf as it's faster than native\n\t// https://jsperf.com/thor-indexof-vs-for/5\n\tindexOf = function( list, elem ) {\n\t\tvar i = 0,\n\t\t\tlen = list.length;\n\t\tfor ( ; i < len; i++ ) {\n\t\t\tif ( list[ i ] === elem ) {\n\t\t\t\treturn i;\n\t\t\t}\n\t\t}\n\t\treturn -1;\n\t},\n\n\tbooleans = \"checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|\" +\n\t\t\"ismap|loop|multiple|open|readonly|required|scoped\",\n\n\t// Regular expressions\n\n\t// http://www.w3.org/TR/css3-selectors/#whitespace\n\twhitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\",\n\n\t// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram\n\tidentifier = \"(?:\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace +\n\t\t\"?|\\\\\\\\[^\\\\r\\\\n\\\\f]|[\\\\w-]|[^\\0-\\\\x7f])+\",\n\n\t// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors\n\tattributes = \"\\\\[\" + whitespace + \"*(\" + identifier + \")(?:\" + whitespace +\n\n\t\t// Operator (capture 2)\n\t\t\"*([*^$|!~]?=)\" + whitespace +\n\n\t\t// \"Attribute values must be CSS identifiers [capture 5]\n\t\t// or strings [capture 3 or capture 4]\"\n\t\t\"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" +\n\t\twhitespace + \"*\\\\]\",\n\n\tpseudos = \":(\" + identifier + \")(?:\\\\((\" +\n\n\t\t// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:\n\t\t// 1. quoted (capture 3; capture 4 or capture 5)\n\t\t\"('((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\")|\" +\n\n\t\t// 2. simple (capture 6)\n\t\t\"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" +\n\n\t\t// 3. anything else (capture 2)\n\t\t\".*\" +\n\t\t\")\\\\)|)\",\n\n\t// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\n\trwhitespace = new RegExp( whitespace + \"+\", \"g\" ),\n\trtrim = new RegExp( \"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" +\n\t\twhitespace + \"+$\", \"g\" ),\n\n\trcomma = new RegExp( \"^\" + whitespace + \"*,\" + whitespace + \"*\" ),\n\trcombinators = new RegExp( \"^\" + whitespace + \"*([>+~]|\" + whitespace + \")\" + whitespace +\n\t\t\"*\" ),\n\trdescend = new RegExp( whitespace + \"|>\" ),\n\n\trpseudo = new RegExp( pseudos ),\n\tridentifier = new RegExp( \"^\" + identifier + \"$\" ),\n\n\tmatchExpr = {\n\t\t\"ID\": new RegExp( \"^#(\" + identifier + \")\" ),\n\t\t\"CLASS\": new RegExp( \"^\\\\.(\" + identifier + \")\" ),\n\t\t\"TAG\": new RegExp( \"^(\" + identifier + \"|[*])\" ),\n\t\t\"ATTR\": new RegExp( \"^\" + attributes ),\n\t\t\"PSEUDO\": new RegExp( \"^\" + pseudos ),\n\t\t\"CHILD\": new RegExp( \"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" +\n\t\t\twhitespace + \"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" +\n\t\t\twhitespace + \"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\" ),\n\t\t\"bool\": new RegExp( \"^(?:\" + booleans + \")$\", \"i\" ),\n\n\t\t// For use in libraries implementing .is()\n\t\t// We use this for POS matching in `select`\n\t\t\"needsContext\": new RegExp( \"^\" + whitespace +\n\t\t\t\"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" + whitespace +\n\t\t\t\"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\" )\n\t},\n\n\trhtml = /HTML$/i,\n\trinputs = /^(?:input|select|textarea|button)$/i,\n\trheader = /^h\\d$/i,\n\n\trnative = /^[^{]+\\{\\s*\\[native \\w/,\n\n\t// Easily-parseable/retrievable ID or TAG or CLASS selectors\n\trquickExpr = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\n\n\trsibling = /[+~]/,\n\n\t// CSS escapes\n\t// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters\n\trunescape = new RegExp( \"\\\\\\\\[\\\\da-fA-F]{1,6}\" + whitespace + \"?|\\\\\\\\([^\\\\r\\\\n\\\\f])\", \"g\" ),\n\tfunescape = function( escape, nonHex ) {\n\t\tvar high = \"0x\" + escape.slice( 1 ) - 0x10000;\n\n\t\treturn nonHex ?\n\n\t\t\t// Strip the backslash prefix from a non-hex escape sequence\n\t\t\tnonHex :\n\n\t\t\t// Replace a hexadecimal escape sequence with the encoded Unicode code point\n\t\t\t// Support: IE <=11+\n\t\t\t// For values outside the Basic Multilingual Plane (BMP), manually construct a\n\t\t\t// surrogate pair\n\t\t\thigh < 0 ?\n\t\t\t\tString.fromCharCode( high + 0x10000 ) :\n\t\t\t\tString.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );\n\t},\n\n\t// CSS string/identifier serialization\n\t// https://drafts.csswg.org/cssom/#common-serializing-idioms\n\trcssescape = /([\\0-\\x1f\\x7f]|^-?\\d)|^-$|[^\\0-\\x1f\\x7f-\\uFFFF\\w-]/g,\n\tfcssescape = function( ch, asCodePoint ) {\n\t\tif ( asCodePoint ) {\n\n\t\t\t// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER\n\t\t\tif ( ch === \"\\0\" ) {\n\t\t\t\treturn \"\\uFFFD\";\n\t\t\t}\n\n\t\t\t// Control characters and (dependent upon position) numbers get escaped as code points\n\t\t\treturn ch.slice( 0, -1 ) + \"\\\\\" +\n\t\t\t\tch.charCodeAt( ch.length - 1 ).toString( 16 ) + \" \";\n\t\t}\n\n\t\t// Other potentially-special ASCII characters get backslash-escaped\n\t\treturn \"\\\\\" + ch;\n\t},\n\n\t// Used for iframes\n\t// See setDocument()\n\t// Removing the function wrapper causes a \"Permission Denied\"\n\t// error in IE\n\tunloadHandler = function() {\n\t\tsetDocument();\n\t},\n\n\tinDisabledFieldset = addCombinator(\n\t\tfunction( elem ) {\n\t\t\treturn elem.disabled === true && elem.nodeName.toLowerCase() === \"fieldset\";\n\t\t},\n\t\t{ dir: \"parentNode\", next: \"legend\" }\n\t);\n\n// Optimize for push.apply( _, NodeList )\ntry {\n\tpush.apply(\n\t\t( arr = slice.call( preferredDoc.childNodes ) ),\n\t\tpreferredDoc.childNodes\n\t);\n\n\t// Support: Android<4.0\n\t// Detect silently failing push.apply\n\t// eslint-disable-next-line no-unused-expressions\n\tarr[ preferredDoc.childNodes.length ].nodeType;\n} catch ( e ) {\n\tpush = { apply: arr.length ?\n\n\t\t// Leverage slice if possible\n\t\tfunction( target, els ) {\n\t\t\tpushNative.apply( target, slice.call( els ) );\n\t\t} :\n\n\t\t// Support: IE<9\n\t\t// Otherwise append directly\n\t\tfunction( target, els ) {\n\t\t\tvar j = target.length,\n\t\t\t\ti = 0;\n\n\t\t\t// Can't trust NodeList.length\n\t\t\twhile ( ( target[ j++ ] = els[ i++ ] ) ) {}\n\t\t\ttarget.length = j - 1;\n\t\t}\n\t};\n}\n\nfunction Sizzle( selector, context, results, seed ) {\n\tvar m, i, elem, nid, match, groups, newSelector,\n\t\tnewContext = context && context.ownerDocument,\n\n\t\t// nodeType defaults to 9, since context defaults to document\n\t\tnodeType = context ? context.nodeType : 9;\n\n\tresults = results || [];\n\n\t// Return early from calls with invalid selector or context\n\tif ( typeof selector !== \"string\" || !selector ||\n\t\tnodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {\n\n\t\treturn results;\n\t}\n\n\t// Try to shortcut find operations (as opposed to filters) in HTML documents\n\tif ( !seed ) {\n\t\tsetDocument( context );\n\t\tcontext = context || document;\n\n\t\tif ( documentIsHTML ) {\n\n\t\t\t// If the selector is sufficiently simple, try using a \"get*By*\" DOM method\n\t\t\t// (excepting DocumentFragment context, where the methods don't exist)\n\t\t\tif ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {\n\n\t\t\t\t// ID selector\n\t\t\t\tif ( ( m = match[ 1 ] ) ) {\n\n\t\t\t\t\t// Document context\n\t\t\t\t\tif ( nodeType === 9 ) {\n\t\t\t\t\t\tif ( ( elem = context.getElementById( m ) ) ) {\n\n\t\t\t\t\t\t\t// Support: IE, Opera, Webkit\n\t\t\t\t\t\t\t// TODO: identify versions\n\t\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\t\tif ( elem.id === m ) {\n\t\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t// Element context\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t// Support: IE, Opera, Webkit\n\t\t\t\t\t\t// TODO: identify versions\n\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\tif ( newContext && ( elem = newContext.getElementById( m ) ) &&\n\t\t\t\t\t\t\tcontains( context, elem ) &&\n\t\t\t\t\t\t\telem.id === m ) {\n\n\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t// Type selector\n\t\t\t\t} else if ( match[ 2 ] ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByTagName( selector ) );\n\t\t\t\t\treturn results;\n\n\t\t\t\t// Class selector\n\t\t\t\t} else if ( ( m = match[ 3 ] ) && support.getElementsByClassName &&\n\t\t\t\t\tcontext.getElementsByClassName ) {\n\n\t\t\t\t\tpush.apply( results, context.getElementsByClassName( m ) );\n\t\t\t\t\treturn results;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Take advantage of querySelectorAll\n\t\t\tif ( support.qsa &&\n\t\t\t\t!nonnativeSelectorCache[ selector + \" \" ] &&\n\t\t\t\t( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&\n\n\t\t\t\t// Support: IE 8 only\n\t\t\t\t// Exclude object elements\n\t\t\t\t( nodeType !== 1 || context.nodeName.toLowerCase() !== \"object\" ) ) {\n\n\t\t\t\tnewSelector = selector;\n\t\t\t\tnewContext = context;\n\n\t\t\t\t// qSA considers elements outside a scoping root when evaluating child or\n\t\t\t\t// descendant combinators, which is not what we want.\n\t\t\t\t// In such cases, we work around the behavior by prefixing every selector in the\n\t\t\t\t// list with an ID selector referencing the scope context.\n\t\t\t\t// The technique has to be used as well when a leading combinator is used\n\t\t\t\t// as such selectors are not recognized by querySelectorAll.\n\t\t\t\t// Thanks to Andrew Dupont for this technique.\n\t\t\t\tif ( nodeType === 1 &&\n\t\t\t\t\t( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {\n\n\t\t\t\t\t// Expand context for sibling selectors\n\t\t\t\t\tnewContext = rsibling.test( selector ) && testContext( context.parentNode ) ||\n\t\t\t\t\t\tcontext;\n\n\t\t\t\t\t// We can use :scope instead of the ID hack if the browser\n\t\t\t\t\t// supports it & if we're not changing the context.\n\t\t\t\t\tif ( newContext !== context || !support.scope ) {\n\n\t\t\t\t\t\t// Capture the context ID, setting it first if necessary\n\t\t\t\t\t\tif ( ( nid = context.getAttribute( \"id\" ) ) ) {\n\t\t\t\t\t\t\tnid = nid.replace( rcssescape, fcssescape );\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tcontext.setAttribute( \"id\", ( nid = expando ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prefix every selector in the list\n\t\t\t\t\tgroups = tokenize( selector );\n\t\t\t\t\ti = groups.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tgroups[ i ] = ( nid ? \"#\" + nid : \":scope\" ) + \" \" +\n\t\t\t\t\t\t\ttoSelector( groups[ i ] );\n\t\t\t\t\t}\n\t\t\t\t\tnewSelector = groups.join( \",\" );\n\t\t\t\t}\n\n\t\t\t\ttry {\n\t\t\t\t\tpush.apply( results,\n\t\t\t\t\t\tnewContext.querySelectorAll( newSelector )\n\t\t\t\t\t);\n\t\t\t\t\treturn results;\n\t\t\t\t} catch ( qsaError ) {\n\t\t\t\t\tnonnativeSelectorCache( selector, true );\n\t\t\t\t} finally {\n\t\t\t\t\tif ( nid === expando ) {\n\t\t\t\t\t\tcontext.removeAttribute( \"id\" );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// All others\n\treturn select( selector.replace( rtrim, \"$1\" ), context, results, seed );\n}\n\n/**\n * Create key-value caches of limited size\n * @returns {function(string, object)} Returns the Object data after storing it on itself with\n *\tproperty name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)\n *\tdeleting the oldest entry\n */\nfunction createCache() {\n\tvar keys = [];\n\n\tfunction cache( key, value ) {\n\n\t\t// Use (key + \" \") to avoid collision with native prototype properties (see Issue #157)\n\t\tif ( keys.push( key + \" \" ) > Expr.cacheLength ) {\n\n\t\t\t// Only keep the most recent entries\n\t\t\tdelete cache[ keys.shift() ];\n\t\t}\n\t\treturn ( cache[ key + \" \" ] = value );\n\t}\n\treturn cache;\n}\n\n/**\n * Mark a function for special use by Sizzle\n * @param {Function} fn The function to mark\n */\nfunction markFunction( fn ) {\n\tfn[ expando ] = true;\n\treturn fn;\n}\n\n/**\n * Support testing using an element\n * @param {Function} fn Passed the created element and returns a boolean result\n */\nfunction assert( fn ) {\n\tvar el = document.createElement( \"fieldset\" );\n\n\ttry {\n\t\treturn !!fn( el );\n\t} catch ( e ) {\n\t\treturn false;\n\t} finally {\n\n\t\t// Remove from its parent by default\n\t\tif ( el.parentNode ) {\n\t\t\tel.parentNode.removeChild( el );\n\t\t}\n\n\t\t// release memory in IE\n\t\tel = null;\n\t}\n}\n\n/**\n * Adds the same handler for all of the specified attrs\n * @param {String} attrs Pipe-separated list of attributes\n * @param {Function} handler The method that will be applied\n */\nfunction addHandle( attrs, handler ) {\n\tvar arr = attrs.split( \"|\" ),\n\t\ti = arr.length;\n\n\twhile ( i-- ) {\n\t\tExpr.attrHandle[ arr[ i ] ] = handler;\n\t}\n}\n\n/**\n * Checks document order of two siblings\n * @param {Element} a\n * @param {Element} b\n * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b\n */\nfunction siblingCheck( a, b ) {\n\tvar cur = b && a,\n\t\tdiff = cur && a.nodeType === 1 && b.nodeType === 1 &&\n\t\t\ta.sourceIndex - b.sourceIndex;\n\n\t// Use IE sourceIndex if available on both nodes\n\tif ( diff ) {\n\t\treturn diff;\n\t}\n\n\t// Check if b follows a\n\tif ( cur ) {\n\t\twhile ( ( cur = cur.nextSibling ) ) {\n\t\t\tif ( cur === b ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn a ? 1 : -1;\n}\n\n/**\n * Returns a function to use in pseudos for input types\n * @param {String} type\n */\nfunction createInputPseudo( type ) {\n\treturn function( elem ) {\n\t\tvar name = elem.nodeName.toLowerCase();\n\t\treturn name === \"input\" && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for buttons\n * @param {String} type\n */\nfunction createButtonPseudo( type ) {\n\treturn function( elem ) {\n\t\tvar name = elem.nodeName.toLowerCase();\n\t\treturn ( name === \"input\" || name === \"button\" ) && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for :enabled/:disabled\n * @param {Boolean} disabled true for :disabled; false for :enabled\n */\nfunction createDisabledPseudo( disabled ) {\n\n\t// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable\n\treturn function( elem ) {\n\n\t\t// Only certain elements can match :enabled or :disabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled\n\t\t// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled\n\t\tif ( \"form\" in elem ) {\n\n\t\t\t// Check for inherited disabledness on relevant non-disabled elements:\n\t\t\t// * listed form-associated elements in a disabled fieldset\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#category-listed\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled\n\t\t\t// * option elements in a disabled optgroup\n\t\t\t//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled\n\t\t\t// All such elements have a \"form\" property.\n\t\t\tif ( elem.parentNode && elem.disabled === false ) {\n\n\t\t\t\t// Option elements defer to a parent optgroup if present\n\t\t\t\tif ( \"label\" in elem ) {\n\t\t\t\t\tif ( \"label\" in elem.parentNode ) {\n\t\t\t\t\t\treturn elem.parentNode.disabled === disabled;\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn elem.disabled === disabled;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Support: IE 6 - 11\n\t\t\t\t// Use the isDisabled shortcut property to check for disabled fieldset ancestors\n\t\t\t\treturn elem.isDisabled === disabled ||\n\n\t\t\t\t\t// Where there is no isDisabled, check manually\n\t\t\t\t\t/* jshint -W018 */\n\t\t\t\t\telem.isDisabled !== !disabled &&\n\t\t\t\t\tinDisabledFieldset( elem ) === disabled;\n\t\t\t}\n\n\t\t\treturn elem.disabled === disabled;\n\n\t\t// Try to winnow out elements that can't be disabled before trusting the disabled property.\n\t\t// Some victims get caught in our net (label, legend, menu, track), but it shouldn't\n\t\t// even exist on them, let alone have a boolean value.\n\t\t} else if ( \"label\" in elem ) {\n\t\t\treturn elem.disabled === disabled;\n\t\t}\n\n\t\t// Remaining elements are neither :enabled nor :disabled\n\t\treturn false;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for positionals\n * @param {Function} fn\n */\nfunction createPositionalPseudo( fn ) {\n\treturn markFunction( function( argument ) {\n\t\targument = +argument;\n\t\treturn markFunction( function( seed, matches ) {\n\t\t\tvar j,\n\t\t\t\tmatchIndexes = fn( [], seed.length, argument ),\n\t\t\t\ti = matchIndexes.length;\n\n\t\t\t// Match elements found at the specified indexes\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( seed[ ( j = matchIndexes[ i ] ) ] ) {\n\t\t\t\t\tseed[ j ] = !( matches[ j ] = seed[ j ] );\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t} );\n}\n\n/**\n * Checks a node for validity as a Sizzle context\n * @param {Element|Object=} context\n * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value\n */\nfunction testContext( context ) {\n\treturn context && typeof context.getElementsByTagName !== \"undefined\" && context;\n}\n\n// Expose support vars for convenience\nsupport = Sizzle.support = {};\n\n/**\n * Detects XML nodes\n * @param {Element|Object} elem An element or a document\n * @returns {Boolean} True iff elem is a non-HTML XML node\n */\nisXML = Sizzle.isXML = function( elem ) {\n\tvar namespace = elem && elem.namespaceURI,\n\t\tdocElem = elem && ( elem.ownerDocument || elem ).documentElement;\n\n\t// Support: IE <=8\n\t// Assume HTML when documentElement doesn't yet exist, such as inside loading iframes\n\t// https://bugs.jquery.com/ticket/4833\n\treturn !rhtml.test( namespace || docElem && docElem.nodeName || \"HTML\" );\n};\n\n/**\n * Sets document-related variables once based on the current document\n * @param {Element|Object} [doc] An element or document object to use to set the document\n * @returns {Object} Returns the current document\n */\nsetDocument = Sizzle.setDocument = function( node ) {\n\tvar hasCompare, subWindow,\n\t\tdoc = node ? node.ownerDocument || node : preferredDoc;\n\n\t// Return early if doc is invalid or already selected\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {\n\t\treturn document;\n\t}\n\n\t// Update global variables\n\tdocument = doc;\n\tdocElem = document.documentElement;\n\tdocumentIsHTML = !isXML( document );\n\n\t// Support: IE 9 - 11+, Edge 12 - 18+\n\t// Accessing iframe documents after unload throws \"permission denied\" errors (jQuery #13936)\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( preferredDoc != document &&\n\t\t( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {\n\n\t\t// Support: IE 11, Edge\n\t\tif ( subWindow.addEventListener ) {\n\t\t\tsubWindow.addEventListener( \"unload\", unloadHandler, false );\n\n\t\t// Support: IE 9 - 10 only\n\t\t} else if ( subWindow.attachEvent ) {\n\t\t\tsubWindow.attachEvent( \"onunload\", unloadHandler );\n\t\t}\n\t}\n\n\t// Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,\n\t// Safari 4 - 5 only, Opera <=11.6 - 12.x only\n\t// IE/Edge & older browsers don't support the :scope pseudo-class.\n\t// Support: Safari 6.0 only\n\t// Safari 6.0 supports :scope but it's an alias of :root there.\n\tsupport.scope = assert( function( el ) {\n\t\tdocElem.appendChild( el ).appendChild( document.createElement( \"div\" ) );\n\t\treturn typeof el.querySelectorAll !== \"undefined\" &&\n\t\t\t!el.querySelectorAll( \":scope fieldset div\" ).length;\n\t} );\n\n\t/* Attributes\n\t---------------------------------------------------------------------- */\n\n\t// Support: IE<8\n\t// Verify that getAttribute really returns attributes and not properties\n\t// (excepting IE8 booleans)\n\tsupport.attributes = assert( function( el ) {\n\t\tel.className = \"i\";\n\t\treturn !el.getAttribute( \"className\" );\n\t} );\n\n\t/* getElement(s)By*\n\t---------------------------------------------------------------------- */\n\n\t// Check if getElementsByTagName(\"*\") returns only elements\n\tsupport.getElementsByTagName = assert( function( el ) {\n\t\tel.appendChild( document.createComment( \"\" ) );\n\t\treturn !el.getElementsByTagName( \"*\" ).length;\n\t} );\n\n\t// Support: IE<9\n\tsupport.getElementsByClassName = rnative.test( document.getElementsByClassName );\n\n\t// Support: IE<10\n\t// Check if getElementById returns elements by name\n\t// The broken getElementById methods don't pick up programmatically-set names,\n\t// so use a roundabout getElementsByName test\n\tsupport.getById = assert( function( el ) {\n\t\tdocElem.appendChild( el ).id = expando;\n\t\treturn !document.getElementsByName || !document.getElementsByName( expando ).length;\n\t} );\n\n\t// ID filter and find\n\tif ( support.getById ) {\n\t\tExpr.filter[ \"ID\" ] = function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn elem.getAttribute( \"id\" ) === attrId;\n\t\t\t};\n\t\t};\n\t\tExpr.find[ \"ID\" ] = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar elem = context.getElementById( id );\n\t\t\t\treturn elem ? [ elem ] : [];\n\t\t\t}\n\t\t};\n\t} else {\n\t\tExpr.filter[ \"ID\" ] =  function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\tvar node = typeof elem.getAttributeNode !== \"undefined\" &&\n\t\t\t\t\telem.getAttributeNode( \"id\" );\n\t\t\t\treturn node && node.value === attrId;\n\t\t\t};\n\t\t};\n\n\t\t// Support: IE 6 - 7 only\n\t\t// getElementById is not reliable as a find shortcut\n\t\tExpr.find[ \"ID\" ] = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar node, i, elems,\n\t\t\t\t\telem = context.getElementById( id );\n\n\t\t\t\tif ( elem ) {\n\n\t\t\t\t\t// Verify the id attribute\n\t\t\t\t\tnode = elem.getAttributeNode( \"id\" );\n\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t}\n\n\t\t\t\t\t// Fall back on getElementsByName\n\t\t\t\t\telems = context.getElementsByName( id );\n\t\t\t\t\ti = 0;\n\t\t\t\t\twhile ( ( elem = elems[ i++ ] ) ) {\n\t\t\t\t\t\tnode = elem.getAttributeNode( \"id\" );\n\t\t\t\t\t\tif ( node && node.value === id ) {\n\t\t\t\t\t\t\treturn [ elem ];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn [];\n\t\t\t}\n\t\t};\n\t}\n\n\t// Tag\n\tExpr.find[ \"TAG\" ] = support.getElementsByTagName ?\n\t\tfunction( tag, context ) {\n\t\t\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\t\t\treturn context.getElementsByTagName( tag );\n\n\t\t\t// DocumentFragment nodes don't have gEBTN\n\t\t\t} else if ( support.qsa ) {\n\t\t\t\treturn context.querySelectorAll( tag );\n\t\t\t}\n\t\t} :\n\n\t\tfunction( tag, context ) {\n\t\t\tvar elem,\n\t\t\t\ttmp = [],\n\t\t\t\ti = 0,\n\n\t\t\t\t// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too\n\t\t\t\tresults = context.getElementsByTagName( tag );\n\n\t\t\t// Filter out possible comments\n\t\t\tif ( tag === \"*\" ) {\n\t\t\t\twhile ( ( elem = results[ i++ ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\ttmp.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn tmp;\n\t\t\t}\n\t\t\treturn results;\n\t\t};\n\n\t// Class\n\tExpr.find[ \"CLASS\" ] = support.getElementsByClassName && function( className, context ) {\n\t\tif ( typeof context.getElementsByClassName !== \"undefined\" && documentIsHTML ) {\n\t\t\treturn context.getElementsByClassName( className );\n\t\t}\n\t};\n\n\t/* QSA/matchesSelector\n\t---------------------------------------------------------------------- */\n\n\t// QSA and matchesSelector support\n\n\t// matchesSelector(:active) reports false when true (IE9/Opera 11.5)\n\trbuggyMatches = [];\n\n\t// qSa(:focus) reports false when true (Chrome 21)\n\t// We allow this because of a bug in IE8/9 that throws an error\n\t// whenever `document.activeElement` is accessed on an iframe\n\t// So, we allow :focus to pass through QSA all the time to avoid the IE error\n\t// See https://bugs.jquery.com/ticket/13378\n\trbuggyQSA = [];\n\n\tif ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {\n\n\t\t// Build QSA regex\n\t\t// Regex strategy adopted from Diego Perini\n\t\tassert( function( el ) {\n\n\t\t\tvar input;\n\n\t\t\t// Select is set to empty string on purpose\n\t\t\t// This is to test IE's treatment of not explicitly\n\t\t\t// setting a boolean content attribute,\n\t\t\t// since its presence should be enough\n\t\t\t// https://bugs.jquery.com/ticket/12359\n\t\t\tdocElem.appendChild( el ).innerHTML = \"<a id='\" + expando + \"'></a>\" +\n\t\t\t\t\"<select id='\" + expando + \"-\\r\\\\' msallowcapture=''>\" +\n\t\t\t\t\"<option selected=''></option></select>\";\n\n\t\t\t// Support: IE8, Opera 11-12.16\n\t\t\t// Nothing should be selected when empty strings follow ^= or $= or *=\n\t\t\t// The test attribute must be unknown in Opera but \"safe\" for WinRT\n\t\t\t// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section\n\t\t\tif ( el.querySelectorAll( \"[msallowcapture^='']\" ).length ) {\n\t\t\t\trbuggyQSA.push( \"[*^$]=\" + whitespace + \"*(?:''|\\\"\\\")\" );\n\t\t\t}\n\n\t\t\t// Support: IE8\n\t\t\t// Boolean attributes and \"value\" are not treated correctly\n\t\t\tif ( !el.querySelectorAll( \"[selected]\" ).length ) {\n\t\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*(?:value|\" + booleans + \")\" );\n\t\t\t}\n\n\t\t\t// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+\n\t\t\tif ( !el.querySelectorAll( \"[id~=\" + expando + \"-]\" ).length ) {\n\t\t\t\trbuggyQSA.push( \"~=\" );\n\t\t\t}\n\n\t\t\t// Support: IE 11+, Edge 15 - 18+\n\t\t\t// IE 11/Edge don't find elements on a `[name='']` query in some cases.\n\t\t\t// Adding a temporary attribute to the document before the selection works\n\t\t\t// around the issue.\n\t\t\t// Interestingly, IE 10 & older don't seem to have the issue.\n\t\t\tinput = document.createElement( \"input\" );\n\t\t\tinput.setAttribute( \"name\", \"\" );\n\t\t\tel.appendChild( input );\n\t\t\tif ( !el.querySelectorAll( \"[name='']\" ).length ) {\n\t\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*name\" + whitespace + \"*=\" +\n\t\t\t\t\twhitespace + \"*(?:''|\\\"\\\")\" );\n\t\t\t}\n\n\t\t\t// Webkit/Opera - :checked should return selected option elements\n\t\t\t// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\t// IE8 throws error here and will not see later tests\n\t\t\tif ( !el.querySelectorAll( \":checked\" ).length ) {\n\t\t\t\trbuggyQSA.push( \":checked\" );\n\t\t\t}\n\n\t\t\t// Support: Safari 8+, iOS 8+\n\t\t\t// https://bugs.webkit.org/show_bug.cgi?id=136851\n\t\t\t// In-page `selector#id sibling-combinator selector` fails\n\t\t\tif ( !el.querySelectorAll( \"a#\" + expando + \"+*\" ).length ) {\n\t\t\t\trbuggyQSA.push( \".#.+[+~]\" );\n\t\t\t}\n\n\t\t\t// Support: Firefox <=3.6 - 5 only\n\t\t\t// Old Firefox doesn't throw on a badly-escaped identifier.\n\t\t\tel.querySelectorAll( \"\\\\\\f\" );\n\t\t\trbuggyQSA.push( \"[\\\\r\\\\n\\\\f]\" );\n\t\t} );\n\n\t\tassert( function( el ) {\n\t\t\tel.innerHTML = \"<a href='' disabled='disabled'></a>\" +\n\t\t\t\t\"<select disabled='disabled'><option/></select>\";\n\n\t\t\t// Support: Windows 8 Native Apps\n\t\t\t// The type and name attributes are restricted during .innerHTML assignment\n\t\t\tvar input = document.createElement( \"input\" );\n\t\t\tinput.setAttribute( \"type\", \"hidden\" );\n\t\t\tel.appendChild( input ).setAttribute( \"name\", \"D\" );\n\n\t\t\t// Support: IE8\n\t\t\t// Enforce case-sensitivity of name attribute\n\t\t\tif ( el.querySelectorAll( \"[name=d]\" ).length ) {\n\t\t\t\trbuggyQSA.push( \"name\" + whitespace + \"*[*^$|!~]?=\" );\n\t\t\t}\n\n\t\t\t// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)\n\t\t\t// IE8 throws error here and will not see later tests\n\t\t\tif ( el.querySelectorAll( \":enabled\" ).length !== 2 ) {\n\t\t\t\trbuggyQSA.push( \":enabled\", \":disabled\" );\n\t\t\t}\n\n\t\t\t// Support: IE9-11+\n\t\t\t// IE's :disabled selector does not pick up the children of disabled fieldsets\n\t\t\tdocElem.appendChild( el ).disabled = true;\n\t\t\tif ( el.querySelectorAll( \":disabled\" ).length !== 2 ) {\n\t\t\t\trbuggyQSA.push( \":enabled\", \":disabled\" );\n\t\t\t}\n\n\t\t\t// Support: Opera 10 - 11 only\n\t\t\t// Opera 10-11 does not throw on post-comma invalid pseudos\n\t\t\tel.querySelectorAll( \"*,:x\" );\n\t\t\trbuggyQSA.push( \",.*:\" );\n\t\t} );\n\t}\n\n\tif ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches ||\n\t\tdocElem.webkitMatchesSelector ||\n\t\tdocElem.mozMatchesSelector ||\n\t\tdocElem.oMatchesSelector ||\n\t\tdocElem.msMatchesSelector ) ) ) ) {\n\n\t\tassert( function( el ) {\n\n\t\t\t// Check to see if it's possible to do matchesSelector\n\t\t\t// on a disconnected node (IE 9)\n\t\t\tsupport.disconnectedMatch = matches.call( el, \"*\" );\n\n\t\t\t// This should fail with an exception\n\t\t\t// Gecko does not error, returns false instead\n\t\t\tmatches.call( el, \"[s!='']:x\" );\n\t\t\trbuggyMatches.push( \"!=\", pseudos );\n\t\t} );\n\t}\n\n\trbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( \"|\" ) );\n\trbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( \"|\" ) );\n\n\t/* Contains\n\t---------------------------------------------------------------------- */\n\thasCompare = rnative.test( docElem.compareDocumentPosition );\n\n\t// Element contains another\n\t// Purposefully self-exclusive\n\t// As in, an element does not contain itself\n\tcontains = hasCompare || rnative.test( docElem.contains ) ?\n\t\tfunction( a, b ) {\n\t\t\tvar adown = a.nodeType === 9 ? a.documentElement : a,\n\t\t\t\tbup = b && b.parentNode;\n\t\t\treturn a === bup || !!( bup && bup.nodeType === 1 && (\n\t\t\t\tadown.contains ?\n\t\t\t\t\tadown.contains( bup ) :\n\t\t\t\t\ta.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16\n\t\t\t) );\n\t\t} :\n\t\tfunction( a, b ) {\n\t\t\tif ( b ) {\n\t\t\t\twhile ( ( b = b.parentNode ) ) {\n\t\t\t\t\tif ( b === a ) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n\n\t/* Sorting\n\t---------------------------------------------------------------------- */\n\n\t// Document order sorting\n\tsortOrder = hasCompare ?\n\tfunction( a, b ) {\n\n\t\t// Flag for duplicate removal\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t\treturn 0;\n\t\t}\n\n\t\t// Sort on method existence if only one input has compareDocumentPosition\n\t\tvar compare = !a.compareDocumentPosition - !b.compareDocumentPosition;\n\t\tif ( compare ) {\n\t\t\treturn compare;\n\t\t}\n\n\t\t// Calculate position if both inputs belong to the same document\n\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t// two documents; shallow comparisons work.\n\t\t// eslint-disable-next-line eqeqeq\n\t\tcompare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?\n\t\t\ta.compareDocumentPosition( b ) :\n\n\t\t\t// Otherwise we know they are disconnected\n\t\t\t1;\n\n\t\t// Disconnected nodes\n\t\tif ( compare & 1 ||\n\t\t\t( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {\n\n\t\t\t// Choose the first element that is related to our preferred document\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tif ( a == document || a.ownerDocument == preferredDoc &&\n\t\t\t\tcontains( preferredDoc, a ) ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tif ( b == document || b.ownerDocument == preferredDoc &&\n\t\t\t\tcontains( preferredDoc, b ) ) {\n\t\t\t\treturn 1;\n\t\t\t}\n\n\t\t\t// Maintain original order\n\t\t\treturn sortInput ?\n\t\t\t\t( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :\n\t\t\t\t0;\n\t\t}\n\n\t\treturn compare & 4 ? -1 : 1;\n\t} :\n\tfunction( a, b ) {\n\n\t\t// Exit early if the nodes are identical\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t\treturn 0;\n\t\t}\n\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\taup = a.parentNode,\n\t\t\tbup = b.parentNode,\n\t\t\tap = [ a ],\n\t\t\tbp = [ b ];\n\n\t\t// Parentless nodes are either documents or disconnected\n\t\tif ( !aup || !bup ) {\n\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t/* eslint-disable eqeqeq */\n\t\t\treturn a == document ? -1 :\n\t\t\t\tb == document ? 1 :\n\t\t\t\t/* eslint-enable eqeqeq */\n\t\t\t\taup ? -1 :\n\t\t\t\tbup ? 1 :\n\t\t\t\tsortInput ?\n\t\t\t\t( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :\n\t\t\t\t0;\n\n\t\t// If the nodes are siblings, we can do a quick check\n\t\t} else if ( aup === bup ) {\n\t\t\treturn siblingCheck( a, b );\n\t\t}\n\n\t\t// Otherwise we need full lists of their ancestors for comparison\n\t\tcur = a;\n\t\twhile ( ( cur = cur.parentNode ) ) {\n\t\t\tap.unshift( cur );\n\t\t}\n\t\tcur = b;\n\t\twhile ( ( cur = cur.parentNode ) ) {\n\t\t\tbp.unshift( cur );\n\t\t}\n\n\t\t// Walk down the tree looking for a discrepancy\n\t\twhile ( ap[ i ] === bp[ i ] ) {\n\t\t\ti++;\n\t\t}\n\n\t\treturn i ?\n\n\t\t\t// Do a sibling check if the nodes have a common ancestor\n\t\t\tsiblingCheck( ap[ i ], bp[ i ] ) :\n\n\t\t\t// Otherwise nodes in our document sort first\n\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t// two documents; shallow comparisons work.\n\t\t\t/* eslint-disable eqeqeq */\n\t\t\tap[ i ] == preferredDoc ? -1 :\n\t\t\tbp[ i ] == preferredDoc ? 1 :\n\t\t\t/* eslint-enable eqeqeq */\n\t\t\t0;\n\t};\n\n\treturn document;\n};\n\nSizzle.matches = function( expr, elements ) {\n\treturn Sizzle( expr, null, null, elements );\n};\n\nSizzle.matchesSelector = function( elem, expr ) {\n\tsetDocument( elem );\n\n\tif ( support.matchesSelector && documentIsHTML &&\n\t\t!nonnativeSelectorCache[ expr + \" \" ] &&\n\t\t( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&\n\t\t( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {\n\n\t\ttry {\n\t\t\tvar ret = matches.call( elem, expr );\n\n\t\t\t// IE 9's matchesSelector returns false on disconnected nodes\n\t\t\tif ( ret || support.disconnectedMatch ||\n\n\t\t\t\t// As well, disconnected nodes are said to be in a document\n\t\t\t\t// fragment in IE 9\n\t\t\t\telem.document && elem.document.nodeType !== 11 ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\t\t} catch ( e ) {\n\t\t\tnonnativeSelectorCache( expr, true );\n\t\t}\n\t}\n\n\treturn Sizzle( expr, document, null, [ elem ] ).length > 0;\n};\n\nSizzle.contains = function( context, elem ) {\n\n\t// Set document vars if needed\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( ( context.ownerDocument || context ) != document ) {\n\t\tsetDocument( context );\n\t}\n\treturn contains( context, elem );\n};\n\nSizzle.attr = function( elem, name ) {\n\n\t// Set document vars if needed\n\t// Support: IE 11+, Edge 17 - 18+\n\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t// two documents; shallow comparisons work.\n\t// eslint-disable-next-line eqeqeq\n\tif ( ( elem.ownerDocument || elem ) != document ) {\n\t\tsetDocument( elem );\n\t}\n\n\tvar fn = Expr.attrHandle[ name.toLowerCase() ],\n\n\t\t// Don't get fooled by Object.prototype properties (jQuery #13807)\n\t\tval = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?\n\t\t\tfn( elem, name, !documentIsHTML ) :\n\t\t\tundefined;\n\n\treturn val !== undefined ?\n\t\tval :\n\t\tsupport.attributes || !documentIsHTML ?\n\t\t\telem.getAttribute( name ) :\n\t\t\t( val = elem.getAttributeNode( name ) ) && val.specified ?\n\t\t\t\tval.value :\n\t\t\t\tnull;\n};\n\nSizzle.escape = function( sel ) {\n\treturn ( sel + \"\" ).replace( rcssescape, fcssescape );\n};\n\nSizzle.error = function( msg ) {\n\tthrow new Error( \"Syntax error, unrecognized expression: \" + msg );\n};\n\n/**\n * Document sorting and removing duplicates\n * @param {ArrayLike} results\n */\nSizzle.uniqueSort = function( results ) {\n\tvar elem,\n\t\tduplicates = [],\n\t\tj = 0,\n\t\ti = 0;\n\n\t// Unless we *know* we can detect duplicates, assume their presence\n\thasDuplicate = !support.detectDuplicates;\n\tsortInput = !support.sortStable && results.slice( 0 );\n\tresults.sort( sortOrder );\n\n\tif ( hasDuplicate ) {\n\t\twhile ( ( elem = results[ i++ ] ) ) {\n\t\t\tif ( elem === results[ i ] ) {\n\t\t\t\tj = duplicates.push( i );\n\t\t\t}\n\t\t}\n\t\twhile ( j-- ) {\n\t\t\tresults.splice( duplicates[ j ], 1 );\n\t\t}\n\t}\n\n\t// Clear input after sorting to release objects\n\t// See https://github.com/jquery/sizzle/pull/225\n\tsortInput = null;\n\n\treturn results;\n};\n\n/**\n * Utility function for retrieving the text value of an array of DOM nodes\n * @param {Array|Element} elem\n */\ngetText = Sizzle.getText = function( elem ) {\n\tvar node,\n\t\tret = \"\",\n\t\ti = 0,\n\t\tnodeType = elem.nodeType;\n\n\tif ( !nodeType ) {\n\n\t\t// If no nodeType, this is expected to be an array\n\t\twhile ( ( node = elem[ i++ ] ) ) {\n\n\t\t\t// Do not traverse comment nodes\n\t\t\tret += getText( node );\n\t\t}\n\t} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {\n\n\t\t// Use textContent for elements\n\t\t// innerText usage removed for consistency of new lines (jQuery #11153)\n\t\tif ( typeof elem.textContent === \"string\" ) {\n\t\t\treturn elem.textContent;\n\t\t} else {\n\n\t\t\t// Traverse its children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tret += getText( elem );\n\t\t\t}\n\t\t}\n\t} else if ( nodeType === 3 || nodeType === 4 ) {\n\t\treturn elem.nodeValue;\n\t}\n\n\t// Do not include comment or processing instruction nodes\n\n\treturn ret;\n};\n\nExpr = Sizzle.selectors = {\n\n\t// Can be adjusted by the user\n\tcacheLength: 50,\n\n\tcreatePseudo: markFunction,\n\n\tmatch: matchExpr,\n\n\tattrHandle: {},\n\n\tfind: {},\n\n\trelative: {\n\t\t\">\": { dir: \"parentNode\", first: true },\n\t\t\" \": { dir: \"parentNode\" },\n\t\t\"+\": { dir: \"previousSibling\", first: true },\n\t\t\"~\": { dir: \"previousSibling\" }\n\t},\n\n\tpreFilter: {\n\t\t\"ATTR\": function( match ) {\n\t\t\tmatch[ 1 ] = match[ 1 ].replace( runescape, funescape );\n\n\t\t\t// Move the given value to match[3] whether quoted or unquoted\n\t\t\tmatch[ 3 ] = ( match[ 3 ] || match[ 4 ] ||\n\t\t\t\tmatch[ 5 ] || \"\" ).replace( runescape, funescape );\n\n\t\t\tif ( match[ 2 ] === \"~=\" ) {\n\t\t\t\tmatch[ 3 ] = \" \" + match[ 3 ] + \" \";\n\t\t\t}\n\n\t\t\treturn match.slice( 0, 4 );\n\t\t},\n\n\t\t\"CHILD\": function( match ) {\n\n\t\t\t/* matches from matchExpr[\"CHILD\"]\n\t\t\t\t1 type (only|nth|...)\n\t\t\t\t2 what (child|of-type)\n\t\t\t\t3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\n\t\t\t\t4 xn-component of xn+y argument ([+-]?\\d*n|)\n\t\t\t\t5 sign of xn-component\n\t\t\t\t6 x of xn-component\n\t\t\t\t7 sign of y-component\n\t\t\t\t8 y of y-component\n\t\t\t*/\n\t\t\tmatch[ 1 ] = match[ 1 ].toLowerCase();\n\n\t\t\tif ( match[ 1 ].slice( 0, 3 ) === \"nth\" ) {\n\n\t\t\t\t// nth-* requires argument\n\t\t\t\tif ( !match[ 3 ] ) {\n\t\t\t\t\tSizzle.error( match[ 0 ] );\n\t\t\t\t}\n\n\t\t\t\t// numeric x and y parameters for Expr.filter.CHILD\n\t\t\t\t// remember that false/true cast respectively to 0/1\n\t\t\t\tmatch[ 4 ] = +( match[ 4 ] ?\n\t\t\t\t\tmatch[ 5 ] + ( match[ 6 ] || 1 ) :\n\t\t\t\t\t2 * ( match[ 3 ] === \"even\" || match[ 3 ] === \"odd\" ) );\n\t\t\t\tmatch[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === \"odd\" );\n\n\t\t\t\t// other types prohibit arguments\n\t\t\t} else if ( match[ 3 ] ) {\n\t\t\t\tSizzle.error( match[ 0 ] );\n\t\t\t}\n\n\t\t\treturn match;\n\t\t},\n\n\t\t\"PSEUDO\": function( match ) {\n\t\t\tvar excess,\n\t\t\t\tunquoted = !match[ 6 ] && match[ 2 ];\n\n\t\t\tif ( matchExpr[ \"CHILD\" ].test( match[ 0 ] ) ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\t// Accept quoted arguments as-is\n\t\t\tif ( match[ 3 ] ) {\n\t\t\t\tmatch[ 2 ] = match[ 4 ] || match[ 5 ] || \"\";\n\n\t\t\t// Strip excess characters from unquoted arguments\n\t\t\t} else if ( unquoted && rpseudo.test( unquoted ) &&\n\n\t\t\t\t// Get excess from tokenize (recursively)\n\t\t\t\t( excess = tokenize( unquoted, true ) ) &&\n\n\t\t\t\t// advance to the next closing parenthesis\n\t\t\t\t( excess = unquoted.indexOf( \")\", unquoted.length - excess ) - unquoted.length ) ) {\n\n\t\t\t\t// excess is a negative index\n\t\t\t\tmatch[ 0 ] = match[ 0 ].slice( 0, excess );\n\t\t\t\tmatch[ 2 ] = unquoted.slice( 0, excess );\n\t\t\t}\n\n\t\t\t// Return only captures needed by the pseudo filter method (type and argument)\n\t\t\treturn match.slice( 0, 3 );\n\t\t}\n\t},\n\n\tfilter: {\n\n\t\t\"TAG\": function( nodeNameSelector ) {\n\t\t\tvar nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn nodeNameSelector === \"*\" ?\n\t\t\t\tfunction() {\n\t\t\t\t\treturn true;\n\t\t\t\t} :\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn elem.nodeName && elem.nodeName.toLowerCase() === nodeName;\n\t\t\t\t};\n\t\t},\n\n\t\t\"CLASS\": function( className ) {\n\t\t\tvar pattern = classCache[ className + \" \" ];\n\n\t\t\treturn pattern ||\n\t\t\t\t( pattern = new RegExp( \"(^|\" + whitespace +\n\t\t\t\t\t\")\" + className + \"(\" + whitespace + \"|$)\" ) ) && classCache(\n\t\t\t\t\t\tclassName, function( elem ) {\n\t\t\t\t\t\t\treturn pattern.test(\n\t\t\t\t\t\t\t\ttypeof elem.className === \"string\" && elem.className ||\n\t\t\t\t\t\t\t\ttypeof elem.getAttribute !== \"undefined\" &&\n\t\t\t\t\t\t\t\t\telem.getAttribute( \"class\" ) ||\n\t\t\t\t\t\t\t\t\"\"\n\t\t\t\t\t\t\t);\n\t\t\t\t} );\n\t\t},\n\n\t\t\"ATTR\": function( name, operator, check ) {\n\t\t\treturn function( elem ) {\n\t\t\t\tvar result = Sizzle.attr( elem, name );\n\n\t\t\t\tif ( result == null ) {\n\t\t\t\t\treturn operator === \"!=\";\n\t\t\t\t}\n\t\t\t\tif ( !operator ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\n\t\t\t\tresult += \"\";\n\n\t\t\t\t/* eslint-disable max-len */\n\n\t\t\t\treturn operator === \"=\" ? result === check :\n\t\t\t\t\toperator === \"!=\" ? result !== check :\n\t\t\t\t\toperator === \"^=\" ? check && result.indexOf( check ) === 0 :\n\t\t\t\t\toperator === \"*=\" ? check && result.indexOf( check ) > -1 :\n\t\t\t\t\toperator === \"$=\" ? check && result.slice( -check.length ) === check :\n\t\t\t\t\toperator === \"~=\" ? ( \" \" + result.replace( rwhitespace, \" \" ) + \" \" ).indexOf( check ) > -1 :\n\t\t\t\t\toperator === \"|=\" ? result === check || result.slice( 0, check.length + 1 ) === check + \"-\" :\n\t\t\t\t\tfalse;\n\t\t\t\t/* eslint-enable max-len */\n\n\t\t\t};\n\t\t},\n\n\t\t\"CHILD\": function( type, what, _argument, first, last ) {\n\t\t\tvar simple = type.slice( 0, 3 ) !== \"nth\",\n\t\t\t\tforward = type.slice( -4 ) !== \"last\",\n\t\t\t\tofType = what === \"of-type\";\n\n\t\t\treturn first === 1 && last === 0 ?\n\n\t\t\t\t// Shortcut for :nth-*(n)\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn !!elem.parentNode;\n\t\t\t\t} :\n\n\t\t\t\tfunction( elem, _context, xml ) {\n\t\t\t\t\tvar cache, uniqueCache, outerCache, node, nodeIndex, start,\n\t\t\t\t\t\tdir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\n\t\t\t\t\t\tparent = elem.parentNode,\n\t\t\t\t\t\tname = ofType && elem.nodeName.toLowerCase(),\n\t\t\t\t\t\tuseCache = !xml && !ofType,\n\t\t\t\t\t\tdiff = false;\n\n\t\t\t\t\tif ( parent ) {\n\n\t\t\t\t\t\t// :(first|last|only)-(child|of-type)\n\t\t\t\t\t\tif ( simple ) {\n\t\t\t\t\t\t\twhile ( dir ) {\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\twhile ( ( node = node[ dir ] ) ) {\n\t\t\t\t\t\t\t\t\tif ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnode.nodeName.toLowerCase() === name :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) {\n\n\t\t\t\t\t\t\t\t\t\treturn false;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t// Reverse direction for :only-* (if we haven't yet done so)\n\t\t\t\t\t\t\t\tstart = dir = type === \"only\" && !start && \"nextSibling\";\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tstart = [ forward ? parent.firstChild : parent.lastChild ];\n\n\t\t\t\t\t\t// non-xml :nth-child(...) stores cache data on `parent`\n\t\t\t\t\t\tif ( forward && useCache ) {\n\n\t\t\t\t\t\t\t// Seek `elem` from a previously-cached index\n\n\t\t\t\t\t\t\t// ...in a gzip-friendly way\n\t\t\t\t\t\t\tnode = parent;\n\t\t\t\t\t\t\touterCache = node[ expando ] || ( node[ expando ] = {} );\n\n\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t( outerCache[ node.uniqueID ] = {} );\n\n\t\t\t\t\t\t\tcache = uniqueCache[ type ] || [];\n\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\tdiff = nodeIndex && cache[ 2 ];\n\t\t\t\t\t\t\tnode = nodeIndex && parent.childNodes[ nodeIndex ];\n\n\t\t\t\t\t\t\twhile ( ( node = ++nodeIndex && node && node[ dir ] ||\n\n\t\t\t\t\t\t\t\t// Fallback to seeking `elem` from the start\n\t\t\t\t\t\t\t\t( diff = nodeIndex = 0 ) || start.pop() ) ) {\n\n\t\t\t\t\t\t\t\t// When found, cache indexes on `parent` and break\n\t\t\t\t\t\t\t\tif ( node.nodeType === 1 && ++diff && node === elem ) {\n\t\t\t\t\t\t\t\t\tuniqueCache[ type ] = [ dirruns, nodeIndex, diff ];\n\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Use previously-cached element index if available\n\t\t\t\t\t\t\tif ( useCache ) {\n\n\t\t\t\t\t\t\t\t// ...in a gzip-friendly way\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\touterCache = node[ expando ] || ( node[ expando ] = {} );\n\n\t\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t\t( outerCache[ node.uniqueID ] = {} );\n\n\t\t\t\t\t\t\t\tcache = uniqueCache[ type ] || [];\n\t\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\t\tdiff = nodeIndex;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// xml :nth-child(...)\n\t\t\t\t\t\t\t// or :nth-last-child(...) or :nth(-last)?-of-type(...)\n\t\t\t\t\t\t\tif ( diff === false ) {\n\n\t\t\t\t\t\t\t\t// Use the same loop as above to seek `elem` from the start\n\t\t\t\t\t\t\t\twhile ( ( node = ++nodeIndex && node && node[ dir ] ||\n\t\t\t\t\t\t\t\t\t( diff = nodeIndex = 0 ) || start.pop() ) ) {\n\n\t\t\t\t\t\t\t\t\tif ( ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnode.nodeName.toLowerCase() === name :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) &&\n\t\t\t\t\t\t\t\t\t\t++diff ) {\n\n\t\t\t\t\t\t\t\t\t\t// Cache the index of each encountered element\n\t\t\t\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\t\t\t\touterCache = node[ expando ] ||\n\t\t\t\t\t\t\t\t\t\t\t\t( node[ expando ] = {} );\n\n\t\t\t\t\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t\t\t\t\t( outerCache[ node.uniqueID ] = {} );\n\n\t\t\t\t\t\t\t\t\t\t\tuniqueCache[ type ] = [ dirruns, diff ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\tif ( node === elem ) {\n\t\t\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Incorporate the offset, then check against cycle size\n\t\t\t\t\t\tdiff -= last;\n\t\t\t\t\t\treturn diff === first || ( diff % first === 0 && diff / first >= 0 );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t},\n\n\t\t\"PSEUDO\": function( pseudo, argument ) {\n\n\t\t\t// pseudo-class names are case-insensitive\n\t\t\t// http://www.w3.org/TR/selectors/#pseudo-classes\n\t\t\t// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\n\t\t\t// Remember that setFilters inherits from pseudos\n\t\t\tvar args,\n\t\t\t\tfn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||\n\t\t\t\t\tSizzle.error( \"unsupported pseudo: \" + pseudo );\n\n\t\t\t// The user may use createPseudo to indicate that\n\t\t\t// arguments are needed to create the filter function\n\t\t\t// just as Sizzle does\n\t\t\tif ( fn[ expando ] ) {\n\t\t\t\treturn fn( argument );\n\t\t\t}\n\n\t\t\t// But maintain support for old signatures\n\t\t\tif ( fn.length > 1 ) {\n\t\t\t\targs = [ pseudo, pseudo, \"\", argument ];\n\t\t\t\treturn Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?\n\t\t\t\t\tmarkFunction( function( seed, matches ) {\n\t\t\t\t\t\tvar idx,\n\t\t\t\t\t\t\tmatched = fn( seed, argument ),\n\t\t\t\t\t\t\ti = matched.length;\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tidx = indexOf( seed, matched[ i ] );\n\t\t\t\t\t\t\tseed[ idx ] = !( matches[ idx ] = matched[ i ] );\n\t\t\t\t\t\t}\n\t\t\t\t\t} ) :\n\t\t\t\t\tfunction( elem ) {\n\t\t\t\t\t\treturn fn( elem, 0, args );\n\t\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn fn;\n\t\t}\n\t},\n\n\tpseudos: {\n\n\t\t// Potentially complex pseudos\n\t\t\"not\": markFunction( function( selector ) {\n\n\t\t\t// Trim the selector passed to compile\n\t\t\t// to avoid treating leading and trailing\n\t\t\t// spaces as combinators\n\t\t\tvar input = [],\n\t\t\t\tresults = [],\n\t\t\t\tmatcher = compile( selector.replace( rtrim, \"$1\" ) );\n\n\t\t\treturn matcher[ expando ] ?\n\t\t\t\tmarkFunction( function( seed, matches, _context, xml ) {\n\t\t\t\t\tvar elem,\n\t\t\t\t\t\tunmatched = matcher( seed, null, xml, [] ),\n\t\t\t\t\t\ti = seed.length;\n\n\t\t\t\t\t// Match elements unmatched by `matcher`\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( ( elem = unmatched[ i ] ) ) {\n\t\t\t\t\t\t\tseed[ i ] = !( matches[ i ] = elem );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} ) :\n\t\t\t\tfunction( elem, _context, xml ) {\n\t\t\t\t\tinput[ 0 ] = elem;\n\t\t\t\t\tmatcher( input, null, xml, results );\n\n\t\t\t\t\t// Don't keep the element (issue #299)\n\t\t\t\t\tinput[ 0 ] = null;\n\t\t\t\t\treturn !results.pop();\n\t\t\t\t};\n\t\t} ),\n\n\t\t\"has\": markFunction( function( selector ) {\n\t\t\treturn function( elem ) {\n\t\t\t\treturn Sizzle( selector, elem ).length > 0;\n\t\t\t};\n\t\t} ),\n\n\t\t\"contains\": markFunction( function( text ) {\n\t\t\ttext = text.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;\n\t\t\t};\n\t\t} ),\n\n\t\t// \"Whether an element is represented by a :lang() selector\n\t\t// is based solely on the element's language value\n\t\t// being equal to the identifier C,\n\t\t// or beginning with the identifier C immediately followed by \"-\".\n\t\t// The matching of C against the element's language value is performed case-insensitively.\n\t\t// The identifier C does not have to be a valid language name.\"\n\t\t// http://www.w3.org/TR/selectors/#lang-pseudo\n\t\t\"lang\": markFunction( function( lang ) {\n\n\t\t\t// lang value must be a valid identifier\n\t\t\tif ( !ridentifier.test( lang || \"\" ) ) {\n\t\t\t\tSizzle.error( \"unsupported lang: \" + lang );\n\t\t\t}\n\t\t\tlang = lang.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn function( elem ) {\n\t\t\t\tvar elemLang;\n\t\t\t\tdo {\n\t\t\t\t\tif ( ( elemLang = documentIsHTML ?\n\t\t\t\t\t\telem.lang :\n\t\t\t\t\t\telem.getAttribute( \"xml:lang\" ) || elem.getAttribute( \"lang\" ) ) ) {\n\n\t\t\t\t\t\telemLang = elemLang.toLowerCase();\n\t\t\t\t\t\treturn elemLang === lang || elemLang.indexOf( lang + \"-\" ) === 0;\n\t\t\t\t\t}\n\t\t\t\t} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );\n\t\t\t\treturn false;\n\t\t\t};\n\t\t} ),\n\n\t\t// Miscellaneous\n\t\t\"target\": function( elem ) {\n\t\t\tvar hash = window.location && window.location.hash;\n\t\t\treturn hash && hash.slice( 1 ) === elem.id;\n\t\t},\n\n\t\t\"root\": function( elem ) {\n\t\t\treturn elem === docElem;\n\t\t},\n\n\t\t\"focus\": function( elem ) {\n\t\t\treturn elem === document.activeElement &&\n\t\t\t\t( !document.hasFocus || document.hasFocus() ) &&\n\t\t\t\t!!( elem.type || elem.href || ~elem.tabIndex );\n\t\t},\n\n\t\t// Boolean properties\n\t\t\"enabled\": createDisabledPseudo( false ),\n\t\t\"disabled\": createDisabledPseudo( true ),\n\n\t\t\"checked\": function( elem ) {\n\n\t\t\t// In CSS3, :checked should return both checked and selected elements\n\t\t\t// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\tvar nodeName = elem.nodeName.toLowerCase();\n\t\t\treturn ( nodeName === \"input\" && !!elem.checked ) ||\n\t\t\t\t( nodeName === \"option\" && !!elem.selected );\n\t\t},\n\n\t\t\"selected\": function( elem ) {\n\n\t\t\t// Accessing this property makes selected-by-default\n\t\t\t// options in Safari work properly\n\t\t\tif ( elem.parentNode ) {\n\t\t\t\t// eslint-disable-next-line no-unused-expressions\n\t\t\t\telem.parentNode.selectedIndex;\n\t\t\t}\n\n\t\t\treturn elem.selected === true;\n\t\t},\n\n\t\t// Contents\n\t\t\"empty\": function( elem ) {\n\n\t\t\t// http://www.w3.org/TR/selectors/#empty-pseudo\n\t\t\t// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),\n\t\t\t//   but not by others (comment: 8; processing instruction: 7; etc.)\n\t\t\t// nodeType < 6 works because attributes (2) do not appear as children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tif ( elem.nodeType < 6 ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t},\n\n\t\t\"parent\": function( elem ) {\n\t\t\treturn !Expr.pseudos[ \"empty\" ]( elem );\n\t\t},\n\n\t\t// Element/input types\n\t\t\"header\": function( elem ) {\n\t\t\treturn rheader.test( elem.nodeName );\n\t\t},\n\n\t\t\"input\": function( elem ) {\n\t\t\treturn rinputs.test( elem.nodeName );\n\t\t},\n\n\t\t\"button\": function( elem ) {\n\t\t\tvar name = elem.nodeName.toLowerCase();\n\t\t\treturn name === \"input\" && elem.type === \"button\" || name === \"button\";\n\t\t},\n\n\t\t\"text\": function( elem ) {\n\t\t\tvar attr;\n\t\t\treturn elem.nodeName.toLowerCase() === \"input\" &&\n\t\t\t\telem.type === \"text\" &&\n\n\t\t\t\t// Support: IE<8\n\t\t\t\t// New HTML5 attribute values (e.g., \"search\") appear with elem.type === \"text\"\n\t\t\t\t( ( attr = elem.getAttribute( \"type\" ) ) == null ||\n\t\t\t\t\tattr.toLowerCase() === \"text\" );\n\t\t},\n\n\t\t// Position-in-collection\n\t\t\"first\": createPositionalPseudo( function() {\n\t\t\treturn [ 0 ];\n\t\t} ),\n\n\t\t\"last\": createPositionalPseudo( function( _matchIndexes, length ) {\n\t\t\treturn [ length - 1 ];\n\t\t} ),\n\n\t\t\"eq\": createPositionalPseudo( function( _matchIndexes, length, argument ) {\n\t\t\treturn [ argument < 0 ? argument + length : argument ];\n\t\t} ),\n\n\t\t\"even\": createPositionalPseudo( function( matchIndexes, length ) {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\t\"odd\": createPositionalPseudo( function( matchIndexes, length ) {\n\t\t\tvar i = 1;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\t\"lt\": createPositionalPseudo( function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ?\n\t\t\t\targument + length :\n\t\t\t\targument > length ?\n\t\t\t\t\tlength :\n\t\t\t\t\targument;\n\t\t\tfor ( ; --i >= 0; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} ),\n\n\t\t\"gt\": createPositionalPseudo( function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ? argument + length : argument;\n\t\t\tfor ( ; ++i < length; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t} )\n\t}\n};\n\nExpr.pseudos[ \"nth\" ] = Expr.pseudos[ \"eq\" ];\n\n// Add button/input type pseudos\nfor ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {\n\tExpr.pseudos[ i ] = createInputPseudo( i );\n}\nfor ( i in { submit: true, reset: true } ) {\n\tExpr.pseudos[ i ] = createButtonPseudo( i );\n}\n\n// Easy API for creating new setFilters\nfunction setFilters() {}\nsetFilters.prototype = Expr.filters = Expr.pseudos;\nExpr.setFilters = new setFilters();\n\ntokenize = Sizzle.tokenize = function( selector, parseOnly ) {\n\tvar matched, match, tokens, type,\n\t\tsoFar, groups, preFilters,\n\t\tcached = tokenCache[ selector + \" \" ];\n\n\tif ( cached ) {\n\t\treturn parseOnly ? 0 : cached.slice( 0 );\n\t}\n\n\tsoFar = selector;\n\tgroups = [];\n\tpreFilters = Expr.preFilter;\n\n\twhile ( soFar ) {\n\n\t\t// Comma and first run\n\t\tif ( !matched || ( match = rcomma.exec( soFar ) ) ) {\n\t\t\tif ( match ) {\n\n\t\t\t\t// Don't consume trailing commas as valid\n\t\t\t\tsoFar = soFar.slice( match[ 0 ].length ) || soFar;\n\t\t\t}\n\t\t\tgroups.push( ( tokens = [] ) );\n\t\t}\n\n\t\tmatched = false;\n\n\t\t// Combinators\n\t\tif ( ( match = rcombinators.exec( soFar ) ) ) {\n\t\t\tmatched = match.shift();\n\t\t\ttokens.push( {\n\t\t\t\tvalue: matched,\n\n\t\t\t\t// Cast descendant combinators to space\n\t\t\t\ttype: match[ 0 ].replace( rtrim, \" \" )\n\t\t\t} );\n\t\t\tsoFar = soFar.slice( matched.length );\n\t\t}\n\n\t\t// Filters\n\t\tfor ( type in Expr.filter ) {\n\t\t\tif ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||\n\t\t\t\t( match = preFilters[ type ]( match ) ) ) ) {\n\t\t\t\tmatched = match.shift();\n\t\t\t\ttokens.push( {\n\t\t\t\t\tvalue: matched,\n\t\t\t\t\ttype: type,\n\t\t\t\t\tmatches: match\n\t\t\t\t} );\n\t\t\t\tsoFar = soFar.slice( matched.length );\n\t\t\t}\n\t\t}\n\n\t\tif ( !matched ) {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t// Return the length of the invalid excess\n\t// if we're just parsing\n\t// Otherwise, throw an error or return tokens\n\treturn parseOnly ?\n\t\tsoFar.length :\n\t\tsoFar ?\n\t\t\tSizzle.error( selector ) :\n\n\t\t\t// Cache the tokens\n\t\t\ttokenCache( selector, groups ).slice( 0 );\n};\n\nfunction toSelector( tokens ) {\n\tvar i = 0,\n\t\tlen = tokens.length,\n\t\tselector = \"\";\n\tfor ( ; i < len; i++ ) {\n\t\tselector += tokens[ i ].value;\n\t}\n\treturn selector;\n}\n\nfunction addCombinator( matcher, combinator, base ) {\n\tvar dir = combinator.dir,\n\t\tskip = combinator.next,\n\t\tkey = skip || dir,\n\t\tcheckNonElements = base && key === \"parentNode\",\n\t\tdoneName = done++;\n\n\treturn combinator.first ?\n\n\t\t// Check against closest ancestor/preceding element\n\t\tfunction( elem, context, xml ) {\n\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\treturn matcher( elem, context, xml );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t} :\n\n\t\t// Check against all ancestor/preceding elements\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar oldCache, uniqueCache, outerCache,\n\t\t\t\tnewCache = [ dirruns, doneName ];\n\n\t\t\t// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching\n\t\t\tif ( xml ) {\n\t\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\tif ( matcher( elem, context, xml ) ) {\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\twhile ( ( elem = elem[ dir ] ) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\touterCache = elem[ expando ] || ( elem[ expando ] = {} );\n\n\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\tuniqueCache = outerCache[ elem.uniqueID ] ||\n\t\t\t\t\t\t\t( outerCache[ elem.uniqueID ] = {} );\n\n\t\t\t\t\t\tif ( skip && skip === elem.nodeName.toLowerCase() ) {\n\t\t\t\t\t\t\telem = elem[ dir ] || elem;\n\t\t\t\t\t\t} else if ( ( oldCache = uniqueCache[ key ] ) &&\n\t\t\t\t\t\t\toldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {\n\n\t\t\t\t\t\t\t// Assign to newCache so results back-propagate to previous elements\n\t\t\t\t\t\t\treturn ( newCache[ 2 ] = oldCache[ 2 ] );\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Reuse newcache so results back-propagate to previous elements\n\t\t\t\t\t\t\tuniqueCache[ key ] = newCache;\n\n\t\t\t\t\t\t\t// A match means we're done; a fail means we have to keep checking\n\t\t\t\t\t\t\tif ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {\n\t\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n}\n\nfunction elementMatcher( matchers ) {\n\treturn matchers.length > 1 ?\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar i = matchers.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( !matchers[ i ]( elem, context, xml ) ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t} :\n\t\tmatchers[ 0 ];\n}\n\nfunction multipleContexts( selector, contexts, results ) {\n\tvar i = 0,\n\t\tlen = contexts.length;\n\tfor ( ; i < len; i++ ) {\n\t\tSizzle( selector, contexts[ i ], results );\n\t}\n\treturn results;\n}\n\nfunction condense( unmatched, map, filter, context, xml ) {\n\tvar elem,\n\t\tnewUnmatched = [],\n\t\ti = 0,\n\t\tlen = unmatched.length,\n\t\tmapped = map != null;\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( ( elem = unmatched[ i ] ) ) {\n\t\t\tif ( !filter || filter( elem, context, xml ) ) {\n\t\t\t\tnewUnmatched.push( elem );\n\t\t\t\tif ( mapped ) {\n\t\t\t\t\tmap.push( i );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn newUnmatched;\n}\n\nfunction setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {\n\tif ( postFilter && !postFilter[ expando ] ) {\n\t\tpostFilter = setMatcher( postFilter );\n\t}\n\tif ( postFinder && !postFinder[ expando ] ) {\n\t\tpostFinder = setMatcher( postFinder, postSelector );\n\t}\n\treturn markFunction( function( seed, results, context, xml ) {\n\t\tvar temp, i, elem,\n\t\t\tpreMap = [],\n\t\t\tpostMap = [],\n\t\t\tpreexisting = results.length,\n\n\t\t\t// Get initial elements from seed or context\n\t\t\telems = seed || multipleContexts(\n\t\t\t\tselector || \"*\",\n\t\t\t\tcontext.nodeType ? [ context ] : context,\n\t\t\t\t[]\n\t\t\t),\n\n\t\t\t// Prefilter to get matcher input, preserving a map for seed-results synchronization\n\t\t\tmatcherIn = preFilter && ( seed || !selector ) ?\n\t\t\t\tcondense( elems, preMap, preFilter, context, xml ) :\n\t\t\t\telems,\n\n\t\t\tmatcherOut = matcher ?\n\n\t\t\t\t// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,\n\t\t\t\tpostFinder || ( seed ? preFilter : preexisting || postFilter ) ?\n\n\t\t\t\t\t// ...intermediate processing is necessary\n\t\t\t\t\t[] :\n\n\t\t\t\t\t// ...otherwise use results directly\n\t\t\t\t\tresults :\n\t\t\t\tmatcherIn;\n\n\t\t// Find primary matches\n\t\tif ( matcher ) {\n\t\t\tmatcher( matcherIn, matcherOut, context, xml );\n\t\t}\n\n\t\t// Apply postFilter\n\t\tif ( postFilter ) {\n\t\t\ttemp = condense( matcherOut, postMap );\n\t\t\tpostFilter( temp, [], context, xml );\n\n\t\t\t// Un-match failing elements by moving them back to matcherIn\n\t\t\ti = temp.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( ( elem = temp[ i ] ) ) {\n\t\t\t\t\tmatcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( seed ) {\n\t\t\tif ( postFinder || preFilter ) {\n\t\t\t\tif ( postFinder ) {\n\n\t\t\t\t\t// Get the final matcherOut by condensing this intermediate into postFinder contexts\n\t\t\t\t\ttemp = [];\n\t\t\t\t\ti = matcherOut.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( ( elem = matcherOut[ i ] ) ) {\n\n\t\t\t\t\t\t\t// Restore matcherIn since elem is not yet a final match\n\t\t\t\t\t\t\ttemp.push( ( matcherIn[ i ] = elem ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tpostFinder( null, ( matcherOut = [] ), temp, xml );\n\t\t\t\t}\n\n\t\t\t\t// Move matched elements from seed to results to keep them synchronized\n\t\t\t\ti = matcherOut.length;\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\tif ( ( elem = matcherOut[ i ] ) &&\n\t\t\t\t\t\t( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) {\n\n\t\t\t\t\t\tseed[ temp ] = !( results[ temp ] = elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Add elements to results, through postFinder if defined\n\t\t} else {\n\t\t\tmatcherOut = condense(\n\t\t\t\tmatcherOut === results ?\n\t\t\t\t\tmatcherOut.splice( preexisting, matcherOut.length ) :\n\t\t\t\t\tmatcherOut\n\t\t\t);\n\t\t\tif ( postFinder ) {\n\t\t\t\tpostFinder( null, results, matcherOut, xml );\n\t\t\t} else {\n\t\t\t\tpush.apply( results, matcherOut );\n\t\t\t}\n\t\t}\n\t} );\n}\n\nfunction matcherFromTokens( tokens ) {\n\tvar checkContext, matcher, j,\n\t\tlen = tokens.length,\n\t\tleadingRelative = Expr.relative[ tokens[ 0 ].type ],\n\t\timplicitRelative = leadingRelative || Expr.relative[ \" \" ],\n\t\ti = leadingRelative ? 1 : 0,\n\n\t\t// The foundational matcher ensures that elements are reachable from top-level context(s)\n\t\tmatchContext = addCombinator( function( elem ) {\n\t\t\treturn elem === checkContext;\n\t\t}, implicitRelative, true ),\n\t\tmatchAnyContext = addCombinator( function( elem ) {\n\t\t\treturn indexOf( checkContext, elem ) > -1;\n\t\t}, implicitRelative, true ),\n\t\tmatchers = [ function( elem, context, xml ) {\n\t\t\tvar ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (\n\t\t\t\t( checkContext = context ).nodeType ?\n\t\t\t\t\tmatchContext( elem, context, xml ) :\n\t\t\t\t\tmatchAnyContext( elem, context, xml ) );\n\n\t\t\t// Avoid hanging onto element (issue #299)\n\t\t\tcheckContext = null;\n\t\t\treturn ret;\n\t\t} ];\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {\n\t\t\tmatchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];\n\t\t} else {\n\t\t\tmatcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );\n\n\t\t\t// Return special upon seeing a positional matcher\n\t\t\tif ( matcher[ expando ] ) {\n\n\t\t\t\t// Find the next relative operator (if any) for proper handling\n\t\t\t\tj = ++i;\n\t\t\t\tfor ( ; j < len; j++ ) {\n\t\t\t\t\tif ( Expr.relative[ tokens[ j ].type ] ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn setMatcher(\n\t\t\t\t\ti > 1 && elementMatcher( matchers ),\n\t\t\t\t\ti > 1 && toSelector(\n\n\t\t\t\t\t// If the preceding token was a descendant combinator, insert an implicit any-element `*`\n\t\t\t\t\ttokens\n\t\t\t\t\t\t.slice( 0, i - 1 )\n\t\t\t\t\t\t.concat( { value: tokens[ i - 2 ].type === \" \" ? \"*\" : \"\" } )\n\t\t\t\t\t).replace( rtrim, \"$1\" ),\n\t\t\t\t\tmatcher,\n\t\t\t\t\ti < j && matcherFromTokens( tokens.slice( i, j ) ),\n\t\t\t\t\tj < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),\n\t\t\t\t\tj < len && toSelector( tokens )\n\t\t\t\t);\n\t\t\t}\n\t\t\tmatchers.push( matcher );\n\t\t}\n\t}\n\n\treturn elementMatcher( matchers );\n}\n\nfunction matcherFromGroupMatchers( elementMatchers, setMatchers ) {\n\tvar bySet = setMatchers.length > 0,\n\t\tbyElement = elementMatchers.length > 0,\n\t\tsuperMatcher = function( seed, context, xml, results, outermost ) {\n\t\t\tvar elem, j, matcher,\n\t\t\t\tmatchedCount = 0,\n\t\t\t\ti = \"0\",\n\t\t\t\tunmatched = seed && [],\n\t\t\t\tsetMatched = [],\n\t\t\t\tcontextBackup = outermostContext,\n\n\t\t\t\t// We must always have either seed elements or outermost context\n\t\t\t\telems = seed || byElement && Expr.find[ \"TAG\" ]( \"*\", outermost ),\n\n\t\t\t\t// Use integer dirruns iff this is the outermost matcher\n\t\t\t\tdirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),\n\t\t\t\tlen = elems.length;\n\n\t\t\tif ( outermost ) {\n\n\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\toutermostContext = context == document || context || outermost;\n\t\t\t}\n\n\t\t\t// Add elements passing elementMatchers directly to results\n\t\t\t// Support: IE<9, Safari\n\t\t\t// Tolerate NodeList properties (IE: \"length\"; Safari: <number>) matching elements by id\n\t\t\tfor ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {\n\t\t\t\tif ( byElement && elem ) {\n\t\t\t\t\tj = 0;\n\n\t\t\t\t\t// Support: IE 11+, Edge 17 - 18+\n\t\t\t\t\t// IE/Edge sometimes throw a \"Permission denied\" error when strict-comparing\n\t\t\t\t\t// two documents; shallow comparisons work.\n\t\t\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\t\t\tif ( !context && elem.ownerDocument != document ) {\n\t\t\t\t\t\tsetDocument( elem );\n\t\t\t\t\t\txml = !documentIsHTML;\n\t\t\t\t\t}\n\t\t\t\t\twhile ( ( matcher = elementMatchers[ j++ ] ) ) {\n\t\t\t\t\t\tif ( matcher( elem, context || document, xml ) ) {\n\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( outermost ) {\n\t\t\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Track unmatched elements for set filters\n\t\t\t\tif ( bySet ) {\n\n\t\t\t\t\t// They will have gone through all possible matchers\n\t\t\t\t\tif ( ( elem = !matcher && elem ) ) {\n\t\t\t\t\t\tmatchedCount--;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Lengthen the array for every element, matched or not\n\t\t\t\t\tif ( seed ) {\n\t\t\t\t\t\tunmatched.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// `i` is now the count of elements visited above, and adding it to `matchedCount`\n\t\t\t// makes the latter nonnegative.\n\t\t\tmatchedCount += i;\n\n\t\t\t// Apply set filters to unmatched elements\n\t\t\t// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`\n\t\t\t// equals `i`), unless we didn't visit _any_ elements in the above loop because we have\n\t\t\t// no element matchers and no seed.\n\t\t\t// Incrementing an initially-string \"0\" `i` allows `i` to remain a string only in that\n\t\t\t// case, which will result in a \"00\" `matchedCount` that differs from `i` but is also\n\t\t\t// numerically zero.\n\t\t\tif ( bySet && i !== matchedCount ) {\n\t\t\t\tj = 0;\n\t\t\t\twhile ( ( matcher = setMatchers[ j++ ] ) ) {\n\t\t\t\t\tmatcher( unmatched, setMatched, context, xml );\n\t\t\t\t}\n\n\t\t\t\tif ( seed ) {\n\n\t\t\t\t\t// Reintegrate element matches to eliminate the need for sorting\n\t\t\t\t\tif ( matchedCount > 0 ) {\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tif ( !( unmatched[ i ] || setMatched[ i ] ) ) {\n\t\t\t\t\t\t\t\tsetMatched[ i ] = pop.call( results );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Discard index placeholder values to get only actual matches\n\t\t\t\t\tsetMatched = condense( setMatched );\n\t\t\t\t}\n\n\t\t\t\t// Add matches to results\n\t\t\t\tpush.apply( results, setMatched );\n\n\t\t\t\t// Seedless set matches succeeding multiple successful matchers stipulate sorting\n\t\t\t\tif ( outermost && !seed && setMatched.length > 0 &&\n\t\t\t\t\t( matchedCount + setMatchers.length ) > 1 ) {\n\n\t\t\t\t\tSizzle.uniqueSort( results );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Override manipulation of globals by nested matchers\n\t\t\tif ( outermost ) {\n\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\toutermostContext = contextBackup;\n\t\t\t}\n\n\t\t\treturn unmatched;\n\t\t};\n\n\treturn bySet ?\n\t\tmarkFunction( superMatcher ) :\n\t\tsuperMatcher;\n}\n\ncompile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {\n\tvar i,\n\t\tsetMatchers = [],\n\t\telementMatchers = [],\n\t\tcached = compilerCache[ selector + \" \" ];\n\n\tif ( !cached ) {\n\n\t\t// Generate a function of recursive functions that can be used to check each element\n\t\tif ( !match ) {\n\t\t\tmatch = tokenize( selector );\n\t\t}\n\t\ti = match.length;\n\t\twhile ( i-- ) {\n\t\t\tcached = matcherFromTokens( match[ i ] );\n\t\t\tif ( cached[ expando ] ) {\n\t\t\t\tsetMatchers.push( cached );\n\t\t\t} else {\n\t\t\t\telementMatchers.push( cached );\n\t\t\t}\n\t\t}\n\n\t\t// Cache the compiled function\n\t\tcached = compilerCache(\n\t\t\tselector,\n\t\t\tmatcherFromGroupMatchers( elementMatchers, setMatchers )\n\t\t);\n\n\t\t// Save selector and tokenization\n\t\tcached.selector = selector;\n\t}\n\treturn cached;\n};\n\n/**\n * A low-level selection function that works with Sizzle's compiled\n *  selector functions\n * @param {String|Function} selector A selector or a pre-compiled\n *  selector function built with Sizzle.compile\n * @param {Element} context\n * @param {Array} [results]\n * @param {Array} [seed] A set of elements to match against\n */\nselect = Sizzle.select = function( selector, context, results, seed ) {\n\tvar i, tokens, token, type, find,\n\t\tcompiled = typeof selector === \"function\" && selector,\n\t\tmatch = !seed && tokenize( ( selector = compiled.selector || selector ) );\n\n\tresults = results || [];\n\n\t// Try to minimize operations if there is only one selector in the list and no seed\n\t// (the latter of which guarantees us context)\n\tif ( match.length === 1 ) {\n\n\t\t// Reduce context if the leading compound selector is an ID\n\t\ttokens = match[ 0 ] = match[ 0 ].slice( 0 );\n\t\tif ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === \"ID\" &&\n\t\t\tcontext.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {\n\n\t\t\tcontext = ( Expr.find[ \"ID\" ]( token.matches[ 0 ]\n\t\t\t\t.replace( runescape, funescape ), context ) || [] )[ 0 ];\n\t\t\tif ( !context ) {\n\t\t\t\treturn results;\n\n\t\t\t// Precompiled matchers will still verify ancestry, so step up a level\n\t\t\t} else if ( compiled ) {\n\t\t\t\tcontext = context.parentNode;\n\t\t\t}\n\n\t\t\tselector = selector.slice( tokens.shift().value.length );\n\t\t}\n\n\t\t// Fetch a seed set for right-to-left matching\n\t\ti = matchExpr[ \"needsContext\" ].test( selector ) ? 0 : tokens.length;\n\t\twhile ( i-- ) {\n\t\t\ttoken = tokens[ i ];\n\n\t\t\t// Abort if we hit a combinator\n\t\t\tif ( Expr.relative[ ( type = token.type ) ] ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( ( find = Expr.find[ type ] ) ) {\n\n\t\t\t\t// Search, expanding context for leading sibling combinators\n\t\t\t\tif ( ( seed = find(\n\t\t\t\t\ttoken.matches[ 0 ].replace( runescape, funescape ),\n\t\t\t\t\trsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) ||\n\t\t\t\t\t\tcontext\n\t\t\t\t) ) ) {\n\n\t\t\t\t\t// If seed is empty or no tokens remain, we can return early\n\t\t\t\t\ttokens.splice( i, 1 );\n\t\t\t\t\tselector = seed.length && toSelector( tokens );\n\t\t\t\t\tif ( !selector ) {\n\t\t\t\t\t\tpush.apply( results, seed );\n\t\t\t\t\t\treturn results;\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Compile and execute a filtering function if one is not provided\n\t// Provide `match` to avoid retokenization if we modified the selector above\n\t( compiled || compile( selector, match ) )(\n\t\tseed,\n\t\tcontext,\n\t\t!documentIsHTML,\n\t\tresults,\n\t\t!context || rsibling.test( selector ) && testContext( context.parentNode ) || context\n\t);\n\treturn results;\n};\n\n// One-time assignments\n\n// Sort stability\nsupport.sortStable = expando.split( \"\" ).sort( sortOrder ).join( \"\" ) === expando;\n\n// Support: Chrome 14-35+\n// Always assume duplicates if they aren't passed to the comparison function\nsupport.detectDuplicates = !!hasDuplicate;\n\n// Initialize against the default document\nsetDocument();\n\n// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)\n// Detached nodes confoundingly follow *each other*\nsupport.sortDetached = assert( function( el ) {\n\n\t// Should return 1, but returns 4 (following)\n\treturn el.compareDocumentPosition( document.createElement( \"fieldset\" ) ) & 1;\n} );\n\n// Support: IE<8\n// Prevent attribute/property \"interpolation\"\n// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx\nif ( !assert( function( el ) {\n\tel.innerHTML = \"<a href='#'></a>\";\n\treturn el.firstChild.getAttribute( \"href\" ) === \"#\";\n} ) ) {\n\taddHandle( \"type|href|height|width\", function( elem, name, isXML ) {\n\t\tif ( !isXML ) {\n\t\t\treturn elem.getAttribute( name, name.toLowerCase() === \"type\" ? 1 : 2 );\n\t\t}\n\t} );\n}\n\n// Support: IE<9\n// Use defaultValue in place of getAttribute(\"value\")\nif ( !support.attributes || !assert( function( el ) {\n\tel.innerHTML = \"<input/>\";\n\tel.firstChild.setAttribute( \"value\", \"\" );\n\treturn el.firstChild.getAttribute( \"value\" ) === \"\";\n} ) ) {\n\taddHandle( \"value\", function( elem, _name, isXML ) {\n\t\tif ( !isXML && elem.nodeName.toLowerCase() === \"input\" ) {\n\t\t\treturn elem.defaultValue;\n\t\t}\n\t} );\n}\n\n// Support: IE<9\n// Use getAttributeNode to fetch booleans when getAttribute lies\nif ( !assert( function( el ) {\n\treturn el.getAttribute( \"disabled\" ) == null;\n} ) ) {\n\taddHandle( booleans, function( elem, name, isXML ) {\n\t\tvar val;\n\t\tif ( !isXML ) {\n\t\t\treturn elem[ name ] === true ? name.toLowerCase() :\n\t\t\t\t( val = elem.getAttributeNode( name ) ) && val.specified ?\n\t\t\t\t\tval.value :\n\t\t\t\t\tnull;\n\t\t}\n\t} );\n}\n\n// EXPOSE\nvar _sizzle = window.Sizzle;\n\nSizzle.noConflict = function() {\n\tif ( window.Sizzle === Sizzle ) {\n\t\twindow.Sizzle = _sizzle;\n\t}\n\n\treturn Sizzle;\n};\n\nif ( typeof define === \"function\" && define.amd ) {\n\tdefine( function() {\n\t\treturn Sizzle;\n\t} );\n\n// Sizzle requires that there be a global window in Common-JS like environments\n} else if ( typeof module !== \"undefined\" && module.exports ) {\n\tmodule.exports = Sizzle;\n} else {\n\twindow.Sizzle = Sizzle;\n}\n\n// EXPOSE\n\n} )( window );\n\n\n\n// WEBPACK FOOTER //\n// ./~/sizzle/dist/sizzle.js","export { default as select, getSingleSelector, getMultiSelector } from './select'\nexport { default as match, initOptions } from './match'\nexport { default as optimize } from './optimize'\nexport * as common from './common'\n\n\n\n// WEBPACK FOOTER //\n// ./src/index.js"],"sourceRoot":""}