node_modules/@asamuzakjp/nwsapi/src/nwsapi.js

/**
 * Forked and modified from nwsapi@2.2.2
 * - Export to cjs only
 * - Remove ./modules directory
 * - Remove unused exported properties
 * - Remove unused pseudo-classes
 * - Remove Snapshot.root and resolve document.documentElement on runtime
 * - Use `let` and `const` as much as possible
 * - Use `===` and `!==`
 * - Fix `:nth-of-type()`
 * - Fix function source for :root, :target and :indeterminate pseudo-classes
 * - Fix <ident-token>
 * - Support complex selectors within `:is()` and `:not()`
 * - Add ::slotted() and ::part() to pseudo-elements list
 * - Add isContentEditable() function
 * - Add createMatchingParensRegex() function from upstream
 * - Invalidate cache for :has() pseudo class
 * - Optimize some regular expressions
 */
/*
 * Copyright (C) 2007-2019 Diego Perini
 * All rights reserved.
 *
 * nwsapi.js - Fast CSS Selectors API Engine
 *
 * Author: Diego Perini <diego.perini at gmail com>
 * Version: 2.2.0
 * Created: 20070722
 * Release: 20220901
 *
 * License:
 *  http://javascript.nwbox.com/nwsapi/MIT-LICENSE
 * Download:
 *  http://javascript.nwbox.com/nwsapi/nwsapi.js
 */

