axe-core 4.2.4 → 4.3.0

package/lib/core/utils/matches.js

@@ -1,263 +0,0 @@
-import cssParser from './css-parser';
-
-function matchesTag(vNode, exp) {
-  return (
-    vNode.props.nodeType === 1 &&
-    (exp.tag === '*' || vNode.props.nodeName === exp.tag)
-  );
-}
-
-function matchesClasses(vNode, exp) {
-  return !exp.classes || exp.classes.every(cl => vNode.hasClass(cl.value));
-}
-
-function matchesAttributes(vNode, exp) {
-  return (
-    !exp.attributes ||
-    exp.attributes.every(att => {
-      var nodeAtt = vNode.attr(att.key);
-      return nodeAtt !== null && (!att.value || att.test(nodeAtt));
-    })
-  );
-}
-
-function matchesId(vNode, exp) {
-  return !exp.id || vNode.props.id === exp.id;
-}
-
-function matchesPseudos(target, exp) {
-  if (
-    !exp.pseudos ||
-    exp.pseudos.every(pseudo => {
-      if (pseudo.name === 'not') {
-        return !pseudo.expressions.some(expression => {
-          return matchesExpression(target, expression);
-        });
-      } else if (pseudo.name === 'is') {
-        return pseudo.expressions.some(expression => {
-          return matchesExpression(target, expression);
-        });
-      }
-      throw new Error(
-        'the pseudo selector ' + pseudo.name + ' has not yet been implemented'
-      );
-    })
-  ) {
-    return true;
-  }
-  return false;
-}
-
-function matchExpression(vNode, expression) {
-  return (
-    matchesTag(vNode, expression) &&
-    matchesClasses(vNode, expression) &&
-    matchesAttributes(vNode, expression) &&
-    matchesId(vNode, expression) &&
-    matchesPseudos(vNode, expression)
-  );
-}
-
-var escapeRegExp = (() => {
-  /*! Credit: XRegExp 0.6.1 (c) 2007-2008 Steven Levithan <http://stevenlevithan.com/regex/xregexp/> MIT License */
-  var from = /(?=[\-\[\]{}()*+?.\\\^$|,#\s])/g;
-  var to = '\\';
-  return string => {
-    return string.replace(from, to);
-  };
-})();
-
-const reUnescape = /\\/g;
-function convertAttributes(atts) {
-  /*! Credit Mootools Copyright Mootools, MIT License */
-  if (!atts) {
-    return;
-  }
-  return atts.map(att => {
-    const attributeKey = att.name.replace(reUnescape, '');
-    const attributeValue = (att.value || '').replace(reUnescape, '');
-    let test, regexp;
-
-    switch (att.operator) {
-      case '^=':
-        regexp = new RegExp('^' + escapeRegExp(attributeValue));
-        break;
-      case '$=':
-        regexp = new RegExp(escapeRegExp(attributeValue) + '$');
-        break;
-      case '~=':
-        regexp = new RegExp(
-          '(^|\\s)' + escapeRegExp(attributeValue) + '(\\s|$)'
-        );
-        break;
-      case '|=':
-        regexp = new RegExp('^' + escapeRegExp(attributeValue) + '(-|$)');
-        break;
-      case '=':
-        test = value => {
-          return attributeValue === value;
-        };
-        break;
-      case '*=':
-        test = value => {
-          return value && value.includes(attributeValue);
-        };
-        break;
-      case '!=':
-        test = value => {
-          return attributeValue !== value;
-        };
-        break;
-      default:
-        test = value => {
-          return !!value;
-        };
-    }
-
-    if (attributeValue === '' && /^[*$^]=$/.test(att.operator)) {
-      test = () => {
-        return false;
-      };
-    }
-
-    if (!test) {
-      test = value => {
-        return value && regexp.test(value);
-      };
-    }
-    return {
-      key: attributeKey,
-      value: attributeValue,
-      test: test
-    };
-  });
-}
-
-function convertClasses(classes) {
-  if (!classes) {
-    return;
-  }
-  return classes.map(className => {
-    className = className.replace(reUnescape, '');
-
-    return {
-      value: className,
-      regexp: new RegExp('(^|\\s)' + escapeRegExp(className) + '(\\s|$)')
-    };
-  });
-}
-
-function convertPseudos(pseudos) {
-  if (!pseudos) {
-    return;
-  }
-  return pseudos.map(p => {
-    var expressions;
-
-    if (['is', 'not'].includes(p.name)) {
-      expressions = p.value;
-      expressions = expressions.selectors
-        ? expressions.selectors
-        : [expressions];
-      expressions = convertExpressions(expressions);
-    }
-    return {
-      name: p.name,
-      expressions: expressions,
-      value: p.value
-    };
-  });
-}
-
-/**
- * convert the css-selector-parser format into the Slick format
- * @private
- * @param Array {Object} expressions
- * @return Array {Object}
- *
- */
-function convertExpressions(expressions) {
-  return expressions.map(exp => {
-    var newExp = [];
-    var rule = exp.rule;
-    while (rule) {
-      /* eslint no-restricted-syntax: 0 */
-      // `.tagName` is a property coming from the `CSSSelectorParser` library
-      newExp.push({
-        tag: rule.tagName ? rule.tagName.toLowerCase() : '*',
-        combinator: rule.nestingOperator ? rule.nestingOperator : ' ',
-        id: rule.id,
-        attributes: convertAttributes(rule.attrs),
-        classes: convertClasses(rule.classNames),
-        pseudos: convertPseudos(rule.pseudos)
-      });
-      rule = rule.rule;
-    }
-    return newExp;
-  });
-}
-
-/**
- * Convert a CSS selector to the Slick format expression
- *
- * @private
- * @param {String} selector CSS selector to convert
- * @returns {Object[]} Array of Slick format expressions
- */
-export function convertSelector(selector) {
-  var expressions = cssParser.parse(selector);
-  expressions = expressions.selectors ? expressions.selectors : [expressions];
-  return convertExpressions(expressions);
-}
-
-/**
- * Determine if a virtual node matches a Slick format CSS expression
- *
- * @private
- * @method matchesExpression
- * @memberof axe.utils
- * @param {VirtualNode} vNode VirtualNode to match
- * @param {Object|Object[]} expressions CSS selector expression or array of expressions
- * @returns {Boolean}
- */
-export function matchesExpression(vNode, expressions, matchAnyParent) {
-  const exps = [].concat(expressions);
-  const expression = exps.pop();
-  let matches = matchExpression(vNode, expression);
-
-  while (!matches && matchAnyParent && vNode.parent) {
-    vNode = vNode.parent;
-    matches = matchExpression(vNode, expression);
-  }
-
-  if (exps.length) {
-    if ([' ', '>'].includes(expression.combinator) === false) {
-      throw new Error(
-        'axe.utils.matchesExpression does not support the combinator: ' +
-          expression.combinator
-      );
-    }
-
-    matches =
-      matches &&
-      matchesExpression(vNode.parent, exps, expression.combinator === ' ');
-  }
-
-  return matches;
-}
-
-/**
- * matches implementation that operates on a VirtualNode
- *
- * @method matches
- * @memberof axe.utils
- * @param {VirtualNode} vNode VirtualNode to match
- * @param {String} selector CSS selector string
- * @return {Boolean}
- */
-function matches(vNode, selector) {
-  const expressions = convertSelector(selector);
-  return expressions.some(expression => matchesExpression(vNode, expression));
-}
-
-export default matches;

package/lib/core/utils/memoize.js

@@ -1,22 +0,0 @@
-import memoize from 'memoizee';
-
-/**
- * Memoize a function.
- * @method memoize
- * @memberof axe.utils
- * @param {Function} fn Function to memoize
- * @return {Function}
- */
-// TODO: es-modules._memoziedFns
-axe._memoizedFns = [];
-function memoizeImplementation(fn) {
-  // keep track of each function that is memoized so it can be cleared at
-  // the end of a run. each memoized function has its own cache, so there is
-  // no method to clear all memoized caches. instead, we have to clear each
-  // individual memoized function ourselves.
-  const memoized = memoize(fn);
-  axe._memoizedFns.push(memoized);
-  return memoized;
-}
-
-export default memoizeImplementation;

package/lib/core/utils/merge-results.js

@@ -1,134 +0,0 @@
-import DqElement from './dq-element';
-import getAllChecks from './get-all-checks';
-import findBy from './find-by';
-
-/**
- * Adds the owning frame's CSS selector onto each instance of DqElement
- * @private
- * @param	{Array} resultSet `nodes` array on a `RuleResult`
- * @param	{HTMLElement} frameElement	The frame element
- * @param	{String} frameSelector		 Unique CSS selector for the frame
- */
-function pushFrame(resultSet, dqFrame, options) {
-  resultSet.forEach(res => {
-    res.node = DqElement.fromFrame(res.node, options, dqFrame);
-    const checks = getAllChecks(res);
-
-    checks.forEach(check => {
-      check.relatedNodes = check.relatedNodes.map(node =>
-        DqElement.fromFrame(node, options, dqFrame)
-      );
-    });
-  });
-}
-
-/**
- * Adds `to` to `from` and then re-sorts by DOM order
- * @private
- * @param	{Array} target	`nodes` array on a `RuleResult`
- * @param	{Array} to	 `nodes` array on a `RuleResult`
- * @return {Array}			The merged and sorted result
- */
-function spliceNodes(target, to) {
-  const firstFromFrame = to[0].node;
-  for (let i = 0; i < target.length; i++) {
-    const node = target[i].node;
-    const resultSort = nodeIndexSort(
-      node.nodeIndexes,
-      firstFromFrame.nodeIndexes
-    );
-    if (
-      resultSort > 0 ||
-      (resultSort === 0 &&
-        firstFromFrame.selector.length < node.selector.length)
-    ) {
-      target.splice(i, 0, ...to);
-      return;
-    }
-  }
-  target.push(...to);
-}
-
-function normalizeResult(result) {
-  if (!result || !result.results) {
-    return null;
-  }
-
-  if (!Array.isArray(result.results)) {
-    return [result.results];
-  }
-
-  if (!result.results.length) {
-    return null;
-  }
-
-  return result.results;
-}
-
-/**
- * Merges one or more RuleResults (possibly from different frames) into one RuleResult
- * @private
- * @param	{Array} frameResults	Array of objects including the RuleResults as `results` and frame as `frame`
- * @return {Array}							The merged RuleResults; should only have one result per rule
- */
-function mergeResults(frameResults, options) {
-  const mergedResult = [];
-  frameResults.forEach(frameResult => {
-    const results = normalizeResult(frameResult);
-    if (!results || !results.length) {
-      return;
-    }
-
-    let dqFrame;
-    if (frameResult.frameElement) {
-      const spec = { selector: [frameResult.frame] };
-      dqFrame = new DqElement(frameResult.frameElement, options, spec);
-    }
-
-    results.forEach(ruleResult => {
-      if (ruleResult.nodes && dqFrame) {
-        pushFrame(ruleResult.nodes, dqFrame, options);
-      }
-
-      var res = findBy(mergedResult, 'id', ruleResult.id);
-      if (!res) {
-        mergedResult.push(ruleResult);
-      } else {
-        if (ruleResult.nodes.length) {
-          spliceNodes(res.nodes, ruleResult.nodes);
-        }
-      }
-    });
-  });
-
-  // Sort results in DOM order
-  mergedResult.forEach(result => {
-    if (result.nodes) {
-      result.nodes.sort((nodeA, nodeB) => {
-        return nodeIndexSort(nodeA.node.nodeIndexes, nodeB.node.nodeIndexes);
-      });
-    }
-  });
-  return mergedResult;
-}
-
-function nodeIndexSort(nodeIndexesA = [], nodeIndexesB = []) {
-  const length = Math.max(nodeIndexesA?.length, nodeIndexesB?.length);
-  for (let i = 0; i < length; i++) {
-    const indexA = nodeIndexesA?.[i];
-    const indexB = nodeIndexesB?.[i];
-    if (typeof indexA !== 'number' || isNaN(indexA)) {
-      // Empty arrays go at the end, otherwise shortest array first
-      return i === 0 ? 1 : -1;
-    }
-    if (typeof indexB !== 'number' || isNaN(indexB)) {
-      return i === 0 ? -1 : 1;
-    }
-    if (indexA !== indexB) {
-      return indexA - indexB;
-    }
-  }
-  return 0;
-}
-
-export default mergeResults;

package/lib/core/utils/node-sorter.js

@@ -1,23 +0,0 @@
-/**
- * Array#sort callback to sort nodes by DOM order
- * @private
- * @param  {Node} nodeA
- * @param  {Node} nodeB
- * @return {Integer}   @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Sort
- */
-function nodeSorter(nodeA, nodeB) {
-  /*eslint no-bitwise: 0 */
-  nodeA = nodeA.actualNode || nodeA;
-  nodeB = nodeB.actualNode || nodeB;
-  if (nodeA === nodeB) {
-    return 0;
-  }
-
-  if (nodeA.compareDocumentPosition(nodeB) & 4) {
-    return -1; // a before b
-  } else {
-    return 1; // b before a
-  }
-}
-
-export default nodeSorter;

package/lib/core/utils/parse-crossorigin-stylesheet.js

@@ -1,66 +0,0 @@
-import parseStylesheet from './parse-stylesheet';
-import constants from '../constants';
-
-/**
- * Parse cross-origin stylesheets
- *
- * @method parseCrossOriginStylesheet
- * @memberof axe.utils
- * @param {String} url url from which to fetch stylesheet
- * @param {Object} options options object from `axe.utils.parseStylesheet`
- * @param {Array<Number>} priority sheet priority
- * @param {Array<String>} importedUrls urls of already imported stylesheets
- * @param {Boolean} isCrossOrigin boolean denoting if a stylesheet is `cross-origin`
- * @returns {Promise}
- */
-function parseCrossOriginStylesheet(
-  url,
-  options,
-  priority,
-  importedUrls,
-  isCrossOrigin
-) {
-  /**
-   * Add `url` to `importedUrls`
-   */
-  importedUrls.push(url);
-
-  return new Promise((resolve, reject) => {
-    const request = new XMLHttpRequest();
-    request.open('GET', url);
-
-    request.timeout = constants.preload.timeout;
-    request.addEventListener('error', reject);
-    request.addEventListener('timeout', reject);
-    request.addEventListener('loadend', event => {
-      if (event.loaded && request.responseText) {
-        return resolve(request.responseText);
-      }
-
-      reject(request.responseText);
-    });
-
-    request.send();
-  }).then(data => {
-    const result = options.convertDataToStylesheet({
-      data,
-      isCrossOrigin,
-      priority,
-      root: options.rootNode,
-      shadowId: options.shadowId
-    });
-
-    /**
-     * Parse resolved stylesheet further for any `@import` styles
-     */
-    return parseStylesheet(
-      result.sheet,
-      options,
-      priority,
-      importedUrls,
-      result.isCrossOrigin
-    );
-  });
-}
-
-export default parseCrossOriginStylesheet;

package/lib/core/utils/parse-sameorigin-stylesheet.js

@@ -1,100 +0,0 @@
-import parseCrossOriginStylesheet from './parse-crossorigin-stylesheet';
-
-/**
- * Parse non cross-origin stylesheets
- *
- * @method parseSameOriginStylesheet
- * @memberof axe.utils
- * @param {Object} sheet CSSStylesheet object
- * @param {Object} options options object from `axe.utils.parseStylesheet`
- * @param {Array<Number>} priority sheet priority
- * @param {Array<String>} importedUrls urls of already imported stylesheets
- * @param {Boolean} isCrossOrigin boolean denoting if a stylesheet is `cross-origin`
- * @returns {Promise}
- */
-function parseSameOriginStylesheet(
-  sheet,
-  options,
-  priority,
-  importedUrls,
-  isCrossOrigin = false
-) {
-  const rules = Array.from(sheet.cssRules);
-
-  if (!rules) {
-    return Promise.resolve();
-  }
-
-  /**
-   * reference -> https://developer.mozilla.org/en-US/docs/Web/API/CSSRule#Type_constants
-   */
-  const cssImportRules = rules.filter(r => r.type === 3); // type === 3 -> CSSRule.IMPORT_RULE
-
-  /**
-   * when no `@import` rules in given sheet -> resolve the current `sheet` & exit
-   */
-  if (!cssImportRules.length) {
-    // exit
-    return Promise.resolve({
-      isCrossOrigin,
-      priority,
-      root: options.rootNode,
-      shadowId: options.shadowId,
-      sheet
-    });
-  }
-
-  /**
-   * filter rules that are not already fetched
-   */
-  const cssImportUrlsNotAlreadyImported = cssImportRules
-    // ensure rule has a href
-    .filter(rule => rule.href)
-    // extract href from object
-    .map(rule => rule.href)
-    // only href that are not already imported
-    .filter(url => !importedUrls.includes(url));
-
-  /**
-   * iterate `@import` rules and fetch styles
-   */
-  const promises = cssImportUrlsNotAlreadyImported.map(
-    (importUrl, cssRuleIndex) => {
-      const newPriority = [...priority, cssRuleIndex];
-      const isCrossOriginRequest = /^https?:\/\/|^\/\//i.test(importUrl);
-
-      return parseCrossOriginStylesheet(
-        importUrl,
-        options,
-        newPriority,
-        importedUrls,
-        isCrossOriginRequest
-      );
-    }
-  );
-
-  const nonImportCSSRules = rules.filter(r => r.type !== 3);
-
-  // no further rules to process in this sheet
-  if (!nonImportCSSRules.length) {
-    return Promise.all(promises);
-  }
-
-  // convert all `nonImportCSSRules` style rules into `text` and chain
-
-  promises.push(
-    Promise.resolve(
-      options.convertDataToStylesheet({
-        data: nonImportCSSRules.map(rule => rule.cssText).join(),
-        isCrossOrigin,
-        priority,
-        root: options.rootNode,
-        shadowId: options.shadowId
-      })
-    )
-  );
-
-  return Promise.all(promises);
-}
-
-export default parseSameOriginStylesheet;

package/lib/core/utils/parse-stylesheet.js

@@ -1,75 +0,0 @@
-import parseSameOriginStylesheet from './parse-sameorigin-stylesheet';
-import parseCrossOriginStylesheet from './parse-crossorigin-stylesheet';
-
-/**
- * Parse a given stylesheet
- *
- * @method parseStylesheet
- * @memberof axe.utils
- * @param {Object} sheet stylesheet to parse
- * @param {Object} options configuration options object from `parseStylesheets`
- * @param {Array<Number>} priority priority of stylesheet
- * @param {Array<String>} importedUrls list of resolved `@import` urls
- * @param {Boolean} isCrossOrigin boolean denoting if a stylesheet is `cross-origin`, passed for re-parsing `cross-origin` sheets
- * @returns {Promise}
- */
-function parseStylesheet(
-  sheet,
-  options,
-  priority,
-  importedUrls,
-  isCrossOrigin = false
-) {
-  const isSameOrigin = isSameOriginStylesheet(sheet);
-  if (isSameOrigin) {
-    /**
-     * resolve `same-origin` stylesheet
-     */
-    return parseSameOriginStylesheet(
-      sheet,
-      options,
-      priority,
-      importedUrls,
-      isCrossOrigin
-    );
-  }
-
-  /**
-   * resolve `cross-origin` stylesheet
-   */
-  return parseCrossOriginStylesheet(
-    sheet.href,
-    options,
-    priority,
-    importedUrls,
-    true // -> isCrossOrigin
-  );
-}
-
-/**
- * Check if a given stylesheet is from the `same-origin`
- * Note:
- * `sheet.cssRules` throws an error on `cross-origin` stylesheets
- *
- * @param {Object} sheet CSS stylesheet
- * @returns {Boolean}
- */
-function isSameOriginStylesheet(sheet) {
-  try {
-    /*eslint no-unused-vars: 0*/
-    const rules = sheet.cssRules;
-
-    /**
-     * Safari, does not throw an error when accessing cssRules property,
-     */
-    if (!rules && sheet.href) {
-      return false;
-    }
-
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-export default parseStylesheet;