axe-core 4.1.2-canary.ec00dc7 → 4.1.2

package/lib/commons/text/is-icon-ligature.js

@@ -14,201 +14,201 @@ import cache from '../../core/base/cache';
  * @return {Boolean}
  */
 function isIconLigature(
-  textVNode,
-  differenceThreshold = 0.15,
-  occuranceThreshold = 3
+	textVNode,
+	differenceThreshold = 0.15,
+	occuranceThreshold = 3
 ) {
-  /**
-   * Determine if the visible text is a ligature by comparing the
-   * first letters image data to the entire strings image data.
-   * If the two images are significantly different (typical set to 5%
-   * statistical significance, but we'll be using a slightly higher value
-   * of 15% to help keep the size of the canvas down) then we know the text
-   * has been replaced by a ligature.
-   *
-   * Example:
-   * If a text node was the string "File", looking at just the first
-   * letter "F" would produce the following image:
-   *
-   * ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
-   * │ │ │█│█│█│█│█│█│█│█│█│█│█│ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │ │█│█│█│█│█│█│█│█│█│█│█│ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │ │█│█│█│█│█│█│█│ │ │ │ │ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │ │█│█│█│█│█│█│█│ │ │ │ │ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
-   * └─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
-   *
-   * But if the entire string "File" produced an image which had at least
-   * a 15% difference in pixels, we would know that the string was replaced
-   * by a ligature:
-   *
-   * ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
-   * │ │█│█│█│█│█│█│█│█│█│█│ │ │ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │█│ │ │ │ │ │ │ │ │█│█│ │ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │█│ │█│█│█│█│█│█│ │█│ │█│ │ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │█│ │ │ │ │ │ │ │ │█│█│█│█│ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │█│ │█│█│█│█│█│█│ │ │ │ │█│ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │█│ │ │ │ │ │ │ │ │ │ │ │█│ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │█│ │█│█│█│█│█│█│█│█│█│ │█│ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │█│ │ │ │ │ │ │ │ │ │ │ │█│ │
-   * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
-   * │ │█│█│█│█│█│█│█│█│█│█│█│█│█│ │
-   * └─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
-   */
-  const nodeValue = textVNode.actualNode.nodeValue.trim();
-
-  // text with unicode or non-bmp letters cannot be ligature icons
-  if (
-    !sanitize(nodeValue) ||
-    hasUnicode(nodeValue, { emoji: true, nonBmp: true })
-  ) {
-    return false;
-  }
-
-  if (!cache.get('canvasContext')) {
-    cache.set(
-      'canvasContext',
-      document.createElement('canvas').getContext('2d')
-    );
-  }
-  const canvasContext = cache.get('canvasContext');
-  const canvas = canvasContext.canvas;
-
-  // keep track of each font encountered and the number of times it shows up
-  // as a ligature.
-  if (!cache.get('fonts')) {
-    cache.set('fonts', {});
-  }
-  const fonts = cache.get('fonts');
-
-  const style = window.getComputedStyle(textVNode.parent.actualNode);
-  const fontFamily = style.getPropertyValue('font-family');
-
-  if (!fonts[fontFamily]) {
-    fonts[fontFamily] = {
-      occurances: 0,
-      numLigatures: 0
-    };
-  }
-  const font = fonts[fontFamily];
-
-  // improve the performance by only comparing the image data of a font
-  // a certain number of times
-  if (font.occurances >= occuranceThreshold) {
-    // if the font has always been a ligature assume it's a ligature font
-    if (font.numLigatures / font.occurances === 1) {
-      return true;
-    }
-    // inversely, if it's never been a ligature assume it's not a ligature font
-    else if (font.numLigatures === 0) {
-      return false;
-    }
-
-    // we could theoretically get into an odd middle ground scenario in which
-    // the font family is being used as normal text sometimes and as icons
-    // other times. in these cases we would need to always check the text
-    // to know if it's an icon or not
-  }
-  font.occurances++;
-
-  // 30px was chosen to account for common ligatures in normal fonts
-  // such as fi, ff, ffi. If a ligature would add a single column of
-  // pixels to a 30x30 grid, it would not meet the statistical significance
-  // threshold of 15% (30x30 = 900; 30/900 = 3.333%). this also allows for
-  // more than 1 column differences (60/900 = 6.666%) and things like
-  // extending the top of the f in the fi ligature.
-  let fontSize = 30;
-  let fontStyle = `${fontSize}px ${fontFamily}`;
-
-  // set the size of the canvas to the width of the first letter
-  canvasContext.font = fontStyle;
-  const firstChar = nodeValue.charAt(0);
-  let width = canvasContext.measureText(firstChar).width;
-
-  // ensure font meets the 30px width requirement (30px font-size doesn't
-  // necessarily mean its 30px wide when drawn)
-  if (width < 30) {
-    const diff = 30 / width;
-    width *= diff;
-    fontSize *= diff;
-    fontStyle = `${fontSize}px ${fontFamily}`;
-  }
-  canvas.width = width;
-  canvas.height = fontSize;
-
-  // changing the dimensions of a canvas resets all properties (include font)
-  // and clears it
-  canvasContext.font = fontStyle;
-  canvasContext.textAlign = 'left';
-  canvasContext.textBaseline = 'top';
-  canvasContext.fillText(firstChar, 0, 0);
-  const compareData = new Uint32Array(
-    canvasContext.getImageData(0, 0, width, fontSize).data.buffer
-  );
-
-  // if the font doesn't even have character data for a single char then
-  // it has to be an icon ligature (e.g. Material Icon)
-  if (!compareData.some(pixel => pixel)) {
-    font.numLigatures++;
-    return true;
-  }
-
-  canvasContext.clearRect(0, 0, width, fontSize);
-  canvasContext.fillText(nodeValue, 0, 0);
-  const compareWith = new Uint32Array(
-    canvasContext.getImageData(0, 0, width, fontSize).data.buffer
-  );
-
-  // calculate the number of differences between the first letter and the
-  // entire string, ignoring color differences
-  const differences = compareData.reduce((diff, pixel, i) => {
-    if (pixel === 0 && compareWith[i] === 0) {
-      return diff;
-    }
-    if (pixel !== 0 && compareWith[i] !== 0) {
-      return diff;
-    }
-    return ++diff;
-  }, 0);
-
-  // calculate the difference between the width of each character and the
-  // combined with of all characters
-  const expectedWidth = nodeValue.split('').reduce((width, char) => {
-    return width + canvasContext.measureText(char).width;
-  }, 0);
-  const actualWidth = canvasContext.measureText(nodeValue).width;
-
-  const pixelDifference = differences / compareData.length;
-  const sizeDifference = 1 - actualWidth / expectedWidth;
-
-  if (
-    pixelDifference >= differenceThreshold &&
-    sizeDifference >= differenceThreshold
-  ) {
-    font.numLigatures++;
-    return true;
-  }
-
-  return false;
+	/**
+	 * Determine if the visible text is a ligature by comparing the
+	 * first letters image data to the entire strings image data.
+	 * If the two images are significantly different (typical set to 5%
+	 * statistical significance, but we'll be using a slightly higher value
+	 * of 15% to help keep the size of the canvas down) then we know the text
+	 * has been replaced by a ligature.
+	 *
+	 * Example:
+	 * If a text node was the string "File", looking at just the first
+	 * letter "F" would produce the following image:
+	 *
+	 * ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
+	 * │ │ │█│█│█│█│█│█│█│█│█│█│█│ │ │
+	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
+	 * │ │ │█│█│█│█│█│█│█│█│█│█│█│ │ │
+	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
+	 * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
+	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
+	 * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
+	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
+	 * │ │ │█│█│█│█│█│█│█│ │ │ │ │ │ │
+	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
+	 * │ │ │█│█│█│█│█│█│█│ │ │ │ │ │ │
+	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
+	 * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
+	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
+	 * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
+	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
+	 * │ │ │█│█│ │ │ │ │ │ │ │ │ │ │ │
+	 * └─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
+	 *
+	 * But if the entire string "File" produced an image which had at least
+	 * a 15% difference in pixels, we would know that the string was replaced
+	 * by a ligature:
+	 *
+	 * ┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
+	 * │ │█│█│█│█│█│█│█│█│█│█│ │ │ │ │
+	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
+	 * │ │█│ │ │ │ │ │ │ │ │█│█│ │ │ │
+	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
+	 * │ │█│ │█│█│█│█│█│█│ │█│ │█│ │ │
+	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
+	 * │ │█│ │ │ │ │ │ │ │ │█│█│█│█│ │
+	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
+	 * │ │█│ │█│█│█│█│█│█│ │ │ │ │█│ │
+	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
+	 * │ │█│ │ │ │ │ │ │ │ │ │ │ │█│ │
+	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
+	 * │ │█│ │█│█│█│█│█│█│█│█│█│ │█│ │
+	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
+	 * │ │█│ │ │ │ │ │ │ │ │ │ │ │█│ │
+	 * ├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
+	 * │ │█│█│█│█│█│█│█│█│█│█│█│█│█│ │
+	 * └─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
+	 */
+	const nodeValue = textVNode.actualNode.nodeValue.trim();
+
+	// text with unicode or non-bmp letters cannot be ligature icons
+	if (
+		!sanitize(nodeValue) ||
+		hasUnicode(nodeValue, { emoji: true, nonBmp: true })
+	) {
+		return false;
+	}
+
+	if (!cache.get('canvasContext')) {
+		cache.set(
+			'canvasContext',
+			document.createElement('canvas').getContext('2d')
+		);
+	}
+	const canvasContext = cache.get('canvasContext');
+	const canvas = canvasContext.canvas;
+
+	// keep track of each font encountered and the number of times it shows up
+	// as a ligature.
+	if (!cache.get('fonts')) {
+		cache.set('fonts', {});
+	}
+	const fonts = cache.get('fonts');
+
+	const style = window.getComputedStyle(textVNode.parent.actualNode);
+	const fontFamily = style.getPropertyValue('font-family');
+
+	if (!fonts[fontFamily]) {
+		fonts[fontFamily] = {
+			occurances: 0,
+			numLigatures: 0
+		};
+	}
+	const font = fonts[fontFamily];
+
+	// improve the performance by only comparing the image data of a font
+	// a certain number of times
+	if (font.occurances >= occuranceThreshold) {
+		// if the font has always been a ligature assume it's a ligature font
+		if (font.numLigatures / font.occurances === 1) {
+			return true;
+		}
+		// inversely, if it's never been a ligature assume it's not a ligature font
+		else if (font.numLigatures === 0) {
+			return false;
+		}
+
+		// we could theoretically get into an odd middle ground scenario in which
+		// the font family is being used as normal text sometimes and as icons
+		// other times. in these cases we would need to always check the text
+		// to know if it's an icon or not
+	}
+	font.occurances++;
+
+	// 30px was chosen to account for common ligatures in normal fonts
+	// such as fi, ff, ffi. If a ligature would add a single column of
+	// pixels to a 30x30 grid, it would not meet the statistical significance
+	// threshold of 15% (30x30 = 900; 30/900 = 3.333%). this also allows for
+	// more than 1 column differences (60/900 = 6.666%) and things like
+	// extending the top of the f in the fi ligature.
+	let fontSize = 30;
+	let fontStyle = `${fontSize}px ${fontFamily}`;
+
+	// set the size of the canvas to the width of the first letter
+	canvasContext.font = fontStyle;
+	const firstChar = nodeValue.charAt(0);
+	let width = canvasContext.measureText(firstChar).width;
+
+	// ensure font meets the 30px width requirement (30px font-size doesn't
+	// necessarily mean its 30px wide when drawn)
+	if (width < 30) {
+		const diff = 30 / width;
+		width *= diff;
+		fontSize *= diff;
+		fontStyle = `${fontSize}px ${fontFamily}`;
+	}
+	canvas.width = width;
+	canvas.height = fontSize;
+
+	// changing the dimensions of a canvas resets all properties (include font)
+	// and clears it
+	canvasContext.font = fontStyle;
+	canvasContext.textAlign = 'left';
+	canvasContext.textBaseline = 'top';
+	canvasContext.fillText(firstChar, 0, 0);
+	const compareData = new Uint32Array(
+		canvasContext.getImageData(0, 0, width, fontSize).data.buffer
+	);
+
+	// if the font doesn't even have character data for a single char then
+	// it has to be an icon ligature (e.g. Material Icon)
+	if (!compareData.some(pixel => pixel)) {
+		font.numLigatures++;
+		return true;
+	}
+
+	canvasContext.clearRect(0, 0, width, fontSize);
+	canvasContext.fillText(nodeValue, 0, 0);
+	const compareWith = new Uint32Array(
+		canvasContext.getImageData(0, 0, width, fontSize).data.buffer
+	);
+
+	// calculate the number of differences between the first letter and the
+	// entire string, ignoring color differences
+	const differences = compareData.reduce((diff, pixel, i) => {
+		if (pixel === 0 && compareWith[i] === 0) {
+			return diff;
+		}
+		if (pixel !== 0 && compareWith[i] !== 0) {
+			return diff;
+		}
+		return ++diff;
+	}, 0);
+
+	// calculate the difference between the width of each character and the
+	// combined with of all characters
+	const expectedWidth = nodeValue.split('').reduce((width, char) => {
+		return width + canvasContext.measureText(char).width;
+	}, 0);
+	const actualWidth = canvasContext.measureText(nodeValue).width;
+
+	const pixelDifference = differences / compareData.length;
+	const sizeDifference = 1 - actualWidth / expectedWidth;
+
+	if (
+		pixelDifference >= differenceThreshold &&
+		sizeDifference >= differenceThreshold
+	) {
+		font.numLigatures++;
+		return true;
+	}
+
+	return false;
 }
 
 export default isIconLigature;