(function Export(global, factory) {
  'use strict';
  module.exports = factory;
})(this, function Factory(global, Export) {
  const version = 'nwsapi-2.2.2';

  let doc = global.document;

  /**
   * Generate a regex that matches a balanced set of parentheses.
   * Outermost parentheses are excluded so any amount of children can be handled.
   * See https://stackoverflow.com/a/35271017 for reference
   *
   * @param {number} depth
   * @return {string}
   */
  function createMatchingParensRegex(depth = 1) {
    const out = '\\([^)(]*?(?:'.repeat(depth) + '\\([^)(]*?\\)' + '[^)(]*?)*?\\)'.repeat(depth);
    // remove outermost escaped parens
    return out.slice(2, out.length - 2);
  }

  const CFG = {
    // extensions
    operators: '[~*^$|]=|=',
    combinators: '[\\s>+~](?=[^>+~])'
  };

  const NOT = {
    // not enclosed in double/single/parens/square
    doubleEnc: '(?=(?:[^"]*"[^"]*")*[^"]*$)',
    singleEnc: "(?=(?:[^']*'[^']*')*[^']*$)",
    parensEnc: '(?![^\\x28]*\\x29)',
    squareEnc: '(?![^\\x5b]*\\x5d)'
  };

  const REX = {
    // regular expressions
    hasEscapes: /\\/,
    hexNumbers: /^[0-9a-f]/i,
    escOrQuote: /^\\|[\x22\x27]/,
    regExpChar: /(?:(?!\\)[\\^$.*+?()[\]{}|/])/g,
    trimSpaces: /[\r\n\f]|^\s+|\s+$/g,
    commaGroup: RegExp('(\\s{0,255},\\s{0,255})' + NOT.squareEnc + NOT.parensEnc, 'g'),
    splitGroup: /((?:\x28[^\x29]{0,255}\x29|\[[^\]]{0,255}\]|\\.|[^,])+)/g,
    fixEscapes: /\\([0-9a-f]{1,6}\s?|.)|([\x22\x27])/gi,
    combineWSP: RegExp('\\s{1,255}' + NOT.singleEnc + NOT.doubleEnc, 'g'),
    tabCharWSP: RegExp('(\\s?\\t{1,255}\\s?)' + NOT.singleEnc + NOT.doubleEnc, 'g'),
    pseudosWSP: RegExp('\\s{1,255}([-+])\\s{1,255}' + NOT.squareEnc, 'g')
  };

  const STD = {
    combinator: /\s?([>+~])\s?/g,
    apimethods: /^(?:[a-z]+|\*)\|/i,
    namespaces: /(\*|[a-z]+)\|[-a-z]+/i
  };

  const GROUPS = {
    // pseudo-classes requiring parameters
    logicalsel: '(is|where|matches|not|has)(?:\\x28\\s?(' + createMatchingParensRegex(3) + ')\\s?\\x29)',
    treestruct: '(nth(?:-last)?(?:-child|-of-type))(?:\\x28\\s?(even|odd|(?:[-+]?\\d*)(?:n\\s?[-+]?\\s?\\d*)?)\\s?(?:\\x29|$))',
    // pseudo-classes not requiring parameters
    locationpc: '(any-link|link|visited|target)\\b',
    structural: '(root|empty|(?:(?:first|last|only)(?:-child|-of-type)))\\b',
    inputstate: '(enabled|disabled|read-(?:only|write)|placeholder-shown|default)\\b',
    inputvalue: '(checked|indeterminate)\\b',
    // pseudo-classes for parsing only selectors
    pseudoNop: '(autofill|-webkit-autofill)\\b',
    // pseudo-elements starting with single colon (:)
    pseudoSng: '(after|before|first-letter|first-line)\\b',
    // pseudo-elements starting with double colon (::)
    pseudoDbl: ':(after|before|first-letter|first-line|selection|part|placeholder|slotted|-webkit-[-a-z0-9]{2,})\\b'
  };

  const Patterns = {
    // pseudo-classes
    treestruct: RegExp('^:(?:' + GROUPS.treestruct + ')(.*)', 'i'),
    structural: RegExp('^:(?:' + GROUPS.structural + ')(.*)', 'i'),
    inputstate: RegExp('^:(?:' + GROUPS.inputstate + ')(.*)', 'i'),
    inputvalue: RegExp('^:(?:' + GROUPS.inputvalue + ')(.*)', 'i'),
    locationpc: RegExp('^:(?:' + GROUPS.locationpc + ')(.*)', 'i'),
    logicalsel: RegExp('^:(?:' + GROUPS.logicalsel + ')(.*)', 'i'),
    pseudoNop: RegExp('^:(?:' + GROUPS.pseudoNop + ')(.*)', 'i'),
    pseudoSng: RegExp('^:(?:' + GROUPS.pseudoSng + ')(.*)', 'i'),
    pseudoDbl: RegExp('^:(?:' + GROUPS.pseudoDbl + ')(.*)', 'i'),
    // combinator symbols
    children: /^\s?>\s?(.*)/,
    adjacent: /^\s?\+\s?(.*)/,
    relative: /^\s?~\s?(.*)/,
    ancestor: /^\s+(.*)/,
    // universal & namespace
    universal: /^\*(.*)/,
    namespace: /^(\w+|\*)?\|(.*)/
  };

  // emulate firefox error strings
  const qsNotArgs = 'Not enough arguments';
  const qsInvalid = ' is not a valid selector';

  // detect structural pseudo-classes in selectors
  const reNthElem = /(:nth(?:-last)?-child)/i;
  const reNthType = /(:nth(?:-last)?-of-type)/i;

  // placeholder for global regexp
  let reOptimizer;
  let reValidator;

  // special handling configuration flags
  const Config = {
    IDS_DUPES: true,
    MIXEDCASE: true,
    LOGERRORS: true,
    VERBOSITY: true
  };

  let NAMESPACE;
  let QUIRKS_MODE;
  let HTML_DOCUMENT;

  const ATTR_STD_OPS = {
    '=': 1,
    '^=': 1,
    '$=': 1,
    '|=': 1,
    '*=': 1,
    '~=': 1
  };

  const HTML_TABLE = {
    accept: 1,
    'accept-charset': 1,
    align: 1,
    alink: 1,
    axis: 1,
    bgcolor: 1,
    charset: 1,
    checked: 1,
    clear: 1,
    codetype: 1,
    color: 1,
    compact: 1,
    declare: 1,
    defer: 1,
    dir: 1,
    direction: 1,
    disabled: 1,
    enctype: 1,
    face: 1,
    frame: 1,
    hreflang: 1,
    'http-equiv': 1,
    lang: 1,
    language: 1,
    link: 1,
    media: 1,
    method: 1,
    multiple: 1,
    nohref: 1,
    noresize: 1,
    noshade: 1,
    nowrap: 1,
    readonly: 1,
    rel: 1,
    rev: 1,
    rules: 1,
    scope: 1,
    scrolling: 1,
    selected: 1,
    shape: 1,
    target: 1,
    text: 1,
    type: 1,
    valign: 1,
    valuetype: 1,
    vlink: 1
  };

  const Combinators = {};

  const Selectors = {};

  const Operators = {
    '=': {
      p1: '^',
      p2: '$',
      p3: 'true'
    },
    '^=': {
      p1: '^',
      p2: '',
      p3: 'true'
    },
    '$=': {
      p1: '',
      p2: '$',
      p3: 'true'
    },
    '*=': {
      p1: '',
      p2: '',
      p3: 'true'
    },
    '|=': {
      p1: '^',
      p2: '(-|$)',
      p3: 'true'
    },
    '~=': {
      p1: '(^|\\s)',
      p2: '(\\s|$)',
      p3: 'true'
    }
  };

  const concatCall = function (nodes, callback) {
    let i = 0;
    const l = nodes.length;
    const list = Array(l);
    while (l > i) {
      if (callback(list[i] = nodes[i]) === false) {
        break;
      }
      ++i;
    }
    return list;
  };

  const concatList = function (list, nodes) {
    let i = -1;
    let l = nodes.length;
    while (l--) {
      list[list.length] = nodes[++i];
    }
    return list;
  };

  let hasDupes = false;

  const documentOrder = function (a, b) {
    if (!hasDupes && a === b) {
      hasDupes = true;
      return 0;
    }
    return a.compareDocumentPosition(b) & 4 ? -1 : 1;
  };

  const unique = function (nodes) {
    let i = 0;
    let j = -1;
    let l = nodes.length + 1;
    const list = [];
    while (--l) {
      if (nodes[i++] === nodes[i]) {
        continue;
      }
      list[++j] = nodes[i - 1];
    }
    hasDupes = false;
    return list;
  };

  // check context for mixed content
  const hasMixedCaseTagNames = function (context) {
    const api = 'getElementsByTagNameNS';

    // current host context (ownerDocument)
    context = context.ownerDocument || context;

    // documentElement (root) element namespace or default html/xhtml namespace
    const ns = context.documentElement && context.documentElement.namespaceURI
       ? context.documentElement.namespaceURI
       : 'http://www.w3.org/1999/xhtml';

    // checking the number of non HTML nodes in the document
    return (context[api]('*', '*').length - context[api](ns, '*').length) > 0;
  };

  // check if the document type is HTML
  const isHTML = function (node) {
    const doc = node.ownerDocument || node;
    return doc.nodeType === 9 && doc.contentType === 'text/html';
  };

  // convert single codepoint to UTF-16 encoding
  const codePointToUTF16 = function (codePoint) {
    // out of range, use replacement character
    if (codePoint < 1 || codePoint > 0x10ffff ||
        (codePoint > 0xd7ff && codePoint < 0xe000)) {
      return '\\ufffd';
    }
    // javascript strings are UTF-16 encoded
    if (codePoint < 0x10000) {
      const lowHex = '000' + codePoint.toString(16);
      return '\\u' + lowHex.substr(lowHex.length - 4);
    }
    // supplementary high + low surrogates
    return '\\u' + (((codePoint - 0x10000) >> 0x0a) + 0xd800).toString(16) +
           '\\u' + (((codePoint - 0x10000) % 0x400) + 0xdc00).toString(16);
  };

  // convert single codepoint to string
  const stringFromCodePoint = function (codePoint) {
    // out of range, use replacement character
    if (codePoint < 1 || codePoint > 0x10ffff ||
        (codePoint > 0xd7ff && codePoint < 0xe000)) {
      return '\ufffd';
    }
    if (codePoint < 0x10000) {
      return String.fromCharCode(codePoint);
    }
    return String.fromCodePoint(codePoint);
  };

  // convert escape sequence in a CSS string or identifier
  // to javascript string with javascript escape sequences
  const convertEscapes = function (str) {
    return REX.hasEscapes.test(str)
      ? str.replace(REX.fixEscapes, function (substring, p1, p2) {
        // unescaped " or '
        return p2
          ? '\\' + p2
          // javascript strings are UTF-16 encoded
          : REX.hexNumbers.test(p1)
            ? codePointToUTF16(parseInt(p1, 16))
            // \' \"
            : REX.escOrQuote.test(p1)
              ? substring
              // \g \h \. \# etc
              : p1;
      })
      : str;
  };

  // convert escape sequence in a CSS string or identifier
  // to javascript string with characters representations
  const unescapeIdentifier = function (str) {
    return REX.hasEscapes.test(str)
      ? str.replace(REX.fixEscapes, function (substring, p1, p2) {
        // unescaped " or '
        return p2 || (REX.hexNumbers.test(p1)
          ? stringFromCodePoint(parseInt(p1, 16))
          // \' \"
          : REX.escOrQuote.test(p1)
            ? substring
            // \g \h \. \# etc
            : p1);
      })
      : str;
  };

  // empty set
  const none = [];

  // cached lambdas
  const matchLambdas = {};
  const selectLambdas = {};

  // cached resolvers
  let matchResolvers = {};
  let selectResolvers = {};

  const method = {
    '#': 'getElementById',
    '*': 'getElementsByTagName',
    '|': 'getElementsByTagNameNS',
    '.': 'getElementsByClassName'
  };

  // find duplicate ids using iterative walk
  const byIdRaw = function (id, context) {
    let node = context;
    const nodes = [];
    let next = node.firstElementChild;
    while ((node = next)) {
      node.id === id && nodes.push(node);
      if ((next = node.firstElementChild || node.nextElementSibling)) {
        continue;
      }
      while (!next && (node = node.parentElement) && node !== context) {
        next = node.nextElementSibling;
      }
    }
    return nodes;
  };

  // context agnostic getElementById
  const byId = function (id, context) {
    let e;
    const api = method['#'];

    // duplicates id allowed
    if (Config.IDS_DUPES === false) {
      if (api in context) {
        e = context[api](id);
        return e ? [e] : none;
      }
    } else if ('all' in context) {
      if ((e = context.all[id])) {
        if (e.nodeType === 1) {
          return e.getAttribute('id') !== id ? [] : [e];
        } else if (id === 'length') {
          e = context[api](id);
          return e ? [e] : none;
        }
        const nodes = [];
        for (let i = 0, l = e.length; l > i; ++i) {
          if (e[i].id === id) {
            nodes.push(e[i]);
          }
        }
        return nodes.length ? nodes : none;
      } else {
        return none;
      }
    }

    return byIdRaw(id, context);
  };

  // context agnostic getElementsByTagName
  const byTag = function (tag, context) {
    let e;
    let nodes;
    const api = method['*'];

    // DOCUMENT_NODE (9) & ELEMENT_NODE (1)
    if (api in context) {
      return Array.prototype.slice.call(context[api](tag));
    } else {
      tag = tag.toLowerCase();
      // DOCUMENT_FRAGMENT_NODE (11)
      if ((e = context.firstElementChild)) {
        if (!(e.nextElementSibling || tag === '*' || e.localName === tag)) {
          return Array.prototype.slice.call(e[api](tag));
        } else {
          nodes = [];
          do {
            if (tag === '*' || e.localName === tag) {
              nodes.push(e);
            }
            concatList(nodes, e[api](tag));
          } while ((e = e.nextElementSibling));
        }
      } else {
        nodes = none;
      }
    }
    return nodes;
  };

  // context agnostic getElementsByClassName
  const byClass = function (cls, context) {
    let e;
    let nodes;
    const api = method['.'];
    let reCls;
    // DOCUMENT_NODE (9) & ELEMENT_NODE (1)
    if (api in context) {
      return Array.prototype.slice.call(context[api](cls));
    } else {
      // DOCUMENT_FRAGMENT_NODE (11)
      if ((e = context.firstElementChild)) {
        reCls = RegExp('(^|\\s)' + cls + '(\\s|$)', QUIRKS_MODE ? 'i' : '');
        if (!(e.nextElementSibling || reCls.test(e.className))) {
          return Array.prototype.slice.call(e[api](cls));
        } else {
          nodes = [];
          do {
            if (reCls.test(e.className)) {
              nodes.push(e);
            }
            concatList(nodes, e[api](cls));
          } while ((e = e.nextElementSibling));
        }
      } else nodes = none;
    }
    return nodes;
  };

  const compat = {
    '#': function (c, n) {
      REX.hasEscapes.test(n) && (n = unescapeIdentifier(n));
      return function (e, f) {
        return byId(n, c);
      };
    },
    '*': function (c, n) {
      REX.hasEscapes.test(n) && (n = unescapeIdentifier(n));
      return function (e, f) {
        return byTag(n, c);
      };
    },
    '|': function (c, n) {
      REX.hasEscapes.test(n) && (n = unescapeIdentifier(n));
      return function (e, f) {
        return byTag(n, c);
      };
    },
    '.': function (c, n) {
      REX.hasEscapes.test(n) && (n = unescapeIdentifier(n));
      return function (e, f) {
        return byClass(n, c);
      };
    }
  };

  // namespace aware hasAttribute
  // helper for XML/XHTML documents
  const hasAttributeNS = function (e, name) {
    let i;
    let l;
    const attr = e.getAttributeNames();
    name = RegExp(':?' + name + '$', HTML_DOCUMENT ? 'i' : '');
    for (i = 0, l = attr.length; l > i; ++i) {
      if (name.test(attr[i])) {
        return true;
      }
    }
    return false;
  };

  // fast resolver for the :nth-child() and :nth-last-child() pseudo-classes
  const nthElement = (function () {
    let idx = 0;
    let len = 0;
    let set = 0;
    let parent;
    let parents = [];
    let nodes = [];
    return function (element, dir) {
      // ensure caches are emptied after each run, invoking with dir = 2
      if (dir === 2) {
        idx = 0; len = 0; set = 0; nodes = []; parents = []; parent = undefined;
        return -1;
      }
      let e, i, j, k, l;
      if (parent === element.parentElement) {
        i = set; j = idx; l = len;
      } else {
        l = parents.length;
        parent = element.parentElement;
        for (i = -1, j = 0, k = l - 1; l > j; ++j, --k) {
          if (parents[j] === parent) {
            i = j;
            break;
          }
          if (parents[k] === parent) {
            i = k;
            break;
          }
        }
        if (i < 0) {
          parents[i = l] = parent;
          l = 0; nodes[i] = [];
          e = (parent && parent.firstElementChild) || element;
          while (e) {
            nodes[i][l] = e;
            if (e === element) {
              j = l;
            }
            e = e.nextElementSibling;
            ++l;
          }
          set = i; idx = 0; len = l;
          if (l < 2) {
            return l;
          }
        } else {
          l = nodes[i].length;
          set = i;
        }
      }
      if (element !== nodes[i][j] && element !== nodes[i][j = 0]) {
        for (j = 0, e = nodes[i], k = l - 1; l > j; ++j, --k) {
          if (e[j] === element) {
            break;
          }
          if (e[k] === element) {
            j = k;
            break;
          }
        }
      }
      idx = j + 1; len = l;
      return dir ? l - j : idx;
    };
  })();

  // fast resolver for the :nth-of-type() and :nth-last-of-type() pseudo-classes
  const nthOfType = (function () {
    let idx = 0;
    let len = 0;
    let set = 0;
    let parent;
    let parents = [];
    let nodes = [];
    return function (element, dir) {
      // ensure caches are emptied after each run, invoking with dir = 2
      if (dir === 2) {
        idx = 0; len = 0; set = 0; nodes = []; parents = []; parent = undefined;
        return -1;
      }
      const name = element.localName;
      const nsURI = element.namespaceURI;
      if (nsURI !== 'http://www.w3.org/1999/xhtml') {
        idx = 0; len = 0; set = 0; nodes = []; parents = []; parent = undefined;
      }
      let e;
      let i;
      let j;
      let k;
      let l;
      if (nodes[set] && nodes[set][name] && parent === element.parentElement) {
        i = set;
        j = idx;
        l = len;
      } else {
        l = parents.length;
        parent = element.parentElement;
        for (i = -1, j = 0, k = l - 1; l > j; ++j, --k) {
          if (parents[j] === parent) {
            i = j;
            break;
          }
          if (parents[k] === parent) {
            i = k;
            break;
          }
        }
        if (i < 0 || !nodes[i][name]) {
          parents[i = l] = parent;
          nodes[i] || (nodes[i] = Object());
          l = 0; nodes[i][name] = [];
          e = (parent && parent.firstElementChild) || element;
          while (e) {
            if (e === element) {
              j = l;
            }
            if (e.localName === name && e.namespaceURI === nsURI) {
              nodes[i][name][l] = e;
              ++l;
            }
            e = e.nextElementSibling;
          }
          set = i; idx = j; len = l;
          if (l < 2) {
            return l;
          }
        } else {
          l = nodes[i][name].length;
          set = i;
        }
      }
      if (element !== nodes[i][name][j] && element !== nodes[i][name][j = 0]) {
        for (j = 0, e = nodes[i][name], k = l - 1; l > j; ++j, --k) {
          if (e[j] === element) {
            break;
          }
          if (e[k] === element) {
            j = k;
            break;
          }
        }
      }
      idx = j + 1; len = l;
      return dir ? l - j : idx;
    };
  })();

  // check if the node is the target
  const isTarget = function (node) {
    const doc = node.ownerDocument || node;
    const { hash } = new URL(doc.URL);
    if (node.id && hash === `#${node.id}` && doc.contains(node)) {
      return true;
    }
    return false;
  };

  // check if node is indeterminate
  const isIndeterminate = function (node) {
    if ((node.indeterminate && node.localName === 'input' &&
         node.type === 'checkbox') ||
        (node.localName === 'progress' && !node.hasAttribute('value'))) {
      return true;
    }
    if (node.localName === 'input' && node.type === 'radio' &&
        !node.hasAttribute('checked')) {
      const nodeName = node.name;
      let parent = node.parentNode;
      while (parent) {
        if (parent.localName === 'form') {
          break;
        }
        parent = parent.parentNode;
      }
      if (!parent) {
        const doc = node.ownerDocument;
        parent = doc.documentElement;
      }
      const items = parent.getElementsByTagName('input');
      const l = items.length;
      let checked;
      for (let i = 0; i < l; i++) {
        const item = items[i];
        if (item.getAttribute('type') === 'radio') {
          if (nodeName) {
            if (item.getAttribute('name') === nodeName) {
              checked = !!item.checked;
            }
          } else if (!item.hasAttribute('name')) {
            checked = !!item.checked;
          }
          if (checked) {
            break;
          }
        }
      }
      if (!checked) {
        return true;
      }
    }
    return false;
  };

  // check if node content is editable
  const isContentEditable = function (node) {
    let attrValue = 'inherit';
    if (node.hasAttribute('contenteditable')) {
      attrValue = node.getAttribute('contenteditable');
    }
    switch (attrValue) {
      case '':
      case 'plaintext-only':
      case 'true':
        return true;
      case 'false':
        return false;
      default:
        if (node.parentNode && node.parentNode.nodeType === 1) {
          return isContentEditable(node.parentNode);
        }
        return false;
    }
  };

  // build validation regexps used by the engine
  const setIdentifierSyntax = function () {
    //
    // NOTE: SPECIAL CASES IN CSS SYNTAX PARSING RULES
    //
    // The <EOF-token> https://drafts.csswg.org/css-syntax/#typedef-eof-token
    // allow mangled|unclosed selector syntax at the end of selectors strings
    //
    // Literal equivalent hex representations of the characters: " ' ` ] )
    //
    //     \\x22 = " - double quotes    \\x5b = [ - open square bracket
    //     \\x27 = ' - single quote     \\x5d = ] - closed square bracket
    //     \\x60 = ` - back tick        \\x28 = ( - open round parens
    //     \\x5c = \ - back slash       \\x29 = ) - closed round parens
    //
    // using hex format prevents false matches of opened/closed instances
    // pairs, coloring breakage and other editors highlightning problems.
    //

    // @see https://drafts.csswg.org/css-syntax-3/#ident-token-diagram
    const nonascii = '[^\\x00-\\x9f]';
    const esctoken = '\\\\(?:[^\\r\\n\\f\\da-f]|[\\da-f]{1,6}\\s{0,255})';
    const identifier =
      '(?:--|-?(?:[a-z_]|' + nonascii + '|' + esctoken + '))' +
      '(?:[\\w-]|' + nonascii + '|' + esctoken + ')*';

    const pseudonames = '[-\\w]+';
    const pseudoparms = '(?:[-+]?\\d*)(?:n\\s?[-+]?\\s?\\d*)';
    const doublequote = '"[^"\\\\]*(?:\\\\.[^"\\\\]*)*(?:"|$)';
    const singlequote = "'[^'\\\\]*(?:\\\\.[^'\\\\]*)*(?:'|$)";

    const attrparser = identifier + '|' + doublequote + '|' + singlequote;

    const attrvalues = '([\\x22\\x27]?)((?!\\3)*|(?:\\\\?.)*?)(?:\\3|$)';

    const attributes =
      '\\[' +
        // attribute presence
        '(?:\\*\\|)?\\s?(' + identifier + '(?::' + identifier + ')?)\\s?' +
        '(?:(' + CFG.operators + ')\\s?(?:' + attrparser + '))?' +
        // attribute case sensitivity
        '(?:\\s?\\b(i))?\\s?' +
      '(?:\\]|$)';

    const attrmatcher = attributes.replace(attrparser, attrvalues);

    const pseudoclass =
      '(?:\\x28\\s*' +
        '(?:' + pseudoparms + '?)?|' +
        // universal * &
        // namespace *|*
        '[*|]|' +
        '(?:' +
          '(?::' + pseudonames + '(?:\\x28' + pseudoparms + '?(?:\\x29|$))?)|' +
          '(?:[.#]?' + identifier + ')|' +
          '(?:' + attributes + ')' +
        ')+|' +
        '\\s?[>+~]\\s?|' +
        '\\s?,\\s?|' +
        '\\s|' +
        '\\x29|$' +
      ')*';

    const standardValidator =
      '(?=\\s?[^>+~(){}<])' +
      '(?:' +
        // universal * &
        // namespace *|*
        '\\*|\\||' +
        '(?:[.#]?' + identifier + ')+|' +
        '(?:' + attributes + ')+|' +
        '(?:::?' + pseudonames + pseudoclass + ')|' +
        '(?:\\s?' + CFG.combinators + '\\s?)|' +
        '\\s?,\\s?|' +
        '\\s?' +
      ')+';

    // the following global RE is used to return the
    // deepest localName in selector strings and then
    // use it to retrieve all possible matching nodes
    // that will be filtered by compiled resolvers
    reOptimizer = RegExp(
      '(?:([.:#*]?)(' + identifier + ')' +
        '(?::[-\\w]+|\\[[^\\]]+(?:\\]|$)|\\x28[^\\x29]+(?:\\x29|$))*' +
      ')$', 'i');

    // global
    reValidator = RegExp(standardValidator, 'gi');

    Patterns.id = RegExp('^#(' + identifier + ')(.*)', 'i');
    Patterns.tagName = RegExp('^(' + identifier + ')(.*)', 'i');
    Patterns.className = RegExp('^\\.(' + identifier + ')(.*)', 'i');
    Patterns.attribute = RegExp('^(?:' + attrmatcher + ')(.*)');
  };

  // configure the engine to use special handling
  const configure = function (option, clear) {
    if (typeof option === 'string') {
      return !!Config[option];
    }
    if (typeof option !== 'object') {
      return Config;
    }
    for (const i in option) {
      Config[i] = !!option[i];
    }
    // clear lambda cache
    if (clear) {
      matchResolvers = {};
      selectResolvers = {};
    }
    setIdentifierSyntax();
    return true;
  };

  // centralized error and exceptions handling
  const emit = function (message, proto) {
    let err;
    if (Config.VERBOSITY) {
      if (global[proto]) {
        err = new global[proto](message);
      } else {
        err = new global.DOMException(message, 'SyntaxError');
      }
      throw err;
    }
    if (Config.LOGERRORS && console && console.log) {
      console.log(message);
    }
  };

  // passed to resolvers
  const Snapshot = {
    doc: null,
    from: null,
    byTag: null,
    first: null,
    match: null,
    ancestor: null,
    nthOfType: null,
    nthElement: null,
    hasAttributeNS: null,
    isTarget: null,
    isIndeterminate: null,
    isContentEditable: null
  };

  // context
  let lastContext;

  const switchContext = function (context, force) {
    const oldDoc = doc;
    doc = context.ownerDocument || context;
    if (force || oldDoc !== doc) {
      // force a new check for each document change
      // performed before the next select operation
      HTML_DOCUMENT = isHTML(doc);
      QUIRKS_MODE = HTML_DOCUMENT && doc.compatMode.indexOf('CSS') < 0;
      NAMESPACE = doc.documentElement && doc.documentElement.namespaceURI;
      Snapshot.doc = doc;
    }
    Snapshot.from = context;
    return context;
  };

  // selector
  let lastMatched;
  let lastSelected;

  const F_INIT = '"use strict";return function Resolver(c,f,x,r)';

  const S_HEAD = 'var e,n,o,j=r.length-1,k=-1';
  const M_HEAD = 'var e,n,o';

  const S_LOOP = 'main:while((e=c[++k]))';
  const N_LOOP = 'main:while((e=c.item(++k)))';
  const M_LOOP = 'e=c;';

  const S_BODY = 'r[++j]=c[k];';
  const N_BODY = 'r[++j]=c.item(k);';
  const M_BODY = '';

  const S_TAIL = 'continue main;';
  const M_TAIL = 'r=true;';

  const S_TEST = 'if(f(c[k])){break main;}';
  const N_TEST = 'if(f(c.item(k))){break main;}';
  const M_TEST = 'f(c);';

  let S_VARS = [];
  let M_VARS = [];

  // build conditional code to check components of selector strings
  const compileSelector = function (expression, source, mode, callback) {
    // N is the negation pseudo-class flag
    // D is the default inverted negation flag
    let a;
    let b;
    let n;
    let f;
    let name;
    let NS;
    const N = '';
    const D = '!';
    let compat;
    let expr;
    let match;
    let result;
    let status;
    let symbol;
    let test;
    let type;
    let selector = expression;
    let vars;

    // original 'select' or 'match' selector string before normalization
    const selectorString = mode ? lastSelected : lastMatched;

    // isolate selector combinators/components and normalize whitespace
    selector = selector.replace(STD.combinator, '$1'); // .replace(STD.whitespace, ' ');

    let selectorRecursion = true;
    while (selector) {
      // get namespace prefix if present or get first char of selector
      symbol = STD.apimethods.test(selector) ? '|' : selector[0];

      switch (symbol) {
        // universal resolver
        case '*':
          match = selector.match(Patterns.universal);
          if (N === '!') {
            source = 'if(' + N + 'true' + '){' + source + '}';
          }
          break;
        // id resolver
        case '#':
          match = selector.match(Patterns.id);
          source = 'if(' + N + '(/^' + match[1] + '$/.test(e.getAttribute("id"))' +
            ')){' + source + '}';
          break;
        // class name resolver
        case '.':
          match = selector.match(Patterns.className);
          compat = (QUIRKS_MODE ? 'i' : '') + '.test(e.getAttribute("class"))';
          source = 'if(' + N + '(/(^|\\s)' + match[1] + '(\\s|$)/' + compat +
            ')){' + source + '}';
          break;
        // tag name resolver
        case (/[_a-z]/i.test(symbol) ? symbol : undefined):
          match = selector.match(Patterns.tagName);
          source = 'if(' + N + '(e.localName' +
            (Config.MIXEDCASE || hasMixedCaseTagNames(doc)
              ? '=="' + match[1].toLowerCase() + '"'
              : '=="' + match[1].toUpperCase() + '"') +
            ')){' + source + '}';
          break;
        // namespace resolver
        case '|':
          match = selector.match(Patterns.namespace);
          if (match[1] === '*') {
            source = 'if(' + N + 'true){' + source + '}';
          } else if (!match[1]) {
            source = 'if(' + N + '(!e.namespaceURI)){' + source + '}';
          } else if (typeof match[1] === 'string' && doc.documentElement &&
                     doc.documentElement.prefix === match[1]) {
            source = 'if(' + N + '(e.namespaceURI=="' + NAMESPACE + '")){' + source + '}';
          } else {
            emit('\'' + selectorString + '\'' + qsInvalid);
          }
          break;
        // attributes resolver
        case '[':
          match = selector.match(Patterns.attribute);
          NS = match[0].match(STD.namespaces);
          name = match[1];
          expr = name.split(':');
          expr = expr.length === 2 ? expr[1] : expr[0];
          if (match[2] && !(test = Operators[match[2]])) {
            emit('\'' + selectorString + '\'' + qsInvalid);
            return '';
          }
          if (match[4] === '') {
            test = match[2] === '~='
              ? { p1: '^\\s', p2: '+$', p3: 'true' }
              : match[2] in ATTR_STD_OPS && match[2] !== '~='
                ? { p1: '^', p2: '$', p3: 'true' }
                : test;
          } else if (match[2] === '~=' && match[4].includes(' ')) {
            // whitespace separated list but value contains space
            source = 'if(' + N + 'false){' + source + '}';
            break;
          } else if (match[4]) {
            match[4] = convertEscapes(match[4]).replace(REX.regExpChar, '\\$&');
          }
          type = match[5] === 'i' || (HTML_DOCUMENT && HTML_TABLE[expr.toLowerCase()])
            ? 'i'
            : '';
          source =
            'if(' + N + '(' +
              (!match[2]
                ? (NS ? 's.hasAttributeNS(e,"' + name + '")' : 'e.hasAttribute&&e.hasAttribute("' + name + '")')
                : !match[4] && ATTR_STD_OPS[match[2]] && match[2] !== '~='
                  ? 'e.getAttribute&&e.getAttribute("' + name + '")==""'
                  : '(/' + test.p1 + match[4] + test.p2 + '/' + type + ').test(e.getAttribute&&e.getAttribute("' + name + '"))==' + test.p3) +
            ')){' + source + '}';
          break;
        // *** General sibling combinator
        // E ~ F (F relative sibling of E)
        case '~':
          match = selector.match(Patterns.relative);
          source = 'n=e;while((e=e.previousElementSibling)){' + source + '}e=n;';
          break;
        // *** Adjacent sibling combinator
        // E + F (F adiacent sibling of E)
        case '+':
          match = selector.match(Patterns.adjacent);
          source = 'n=e;if((e=e.previousElementSibling)){' + source + '}e=n;';
          break;
        // *** Descendant combinator
        // E F (E ancestor of F)
        case '\x09':
        case '\x20':
          match = selector.match(Patterns.ancestor);
          source = 'n=e;while((e=e.parentElement)){' + source + '}e=n;';
          break;
        // *** Child combinator
        // E > F (F children of E)
        case '>':
          match = selector.match(Patterns.children);
          source = 'n=e;if((e=e.parentElement)){' + source + '}e=n;';
          break;
        // *** user supplied combinators extensions
        case (symbol in Combinators ? symbol : undefined):
          // for other registered combinators extensions
          match[match.length - 1] = '*';
          source = Combinators[symbol](match) + source;
          break;
        // *** tree-structural pseudo-classes
        // :root, :empty, :first-child, :last-child, :only-child, :first-of-type, :last-of-type, :only-of-type
        case ':':
          if ((match = selector.match(Patterns.structural))) {
            match[1] = match[1].toLowerCase();
            switch (match[1]) {
              case 'root':
                // there can only be one :root element, so exit the loop once found
                source = 'if(' + N + '(e===s.doc.documentElement)){' + source + (mode ? 'break main;' : '') + '}';
                break;
              case 'empty':
                // matches elements that don't contain elements or text nodes
                source = 'n=e.firstChild;while(n&&!(/1|3/).test(n.nodeType)){n=n.nextSibling}if(' + D + 'n){' + source + '}';
                break;
              // *** child-indexed pseudo-classes
              // :first-child, :last-child, :only-child
              case 'only-child':
                source = 'if(' + N + '(!e.nextElementSibling&&!e.previousElementSibling)){' + source + '}';
                break;
              case 'last-child':
                source = 'if(' + N + '(!e.nextElementSibling)){' + source + '}';
                break;
              case 'first-child':
                source = 'if(' + N + '(!e.previousElementSibling)){' + source + '}';
                break;
              // *** typed child-indexed pseudo-classes
              // :only-of-type, :last-of-type, :first-of-type
              case 'only-of-type':
                source = 'o=e.localName;' +
                  'n=e;while((n=n.nextElementSibling)&&n.localName!=o);if(!n){' +
                  'n=e;while((n=n.previousElementSibling)&&n.localName!=o);}if(' + D + 'n){' + source + '}';
                break;
              case 'last-of-type':
                source = 'n=e;o=e.localName;while((n=n.nextElementSibling)&&n.localName!=o);if(' + D + 'n){' + source + '}';
                break;
              case 'first-of-type':
                source = 'n=e;o=e.localName;while((n=n.previousElementSibling)&&n.localName!=o);if(' + D + 'n){' + source + '}';
                break;
              default:
                emit('\'' + selectorString + '\'' + qsInvalid);
            }
          // *** child-indexed & typed child-indexed pseudo-classes
          // :nth-child, :nth-of-type, :nth-last-child, :nth-last-of-type
          } else if ((match = selector.match(Patterns.treestruct))) {
            match[1] = match[1].toLowerCase();
            switch (match[1]) {
              case 'nth-child':
              case 'nth-of-type':
              case 'nth-last-child':
              case 'nth-last-of-type':
                expr = /-of-type/i.test(match[1]);
                if (match[1] && match[2]) {
                  type = /last/i.test(match[1]);
                  if (match[2] === 'n') {
                    source = 'if(' + N + 'true){' + source + '}';
                    break;
                  } else if (match[2] === '1') {
                    test = type ? 'next' : 'previous';
                    source = expr
                      ? 'n=e;o=e.localName;' +
                          'while((n=n.' + test + 'ElementSibling)&&n.localName!=o);if(' + D + 'n){' + source + '}'
                      : 'if(' + N + '!e.' + test + 'ElementSibling){' + source + '}';
                    break;
                  } else if (match[2] === 'even' || match[2] === '2n0' || match[2] === '2n+0' || match[2] === '2n') {
                    test = 'n%2==0';
                  } else if (match[2] === 'odd' || match[2] === '2n1' || match[2] === '2n+1') {
                    test = 'n%2==1';
                  } else {
                    f = /n/i.test(match[2]);
                    n = match[2].split('n');
                    a = parseInt(n[0], 10) || 0;
                    b = parseInt(n[1], 10) || 0;
                    if (n[0] === '-') {
                      a = -1;
                    }
                    if (n[0] === '+') {
                      a = +1;
                    }
                    test = (b ? '(n' + (b > 0 ? '-' : '+') + Math.abs(b) + ')' : 'n') + '%' + a + '==0';
                    test = a >= +1
                      ? (f
                          ? 'n>' + (b - 1) + (Math.abs(a) !== 1
                            ? '&&' + test
                            : '')
                          : 'n==' + a)
                      : a <= -1
                        ? (f
                            ? 'n<' + (b + 1) + (Math.abs(a) !== 1
                              ? '&&' + test
                              : '')
                            : 'n==' + a)
                        : a === 0
                          ? (n[0]
                              ? 'n==' + b
                              : 'n>' + (b - 1))
                          : 'false';
                  }
                  expr = expr ? 'OfType' : 'Element';
                  type = type ? 'true' : 'false';
                  source = 'n=s.nth' + expr + '(e,' + type + ');if(' + N + '(' + test + ')){' + source + '}';
                } else {
                  emit('\'' + selectorString + '\'' + qsInvalid);
                }
                break;
              default:
                emit('\'' + selectorString + '\'' + qsInvalid);
            }
          // *** logical combination pseudo-classes
          // :is( s1, [ s2, ... ]), :not( s1, [ s2, ... ])
          } else if ((match = selector.match(Patterns.logicalsel))) {
            match[1] = match[1].toLowerCase();
            expr = match[2].replace(REX.CommaGroup, ',').replace(REX.TrimSpaces, '');
            switch (match[1]) {
              // FIXME:
              case 'is':
              case 'where':
              case 'matches':
                source = 'if(s.match("' + expr.replace(/\x22/g, '\\"') + '",e)){' + source + '}';
                break;
              // FIXME:
              case 'not':
                source = 'if(!s.match("' + expr.replace(/\x22/g, '\\"') + '",e)){' + source + '}';
                break;
              // FIXME:
              case 'has':
                // clear cache
                matchResolvers = {};
                source = 'if(e.querySelector(":scope ' + expr.replace(/\x22/g, '\\"') + '")){' + source + '}';
                break;
              default:
                emit('\'' + selectorString + '\'' + qsInvalid);
            }
          // *** location pseudo-classes
          // :any-link, :link, :visited, :target
          } else if ((match = selector.match(Patterns.locationpc))) {
            match[1] = match[1].toLowerCase();
            switch (match[1]) {
              case 'any-link':
                source = 'if(' + N + '(/^a|area$/i.test(e.localName)&&e.hasAttribute("href")||e.visited)){' + source + '}';
                break;
              case 'link':
                source = 'if(' + N + '(/^a|area$/i.test(e.localName)&&e.hasAttribute("href"))){' + source + '}';
                break;
              // FIXME:
              case 'visited':
                source = 'if(' + N + '(/^a|area$/i.test(e.localName)&&e.hasAttribute("href")&&e.visited)){' + source + '}';
                break;
              case 'target':
                source = 'if(s.isTarget(e)){' + source + '}';
                break;
              default:
                emit('\'' + selectorString + '\'' + qsInvalid);
            }
          // *** user interface and form pseudo-classes
          // :enabled, :disabled, :read-only, :read-write, :placeholder-shown, :default
          } else if ((match = selector.match(Patterns.inputstate))) {
            match[1] = match[1].toLowerCase();
            switch (match[1]) {
              // FIXME: lacks custom element support
              case 'enabled':
                source = 'if((("form" in e||/^optgroup$/i.test(e.localName))&&"disabled" in e &&e.disabled===false' +
                  ')){' + source + '}';
                break;
              // FIXME: lacks custom element support
              case 'disabled':
                // https://html.spec.whatwg.org/#enabling-and-disabling-form-controls:-the-disabled-attribute
                source = 'if((("form" in e||/^optgroup$/i.test(e.localName))&&"disabled" in e)){' +
                  // F is true if any of the fieldset elements in the ancestry chain has the disabled attribute specified
                  // L is true if the first legend element of the fieldset contains the element
                  'var x=0,N=[],F=false,L=false;' +
                  'if(!(/^(optgroup|option)$/i.test(e.localName))){' +
                    'n=e.parentElement;' +
                    'while(n){' +
                      'if(n.localName==="fieldset"){' +
                        'N[x++]=n;' +
                        'if(n.disabled===true){' +
                          'F=true;' +
                          'break;' +
                        '}' +
                      '}' +
                      'n=n.parentElement;' +
                    '}' +
                    'for(var x=0;x<N.length;x++){' +
                      'if((n=s.first("legend",N[x]))&&n.contains(e)){' +
                        'L=true;' +
                        'break;' +
                      '}' +
                    '}' +
                  '}' +
                  'if(e.disabled===true||(F&&!L)){' + source + '}}';
                break;
              case 'read-only':
                source =
                  'if(' +
                    '(/^textarea$/i.test(e.localName)&&(e.readOnly||e.disabled))||' +
                    '(/^input$/i.test(e.localName)&&("|date|datetime-local|email|month|number|password|search|tel|text|time|url|week|".includes("|"+e.type+"|")?(e.readOnly||e.disabled):true))||' +
                    '(!/^(?:input|textarea)$/i.test(e.localName) && !s.isContentEditable(e))' +
                  '){' + source + '}';
                break;
              case 'read-write':
                source =
                  'if(' +
                    '(/^textarea$/i.test(e.localName)&&!e.readOnly&&!e.disabled)||' +
                    '(/^input$/i.test(e.localName)&&"|date|datetime-local|email|month|number|password|search|tel|text|time|url|week|".includes("|"+e.type+"|")&&!e.readOnly&&!e.disabled)||' +
                    '(!/^(?:input|textarea)$/i.test(e.localName) && s.isContentEditable(e))' +
                  '){' + source + '}';
                break;
              // FIXME:
              case 'placeholder-shown':
                source =
                  'if((' +
                    '(/^input|textarea$/i.test(e.localName))&&e.hasAttribute("placeholder")&&' +
                    '("|textarea|password|number|search|email|text|tel|url|".includes("|"+e.type+"|"))&&' +
                    '(!s.match(":focus",e))' +
                  ')){' + source + '}';
                break;
              // FIXME:
              case 'default':
                source =
                  'if(("form" in e && e.form)){' +
                    'var x=0;n=[];' +
                    'if(e.type=="image")n=e.form.getElementsByTagName("input");' +
                    'if(e.type=="submit")n=e.form.elements;' +
                    'while(n[x]&&e!==n[x]){' +
                      'if(n[x].type=="image")break;' +
                      'if(n[x].type=="submit")break;' +
                      'x++;' +
                    '}' +
                  '}' +
                  'if((e.form&&(e===n[x]&&"|image|submit|".includes("|"+e.type+"|"))||' +
                    '((/^option$/i.test(e.localName))&&e.defaultSelected)||' +
                    '(("|radio|checkbox|".includes("|"+e.type+"|"))&&e.defaultChecked)' +
                  ')){' + source + '}';
                break;
              default:
                emit('\'' + selector_string + '\'' + qsInvalid);
                break;
            }
          // *** input pseudo-classes (for form validation)
          // :checked, :indeterminate, :valid, :invalid, :in-range, :out-of-range, :required, :optional
          } else if ((match = selector.match(Patterns.inputvalue))) {
            match[1] = match[1].toLowerCase();
            switch (match[1]) {
              case 'checked':
                source = 'if(' + N + '(/^input$/i.test(e.localName)&&' +
                  '("|radio|checkbox|".includes("|"+e.type+"|")&&e.checked)||' +
                  '(/^option$/i.test(e.localName)&&(e.selected||e.checked))' +
                  ')){' + source + '}';
                break;
              case 'indeterminate':
                source = 'if(s.isIndeterminate(e)){' + source + '}';
                break;
              // FIXME:
              case 'required':
                source =
                  'if(' + N +
                    '(/^input|select|textarea$/i.test(e.localName)&&e.required)' +
                  '){' + source + '}';
                break;
              // FIXME:
              case 'optional':
                source =
                  'if(' + N +
                    '(/^input|select|textarea$/i.test(e.localName)&&!e.required)' +
                  '){' + source + '}';
                break;
              // FIXME:
              case 'invalid':
                source =
                  'if(' + N + '((' +
                    '(/^form$/i.test(e.localName)&&!e.noValidate)||' +
                    '(e.willValidate&&!e.formNoValidate))&&!e.checkValidity())||' +
                    '(/^fieldset$/i.test(e.localName)&&s.first(":invalid",e))' +
                  '){' + source + '}';
                break;
              // FIXME:
              case 'valid':
                source =
                  'if(' + N + '((' +
                    '(/^form$/i.test(e.localName)&&!e.noValidate)||' +
                    '(e.willValidate&&!e.formNoValidate))&&e.checkValidity())||' +
                    '(/^fieldset$/i.test(e.localName)&&s.first(":valid",e))' +
                  '){' + source + '}';
                break;
              // FIXME:
              case 'in-range':
                source =
                  'if(' + N +
                    '(/^input$/i.test(e.localName))&&' +
                    '(e.willValidate&&!e.formNoValidate)&&' +
                    '(!e.validity.rangeUnderflow&&!e.validity.rangeOverflow)&&' +
                    '("|date|datetime-local|month|number|range|time|week|".includes("|"+e.type+"|"))&&' +
                    '("range"==e.type||e.getAttribute("min")||e.getAttribute("max"))' +
                  '){' + source + '}';
                break;
              // FIXME:
              case 'out-of-range':
                source =
                  'if(' + N +
                    '(/^input$/i.test(e.localName))&&' +
                    '(e.willValidate&&!e.formNoValidate)&&' +
                    '(e.validity.rangeUnderflow||e.validity.rangeOverflow)&&' +
                    '("|date|datetime-local|month|number|range|time|week|".includes("|"+e.type+"|"))&&' +
                    '("range"==e.type||e.getAttribute("min")||e.getAttribute("max"))' +
                  '){' + source + '}';
                break;
              default:
                emit('\'' + selectorString + '\'' + qsInvalid);
            }
          // allow pseudo-elements starting with single colon (:)
          // :after, :before, :first-letter, :first-line
          // assert: e.type is in double-colon format, like ::after
          } else if ((match = selector.match(Patterns.pseudoSng))) {
            source = 'if(e.element&&e.type.toLowerCase()=="' +
              ':' + match[0].toLowerCase() + '"){e=e.element;' + source + '}';
          // allow pseudo-elements starting with double colon (::)
          // ::after, ::before, ::marker, ::placeholder, ::inactive-selection, ::selection, ::-webkit-<foo-bar>
          // assert: e.type is in double-colon format, like ::after
          } else if ((match = selector.match(Patterns.pseudoDbl))) {
            source = 'if(e.element&&e.type.toLowerCase()=="' +
              match[0].toLowerCase() + '"){e=e.element;' + source + '}';
          // placeholder for parsed only no-op selectors
          } else if ((match = selector.match(Patterns.pseudoNop))) {
            source = 'if(' + N + 'false' + '){' + source + '}';
          } else {
            // reset
            expr = false;
            status = false;
            // process registered selector extensions
            for (expr in Selectors) {
              if ((match = selector.match(Selectors[expr].Expression))) {
                result = Selectors[expr].Callback(match, source, mode, callback);
                if ('match' in result) {
                  match = result.match;
                }
                vars = result.modvar;
                if (mode) {
                  // add extra select() vars
                  vars && !S_VARS.includes(vars) && S_VARS.push(vars);
                } else {
                  // add extra match() vars
                  vars && M_VARS.includes(vars) && M_VARS.push(vars);
                }
                // extension source code
                source = result.source;
                // extension status code
                status = result.status;
                // break on status error
                if (status) { break; }
              }
            }
            if (!status) {
              emit('unknown pseudo-class selector \'' + selector + '\'');
              return '';
            }
            if (!expr) {
              emit('unknown token in selector \'' + selector + '\'');
              return '';
            }
          }
          break;
        default:
          selectorRecursion = false;
          emit('\'' + selectorString + '\'' + qsInvalid);
      }
      // end of switch symbol
      if (!selectorRecursion) {
        break;
      }
      if (!match) {
        emit('\'' + selectorString + '\'' + qsInvalid);
        return '';
      }

      // pop last component
      selector = match.pop();
    }
    // end of while selector

    return source;
  };

  // compile groups or single selector strings into
  // executable functions for matching or selecting
  const compile = function (selector, mode, callback) {
    let head = ''; let loop = ''; let macro = ''; let source = ''; let vars = '';

    // 'mode' can be boolean or null
    // true = select / false = match
    // null to use collection.item()
    switch (mode) {
      case true:
        if (selectLambdas[selector]) {
          return selectLambdas[selector];
        }
        macro = S_BODY + (callback ? S_TEST : '') + S_TAIL;
        head = S_HEAD;
        loop = S_LOOP;
        break;
      case false:
        if (matchLambdas[selector]) {
          return matchLambdas[selector];
        }
        macro = M_BODY + (callback ? M_TEST : '') + M_TAIL;
        head = M_HEAD;
        loop = M_LOOP;
        break;
      case null:
        if (selectLambdas[selector]) {
          return selectLambdas[selector];
        }
        macro = N_BODY + (callback ? N_TEST : '') + S_TAIL;
        head = S_HEAD;
        loop = N_LOOP;
        break;
      default:
    }

    source = compileSelector(selector, macro, mode, callback);

    loop += (mode || mode === null) ? '{' + source + '}' : source;

    if ((mode || mode === null) && selector.includes(':nth')) {
      loop += reNthElem.test(selector) ? 's.nthElement(null, 2);' : '';
      loop += reNthType.test(selector) ? 's.nthOfType(null, 2);' : '';
    }

    if (S_VARS[0] || M_VARS[0]) {
      vars = ',' + (S_VARS.join(',') || M_VARS.join(','));
      S_VARS = [];
      M_VARS = [];
    }

    const factory = Function('s', F_INIT + '{' + head + vars + ';' + loop + 'return r;}')(Snapshot);

    return mode || mode === null ? (selectLambdas[selector] = factory) : (matchLambdas[selector] = factory);
  };

  // optimize selectors avoiding duplicated checks
  const optimize = function (selector, token) {
    const index = token.index;
    const length = token[1].length + token[2].length;
    return selector.slice(0, index) +
      (' >+~'.indexOf(selector.charAt(index - 1)) > -1
        ? (':['.indexOf(selector.charAt(index + length + 1)) > -1
            ? '*'
            : '')
        : '') + selector.slice(index + length - (token[1] === '*' ? 1 : 0));
  };

  // prepare factory resolvers and closure collections
  const collect = function (selectors, context, callback) {
    let i;
    let l;
    const seen = { };
    let token = ['', '*', '*'];
    const optimized = selectors;
    const factory = [];
    const htmlset = [];
    const nodeset = [];
    let results = [];
    let type;

    for (i = 0, l = selectors.length; l > i; ++i) {
      if (!seen[selectors[i]] && (seen[selectors[i]] = true)) {
        type = selectors[i].match(reOptimizer);
        if (type && type[1] !== ':' && (token = type)) {
          token[1] || (token[1] = '*');
          optimized[i] = optimize(optimized[i], token);
        } else {
          token = ['', '*', '*'];
        }
      }

      nodeset[i] = token[1] + token[2];
      htmlset[i] = compat[token[1]](context, token[2]);
      factory[i] = compile(optimized[i], true, null);

      factory[i]
        ? factory[i](htmlset[i](), callback, context, results)
        : results.concat(htmlset[i]());
    }

    if (l > 1) {
      results.sort(documentOrder);
      hasDupes && (results = unique(results));
    }

    return {
      callback,
      context,
      factory,
      htmlset,
      nodeset,
      results
    };
  };

  // replace ':scope' pseudo-class with element references
  const makeref = function (selectors, element) {
    // DOCUMENT_NODE (9)
    if (element.nodeType === 9) {
      element = element.documentElement;
    }

    return selectors.replace(/:scope/gi,
      element.localName +
        (element.id ? '#' + element.id : '') +
        (element.className ? '.' + element.classList[0] : ''));
  };

  const matchAssert = function (f, element, callback) {
    let r = false;
    for (let i = 0, l = f.length; l > i; ++i) {
      f[i](element, callback, null, false) && (r = true);
    }
    return r;
  };

  const matchCollect = function (selectors, callback) {
    const f = [];
    for (let i = 0, l = selectors.length; l > i; ++i) {
      f[i] = compile(selectors[i], false, callback);
    }
    return { factory: f };
  };

  // equivalent of w3c 'matches' method
  const match = function _matches(selectors, element, callback) {
    let expressions;

    if (element && !/:has\(/.test(selectors) && matchResolvers[selectors]) {
      return matchAssert(matchResolvers[selectors].factory, element, callback);
    }

    lastMatched = selectors;

    // arguments validation
    if (arguments.length === 0) {
      emit(qsNotArgs, 'TypeError');
      return Config.VERBOSITY ? undefined : false;
    } else if (arguments[0] === '') {
      emit('\'\'' + qsInvalid);
      return Config.VERBOSITY ? undefined : false;
    }

    // input NULL or UNDEFINED
    if (typeof selectors !== 'string') {
      selectors = '' + selectors;
    }

    if ((/:scope/i).test(selectors)) {
      selectors = makeref(selectors, element);
    }

    // normalize input string
    const parsed = selectors
      .replace(/\0|\\$/g, '\ufffd')
      .replace(REX.combineWSP, '\x20')
      .replace(REX.pseudosWSP, '$1')
      .replace(REX.tabCharWSP, '\t')
      .replace(REX.commaGroup, ',')
      .replace(REX.trimSpaces, '');

    // parse, validate and split possible compound selectors
    if ((expressions = parsed.match(reValidator)) && expressions.join('') === parsed) {
      expressions = parsed.match(REX.splitGroup);
      if (parsed[parsed.length - 1] === ',') {
        emit(qsInvalid);
        return Config.VERBOSITY ? undefined : false;
      }
    } else {
      emit('\'' + selectors + '\'' + qsInvalid);
      return Config.VERBOSITY ? undefined : false;
    }

    matchResolvers[selectors] = matchCollect(expressions, callback);

    return matchAssert(matchResolvers[selectors].factory, element, callback);
  };

  // equivalent of w3c 'closest' method
  const ancestor = function _closest(selectors, element, callback) {
    if ((/:scope/i).test(selectors)) {
      selectors = makeref(selectors, element);
    }

    while (element) {
      if (match(selectors, element, callback)) break;
      element = element.parentElement;
    }
    return element;
  };

  // equivalent of w3c 'querySelectorAll' method
  const select = function _querySelectorAll(selectors, context, callback) {
    let expressions; let nodes = []; let resolver;

    context || (context = doc);

    if (selectors) {
      if ((resolver = selectResolvers[selectors])) {
        if (resolver.context === context && resolver.callback === callback) {
          const f = resolver.factory;
          const h = resolver.htmlset;
          const n = resolver.nodeset;
          if (n.length > 1) {
            const l = n.length;
            for (let i = 0, l = n.length, list; l > i; ++i) {
              list = compat[n[i][0]](context, n[i].slice(1))();
              if (f[i] !== null) {
                f[i](list, callback, context, nodes);
              } else {
                nodes = nodes.concat(list);
              }
            }
            if (l > 1 && nodes.length > 1) {
              nodes.sort(documentOrder);
              hasDupes && (nodes = unique(nodes));
            }
          } else {
            if (f[0]) {
              nodes = f[0](h[0](), callback, context, nodes);
            } else {
              nodes = h[0]();
            }
          }
          return typeof callback === 'function'
            ? concatCall(nodes, callback)
            : nodes;
        }
      }
    }

    lastSelected = selectors;

    // arguments validation
    if (arguments.length === 0) {
      emit(qsNotArgs, 'TypeError');
      return Config.VERBOSITY ? undefined : none;
    } else if (arguments[0] === '') {
      emit('\'\'' + qsInvalid);
      return Config.VERBOSITY ? undefined : none;
    } else if (lastContext !== context) {
      lastContext = switchContext(context);
    }

    // input NULL or UNDEFINED
    if (typeof selectors !== 'string') {
      selectors = '' + selectors;
    }

    if ((/:scope/i).test(selectors)) {
      selectors = makeref(selectors, context);
    }

    // normalize input string
    const parsed = selectors
      .replace(/\0|\\$/g, '\ufffd')
      .replace(REX.combineWSP, '\x20')
      .replace(REX.pseudosWSP, '$1')
      .replace(REX.tabCharWSP, '\t')
      .replace(REX.commaGroup, ',')
      .replace(REX.trimSpaces, '');

    // parse, validate and split possible compound selectors
    if ((expressions = parsed.match(reValidator)) && expressions.join('') === parsed) {
      expressions = parsed.match(REX.splitGroup);
      if (parsed[parsed.length - 1] === ',') {
        emit(qsInvalid);
        return Config.VERBOSITY ? undefined : false;
      }
    } else {
      emit('\'' + selectors + '\'' + qsInvalid);
      return Config.VERBOSITY ? undefined : false;
    }

    // save/reuse factory and closure collection
    selectResolvers[selectors] = collect(expressions, context, callback);

    nodes = selectResolvers[selectors].results;

    return typeof callback === 'function'
      ? concatCall(nodes, callback)
      : nodes;
  };

  // equivalent of w3c 'querySelector' method
  const first = function _querySelector(selectors, context, callback) {
    if (arguments.length === 0) {
      emit(qsNotArgs, 'TypeError');
    }
    return select(selectors, context, typeof callback === 'function'
      ? function firstMatch(element) {
        callback(element);
        return false;
      }
      : function firstMatch() {
        return false;
      }
    )[0] || null;
  };

  // execute the engine initialization code
  const initialize = function (d) {
    setIdentifierSyntax();
    lastContext = switchContext(d, true);
    Snapshot.doc = doc;
    Snapshot.from = doc;
    Snapshot.byTag = byTag;
    Snapshot.first = first;
    Snapshot.match = match;
    Snapshot.ancestor = ancestor;
    Snapshot.nthOfType = nthOfType;
    Snapshot.nthElement = nthElement;
    Snapshot.hasAttributeNS = hasAttributeNS;
    Snapshot.isTarget = isTarget;
    Snapshot.isIndeterminate = isIndeterminate;
    Snapshot.isContentEditable = isContentEditable;
  };

  initialize(doc);

  // public exported methods/objects
  const Dom = {
    // exported engine methods
    Version: version,
    configure,
    match,
    closest: ancestor,
    first,
    select
  };

  return Dom;
});