package/lib/commons/text/is-valid-autocomplete.js

@@ -1,118 +1,118 @@
 export const autocomplete = {
-  stateTerms: ['on', 'off'],
-  standaloneTerms: [
-    'name',
-    'honorific-prefix',
-    'given-name',
-    'additional-name',
-    'family-name',
-    'honorific-suffix',
-    'nickname',
-    'username',
-    'new-password',
-    'current-password',
-    'organization-title',
-    'organization',
-    'street-address',
-    'address-line1',
-    'address-line2',
-    'address-line3',
-    'address-level4',
-    'address-level3',
-    'address-level2',
-    'address-level1',
-    'country',
-    'country-name',
-    'postal-code',
-    'cc-name',
-    'cc-given-name',
-    'cc-additional-name',
-    'cc-family-name',
-    'cc-number',
-    'cc-exp',
-    'cc-exp-month',
-    'cc-exp-year',
-    'cc-csc',
-    'cc-type',
-    'transaction-currency',
-    'transaction-amount',
-    'language',
-    'bday',
-    'bday-day',
-    'bday-month',
-    'bday-year',
-    'sex',
-    'url',
-    'photo',
-    'one-time-code'
-  ],
-  qualifiers: ['home', 'work', 'mobile', 'fax', 'pager'],
-  qualifiedTerms: [
-    'tel',
-    'tel-country-code',
-    'tel-national',
-    'tel-area-code',
-    'tel-local',
-    'tel-local-prefix',
-    'tel-local-suffix',
-    'tel-extension',
-    'email',
-    'impp'
-  ],
-  locations: ['billing', 'shipping']
+	stateTerms: ['on', 'off'],
+	standaloneTerms: [
+		'name',
+		'honorific-prefix',
+		'given-name',
+		'additional-name',
+		'family-name',
+		'honorific-suffix',
+		'nickname',
+		'username',
+		'new-password',
+		'current-password',
+		'organization-title',
+		'organization',
+		'street-address',
+		'address-line1',
+		'address-line2',
+		'address-line3',
+		'address-level4',
+		'address-level3',
+		'address-level2',
+		'address-level1',
+		'country',
+		'country-name',
+		'postal-code',
+		'cc-name',
+		'cc-given-name',
+		'cc-additional-name',
+		'cc-family-name',
+		'cc-number',
+		'cc-exp',
+		'cc-exp-month',
+		'cc-exp-year',
+		'cc-csc',
+		'cc-type',
+		'transaction-currency',
+		'transaction-amount',
+		'language',
+		'bday',
+		'bday-day',
+		'bday-month',
+		'bday-year',
+		'sex',
+		'url',
+		'photo',
+		'one-time-code'
+	],
+	qualifiers: ['home', 'work', 'mobile', 'fax', 'pager'],
+	qualifiedTerms: [
+		'tel',
+		'tel-country-code',
+		'tel-national',
+		'tel-area-code',
+		'tel-local',
+		'tel-local-prefix',
+		'tel-local-suffix',
+		'tel-extension',
+		'email',
+		'impp'
+	],
+	locations: ['billing', 'shipping']
 };
 
 function isValidAutocomplete(
-  autocompleteValue,
-  {
-    looseTyped = false,
-    stateTerms = [],
-    locations = [],
-    qualifiers = [],
-    standaloneTerms = [],
-    qualifiedTerms = []
-  } = {}
+	autocompleteValue,
+	{
+		looseTyped = false,
+		stateTerms = [],
+		locations = [],
+		qualifiers = [],
+		standaloneTerms = [],
+		qualifiedTerms = []
+	} = {}
 ) {
-  autocompleteValue = autocompleteValue.toLowerCase().trim();
-  stateTerms = stateTerms.concat(autocomplete.stateTerms);
-  if (stateTerms.includes(autocompleteValue) || autocompleteValue === '') {
-    return true;
-  }
+	autocompleteValue = autocompleteValue.toLowerCase().trim();
+	stateTerms = stateTerms.concat(autocomplete.stateTerms);
+	if (stateTerms.includes(autocompleteValue) || autocompleteValue === '') {
+		return true;
+	}
 
-  qualifiers = qualifiers.concat(autocomplete.qualifiers);
-  locations = locations.concat(autocomplete.locations);
-  standaloneTerms = standaloneTerms.concat(autocomplete.standaloneTerms);
-  qualifiedTerms = qualifiedTerms.concat(autocomplete.qualifiedTerms);
+	qualifiers = qualifiers.concat(autocomplete.qualifiers);
+	locations = locations.concat(autocomplete.locations);
+	standaloneTerms = standaloneTerms.concat(autocomplete.standaloneTerms);
+	qualifiedTerms = qualifiedTerms.concat(autocomplete.qualifiedTerms);
 
-  const autocompleteTerms = autocompleteValue.split(/\s+/g);
-  if (!looseTyped) {
-    if (
-      autocompleteTerms[0].length > 8 &&
-      autocompleteTerms[0].substr(0, 8) === 'section-'
-    ) {
-      autocompleteTerms.shift();
-    }
+	const autocompleteTerms = autocompleteValue.split(/\s+/g);
+	if (!looseTyped) {
+		if (
+			autocompleteTerms[0].length > 8 &&
+			autocompleteTerms[0].substr(0, 8) === 'section-'
+		) {
+			autocompleteTerms.shift();
+		}
 
-    if (locations.includes(autocompleteTerms[0])) {
-      autocompleteTerms.shift();
-    }
+		if (locations.includes(autocompleteTerms[0])) {
+			autocompleteTerms.shift();
+		}
 
-    if (qualifiers.includes(autocompleteTerms[0])) {
-      autocompleteTerms.shift();
-      // only quantifiers allowed at this point
-      standaloneTerms = [];
-    }
+		if (qualifiers.includes(autocompleteTerms[0])) {
+			autocompleteTerms.shift();
+			// only quantifiers allowed at this point
+			standaloneTerms = [];
+		}
 
-    if (autocompleteTerms.length !== 1) {
-      return false;
-    }
-  }
+		if (autocompleteTerms.length !== 1) {
+			return false;
+		}
+	}
 
-  const purposeTerm = autocompleteTerms[autocompleteTerms.length - 1];
-  return (
-    standaloneTerms.includes(purposeTerm) ||
-    qualifiedTerms.includes(purposeTerm)
-  );
+	const purposeTerm = autocompleteTerms[autocompleteTerms.length - 1];
+	return (
+		standaloneTerms.includes(purposeTerm) ||
+		qualifiedTerms.includes(purposeTerm)
+	);
 }
 
 export default isValidAutocomplete;