diff --git a/chrome/test/data/webui/BUILD.gn b/chrome/test/data/webui/BUILD.gn index a4c2fadc83c634..146df6e4c4b120 100644 --- a/chrome/test/data/webui/BUILD.gn +++ b/chrome/test/data/webui/BUILD.gn @@ -99,6 +99,8 @@ js2gtest("browser_tests_js_webui") { "webui_resource_async_browsertest.js", ] + gen_include_files = [ "a11y/accessibility_audit_rules.js" ] + extra_js_files = [ "test_browser_proxy.js", "settings/test_password_manager_proxy.js", diff --git a/chrome/test/data/webui/a11y/accessibility_audit_rules.js b/chrome/test/data/webui/a11y/accessibility_audit_rules.js index 5079576101b418..6c08d3ec9dfd94 100644 --- a/chrome/test/data/webui/a11y/accessibility_audit_rules.js +++ b/chrome/test/data/webui/a11y/accessibility_audit_rules.js @@ -52,7 +52,6 @@ AccessibilityTest.ruleIds = [ 'frame-title', 'heading-order', 'hidden-content', - 'href-no-hash', 'html-has-lang', 'html-lang-valid', 'image-alt', diff --git a/chrome/test/data/webui/extensions/a11y/extensions_a11y_test.js b/chrome/test/data/webui/extensions/a11y/extensions_a11y_test.js index fcb77c0b297903..11bc8789768631 100644 --- a/chrome/test/data/webui/extensions/a11y/extensions_a11y_test.js +++ b/chrome/test/data/webui/extensions/a11y/extensions_a11y_test.js @@ -56,6 +56,16 @@ var CrExtensionsA11yTest = class extends PolymerTest { return parentNode && parentNode.host && parentNode.host.tagName == 'CR-TOGGLE'; }, + + // TODO(crbug.com/1002620): this filter can be removed after + // addressing the bug + 'heading-order': function(nodeResult) { + // Filter out 'Heading levels do not increase by one' error when + // enumerating extensions + const expectedMarkup = '
My extension 1
'; + return nodeResult['html'] === expectedMarkup; + }, }; } @@ -85,7 +95,13 @@ AccessibilityTest.define('CrExtensionsA11yTest', { name: 'NoExtensions', /** @override */ - axeOptions: CrExtensionsA11yTest.axeOptions, + // TODO(crbug.com/1002627): when bug is addressed, this should be replaced + // with axeOptions: CrExtensionsA11yTest.axeOptions, + axeOptions: Object.assign({}, CrExtensionsA11yTest.axeOptions, { + 'rules': Object.assign({}, CrExtensionsA11yTest.axeOptions.rules, { + 'link-in-text-block': {enabled: false}, + }) + }), /** @override */ violationFilter: CrExtensionsA11yTest.violationFilter, diff --git a/chrome/test/data/webui/management/a11y/management_a11y_test.js b/chrome/test/data/webui/management/a11y/management_a11y_test.js index a89088c6897118..bc5486115f3710 100644 --- a/chrome/test/data/webui/management/a11y/management_a11y_test.js +++ b/chrome/test/data/webui/management/a11y/management_a11y_test.js @@ -31,6 +31,8 @@ var CrManagementA11yTest = class extends PolymerTest { 'skip-link': {enabled: false}, // TODO(crbug.com/761461): enable after addressing flaky tests. 'color-contrast': {enabled: false}, + // TODO(crbug.com/1002623): remove this line after addressing bug + 'link-in-text-block': {enabled: false}, }, }; } diff --git a/chrome/test/data/webui/settings/a11y/crostini_settings_subpage_a11y_test.js b/chrome/test/data/webui/settings/a11y/crostini_settings_subpage_a11y_test.js index f9349f2d5ed2bf..c2a8327f1fe834 100644 --- a/chrome/test/data/webui/settings/a11y/crostini_settings_subpage_a11y_test.js +++ b/chrome/test/data/webui/settings/a11y/crostini_settings_subpage_a11y_test.js @@ -15,7 +15,7 @@ AccessibilityTest.define('CrostiniAccessibilityTest', { /** @override */ name: 'CROSTINI', /** @override */ - axeOptions: SettingsAccessibilityTest.axeOptions, + axeOptions: SettingsAccessibilityTest.axeOptionsExcludeLinkInTextBlock, /** @override */ setup: function() { settings.router.navigateTo(settings.routes.CROSTINI); diff --git a/chrome/test/data/webui/settings/a11y/multidevice_a11y_test.js b/chrome/test/data/webui/settings/a11y/multidevice_a11y_test.js index 1eb57f3553727d..97c77590326e22 100644 --- a/chrome/test/data/webui/settings/a11y/multidevice_a11y_test.js +++ b/chrome/test/data/webui/settings/a11y/multidevice_a11y_test.js @@ -32,7 +32,7 @@ AccessibilityTest.define('MultideviceA11yTest', { /** @override */ name: 'MULTIDEVICE', /** @override */ - axeOptions: SettingsAccessibilityTest.axeOptions, + axeOptions: SettingsAccessibilityTest.axeOptionsExcludeLinkInTextBlock, /** @override */ setup: function() { settings.router.navigateTo(settings.routes.MULTIDEVICE); diff --git a/chrome/test/data/webui/settings/a11y/multidevice_features_a11y_test.js b/chrome/test/data/webui/settings/a11y/multidevice_features_a11y_test.js index 841c3feb2fdde4..5a0f2a0755d00c 100644 --- a/chrome/test/data/webui/settings/a11y/multidevice_features_a11y_test.js +++ b/chrome/test/data/webui/settings/a11y/multidevice_features_a11y_test.js @@ -32,7 +32,7 @@ AccessibilityTest.define('MultideviceFeaturesA11yTest', { /** @override */ name: 'MULTIDEVICE_FEATURES_ACCESSIBILITY', /** @override */ - axeOptions: SettingsAccessibilityTest.axeOptions, + axeOptions: SettingsAccessibilityTest.axeOptionsExcludeLinkInTextBlock, /** @override */ setup: function() { settings.router.navigateTo(settings.routes.MULTIDEVICE_FEATURES); diff --git a/chrome/test/data/webui/settings/a11y/settings_accessibility_test.js b/chrome/test/data/webui/settings/a11y/settings_accessibility_test.js index 7d52614760117e..b871ad85f18709 100644 --- a/chrome/test/data/webui/settings/a11y/settings_accessibility_test.js +++ b/chrome/test/data/webui/settings/a11y/settings_accessibility_test.js @@ -28,6 +28,17 @@ SettingsAccessibilityTest.axeOptions = { } }; +// TODO(crbug.com/1002627): This block prevents generation of a +// link-in-text-block browser-test. This can be removed once the bug is +// addressed, and usage should be replaced with +// SettingsAccessibilityTest.axeOptions +SettingsAccessibilityTest.axeOptionsExcludeLinkInTextBlock = + Object.assign({}, SettingsAccessibilityTest.axeOptions, { + 'rules': Object.assign({}, SettingsAccessibilityTest.axeOptions.rules, { + 'link-in-text-block': {enabled: false}, + }) + }); + // Default accessibility audit options. Specify in test definition to use. SettingsAccessibilityTest.violationFilter = { // Polymer components use aria-active-attribute. diff --git a/third_party/axe-core/README.chromium b/third_party/axe-core/README.chromium index 7697284fb57de3..54f550724b07d2 100644 --- a/third_party/axe-core/README.chromium +++ b/third_party/axe-core/README.chromium @@ -1,9 +1,9 @@ Name: AXE-CORE Accessibility Audit Short Name: axe-core URL: https://github.com/dequelabs/axe-core/ -Version: 0 -Date: Mon Jul 24 12:17:05 2017 -Revision: d02dba3223fefe525438330e40b5da5de81eeeb5 +Version: 3.3.2 +Date: Thur Aug 22 12:45:00 2019 +Revision: 281653df3794f429b71327fe3afa37ca0fadb1c7 License: MPL 2.0 License File: LICENSE Security Critical: no diff --git a/third_party/axe-core/axe.d.ts b/third_party/axe-core/axe.d.ts index 258cf3dc9cce3a..b68b2c6f464c96 100644 --- a/third_party/axe-core/axe.d.ts +++ b/third_party/axe-core/axe.d.ts @@ -1,169 +1,224 @@ -// Type definitions for axe-core 2.3.1 +// Type definitions for axe-core // Project: https://github.com/dequelabs/axe-core // Definitions by: Marcy Sutton -declare module axe { +declare namespace axe { + type ImpactValue = 'minor' | 'moderate' | 'serious' | 'critical'; - type ImpactValue = "minor" | "moderate" | "serious" | "critical"; + type TagValue = 'wcag2a' | 'wcag2aa' | 'section508' | 'best-practice'; - type TagValue = "wcag2a" | "wcag2aa" | "section508" | "best-practice"; + type ReporterVersion = 'v1' | 'v2' | 'raw' | 'raw-env' | 'no-passes'; - type ReporterVersion = "v1" | "v2"; + type RunOnlyType = 'rule' | 'rules' | 'tag' | 'tags'; - type RunOnlyType = "rule" | "rules" | "tag" | "tags"; + type resultGroups = 'inapplicable' | 'passes' | 'incomplete' | 'violations'; - interface ElementContext { - node?: Object, - selector?: string, - include?: any[], - exclude?: any[] + type RunOnlyObject = { + include?: string[] | string[][]; + exclude?: string[] | string[][]; + }; + + type RunCallback = (error: Error, results: AxeResults) => void; + + type ElementContext = Node | string | RunOnlyObject; + + interface TestEngine { + name: string; + version: string; + } + interface TestRunner { + name: string; + } + interface TestEnvironment { + userAgent: string; + windowWidth: number; + windowHeight: number; + orientationAngle?: number; + orientationType?: string; } interface RunOnly { - type: RunOnlyType, - value?: { - include?: string[], - exclude?: string[] - } - values?: TagValue[] + type: RunOnlyType; + values?: TagValue[] | string[] | RunOnlyObject; + } + interface RunOptions { + runOnly?: RunOnly; + rules?: Object; + iframes?: boolean; + elementRef?: boolean; + selectors?: boolean; + resultTypes?: resultGroups[]; + reporter?: ReporterVersion; + xpath?: boolean; + absolutePaths?: boolean; + restoreScroll?: boolean; + frameWaitTime?: number; + preload?: boolean; + performanceTimer?: boolean; } interface AxeResults { - url: string, - timestamp: string, - passes: Result[], - violations: Result[], - incomplete: Result[], - inapplicable: Result[] + toolOptions: RunOptions; + testEngine: TestEngine; + testRunner: TestRunner; + testEnvironment: TestEnvironment; + url: string; + timestamp: string; + passes: Result[]; + violations: Result[]; + incomplete: Result[]; + inapplicable: Result[]; } interface Result { - description: string, - help: string, - helpUrl: string, - id: string, - impact: ImpactValue, - tags: TagValue[], - nodes: NodeResult[] + description: string; + help: string; + helpUrl: string; + id: string; + impact?: ImpactValue; + tags: TagValue[]; + nodes: NodeResult[]; } interface NodeResult { - html: string, - impact: ImpactValue, - target: string[], - any: CheckResult[], - all: CheckResult[], - none: CheckResult[], - failureSummary?: string + html: string; + impact?: ImpactValue; + target: string[]; + xpath?: string[]; + any: CheckResult[]; + all: CheckResult[]; + none: CheckResult[]; + failureSummary?: string; } interface CheckResult { - id: string, - impact: string, - message: string, - data: any, - relatedNodes?: RelatedNode[] + id: string; + impact: string; + message: string; + data: any; + relatedNodes?: RelatedNode[]; } interface RelatedNode { - target: string[], - html: string + target: string[]; + html: string; + } + interface RuleLocale { + [key: string]: { + description: string; + help: string; + }; + } + interface CheckLocale { + [key: string]: { + pass: string; + fail: string; + incomplete: string | { [key: string]: string }; + }; + } + interface Locale { + lang?: string; + rules?: RuleLocale; + checks?: CheckLocale; } interface Spec { branding?: { - brand: string, - application: string - }, - reporter?: ReporterVersion, - checks?: Check[], - rules?: Rule[] + brand?: string; + application?: string; + }; + reporter?: ReporterVersion; + checks?: Check[]; + rules?: Rule[]; + locale?: Locale; } interface Check { - id: string, - evaluate: Function, - after?: Function, - options?: any, - matches?: string, - enabled?: boolean + id: string; + evaluate: Function | string; + after?: Function | string; + options?: any; + matches?: string; + enabled?: boolean; } interface Rule { - id: string, - selector?: string, - excludeHidden?: boolean, - enabled?: boolean, - pageLevel?: boolean, - any?: string[], - all?: string[], - none?: string[], - tags?: string[], - matches?: string + id: string; + selector?: string; + excludeHidden?: boolean; + enabled?: boolean; + pageLevel?: boolean; + any?: string[]; + all?: string[]; + none?: string[]; + tags?: string[]; + matches?: string; } interface AxePlugin { - id: string, - run(...args:any[]): any, + id: string; + run(...args: any[]): any; commands: { - id: string, - callback(...args:any[]): void - }[], - cleanup?(callback:Function): void + id: string; + callback(...args: any[]): void; + }[]; + cleanup?(callback: Function): void; } - let plugins: any + let plugins: any; /** * Source string to use as an injected script in Selenium */ - let source: string + let source: string; /** - * Object for aXe Results + * Object for axe Results */ - var AxeResults: AxeResults + var AxeResults: AxeResults; /** * Runs a number of rules against the provided HTML page and returns the resulting issue list * - * @param {Object} context Optional The `Context` specification object @see Context - * @param {Array} options Optional Options passed into rules or checks, temporarily modifying them. - * @param {Function} callback Optional The function to invoke when analysis is complete. - * @returns {any} results If the callback was not defined, aXe will return a Promise instead. + * @param {ElementContext} context Optional The `Context` specification object @see Context + * @param {RunOptions} options Optional Options passed into rules or checks, temporarily modifying them. + * @param {RunCallback} callback Optional The function to invoke when analysis is complete. + * @returns {Promise|void} If the callback was not defined, axe will return a Promise. */ - function run(context?: ElementContext, options?: {runOnly?: RunOnly, rules?: Object, iframes?: Boolean, elementRef?: Boolean, selectors?: Boolean}, callback?: (error: Error, results:AxeResults) => void): any + function run(context?: ElementContext): Promise; + function run(options: RunOptions): Promise; + function run(callback: (error: Error, results: AxeResults) => void): void; + function run(context: ElementContext, callback: RunCallback): void; + function run(options: RunOptions, callback: RunCallback): void; + function run( + context: ElementContext, + options: RunOptions + ): Promise; + function run( + context: ElementContext, + options: RunOptions, + callback: RunCallback + ): void; /** - * Starts analysis on the current document and its subframes - * - * @param {Object} context The `Context` specification object @see Context - * @param {Array} options Options passed into rules or checks, temporarily modifyint them. - * @param {Function} callback The function to invoke when analysis is complete. - * @returns {Object} results The aXe results object - */ - function a11yCheck(context: ElementContext, options: {runOnly?: RunOnly, rules?: Object, iframes?: Boolean, elementRef?: Boolean, selectors?: Boolean}, callback: (results:AxeResults) => void): AxeResults - - /** - * Method for configuring the data format used by aXe. Helpful for adding new + * Method for configuring the data format used by axe. Helpful for adding new * rules, which must be registered with the library to execute. * @param {Spec} Spec Object with valid `branding`, `reporter`, `checks` and `rules` data */ - function configure(spec: Spec): void + function configure(spec: Spec): void; /** * Searches and returns rules that contain a tag in the list of tags. * @param {Array} tags Optional array of tags * @return {Array} Array of rules */ - function getRules(tags?: string[]): Object[] + function getRules(tags?: string[]): Object[]; /** * Restores the default axe configuration */ - function reset(): void + function reset(): void; /** * Function to register a plugin configuration in document and its subframes * @param {Object} plugin A plugin configuration object */ - function registerPlugin(plugin: AxePlugin): void + function registerPlugin(plugin: AxePlugin): void; /** * Function to clean up plugin configuration in document and its subframes */ - function cleanup(): void - + function cleanup(): void; } export = axe; diff --git a/third_party/axe-core/axe.js b/third_party/axe-core/axe.js index 2e2c746b2bf160..3b7cfe6eff959f 100644 --- a/third_party/axe-core/axe.js +++ b/third_party/axe-core/axe.js @@ -1,5 +1,5 @@ -/*! aXe v3.0.0-alpha-1 - * Copyright (c) 2017 Deque Systems, Inc. +/*! axe v3.3.2 + * Copyright (c) 2019 Deque Systems, Inc. * * Your use of this Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this @@ -13,15 +13,22 @@ var global = window; var document = window.document; 'use strict'; - var _typeof = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? function(obj) { - return typeof obj; - } : function(obj) { - return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; - }; + function _typeof(obj) { + if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; + }; + } + return _typeof(obj); + } var axe = axe || {}; - axe.version = '3.0.0-alpha-1'; + axe.version = '3.3.2'; if (typeof define === 'function' && define.amd) { - define([], function() { + define('axe-core', [], function() { 'use strict'; return axe; }); @@ -37,227 +44,2860 @@ function SupportError(error) { this.name = 'SupportError'; this.cause = error.cause; - this.message = '`' + error.cause + '` - feature unsupported in your environment.'; + this.message = '`'.concat(error.cause, '` - feature unsupported in your environment.'); if (error.ruleId) { this.ruleId = error.ruleId; - this.message += ' Skipping ' + this.ruleId + ' rule.'; + this.message += ' Skipping '.concat(this.ruleId, ' rule.'); } this.stack = new Error().stack; } SupportError.prototype = Object.create(Error.prototype); SupportError.prototype.constructor = SupportError; - 'use strict'; - var utils = axe.utils = {}; - 'use strict'; - var helpers = {}; - 'use strict'; - var _typeof = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? function(obj) { - return typeof obj; - } : function(obj) { - return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; - }; - function getDefaultConfiguration(audit) { - 'use strict'; - var config; - if (audit) { - config = axe.utils.clone(audit); - config.commons = audit.commons; - } else { - config = {}; - } - config.reporter = config.reporter || null; - config.rules = config.rules || []; - config.checks = config.checks || []; - config.data = Object.assign({ - checks: {}, - rules: {} - }, config.data); - return config; - } - function unpackToObject(collection, audit, method) { - 'use strict'; - var i, l; - for (i = 0, l = collection.length; i < l; i++) { - audit[method](collection[i]); - } - } - function Audit(audit) { - this.brand = 'axe'; - this.application = 'axeAPI'; - this.tagExclude = [ 'experimental' ]; - this.defaultConfig = audit; - this._init(); - } - Audit.prototype._init = function() { - var audit = getDefaultConfiguration(this.defaultConfig); - axe.commons = commons = audit.commons; - this.reporter = audit.reporter; - this.commands = {}; - this.rules = []; - this.checks = {}; - unpackToObject(audit.rules, this, 'addRule'); - unpackToObject(audit.checks, this, 'addCheck'); - this.data = {}; - this.data.checks = audit.data && audit.data.checks || {}; - this.data.rules = audit.data && audit.data.rules || {}; - this.data.failureSummaries = audit.data && audit.data.failureSummaries || {}; - this.data.incompleteFallbackMessage = audit.data && audit.data.incompleteFallbackMessage || ''; - this._constructHelpUrls(); - }; - Audit.prototype.registerCommand = function(command) { - 'use strict'; - this.commands[command.id] = command.callback; - }; - Audit.prototype.addRule = function(spec) { - 'use strict'; - if (spec.metadata) { - this.data.rules[spec.id] = spec.metadata; - } - var rule = this.getRule(spec.id); - if (rule) { - rule.configure(spec); - } else { - this.rules.push(new Rule(spec, this)); - } - }; - Audit.prototype.addCheck = function(spec) { - 'use strict'; - var metadata = spec.metadata; - if ((typeof metadata === 'undefined' ? 'undefined' : _typeof(metadata)) === 'object') { - this.data.checks[spec.id] = metadata; - if (_typeof(metadata.messages) === 'object') { - Object.keys(metadata.messages).filter(function(prop) { - return metadata.messages.hasOwnProperty(prop) && typeof metadata.messages[prop] === 'string'; - }).forEach(function(prop) { - if (metadata.messages[prop].indexOf('function') === 0) { - metadata.messages[prop] = new Function('return ' + metadata.messages[prop] + ';')(); + (function() { + function r(e, n, t) { + function o(i, f) { + if (!n[i]) { + if (!e[i]) { + var c = 'function' == typeof require && require; + if (!f && c) { + return c(i, !0); + } + if (u) { + return u(i, !0); + } + var a = new Error('Cannot find module \'' + i + '\''); + throw a.code = 'MODULE_NOT_FOUND', a; } - }); + var p = n[i] = { + exports: {} + }; + e[i][0].call(p.exports, function(r) { + var n = e[i][1][r]; + return o(n || r); + }, p, p.exports, r, e, n, t); + } + return n[i].exports; } + for (var u = 'function' == typeof require && require, i = 0; i < t.length; i++) { + o(t[i]); + } + return o; } - if (this.checks[spec.id]) { - this.checks[spec.id].configure(spec); - } else { - this.checks[spec.id] = new Check(spec); - } - }; - Audit.prototype.run = function(context, options, resolve, reject) { - 'use strict'; - this.validateOptions(options); - axe._tree = axe.utils.getFlattenedTree(document.documentElement); - var q = axe.utils.queue(); - this.rules.forEach(function(rule) { - if (axe.utils.ruleShouldRun(rule, context, options)) { - if (options.performanceTimer) { - var markEnd = 'mark_rule_end_' + rule.id; - var markStart = 'mark_rule_start_' + rule.id; - axe.utils.performanceTimer.mark(markStart); - } - q.defer(function(res, rej) { - rule.run(context, options, function(out) { - if (options.performanceTimer) { - axe.utils.performanceTimer.mark(markEnd); - axe.utils.performanceTimer.measure('rule_' + rule.id, markStart, markEnd); - } - res(out); - }, function(err) { - if (!options.debug) { - var errResult = Object.assign(new RuleResult(rule), { - result: axe.constants.CANTTELL, - description: 'An error occured while running this rule', - message: err.message, - stack: err.stack, - error: err + return r; + })()({ + 1: [ function(_dereq_, module, exports) { + if (!('Promise' in window)) { + _dereq_('es6-promise').polyfill(); + } + _dereq_('weakmap-polyfill'); + axe.imports = { + axios: _dereq_('axios'), + CssSelectorParser: _dereq_('css-selector-parser').CssSelectorParser, + doT: _dereq_('@deque/dot'), + emojiRegexText: _dereq_('emoji-regex') + }; + }, { + '@deque/dot': 2, + axios: 3, + 'css-selector-parser': 29, + 'emoji-regex': 31, + 'es6-promise': 32, + 'weakmap-polyfill': 34 + } ], + 2: [ function(_dereq_, module, exports) { + (function() { + 'use strict'; + var doT = { + name: 'doT', + version: '1.1.1', + templateSettings: { + evaluate: /\{\{([\s\S]+?(\}?)+)\}\}/g, + interpolate: /\{\{=([\s\S]+?)\}\}/g, + encode: /\{\{!([\s\S]+?)\}\}/g, + use: /\{\{#([\s\S]+?)\}\}/g, + useParams: /(^|[^\w$])def(?:\.|\[[\'\"])([\w$\.]+)(?:[\'\"]\])?\s*\:\s*([\w$\.]+|\"[^\"]+\"|\'[^\']+\'|\{[^\}]+\})/g, + define: /\{\{##\s*([\w\.$]+)\s*(\:|=)([\s\S]+?)#\}\}/g, + defineParams: /^\s*([\w$]+):([\s\S]+)/, + conditional: /\{\{\?(\?)?\s*([\s\S]*?)\s*\}\}/g, + iterate: /\{\{~\s*(?:\}\}|([\s\S]+?)\s*\:\s*([\w$]+)\s*(?:\:\s*([\w$]+))?\s*\}\})/g, + varname: 'it', + strip: true, + append: true, + selfcontained: false, + doNotSkipEncoded: false + }, + template: undefined, + compile: undefined, + log: true + }; + (function() { + if (typeof globalThis === 'object') { + return; + } + Object.defineProperty(Object.prototype, '__magic__', { + get: function() { + return this; + }, + configurable: true + }); + __magic__.globalThis = __magic__; + delete Object.prototype.__magic__; + })(); + doT.encodeHTMLSource = function(doNotSkipEncoded) { + var encodeHTMLRules = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + '\'': ''', + '/': '/' + }, matchHTML = doNotSkipEncoded ? /[&<>"'\/]/g : /&(?!#?\w+;)|<|>|"|'|\//g; + return function(code) { + return code ? code.toString().replace(matchHTML, function(m) { + return encodeHTMLRules[m] || m; + }) : ''; + }; + }; + if (typeof module !== 'undefined' && module.exports) { + module.exports = doT; + } else if (typeof define === 'function' && define.amd) { + define(function() { + return doT; + }); + } else { + globalThis.doT = doT; + } + var startend = { + append: { + start: '\'+(', + end: ')+\'', + startencode: '\'+encodeHTML(' + }, + split: { + start: '\';out+=(', + end: ');out+=\'', + startencode: '\';out+=encodeHTML(' + } + }, skip = /$^/; + function resolveDefs(c, block, def) { + return (typeof block === 'string' ? block : block.toString()).replace(c.define || skip, function(m, code, assign, value) { + if (code.indexOf('def.') === 0) { + code = code.substring(4); + } + if (!(code in def)) { + if (assign === ':') { + if (c.defineParams) { + value.replace(c.defineParams, function(m, param, v) { + def[code] = { + arg: param, + text: v + }; + }); + } + if (!(code in def)) { + def[code] = value; + } + } else { + new Function('def', 'def[\'' + code + '\']=' + value)(def); + } + } + return ''; + }).replace(c.use || skip, function(m, code) { + if (c.useParams) { + code = code.replace(c.useParams, function(m, s, d, param) { + if (def[d] && def[d].arg && param) { + var rw = (d + ':' + param).replace(/'|\\/g, '_'); + def.__exp = def.__exp || {}; + def.__exp[rw] = def[d].text.replace(new RegExp('(^|[^\\w$])' + def[d].arg + '([^\\w$])', 'g'), '$1' + param + '$2'); + return s + 'def.__exp[\'' + rw + '\']'; + } }); - res(errResult); - } else { - rej(err); } + var v = new Function('def', 'return ' + code)(def); + return v ? resolveDefs(c, v, def) : v; }); + } + function unescape(code) { + return code.replace(/\\('|\\)/g, '$1').replace(/[\r\t\n]/g, ' '); + } + doT.template = function(tmpl, c, def) { + c = c || doT.templateSettings; + var cse = c.append ? startend.append : startend.split, needhtmlencode, sid = 0, indv, str = c.use || c.define ? resolveDefs(c, tmpl, def || {}) : tmpl; + str = ('var out=\'' + (c.strip ? str.replace(/(^|\r|\n)\t* +| +\t*(\r|\n|$)/g, ' ').replace(/\r|\n|\t|\/\*[\s\S]*?\*\//g, '') : str).replace(/'|\\/g, '\\$&').replace(c.interpolate || skip, function(m, code) { + return cse.start + unescape(code) + cse.end; + }).replace(c.encode || skip, function(m, code) { + needhtmlencode = true; + return cse.startencode + unescape(code) + cse.end; + }).replace(c.conditional || skip, function(m, elsecase, code) { + return elsecase ? code ? '\';}else if(' + unescape(code) + '){out+=\'' : '\';}else{out+=\'' : code ? '\';if(' + unescape(code) + '){out+=\'' : '\';}out+=\''; + }).replace(c.iterate || skip, function(m, iterate, vname, iname) { + if (!iterate) { + return '\';} } out+=\''; + } + sid += 1; + indv = iname || 'i' + sid; + iterate = unescape(iterate); + return '\';var arr' + sid + '=' + iterate + ';if(arr' + sid + '){var ' + vname + ',' + indv + '=-1,l' + sid + '=arr' + sid + '.length-1;while(' + indv + ' 0) { - var tags = [].concat(only.value); - audit.rules.forEach(function(rule) { - var tagPos, i, l; - if (!tags) { + var token = this; + executor(function cancel(message) { + if (token.reason) { return; } - for (i = 0, l = rule.tags.length; i < l; i++) { - tagPos = tags.indexOf(rule.tags[i]); - if (tagPos !== -1) { - tags.splice(tagPos, 1); - } - } + token.reason = new Cancel(message); + resolvePromise(token.reason); }); - if (tags.length !== 0) { - throw new Error('could not find tags `' + tags.join('`, `') + '`'); + } + CancelToken.prototype.throwIfRequested = function throwIfRequested() { + if (this.reason) { + throw this.reason; } + }; + CancelToken.source = function source() { + var cancel; + var token = new CancelToken(function executor(c) { + cancel = c; + }); + return { + token: token, + cancel: cancel + }; + }; + module.exports = CancelToken; + }, { + './Cancel': 6 + } ], + 8: [ function(_dereq_, module, exports) { + 'use strict'; + module.exports = function isCancel(value) { + return !!(value && value.__CANCEL__); + }; + }, {} ], + 9: [ function(_dereq_, module, exports) { + 'use strict'; + var utils = _dereq_('./../utils'); + var buildURL = _dereq_('../helpers/buildURL'); + var InterceptorManager = _dereq_('./InterceptorManager'); + var dispatchRequest = _dereq_('./dispatchRequest'); + var mergeConfig = _dereq_('./mergeConfig'); + function Axios(instanceConfig) { + this.defaults = instanceConfig; + this.interceptors = { + request: new InterceptorManager(), + response: new InterceptorManager() + }; } - } - if (_typeof(options.rules) === 'object') { - Object.keys(options.rules).forEach(function(ruleId) { - if (!audit.getRule(ruleId)) { - throw new Error('unknown rule `' + ruleId + '` in options.rules'); + Axios.prototype.request = function request(config) { + if (typeof config === 'string') { + config = arguments[1] || {}; + config.url = arguments[0]; + } else { + config = config || {}; + } + config = mergeConfig(this.defaults, config); + config.method = config.method ? config.method.toLowerCase() : 'get'; + var chain = [ dispatchRequest, undefined ]; + var promise = Promise.resolve(config); + this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) { + chain.unshift(interceptor.fulfilled, interceptor.rejected); + }); + this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) { + chain.push(interceptor.fulfilled, interceptor.rejected); + }); + while (chain.length) { + promise = promise.then(chain.shift(), chain.shift()); } + return promise; + }; + Axios.prototype.getUri = function getUri(config) { + config = mergeConfig(this.defaults, config); + return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, ''); + }; + utils.forEach([ 'delete', 'get', 'head', 'options' ], function forEachMethodNoData(method) { + Axios.prototype[method] = function(url, config) { + return this.request(utils.merge(config || {}, { + method: method, + url: url + })); + }; }); - } - return options; - }; - Audit.prototype.setBranding = function(branding) { - 'use strict'; - var previous = { - brand: this.brand, - application: this.application - }; - if (branding && branding.hasOwnProperty('brand') && branding.brand && typeof branding.brand === 'string') { - this.brand = branding.brand; - } - if (branding && branding.hasOwnProperty('application') && branding.application && typeof branding.application === 'string') { - this.application = branding.application; - } - this._constructHelpUrls(previous); - }; - function getHelpUrl(_ref, ruleId, version) { - var brand = _ref.brand, application = _ref.application; - return axe.constants.helpUrlBase + brand + '/' + (version || axe.version.substring(0, axe.version.lastIndexOf('.'))) + '/' + ruleId + '?application=' + application; - } - Audit.prototype._constructHelpUrls = function() { + utils.forEach([ 'post', 'put', 'patch' ], function forEachMethodWithData(method) { + Axios.prototype[method] = function(url, data, config) { + return this.request(utils.merge(config || {}, { + method: method, + url: url, + data: data + })); + }; + }); + module.exports = Axios; + }, { + '../helpers/buildURL': 19, + './../utils': 27, + './InterceptorManager': 10, + './dispatchRequest': 12, + './mergeConfig': 14 + } ], + 10: [ function(_dereq_, module, exports) { + 'use strict'; + var utils = _dereq_('./../utils'); + function InterceptorManager() { + this.handlers = []; + } + InterceptorManager.prototype.use = function use(fulfilled, rejected) { + this.handlers.push({ + fulfilled: fulfilled, + rejected: rejected + }); + return this.handlers.length - 1; + }; + InterceptorManager.prototype.eject = function eject(id) { + if (this.handlers[id]) { + this.handlers[id] = null; + } + }; + InterceptorManager.prototype.forEach = function forEach(fn) { + utils.forEach(this.handlers, function forEachHandler(h) { + if (h !== null) { + fn(h); + } + }); + }; + module.exports = InterceptorManager; + }, { + './../utils': 27 + } ], + 11: [ function(_dereq_, module, exports) { + 'use strict'; + var enhanceError = _dereq_('./enhanceError'); + module.exports = function createError(message, config, code, request, response) { + var error = new Error(message); + return enhanceError(error, config, code, request, response); + }; + }, { + './enhanceError': 13 + } ], + 12: [ function(_dereq_, module, exports) { + 'use strict'; + var utils = _dereq_('./../utils'); + var transformData = _dereq_('./transformData'); + var isCancel = _dereq_('../cancel/isCancel'); + var defaults = _dereq_('../defaults'); + var isAbsoluteURL = _dereq_('./../helpers/isAbsoluteURL'); + var combineURLs = _dereq_('./../helpers/combineURLs'); + function throwIfCancellationRequested(config) { + if (config.cancelToken) { + config.cancelToken.throwIfRequested(); + } + } + module.exports = function dispatchRequest(config) { + throwIfCancellationRequested(config); + if (config.baseURL && !isAbsoluteURL(config.url)) { + config.url = combineURLs(config.baseURL, config.url); + } + config.headers = config.headers || {}; + config.data = transformData(config.data, config.headers, config.transformRequest); + config.headers = utils.merge(config.headers.common || {}, config.headers[config.method] || {}, config.headers || {}); + utils.forEach([ 'delete', 'get', 'head', 'post', 'put', 'patch', 'common' ], function cleanHeaderConfig(method) { + delete config.headers[method]; + }); + var adapter = config.adapter || defaults.adapter; + return adapter(config).then(function onAdapterResolution(response) { + throwIfCancellationRequested(config); + response.data = transformData(response.data, response.headers, config.transformResponse); + return response; + }, function onAdapterRejection(reason) { + if (!isCancel(reason)) { + throwIfCancellationRequested(config); + if (reason && reason.response) { + reason.response.data = transformData(reason.response.data, reason.response.headers, config.transformResponse); + } + } + return Promise.reject(reason); + }); + }; + }, { + '../cancel/isCancel': 8, + '../defaults': 17, + './../helpers/combineURLs': 20, + './../helpers/isAbsoluteURL': 22, + './../utils': 27, + './transformData': 16 + } ], + 13: [ function(_dereq_, module, exports) { + 'use strict'; + module.exports = function enhanceError(error, config, code, request, response) { + error.config = config; + if (code) { + error.code = code; + } + error.request = request; + error.response = response; + error.isAxiosError = true; + error.toJSON = function() { + return { + message: this.message, + name: this.name, + description: this.description, + number: this.number, + fileName: this.fileName, + lineNumber: this.lineNumber, + columnNumber: this.columnNumber, + stack: this.stack, + config: this.config, + code: this.code + }; + }; + return error; + }; + }, {} ], + 14: [ function(_dereq_, module, exports) { + 'use strict'; + var utils = _dereq_('../utils'); + module.exports = function mergeConfig(config1, config2) { + config2 = config2 || {}; + var config = {}; + utils.forEach([ 'url', 'method', 'params', 'data' ], function valueFromConfig2(prop) { + if (typeof config2[prop] !== 'undefined') { + config[prop] = config2[prop]; + } + }); + utils.forEach([ 'headers', 'auth', 'proxy' ], function mergeDeepProperties(prop) { + if (utils.isObject(config2[prop])) { + config[prop] = utils.deepMerge(config1[prop], config2[prop]); + } else if (typeof config2[prop] !== 'undefined') { + config[prop] = config2[prop]; + } else if (utils.isObject(config1[prop])) { + config[prop] = utils.deepMerge(config1[prop]); + } else if (typeof config1[prop] !== 'undefined') { + config[prop] = config1[prop]; + } + }); + utils.forEach([ 'baseURL', 'transformRequest', 'transformResponse', 'paramsSerializer', 'timeout', 'withCredentials', 'adapter', 'responseType', 'xsrfCookieName', 'xsrfHeaderName', 'onUploadProgress', 'onDownloadProgress', 'maxContentLength', 'validateStatus', 'maxRedirects', 'httpAgent', 'httpsAgent', 'cancelToken', 'socketPath' ], function defaultToConfig2(prop) { + if (typeof config2[prop] !== 'undefined') { + config[prop] = config2[prop]; + } else if (typeof config1[prop] !== 'undefined') { + config[prop] = config1[prop]; + } + }); + return config; + }; + }, { + '../utils': 27 + } ], + 15: [ function(_dereq_, module, exports) { + 'use strict'; + var createError = _dereq_('./createError'); + module.exports = function settle(resolve, reject, response) { + var validateStatus = response.config.validateStatus; + if (!validateStatus || validateStatus(response.status)) { + resolve(response); + } else { + reject(createError('Request failed with status code ' + response.status, response.config, null, response.request, response)); + } + }; + }, { + './createError': 11 + } ], + 16: [ function(_dereq_, module, exports) { + 'use strict'; + var utils = _dereq_('./../utils'); + module.exports = function transformData(data, headers, fns) { + utils.forEach(fns, function transform(fn) { + data = fn(data, headers); + }); + return data; + }; + }, { + './../utils': 27 + } ], + 17: [ function(_dereq_, module, exports) { + (function(process) { + 'use strict'; + var utils = _dereq_('./utils'); + var normalizeHeaderName = _dereq_('./helpers/normalizeHeaderName'); + var DEFAULT_CONTENT_TYPE = { + 'Content-Type': 'application/x-www-form-urlencoded' + }; + function setContentTypeIfUnset(headers, value) { + if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) { + headers['Content-Type'] = value; + } + } + function getDefaultAdapter() { + var adapter; + if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') { + adapter = _dereq_('./adapters/http'); + } else if (typeof XMLHttpRequest !== 'undefined') { + adapter = _dereq_('./adapters/xhr'); + } + return adapter; + } + var defaults = { + adapter: getDefaultAdapter(), + transformRequest: [ function transformRequest(data, headers) { + normalizeHeaderName(headers, 'Accept'); + normalizeHeaderName(headers, 'Content-Type'); + if (utils.isFormData(data) || utils.isArrayBuffer(data) || utils.isBuffer(data) || utils.isStream(data) || utils.isFile(data) || utils.isBlob(data)) { + return data; + } + if (utils.isArrayBufferView(data)) { + return data.buffer; + } + if (utils.isURLSearchParams(data)) { + setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8'); + return data.toString(); + } + if (utils.isObject(data)) { + setContentTypeIfUnset(headers, 'application/json;charset=utf-8'); + return JSON.stringify(data); + } + return data; + } ], + transformResponse: [ function transformResponse(data) { + if (typeof data === 'string') { + try { + data = JSON.parse(data); + } catch (e) {} + } + return data; + } ], + timeout: 0, + xsrfCookieName: 'XSRF-TOKEN', + xsrfHeaderName: 'X-XSRF-TOKEN', + maxContentLength: -1, + validateStatus: function validateStatus(status) { + return status >= 200 && status < 300; + } + }; + defaults.headers = { + common: { + Accept: 'application/json, text/plain, */*' + } + }; + utils.forEach([ 'delete', 'get', 'head' ], function forEachMethodNoData(method) { + defaults.headers[method] = {}; + }); + utils.forEach([ 'post', 'put', 'patch' ], function forEachMethodWithData(method) { + defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE); + }); + module.exports = defaults; + }).call(this, _dereq_('_process')); + }, { + './adapters/http': 4, + './adapters/xhr': 4, + './helpers/normalizeHeaderName': 24, + './utils': 27, + _process: 33 + } ], + 18: [ function(_dereq_, module, exports) { + 'use strict'; + module.exports = function bind(fn, thisArg) { + return function wrap() { + var args = new Array(arguments.length); + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i]; + } + return fn.apply(thisArg, args); + }; + }; + }, {} ], + 19: [ function(_dereq_, module, exports) { + 'use strict'; + var utils = _dereq_('./../utils'); + function encode(val) { + return encodeURIComponent(val).replace(/%40/gi, '@').replace(/%3A/gi, ':').replace(/%24/g, '$').replace(/%2C/gi, ',').replace(/%20/g, '+').replace(/%5B/gi, '[').replace(/%5D/gi, ']'); + } + module.exports = function buildURL(url, params, paramsSerializer) { + if (!params) { + return url; + } + var serializedParams; + if (paramsSerializer) { + serializedParams = paramsSerializer(params); + } else if (utils.isURLSearchParams(params)) { + serializedParams = params.toString(); + } else { + var parts = []; + utils.forEach(params, function serialize(val, key) { + if (val === null || typeof val === 'undefined') { + return; + } + if (utils.isArray(val)) { + key = key + '[]'; + } else { + val = [ val ]; + } + utils.forEach(val, function parseValue(v) { + if (utils.isDate(v)) { + v = v.toISOString(); + } else if (utils.isObject(v)) { + v = JSON.stringify(v); + } + parts.push(encode(key) + '=' + encode(v)); + }); + }); + serializedParams = parts.join('&'); + } + if (serializedParams) { + var hashmarkIndex = url.indexOf('#'); + if (hashmarkIndex !== -1) { + url = url.slice(0, hashmarkIndex); + } + url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams; + } + return url; + }; + }, { + './../utils': 27 + } ], + 20: [ function(_dereq_, module, exports) { + 'use strict'; + module.exports = function combineURLs(baseURL, relativeURL) { + return relativeURL ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '') : baseURL; + }; + }, {} ], + 21: [ function(_dereq_, module, exports) { + 'use strict'; + var utils = _dereq_('./../utils'); + module.exports = utils.isStandardBrowserEnv() ? function standardBrowserEnv() { + return { + write: function write(name, value, expires, path, domain, secure) { + var cookie = []; + cookie.push(name + '=' + encodeURIComponent(value)); + if (utils.isNumber(expires)) { + cookie.push('expires=' + new Date(expires).toGMTString()); + } + if (utils.isString(path)) { + cookie.push('path=' + path); + } + if (utils.isString(domain)) { + cookie.push('domain=' + domain); + } + if (secure === true) { + cookie.push('secure'); + } + document.cookie = cookie.join('; '); + }, + read: function read(name) { + var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)')); + return match ? decodeURIComponent(match[3]) : null; + }, + remove: function remove(name) { + this.write(name, '', Date.now() - 864e5); + } + }; + }() : function nonStandardBrowserEnv() { + return { + write: function write() {}, + read: function read() { + return null; + }, + remove: function remove() {} + }; + }(); + }, { + './../utils': 27 + } ], + 22: [ function(_dereq_, module, exports) { + 'use strict'; + module.exports = function isAbsoluteURL(url) { + return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url); + }; + }, {} ], + 23: [ function(_dereq_, module, exports) { + 'use strict'; + var utils = _dereq_('./../utils'); + module.exports = utils.isStandardBrowserEnv() ? function standardBrowserEnv() { + var msie = /(msie|trident)/i.test(navigator.userAgent); + var urlParsingNode = document.createElement('a'); + var originURL; + function resolveURL(url) { + var href = url; + if (msie) { + urlParsingNode.setAttribute('href', href); + href = urlParsingNode.href; + } + urlParsingNode.setAttribute('href', href); + return { + href: urlParsingNode.href, + protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '', + host: urlParsingNode.host, + search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '', + hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '', + hostname: urlParsingNode.hostname, + port: urlParsingNode.port, + pathname: urlParsingNode.pathname.charAt(0) === '/' ? urlParsingNode.pathname : '/' + urlParsingNode.pathname + }; + } + originURL = resolveURL(window.location.href); + return function isURLSameOrigin(requestURL) { + var parsed = utils.isString(requestURL) ? resolveURL(requestURL) : requestURL; + return parsed.protocol === originURL.protocol && parsed.host === originURL.host; + }; + }() : function nonStandardBrowserEnv() { + return function isURLSameOrigin() { + return true; + }; + }(); + }, { + './../utils': 27 + } ], + 24: [ function(_dereq_, module, exports) { + 'use strict'; + var utils = _dereq_('../utils'); + module.exports = function normalizeHeaderName(headers, normalizedName) { + utils.forEach(headers, function processHeader(value, name) { + if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) { + headers[normalizedName] = value; + delete headers[name]; + } + }); + }; + }, { + '../utils': 27 + } ], + 25: [ function(_dereq_, module, exports) { + 'use strict'; + var utils = _dereq_('./../utils'); + var ignoreDuplicateOf = [ 'age', 'authorization', 'content-length', 'content-type', 'etag', 'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since', 'last-modified', 'location', 'max-forwards', 'proxy-authorization', 'referer', 'retry-after', 'user-agent' ]; + module.exports = function parseHeaders(headers) { + var parsed = {}; + var key; + var val; + var i; + if (!headers) { + return parsed; + } + utils.forEach(headers.split('\n'), function parser(line) { + i = line.indexOf(':'); + key = utils.trim(line.substr(0, i)).toLowerCase(); + val = utils.trim(line.substr(i + 1)); + if (key) { + if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) { + return; + } + if (key === 'set-cookie') { + parsed[key] = (parsed[key] ? parsed[key] : []).concat([ val ]); + } else { + parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val; + } + } + }); + return parsed; + }; + }, { + './../utils': 27 + } ], + 26: [ function(_dereq_, module, exports) { + 'use strict'; + module.exports = function spread(callback) { + return function wrap(arr) { + return callback.apply(null, arr); + }; + }; + }, {} ], + 27: [ function(_dereq_, module, exports) { + 'use strict'; + var bind = _dereq_('./helpers/bind'); + var isBuffer = _dereq_('is-buffer'); + var toString = Object.prototype.toString; + function isArray(val) { + return toString.call(val) === '[object Array]'; + } + function isArrayBuffer(val) { + return toString.call(val) === '[object ArrayBuffer]'; + } + function isFormData(val) { + return typeof FormData !== 'undefined' && val instanceof FormData; + } + function isArrayBufferView(val) { + var result; + if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) { + result = ArrayBuffer.isView(val); + } else { + result = val && val.buffer && val.buffer instanceof ArrayBuffer; + } + return result; + } + function isString(val) { + return typeof val === 'string'; + } + function isNumber(val) { + return typeof val === 'number'; + } + function isUndefined(val) { + return typeof val === 'undefined'; + } + function isObject(val) { + return val !== null && typeof val === 'object'; + } + function isDate(val) { + return toString.call(val) === '[object Date]'; + } + function isFile(val) { + return toString.call(val) === '[object File]'; + } + function isBlob(val) { + return toString.call(val) === '[object Blob]'; + } + function isFunction(val) { + return toString.call(val) === '[object Function]'; + } + function isStream(val) { + return isObject(val) && isFunction(val.pipe); + } + function isURLSearchParams(val) { + return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams; + } + function trim(str) { + return str.replace(/^\s*/, '').replace(/\s*$/, ''); + } + function isStandardBrowserEnv() { + if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' || navigator.product === 'NativeScript' || navigator.product === 'NS')) { + return false; + } + return typeof window !== 'undefined' && typeof document !== 'undefined'; + } + function forEach(obj, fn) { + if (obj === null || typeof obj === 'undefined') { + return; + } + if (typeof obj !== 'object') { + obj = [ obj ]; + } + if (isArray(obj)) { + for (var i = 0, l = obj.length; i < l; i++) { + fn.call(null, obj[i], i, obj); + } + } else { + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + fn.call(null, obj[key], key, obj); + } + } + } + } + function merge() { + var result = {}; + function assignValue(val, key) { + if (typeof result[key] === 'object' && typeof val === 'object') { + result[key] = merge(result[key], val); + } else { + result[key] = val; + } + } + for (var i = 0, l = arguments.length; i < l; i++) { + forEach(arguments[i], assignValue); + } + return result; + } + function deepMerge() { + var result = {}; + function assignValue(val, key) { + if (typeof result[key] === 'object' && typeof val === 'object') { + result[key] = deepMerge(result[key], val); + } else if (typeof val === 'object') { + result[key] = deepMerge({}, val); + } else { + result[key] = val; + } + } + for (var i = 0, l = arguments.length; i < l; i++) { + forEach(arguments[i], assignValue); + } + return result; + } + function extend(a, b, thisArg) { + forEach(b, function assignValue(val, key) { + if (thisArg && typeof val === 'function') { + a[key] = bind(val, thisArg); + } else { + a[key] = val; + } + }); + return a; + } + module.exports = { + isArray: isArray, + isArrayBuffer: isArrayBuffer, + isBuffer: isBuffer, + isFormData: isFormData, + isArrayBufferView: isArrayBufferView, + isString: isString, + isNumber: isNumber, + isObject: isObject, + isUndefined: isUndefined, + isDate: isDate, + isFile: isFile, + isBlob: isBlob, + isFunction: isFunction, + isStream: isStream, + isURLSearchParams: isURLSearchParams, + isStandardBrowserEnv: isStandardBrowserEnv, + forEach: forEach, + merge: merge, + deepMerge: deepMerge, + extend: extend, + trim: trim + }; + }, { + './helpers/bind': 18, + 'is-buffer': 28 + } ], + 28: [ function(_dereq_, module, exports) { + module.exports = function isBuffer(obj) { + return obj != null && obj.constructor != null && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj); + }; + }, {} ], + 29: [ function(_dereq_, module, exports) { + module.exports = { + CssSelectorParser: _dereq_('./lib/css-selector-parser.js').CssSelectorParser + }; + }, { + './lib/css-selector-parser.js': 30 + } ], + 30: [ function(_dereq_, module, exports) { + function CssSelectorParser() { + this.pseudos = {}; + this.attrEqualityMods = {}; + this.ruleNestingOperators = {}; + this.substitutesEnabled = false; + } + CssSelectorParser.prototype.registerSelectorPseudos = function(name) { + for (var j = 0, len = arguments.length; j < len; j++) { + name = arguments[j]; + this.pseudos[name] = 'selector'; + } + return this; + }; + CssSelectorParser.prototype.unregisterSelectorPseudos = function(name) { + for (var j = 0, len = arguments.length; j < len; j++) { + name = arguments[j]; + delete this.pseudos[name]; + } + return this; + }; + CssSelectorParser.prototype.registerNumericPseudos = function(name) { + for (var j = 0, len = arguments.length; j < len; j++) { + name = arguments[j]; + this.pseudos[name] = 'numeric'; + } + return this; + }; + CssSelectorParser.prototype.unregisterNumericPseudos = function(name) { + for (var j = 0, len = arguments.length; j < len; j++) { + name = arguments[j]; + delete this.pseudos[name]; + } + return this; + }; + CssSelectorParser.prototype.registerNestingOperators = function(operator) { + for (var j = 0, len = arguments.length; j < len; j++) { + operator = arguments[j]; + this.ruleNestingOperators[operator] = true; + } + return this; + }; + CssSelectorParser.prototype.unregisterNestingOperators = function(operator) { + for (var j = 0, len = arguments.length; j < len; j++) { + operator = arguments[j]; + delete this.ruleNestingOperators[operator]; + } + return this; + }; + CssSelectorParser.prototype.registerAttrEqualityMods = function(mod) { + for (var j = 0, len = arguments.length; j < len; j++) { + mod = arguments[j]; + this.attrEqualityMods[mod] = true; + } + return this; + }; + CssSelectorParser.prototype.unregisterAttrEqualityMods = function(mod) { + for (var j = 0, len = arguments.length; j < len; j++) { + mod = arguments[j]; + delete this.attrEqualityMods[mod]; + } + return this; + }; + CssSelectorParser.prototype.enableSubstitutes = function() { + this.substitutesEnabled = true; + return this; + }; + CssSelectorParser.prototype.disableSubstitutes = function() { + this.substitutesEnabled = false; + return this; + }; + function isIdentStart(c) { + return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c === '-' || c === '_'; + } + function isIdent(c) { + return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || c === '-' || c === '_'; + } + function isHex(c) { + return c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F' || c >= '0' && c <= '9'; + } + function isDecimal(c) { + return c >= '0' && c <= '9'; + } + function isAttrMatchOperator(chr) { + return chr === '=' || chr === '^' || chr === '$' || chr === '*' || chr === '~'; + } + var identSpecialChars = { + '!': true, + '"': true, + '#': true, + $: true, + '%': true, + '&': true, + '\'': true, + '(': true, + ')': true, + '*': true, + '+': true, + ',': true, + '.': true, + '/': true, + ';': true, + '<': true, + '=': true, + '>': true, + '?': true, + '@': true, + '[': true, + '\\': true, + ']': true, + '^': true, + '`': true, + '{': true, + '|': true, + '}': true, + '~': true + }; + var strReplacementsRev = { + '\n': '\\n', + '\r': '\\r', + '\t': '\\t', + '\f': '\\f', + '\v': '\\v' + }; + var singleQuoteEscapeChars = { + n: '\n', + r: '\r', + t: '\t', + f: '\f', + '\\': '\\', + '\'': '\'' + }; + var doubleQuotesEscapeChars = { + n: '\n', + r: '\r', + t: '\t', + f: '\f', + '\\': '\\', + '"': '"' + }; + function ParseContext(str, pos, pseudos, attrEqualityMods, ruleNestingOperators, substitutesEnabled) { + var chr, getIdent, getStr, l, skipWhitespace; + l = str.length; + chr = null; + getStr = function(quote, escapeTable) { + var esc, hex, result; + result = ''; + pos++; + chr = str.charAt(pos); + while (pos < l) { + if (chr === quote) { + pos++; + return result; + } else if (chr === '\\') { + pos++; + chr = str.charAt(pos); + if (chr === quote) { + result += quote; + } else if (esc = escapeTable[chr]) { + result += esc; + } else if (isHex(chr)) { + hex = chr; + pos++; + chr = str.charAt(pos); + while (isHex(chr)) { + hex += chr; + pos++; + chr = str.charAt(pos); + } + if (chr === ' ') { + pos++; + chr = str.charAt(pos); + } + result += String.fromCharCode(parseInt(hex, 16)); + continue; + } else { + result += chr; + } + } else { + result += chr; + } + pos++; + chr = str.charAt(pos); + } + return result; + }; + getIdent = function() { + var result = ''; + chr = str.charAt(pos); + while (pos < l) { + if (isIdent(chr)) { + result += chr; + } else if (chr === '\\') { + pos++; + if (pos >= l) { + throw Error('Expected symbol but end of file reached.'); + } + chr = str.charAt(pos); + if (identSpecialChars[chr]) { + result += chr; + } else if (isHex(chr)) { + var hex = chr; + pos++; + chr = str.charAt(pos); + while (isHex(chr)) { + hex += chr; + pos++; + chr = str.charAt(pos); + } + if (chr === ' ') { + pos++; + chr = str.charAt(pos); + } + result += String.fromCharCode(parseInt(hex, 16)); + continue; + } else { + result += chr; + } + } else { + return result; + } + pos++; + chr = str.charAt(pos); + } + return result; + }; + skipWhitespace = function() { + chr = str.charAt(pos); + var result = false; + while (chr === ' ' || chr === '\t' || chr === '\n' || chr === '\r' || chr === '\f') { + result = true; + pos++; + chr = str.charAt(pos); + } + return result; + }; + this.parse = function() { + var res = this.parseSelector(); + if (pos < l) { + throw Error('Rule expected but "' + str.charAt(pos) + '" found.'); + } + return res; + }; + this.parseSelector = function() { + var res; + var selector = res = this.parseSingleSelector(); + chr = str.charAt(pos); + while (chr === ',') { + pos++; + skipWhitespace(); + if (res.type !== 'selectors') { + res = { + type: 'selectors', + selectors: [ selector ] + }; + } + selector = this.parseSingleSelector(); + if (!selector) { + throw Error('Rule expected after ",".'); + } + res.selectors.push(selector); + } + return res; + }; + this.parseSingleSelector = function() { + skipWhitespace(); + var selector = { + type: 'ruleSet' + }; + var rule = this.parseRule(); + if (!rule) { + return null; + } + var currentRule = selector; + while (rule) { + rule.type = 'rule'; + currentRule.rule = rule; + currentRule = rule; + skipWhitespace(); + chr = str.charAt(pos); + if (pos >= l || chr === ',' || chr === ')') { + break; + } + if (ruleNestingOperators[chr]) { + var op = chr; + pos++; + skipWhitespace(); + rule = this.parseRule(); + if (!rule) { + throw Error('Rule expected after "' + op + '".'); + } + rule.nestingOperator = op; + } else { + rule = this.parseRule(); + if (rule) { + rule.nestingOperator = null; + } + } + } + return selector; + }; + this.parseRule = function() { + var rule = null; + while (pos < l) { + chr = str.charAt(pos); + if (chr === '*') { + pos++; + (rule = rule || {}).tagName = '*'; + } else if (isIdentStart(chr) || chr === '\\') { + (rule = rule || {}).tagName = getIdent(); + } else if (chr === '.') { + pos++; + rule = rule || {}; + (rule.classNames = rule.classNames || []).push(getIdent()); + } else if (chr === '#') { + pos++; + (rule = rule || {}).id = getIdent(); + } else if (chr === '[') { + pos++; + skipWhitespace(); + var attr = { + name: getIdent() + }; + skipWhitespace(); + if (chr === ']') { + pos++; + } else { + var operator = ''; + if (attrEqualityMods[chr]) { + operator = chr; + pos++; + chr = str.charAt(pos); + } + if (pos >= l) { + throw Error('Expected "=" but end of file reached.'); + } + if (chr !== '=') { + throw Error('Expected "=" but "' + chr + '" found.'); + } + attr.operator = operator + '='; + pos++; + skipWhitespace(); + var attrValue = ''; + attr.valueType = 'string'; + if (chr === '"') { + attrValue = getStr('"', doubleQuotesEscapeChars); + } else if (chr === '\'') { + attrValue = getStr('\'', singleQuoteEscapeChars); + } else if (substitutesEnabled && chr === '$') { + pos++; + attrValue = getIdent(); + attr.valueType = 'substitute'; + } else { + while (pos < l) { + if (chr === ']') { + break; + } + attrValue += chr; + pos++; + chr = str.charAt(pos); + } + attrValue = attrValue.trim(); + } + skipWhitespace(); + if (pos >= l) { + throw Error('Expected "]" but end of file reached.'); + } + if (chr !== ']') { + throw Error('Expected "]" but "' + chr + '" found.'); + } + pos++; + attr.value = attrValue; + } + rule = rule || {}; + (rule.attrs = rule.attrs || []).push(attr); + } else if (chr === ':') { + pos++; + var pseudoName = getIdent(); + var pseudo = { + name: pseudoName + }; + if (chr === '(') { + pos++; + var value = ''; + skipWhitespace(); + if (pseudos[pseudoName] === 'selector') { + pseudo.valueType = 'selector'; + value = this.parseSelector(); + } else { + pseudo.valueType = pseudos[pseudoName] || 'string'; + if (chr === '"') { + value = getStr('"', doubleQuotesEscapeChars); + } else if (chr === '\'') { + value = getStr('\'', singleQuoteEscapeChars); + } else if (substitutesEnabled && chr === '$') { + pos++; + value = getIdent(); + pseudo.valueType = 'substitute'; + } else { + while (pos < l) { + if (chr === ')') { + break; + } + value += chr; + pos++; + chr = str.charAt(pos); + } + value = value.trim(); + } + skipWhitespace(); + } + if (pos >= l) { + throw Error('Expected ")" but end of file reached.'); + } + if (chr !== ')') { + throw Error('Expected ")" but "' + chr + '" found.'); + } + pos++; + pseudo.value = value; + } + rule = rule || {}; + (rule.pseudos = rule.pseudos || []).push(pseudo); + } else { + break; + } + } + return rule; + }; + return this; + } + CssSelectorParser.prototype.parse = function(str) { + var context = new ParseContext(str, 0, this.pseudos, this.attrEqualityMods, this.ruleNestingOperators, this.substitutesEnabled); + return context.parse(); + }; + CssSelectorParser.prototype.escapeIdentifier = function(s) { + var result = ''; + var i = 0; + var len = s.length; + while (i < len) { + var chr = s.charAt(i); + if (identSpecialChars[chr]) { + result += '\\' + chr; + } else { + if (!(chr === '_' || chr === '-' || chr >= 'A' && chr <= 'Z' || chr >= 'a' && chr <= 'z' || i !== 0 && chr >= '0' && chr <= '9')) { + var charCode = chr.charCodeAt(0); + if ((charCode & 63488) === 55296) { + var extraCharCode = s.charCodeAt(i++); + if ((charCode & 64512) !== 55296 || (extraCharCode & 64512) !== 56320) { + throw Error('UCS-2(decode): illegal sequence'); + } + charCode = ((charCode & 1023) << 10) + (extraCharCode & 1023) + 65536; + } + result += '\\' + charCode.toString(16) + ' '; + } else { + result += chr; + } + } + i++; + } + return result; + }; + CssSelectorParser.prototype.escapeStr = function(s) { + var result = ''; + var i = 0; + var len = s.length; + var chr, replacement; + while (i < len) { + chr = s.charAt(i); + if (chr === '"') { + chr = '\\"'; + } else if (chr === '\\') { + chr = '\\\\'; + } else if (replacement = strReplacementsRev[chr]) { + chr = replacement; + } + result += chr; + i++; + } + return '"' + result + '"'; + }; + CssSelectorParser.prototype.render = function(path) { + return this._renderEntity(path).trim(); + }; + CssSelectorParser.prototype._renderEntity = function(entity) { + var currentEntity, parts, res; + res = ''; + switch (entity.type) { + case 'ruleSet': + currentEntity = entity.rule; + parts = []; + while (currentEntity) { + if (currentEntity.nestingOperator) { + parts.push(currentEntity.nestingOperator); + } + parts.push(this._renderEntity(currentEntity)); + currentEntity = currentEntity.rule; + } + res = parts.join(' '); + break; + + case 'selectors': + res = entity.selectors.map(this._renderEntity, this).join(', '); + break; + + case 'rule': + if (entity.tagName) { + if (entity.tagName === '*') { + res = '*'; + } else { + res = this.escapeIdentifier(entity.tagName); + } + } + if (entity.id) { + res += '#' + this.escapeIdentifier(entity.id); + } + if (entity.classNames) { + res += entity.classNames.map(function(cn) { + return '.' + this.escapeIdentifier(cn); + }, this).join(''); + } + if (entity.attrs) { + res += entity.attrs.map(function(attr) { + if (attr.operator) { + if (attr.valueType === 'substitute') { + return '[' + this.escapeIdentifier(attr.name) + attr.operator + '$' + attr.value + ']'; + } else { + return '[' + this.escapeIdentifier(attr.name) + attr.operator + this.escapeStr(attr.value) + ']'; + } + } else { + return '[' + this.escapeIdentifier(attr.name) + ']'; + } + }, this).join(''); + } + if (entity.pseudos) { + res += entity.pseudos.map(function(pseudo) { + if (pseudo.valueType) { + if (pseudo.valueType === 'selector') { + return ':' + this.escapeIdentifier(pseudo.name) + '(' + this._renderEntity(pseudo.value) + ')'; + } else if (pseudo.valueType === 'substitute') { + return ':' + this.escapeIdentifier(pseudo.name) + '($' + pseudo.value + ')'; + } else if (pseudo.valueType === 'numeric') { + return ':' + this.escapeIdentifier(pseudo.name) + '(' + pseudo.value + ')'; + } else { + return ':' + this.escapeIdentifier(pseudo.name) + '(' + this.escapeIdentifier(pseudo.value) + ')'; + } + } else { + return ':' + this.escapeIdentifier(pseudo.name); + } + }, this).join(''); + } + break; + + default: + throw Error('Unknown entity type: "' + entity.type(+'".')); + } + return res; + }; + exports.CssSelectorParser = CssSelectorParser; + }, {} ], + 31: [ function(_dereq_, module, exports) { + 'use strict'; + module.exports = function() { + return /\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73)\uDB40\uDC7F|\uD83D\uDC68(?:\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68\uD83C\uDFFB|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|[\u2695\u2696\u2708]\uFE0F|\uD83D[\uDC66\uDC67]|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|(?:\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708])\uFE0F|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C[\uDFFB-\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)\uD83C\uDFFB|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1)|(?:\uD83E\uDDD1\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFE])|(?:\uD83E\uDDD1\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB\uDFFC])|\uD83D\uDC69(?:\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFC-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|(?:\uD83E\uDDD1\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D\uD83D\uDC69)(?:\uD83C[\uDFFB-\uDFFD])|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|(?:(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)\uFE0F|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:(?:\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\u200D[\u2640\u2642])|\uD83C\uDFF4\u200D\u2620)\uFE0F|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|\uD83D\uDC15\u200D\uD83E\uDDBA|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF4\uD83C\uDDF2|\uD83C\uDDF6\uD83C\uDDE6|[#\*0-9]\uFE0F\u20E3|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83D\uDC69(?:\uD83C[\uDFFB-\uDFFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270A-\u270D]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC70\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDCAA\uDD74\uDD7A\uDD90\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD36\uDDB5\uDDB6\uDDBB\uDDD2-\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDED5\uDEEB\uDEEC\uDEF4-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDED5\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEFA\uDFE0-\uDFEB]|\uD83E[\uDD0D-\uDD3A\uDD3C-\uDD45\uDD47-\uDD71\uDD73-\uDD76\uDD7A-\uDDA2\uDDA5-\uDDAA\uDDAE-\uDDCA\uDDCD-\uDDFF\uDE70-\uDE73\uDE78-\uDE7A\uDE80-\uDE82\uDE90-\uDE95])\uFE0F|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDC8F\uDC91\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD0F\uDD18-\uDD1F\uDD26\uDD30-\uDD39\uDD3C-\uDD3E\uDDB5\uDDB6\uDDB8\uDDB9\uDDBB\uDDCD-\uDDCF\uDDD1-\uDDDD])/g; + }; + }, {} ], + 32: [ function(_dereq_, module, exports) { + (function(process, global) { + (function(global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : global.ES6Promise = factory(); + })(this, function() { + 'use strict'; + function objectOrFunction(x) { + var type = typeof x; + return x !== null && (type === 'object' || type === 'function'); + } + function isFunction(x) { + return typeof x === 'function'; + } + var _isArray = void 0; + if (Array.isArray) { + _isArray = Array.isArray; + } else { + _isArray = function(x) { + return Object.prototype.toString.call(x) === '[object Array]'; + }; + } + var isArray = _isArray; + var len = 0; + var vertxNext = void 0; + var customSchedulerFn = void 0; + var asap = function asap(callback, arg) { + queue[len] = callback; + queue[len + 1] = arg; + len += 2; + if (len === 2) { + if (customSchedulerFn) { + customSchedulerFn(flush); + } else { + scheduleFlush(); + } + } + }; + function setScheduler(scheduleFn) { + customSchedulerFn = scheduleFn; + } + function setAsap(asapFn) { + asap = asapFn; + } + var browserWindow = typeof window !== 'undefined' ? window : undefined; + var browserGlobal = browserWindow || {}; + var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver; + var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]'; + var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined'; + function useNextTick() { + return function() { + return process.nextTick(flush); + }; + } + function useVertxTimer() { + if (typeof vertxNext !== 'undefined') { + return function() { + vertxNext(flush); + }; + } + return useSetTimeout(); + } + function useMutationObserver() { + var iterations = 0; + var observer = new BrowserMutationObserver(flush); + var node = document.createTextNode(''); + observer.observe(node, { + characterData: true + }); + return function() { + node.data = iterations = ++iterations % 2; + }; + } + function useMessageChannel() { + var channel = new MessageChannel(); + channel.port1.onmessage = flush; + return function() { + return channel.port2.postMessage(0); + }; + } + function useSetTimeout() { + var globalSetTimeout = setTimeout; + return function() { + return globalSetTimeout(flush, 1); + }; + } + var queue = new Array(1e3); + function flush() { + for (var i = 0; i < len; i += 2) { + var callback = queue[i]; + var arg = queue[i + 1]; + callback(arg); + queue[i] = undefined; + queue[i + 1] = undefined; + } + len = 0; + } + function attemptVertx() { + try { + var vertx = Function('return this')().require('vertx'); + vertxNext = vertx.runOnLoop || vertx.runOnContext; + return useVertxTimer(); + } catch (e) { + return useSetTimeout(); + } + } + var scheduleFlush = void 0; + if (isNode) { + scheduleFlush = useNextTick(); + } else if (BrowserMutationObserver) { + scheduleFlush = useMutationObserver(); + } else if (isWorker) { + scheduleFlush = useMessageChannel(); + } else if (browserWindow === undefined && typeof _dereq_ === 'function') { + scheduleFlush = attemptVertx(); + } else { + scheduleFlush = useSetTimeout(); + } + function then(onFulfillment, onRejection) { + var parent = this; + var child = new this.constructor(noop); + if (child[PROMISE_ID] === undefined) { + makePromise(child); + } + var _state = parent._state; + if (_state) { + var callback = arguments[_state - 1]; + asap(function() { + return invokeCallback(_state, child, callback, parent._result); + }); + } else { + subscribe(parent, child, onFulfillment, onRejection); + } + return child; + } + function resolve$1(object) { + var Constructor = this; + if (object && typeof object === 'object' && object.constructor === Constructor) { + return object; + } + var promise = new Constructor(noop); + resolve(promise, object); + return promise; + } + var PROMISE_ID = Math.random().toString(36).substring(2); + function noop() {} + var PENDING = void 0; + var FULFILLED = 1; + var REJECTED = 2; + function selfFulfillment() { + return new TypeError('You cannot resolve a promise with itself'); + } + function cannotReturnOwn() { + return new TypeError('A promises callback cannot return that same promise.'); + } + function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) { + try { + then$$1.call(value, fulfillmentHandler, rejectionHandler); + } catch (e) { + return e; + } + } + function handleForeignThenable(promise, thenable, then$$1) { + asap(function(promise) { + var sealed = false; + var error = tryThen(then$$1, thenable, function(value) { + if (sealed) { + return; + } + sealed = true; + if (thenable !== value) { + resolve(promise, value); + } else { + fulfill(promise, value); + } + }, function(reason) { + if (sealed) { + return; + } + sealed = true; + reject(promise, reason); + }, 'Settle: ' + (promise._label || ' unknown promise')); + if (!sealed && error) { + sealed = true; + reject(promise, error); + } + }, promise); + } + function handleOwnThenable(promise, thenable) { + if (thenable._state === FULFILLED) { + fulfill(promise, thenable._result); + } else if (thenable._state === REJECTED) { + reject(promise, thenable._result); + } else { + subscribe(thenable, undefined, function(value) { + return resolve(promise, value); + }, function(reason) { + return reject(promise, reason); + }); + } + } + function handleMaybeThenable(promise, maybeThenable, then$$1) { + if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) { + handleOwnThenable(promise, maybeThenable); + } else { + if (then$$1 === undefined) { + fulfill(promise, maybeThenable); + } else if (isFunction(then$$1)) { + handleForeignThenable(promise, maybeThenable, then$$1); + } else { + fulfill(promise, maybeThenable); + } + } + } + function resolve(promise, value) { + if (promise === value) { + reject(promise, selfFulfillment()); + } else if (objectOrFunction(value)) { + var then$$1 = void 0; + try { + then$$1 = value.then; + } catch (error) { + reject(promise, error); + return; + } + handleMaybeThenable(promise, value, then$$1); + } else { + fulfill(promise, value); + } + } + function publishRejection(promise) { + if (promise._onerror) { + promise._onerror(promise._result); + } + publish(promise); + } + function fulfill(promise, value) { + if (promise._state !== PENDING) { + return; + } + promise._result = value; + promise._state = FULFILLED; + if (promise._subscribers.length !== 0) { + asap(publish, promise); + } + } + function reject(promise, reason) { + if (promise._state !== PENDING) { + return; + } + promise._state = REJECTED; + promise._result = reason; + asap(publishRejection, promise); + } + function subscribe(parent, child, onFulfillment, onRejection) { + var _subscribers = parent._subscribers; + var length = _subscribers.length; + parent._onerror = null; + _subscribers[length] = child; + _subscribers[length + FULFILLED] = onFulfillment; + _subscribers[length + REJECTED] = onRejection; + if (length === 0 && parent._state) { + asap(publish, parent); + } + } + function publish(promise) { + var subscribers = promise._subscribers; + var settled = promise._state; + if (subscribers.length === 0) { + return; + } + var child = void 0, callback = void 0, detail = promise._result; + for (var i = 0; i < subscribers.length; i += 3) { + child = subscribers[i]; + callback = subscribers[i + settled]; + if (child) { + invokeCallback(settled, child, callback, detail); + } else { + callback(detail); + } + } + promise._subscribers.length = 0; + } + function invokeCallback(settled, promise, callback, detail) { + var hasCallback = isFunction(callback), value = void 0, error = void 0, succeeded = true; + if (hasCallback) { + try { + value = callback(detail); + } catch (e) { + succeeded = false; + error = e; + } + if (promise === value) { + reject(promise, cannotReturnOwn()); + return; + } + } else { + value = detail; + } + if (promise._state !== PENDING) {} else if (hasCallback && succeeded) { + resolve(promise, value); + } else if (succeeded === false) { + reject(promise, error); + } else if (settled === FULFILLED) { + fulfill(promise, value); + } else if (settled === REJECTED) { + reject(promise, value); + } + } + function initializePromise(promise, resolver) { + try { + resolver(function resolvePromise(value) { + resolve(promise, value); + }, function rejectPromise(reason) { + reject(promise, reason); + }); + } catch (e) { + reject(promise, e); + } + } + var id = 0; + function nextId() { + return id++; + } + function makePromise(promise) { + promise[PROMISE_ID] = id++; + promise._state = undefined; + promise._result = undefined; + promise._subscribers = []; + } + function validationError() { + return new Error('Array Methods must be provided an Array'); + } + var Enumerator = function() { + function Enumerator(Constructor, input) { + this._instanceConstructor = Constructor; + this.promise = new Constructor(noop); + if (!this.promise[PROMISE_ID]) { + makePromise(this.promise); + } + if (isArray(input)) { + this.length = input.length; + this._remaining = input.length; + this._result = new Array(this.length); + if (this.length === 0) { + fulfill(this.promise, this._result); + } else { + this.length = this.length || 0; + this._enumerate(input); + if (this._remaining === 0) { + fulfill(this.promise, this._result); + } + } + } else { + reject(this.promise, validationError()); + } + } + Enumerator.prototype._enumerate = function _enumerate(input) { + for (var i = 0; this._state === PENDING && i < input.length; i++) { + this._eachEntry(input[i], i); + } + }; + Enumerator.prototype._eachEntry = function _eachEntry(entry, i) { + var c = this._instanceConstructor; + var resolve$$1 = c.resolve; + if (resolve$$1 === resolve$1) { + var _then = void 0; + var error = void 0; + var didError = false; + try { + _then = entry.then; + } catch (e) { + didError = true; + error = e; + } + if (_then === then && entry._state !== PENDING) { + this._settledAt(entry._state, i, entry._result); + } else if (typeof _then !== 'function') { + this._remaining--; + this._result[i] = entry; + } else if (c === Promise$1) { + var promise = new c(noop); + if (didError) { + reject(promise, error); + } else { + handleMaybeThenable(promise, entry, _then); + } + this._willSettleAt(promise, i); + } else { + this._willSettleAt(new c(function(resolve$$1) { + return resolve$$1(entry); + }), i); + } + } else { + this._willSettleAt(resolve$$1(entry), i); + } + }; + Enumerator.prototype._settledAt = function _settledAt(state, i, value) { + var promise = this.promise; + if (promise._state === PENDING) { + this._remaining--; + if (state === REJECTED) { + reject(promise, value); + } else { + this._result[i] = value; + } + } + if (this._remaining === 0) { + fulfill(promise, this._result); + } + }; + Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) { + var enumerator = this; + subscribe(promise, undefined, function(value) { + return enumerator._settledAt(FULFILLED, i, value); + }, function(reason) { + return enumerator._settledAt(REJECTED, i, reason); + }); + }; + return Enumerator; + }(); + function all(entries) { + return new Enumerator(this, entries).promise; + } + function race(entries) { + var Constructor = this; + if (!isArray(entries)) { + return new Constructor(function(_, reject) { + return reject(new TypeError('You must pass an array to race.')); + }); + } else { + return new Constructor(function(resolve, reject) { + var length = entries.length; + for (var i = 0; i < length; i++) { + Constructor.resolve(entries[i]).then(resolve, reject); + } + }); + } + } + function reject$1(reason) { + var Constructor = this; + var promise = new Constructor(noop); + reject(promise, reason); + return promise; + } + function needsResolver() { + throw new TypeError('You must pass a resolver function as the first argument to the promise constructor'); + } + function needsNew() { + throw new TypeError('Failed to construct \'Promise\': Please use the \'new\' operator, this object constructor cannot be called as a function.'); + } + var Promise$1 = function() { + function Promise(resolver) { + this[PROMISE_ID] = nextId(); + this._result = this._state = undefined; + this._subscribers = []; + if (noop !== resolver) { + typeof resolver !== 'function' && needsResolver(); + this instanceof Promise ? initializePromise(this, resolver) : needsNew(); + } + } + Promise.prototype.catch = function _catch(onRejection) { + return this.then(null, onRejection); + }; + Promise.prototype.finally = function _finally(callback) { + var promise = this; + var constructor = promise.constructor; + if (isFunction(callback)) { + return promise.then(function(value) { + return constructor.resolve(callback()).then(function() { + return value; + }); + }, function(reason) { + return constructor.resolve(callback()).then(function() { + throw reason; + }); + }); + } + return promise.then(callback, callback); + }; + return Promise; + }(); + Promise$1.prototype.then = then; + Promise$1.all = all; + Promise$1.race = race; + Promise$1.resolve = resolve$1; + Promise$1.reject = reject$1; + Promise$1._setScheduler = setScheduler; + Promise$1._setAsap = setAsap; + Promise$1._asap = asap; + function polyfill() { + var local = void 0; + if (typeof global !== 'undefined') { + local = global; + } else if (typeof self !== 'undefined') { + local = self; + } else { + try { + local = Function('return this')(); + } catch (e) { + throw new Error('polyfill failed because global object is unavailable in this environment'); + } + } + var P = local.Promise; + if (P) { + var promiseToString = null; + try { + promiseToString = Object.prototype.toString.call(P.resolve()); + } catch (e) {} + if (promiseToString === '[object Promise]' && !P.cast) { + return; + } + } + local.Promise = Promise$1; + } + Promise$1.polyfill = polyfill; + Promise$1.Promise = Promise$1; + return Promise$1; + }); + }).call(this, _dereq_('_process'), typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : {}); + }, { + _process: 33 + } ], + 33: [ function(_dereq_, module, exports) { + var process = module.exports = {}; + var cachedSetTimeout; + var cachedClearTimeout; + function defaultSetTimout() { + throw new Error('setTimeout has not been defined'); + } + function defaultClearTimeout() { + throw new Error('clearTimeout has not been defined'); + } + (function() { + try { + if (typeof setTimeout === 'function') { + cachedSetTimeout = setTimeout; + } else { + cachedSetTimeout = defaultSetTimout; + } + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + if (typeof clearTimeout === 'function') { + cachedClearTimeout = clearTimeout; + } else { + cachedClearTimeout = defaultClearTimeout; + } + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } + })(); + function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) { + return setTimeout(fun, 0); + } + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { + cachedSetTimeout = setTimeout; + return setTimeout(fun, 0); + } + try { + return cachedSetTimeout(fun, 0); + } catch (e) { + try { + return cachedSetTimeout.call(null, fun, 0); + } catch (e) { + return cachedSetTimeout.call(this, fun, 0); + } + } + } + function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) { + return clearTimeout(marker); + } + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { + cachedClearTimeout = clearTimeout; + return clearTimeout(marker); + } + try { + return cachedClearTimeout(marker); + } catch (e) { + try { + return cachedClearTimeout.call(null, marker); + } catch (e) { + return cachedClearTimeout.call(this, marker); + } + } + } + var queue = []; + var draining = false; + var currentQueue; + var queueIndex = -1; + function cleanUpNextTick() { + if (!draining || !currentQueue) { + return; + } + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } + } + function drainQueue() { + if (draining) { + return; + } + var timeout = runTimeout(cleanUpNextTick); + draining = true; + var len = queue.length; + while (len) { + currentQueue = queue; + queue = []; + while (++queueIndex < len) { + if (currentQueue) { + currentQueue[queueIndex].run(); + } + } + queueIndex = -1; + len = queue.length; + } + currentQueue = null; + draining = false; + runClearTimeout(timeout); + } + process.nextTick = function(fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } + } + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + runTimeout(drainQueue); + } + }; + function Item(fun, array) { + this.fun = fun; + this.array = array; + } + Item.prototype.run = function() { + this.fun.apply(null, this.array); + }; + process.title = 'browser'; + process.browser = true; + process.env = {}; + process.argv = []; + process.version = ''; + process.versions = {}; + function noop() {} + process.on = noop; + process.addListener = noop; + process.once = noop; + process.off = noop; + process.removeListener = noop; + process.removeAllListeners = noop; + process.emit = noop; + process.prependListener = noop; + process.prependOnceListener = noop; + process.listeners = function(name) { + return []; + }; + process.binding = function(name) { + throw new Error('process.binding is not supported'); + }; + process.cwd = function() { + return '/'; + }; + process.chdir = function(dir) { + throw new Error('process.chdir is not supported'); + }; + process.umask = function() { + return 0; + }; + }, {} ], + 34: [ function(_dereq_, module, exports) { + (function(global) { + (function(self) { + 'use strict'; + if (self.WeakMap) { + return; + } + var hasOwnProperty = Object.prototype.hasOwnProperty; + var defineProperty = function(object, name, value) { + if (Object.defineProperty) { + Object.defineProperty(object, name, { + configurable: true, + writable: true, + value: value + }); + } else { + object[name] = value; + } + }; + self.WeakMap = function() { + function WeakMap() { + if (this === void 0) { + throw new TypeError('Constructor WeakMap requires \'new\''); + } + defineProperty(this, '_id', genId('_WeakMap')); + if (arguments.length > 0) { + throw new TypeError('WeakMap iterable is not supported'); + } + } + defineProperty(WeakMap.prototype, 'delete', function(key) { + checkInstance(this, 'delete'); + if (!isObject(key)) { + return false; + } + var entry = key[this._id]; + if (entry && entry[0] === key) { + delete key[this._id]; + return true; + } + return false; + }); + defineProperty(WeakMap.prototype, 'get', function(key) { + checkInstance(this, 'get'); + if (!isObject(key)) { + return void 0; + } + var entry = key[this._id]; + if (entry && entry[0] === key) { + return entry[1]; + } + return void 0; + }); + defineProperty(WeakMap.prototype, 'has', function(key) { + checkInstance(this, 'has'); + if (!isObject(key)) { + return false; + } + var entry = key[this._id]; + if (entry && entry[0] === key) { + return true; + } + return false; + }); + defineProperty(WeakMap.prototype, 'set', function(key, value) { + checkInstance(this, 'set'); + if (!isObject(key)) { + throw new TypeError('Invalid value used as weak map key'); + } + var entry = key[this._id]; + if (entry && entry[0] === key) { + entry[1] = value; + return this; + } + defineProperty(key, this._id, [ key, value ]); + return this; + }); + function checkInstance(x, methodName) { + if (!isObject(x) || !hasOwnProperty.call(x, '_id')) { + throw new TypeError(methodName + ' method called on incompatible receiver ' + typeof x); + } + } + function genId(prefix) { + return prefix + '_' + rand() + '.' + rand(); + } + function rand() { + return Math.random().toString().substring(2); + } + defineProperty(WeakMap, '_polyfill', true); + return WeakMap; + }(); + function isObject(x) { + return Object(x) === x; + } + })(typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : this); + }).call(this, typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : {}); + }, {} ] + }, {}, [ 1 ]); + 'use strict'; + var utils = axe.utils = {}; + 'use strict'; + var helpers = {}; + 'use strict'; + function _typeof(obj) { + if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; + }; + } + return _typeof(obj); + } + function _extends() { + _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + return target; + }; + return _extends.apply(this, arguments); + } + function getDefaultConfiguration(audit) { + 'use strict'; + var config; + if (audit) { + config = axe.utils.clone(audit); + config.commons = audit.commons; + } else { + config = {}; + } + config.reporter = config.reporter || null; + config.rules = config.rules || []; + config.checks = config.checks || []; + config.data = _extends({ + checks: {}, + rules: {} + }, config.data); + return config; + } + function unpackToObject(collection, audit, method) { + 'use strict'; + var i, l; + for (i = 0, l = collection.length; i < l; i++) { + audit[method](collection[i]); + } + } + function Audit(audit) { + this.brand = 'axe'; + this.application = 'axeAPI'; + this.tagExclude = [ 'experimental' ]; + this.defaultConfig = audit; + this._init(); + this._defaultLocale = null; + } + Audit.prototype._setDefaultLocale = function() { + if (this._defaultLocale) { + return; + } + var locale = { + checks: {}, + rules: {} + }; + var checkIDs = Object.keys(this.data.checks); + for (var i = 0; i < checkIDs.length; i++) { + var id = checkIDs[i]; + var check = this.data.checks[id]; + var _check$messages = check.messages, pass = _check$messages.pass, fail = _check$messages.fail, incomplete = _check$messages.incomplete; + locale.checks[id] = { + pass: pass, + fail: fail, + incomplete: incomplete + }; + } + var ruleIDs = Object.keys(this.data.rules); + for (var _i = 0; _i < ruleIDs.length; _i++) { + var _id = ruleIDs[_i]; + var rule = this.data.rules[_id]; + var description = rule.description, help = rule.help; + locale.rules[_id] = { + description: description, + help: help + }; + } + this._defaultLocale = locale; + }; + Audit.prototype._resetLocale = function() { + var defaultLocale = this._defaultLocale; + if (!defaultLocale) { + return; + } + this.applyLocale(defaultLocale); + }; + var mergeCheckLocale = function mergeCheckLocale(a, b) { + var pass = b.pass, fail = b.fail; + if (typeof pass === 'string') { + pass = axe.imports.doT.compile(pass); + } + if (typeof fail === 'string') { + fail = axe.imports.doT.compile(fail); + } + return _extends({}, a, { + messages: { + pass: pass || a.messages.pass, + fail: fail || a.messages.fail, + incomplete: _typeof(a.messages.incomplete) === 'object' ? _extends({}, a.messages.incomplete, {}, b.incomplete) : b.incomplete + } + }); + }; + var mergeRuleLocale = function mergeRuleLocale(a, b) { + var help = b.help, description = b.description; + if (typeof help === 'string') { + help = axe.imports.doT.compile(help); + } + if (typeof description === 'string') { + description = axe.imports.doT.compile(description); + } + return _extends({}, a, { + help: help || a.help, + description: description || a.description + }); + }; + Audit.prototype._applyCheckLocale = function(checks) { + var keys = Object.keys(checks); + for (var i = 0; i < keys.length; i++) { + var id = keys[i]; + if (!this.data.checks[id]) { + throw new Error('Locale provided for unknown check: "'.concat(id, '"')); + } + this.data.checks[id] = mergeCheckLocale(this.data.checks[id], checks[id]); + } + }; + Audit.prototype._applyRuleLocale = function(rules) { + var keys = Object.keys(rules); + for (var i = 0; i < keys.length; i++) { + var id = keys[i]; + if (!this.data.rules[id]) { + throw new Error('Locale provided for unknown rule: "'.concat(id, '"')); + } + this.data.rules[id] = mergeRuleLocale(this.data.rules[id], rules[id]); + } + }; + Audit.prototype.applyLocale = function(locale) { + this._setDefaultLocale(); + if (locale.checks) { + this._applyCheckLocale(locale.checks); + } + if (locale.rules) { + this._applyRuleLocale(locale.rules); + } + }; + Audit.prototype._init = function() { + var audit = getDefaultConfiguration(this.defaultConfig); + axe.commons = commons = audit.commons; + this.reporter = audit.reporter; + this.commands = {}; + this.rules = []; + this.checks = {}; + unpackToObject(audit.rules, this, 'addRule'); + unpackToObject(audit.checks, this, 'addCheck'); + this.data = {}; + this.data.checks = audit.data && audit.data.checks || {}; + this.data.rules = audit.data && audit.data.rules || {}; + this.data.failureSummaries = audit.data && audit.data.failureSummaries || {}; + this.data.incompleteFallbackMessage = audit.data && audit.data.incompleteFallbackMessage || ''; + this._constructHelpUrls(); + }; + Audit.prototype.registerCommand = function(command) { + 'use strict'; + this.commands[command.id] = command.callback; + }; + Audit.prototype.addRule = function(spec) { + 'use strict'; + if (spec.metadata) { + this.data.rules[spec.id] = spec.metadata; + } + var rule = this.getRule(spec.id); + if (rule) { + rule.configure(spec); + } else { + this.rules.push(new Rule(spec, this)); + } + }; + Audit.prototype.addCheck = function(spec) { + 'use strict'; + var metadata = spec.metadata; + if (_typeof(metadata) === 'object') { + this.data.checks[spec.id] = metadata; + if (_typeof(metadata.messages) === 'object') { + Object.keys(metadata.messages).filter(function(prop) { + return metadata.messages.hasOwnProperty(prop) && typeof metadata.messages[prop] === 'string'; + }).forEach(function(prop) { + if (metadata.messages[prop].indexOf('function') === 0) { + metadata.messages[prop] = new Function('return ' + metadata.messages[prop] + ';')(); + } + }); + } + } + if (this.checks[spec.id]) { + this.checks[spec.id].configure(spec); + } else { + this.checks[spec.id] = new Check(spec); + } + }; + function getRulesToRun(rules, context, options) { + var base = { + now: [], + later: [] + }; + var splitRules = rules.reduce(function(out, rule) { + if (!axe.utils.ruleShouldRun(rule, context, options)) { + return out; + } + if (rule.preload) { + out.later.push(rule); + return out; + } + out.now.push(rule); + return out; + }, base); + return splitRules; + } + function getDefferedRule(rule, context, options) { + if (options.performanceTimer) { + axe.utils.performanceTimer.mark('mark_rule_start_' + rule.id); + } + return function(resolve, reject) { + rule.run(context, options, function(ruleResult) { + resolve(ruleResult); + }, function(err) { + if (!options.debug) { + var errResult = Object.assign(new RuleResult(rule), { + result: axe.constants.CANTTELL, + description: 'An error occured while running this rule', + message: err.message, + stack: err.stack, + error: err, + errorNode: err.errorNode + }); + resolve(errResult); + } else { + reject(err); + } + }); + }; + } + Audit.prototype.run = function(context, options, resolve, reject) { + 'use strict'; + this.normalizeOptions(options); + axe._selectCache = []; + var allRulesToRun = getRulesToRun(this.rules, context, options); + var runNowRules = allRulesToRun.now; + var runLaterRules = allRulesToRun.later; + var nowRulesQueue = axe.utils.queue(); + runNowRules.forEach(function(rule) { + nowRulesQueue.defer(getDefferedRule(rule, context, options)); + }); + var preloaderQueue = axe.utils.queue(); + if (runLaterRules.length) { + preloaderQueue.defer(function(resolve) { + axe.utils.preload(options).then(function(assets) { + return resolve(assets); + })['catch'](function(err) { + console.warn('Couldn\'t load preload assets: ', err); + resolve(undefined); + }); + }); + } + var queueForNowRulesAndPreloader = axe.utils.queue(); + queueForNowRulesAndPreloader.defer(nowRulesQueue); + queueForNowRulesAndPreloader.defer(preloaderQueue); + queueForNowRulesAndPreloader.then(function(nowRulesAndPreloaderResults) { + var assetsFromQueue = nowRulesAndPreloaderResults.pop(); + if (assetsFromQueue && assetsFromQueue.length) { + var assets = assetsFromQueue[0]; + if (assets) { + context = _extends({}, context, {}, assets); + } + } + var nowRulesResults = nowRulesAndPreloaderResults[0]; + if (!runLaterRules.length) { + axe._selectCache = undefined; + resolve(nowRulesResults.filter(function(result) { + return !!result; + })); + return; + } + var laterRulesQueue = axe.utils.queue(); + runLaterRules.forEach(function(rule) { + var deferredRule = getDefferedRule(rule, context, options); + laterRulesQueue.defer(deferredRule); + }); + laterRulesQueue.then(function(laterRuleResults) { + axe._selectCache = undefined; + resolve(nowRulesResults.concat(laterRuleResults).filter(function(result) { + return !!result; + })); + })['catch'](reject); + })['catch'](reject); + }; + Audit.prototype.after = function(results, options) { + 'use strict'; + var rules = this.rules; + return results.map(function(ruleResult) { + var rule = axe.utils.findBy(rules, 'id', ruleResult.id); + if (!rule) { + throw new Error('Result for unknown rule. You may be running mismatch axe-core versions'); + } + return rule.after(ruleResult, options); + }); + }; + Audit.prototype.getRule = function(ruleId) { + return this.rules.find(function(rule) { + return rule.id === ruleId; + }); + }; + Audit.prototype.normalizeOptions = function(options) { + 'use strict'; + var audit = this; + if (_typeof(options.runOnly) === 'object') { + if (Array.isArray(options.runOnly)) { + options.runOnly = { + type: 'tag', + values: options.runOnly + }; + } + var only = options.runOnly; + if (only.value && !only.values) { + only.values = only.value; + delete only.value; + } + if (!Array.isArray(only.values) || only.values.length === 0) { + throw new Error('runOnly.values must be a non-empty array'); + } + if ([ 'rule', 'rules' ].includes(only.type)) { + only.type = 'rule'; + only.values.forEach(function(ruleId) { + if (!audit.getRule(ruleId)) { + throw new Error('unknown rule `' + ruleId + '` in options.runOnly'); + } + }); + } else if ([ 'tag', 'tags', undefined ].includes(only.type)) { + only.type = 'tag'; + var unmatchedTags = audit.rules.reduce(function(unmatchedTags, rule) { + return unmatchedTags.length ? unmatchedTags.filter(function(tag) { + return !rule.tags.includes(tag); + }) : unmatchedTags; + }, only.values); + if (unmatchedTags.length !== 0) { + axe.log('Could not find tags `' + unmatchedTags.join('`, `') + '`'); + } + } else { + throw new Error('Unknown runOnly type \''.concat(only.type, '\'')); + } + } + if (_typeof(options.rules) === 'object') { + Object.keys(options.rules).forEach(function(ruleId) { + if (!audit.getRule(ruleId)) { + throw new Error('unknown rule `' + ruleId + '` in options.rules'); + } + }); + } + return options; + }; + Audit.prototype.setBranding = function(branding) { + 'use strict'; + var previous = { + brand: this.brand, + application: this.application + }; + if (branding && branding.hasOwnProperty('brand') && branding.brand && typeof branding.brand === 'string') { + this.brand = branding.brand; + } + if (branding && branding.hasOwnProperty('application') && branding.application && typeof branding.application === 'string') { + this.application = branding.application; + } + this._constructHelpUrls(previous); + }; + function getHelpUrl(_ref, ruleId, version) { + var brand = _ref.brand, application = _ref.application; + return axe.constants.helpUrlBase + brand + '/' + (version || axe.version.substring(0, axe.version.lastIndexOf('.'))) + '/' + ruleId + '?application=' + application; + } + Audit.prototype._constructHelpUrls = function() { var _this = this; var previous = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; - var version = axe.version.substring(0, axe.version.lastIndexOf('.')); + var version = (axe.version.match(/^[1-9][0-9]*\.[0-9]+/) || [ 'x.y' ])[0]; this.rules.forEach(function(rule) { if (!_this.data.rules[rule.id]) { _this.data.rules[rule.id] = {}; @@ -271,8 +2911,26 @@ Audit.prototype.resetRulesAndChecks = function() { 'use strict'; this._init(); + this._resetLocale(); }; 'use strict'; + (function() { + 'use strict'; + var _cache = {}; + var cache = { + set: function set(key, value) { + _cache[key] = value; + }, + get: function get(key) { + return _cache[key]; + }, + clear: function clear() { + _cache = {}; + } + }; + axe._cache = cache; + })(); + 'use strict'; function CheckResult(check) { 'use strict'; this.id = check.id; @@ -295,7 +2953,7 @@ } } Check.prototype.enabled = true; - Check.prototype.run = function(node, options, resolve, reject) { + Check.prototype.run = function(node, options, context, resolve, reject) { 'use strict'; options = options || {}; var enabled = options.hasOwnProperty('enabled') ? options.enabled : this.enabled, checkOptions = options.options || this.options; @@ -304,21 +2962,46 @@ var checkHelper = axe.utils.checkHelper(checkResult, options, resolve, reject); var result; try { - result = this.evaluate.call(checkHelper, node.actualNode, checkOptions, node); + result = this.evaluate.call(checkHelper, node.actualNode, checkOptions, node, context); } catch (e) { + if (node && node.actualNode) { + e.errorNode = new DqElement(node.actualNode).toJSON(); + } reject(e); return; } if (!checkHelper.isAsync) { checkResult.result = result; - setTimeout(function() { - resolve(checkResult); - }, 0); + resolve(checkResult); } } else { resolve(null); } }; + Check.prototype.runSync = function(node, options, context) { + options = options || {}; + var _options = options, _options$enabled = _options.enabled, enabled = _options$enabled === void 0 ? this.enabled : _options$enabled; + if (!enabled) { + return null; + } + var checkOptions = options.options || this.options; + var checkResult = new CheckResult(this); + var checkHelper = axe.utils.checkHelper(checkResult, options); + checkHelper.async = function() { + throw new Error('Cannot run async check while in a synchronous run'); + }; + var result; + try { + result = this.evaluate.call(checkHelper, node.actualNode, checkOptions, node, context); + } catch (e) { + if (node && node.actualNode) { + e.errorNode = new DqElement(node.actualNode).toJSON(); + } + throw e; + } + checkResult.result = result; + return checkResult; + }; Check.prototype.configure = function(spec) { var _this = this; [ 'options', 'enabled' ].filter(function(prop) { @@ -333,11 +3016,18 @@ }); }; 'use strict'; - var _typeof = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? function(obj) { - return typeof obj; - } : function(obj) { - return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; - }; + function _typeof(obj) { + if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; + }; + } + return _typeof(obj); + } function pushUniqueFrame(collection, frame) { 'use strict'; if (axe.utils.isHidden(frame)) { @@ -378,7 +3068,7 @@ } function normalizeContext(context) { 'use strict'; - if (context && (typeof context === 'undefined' ? 'undefined' : _typeof(context)) === 'object' || context instanceof NodeList) { + if (context && _typeof(context) === 'object' || context instanceof NodeList) { if (context instanceof Node) { return { include: [ context ], @@ -417,7 +3107,7 @@ if (typeof item === 'string') { nodeList = Array.from(document.querySelectorAll(item)); result = result.concat(nodeList.map(function(node) { - return axe.utils.getFlattenedTree(node)[0]; + return axe.utils.getNodeFromTree(node); })); break; } else if (item && item.length && !(item instanceof Node)) { @@ -426,11 +3116,15 @@ } else { nodeList = Array.from(document.querySelectorAll(item[0])); result = result.concat(nodeList.map(function(node) { - return axe.utils.getFlattenedTree(node)[0]; + return axe.utils.getNodeFromTree(node); })); } } else if (item instanceof Node) { - result.push(axe.utils.getFlattenedTree(item)[0]); + if (item.documentElement instanceof Node) { + result.push(context.flatTree[0]); + } else { + result.push(axe.utils.getNodeFromTree(item)); + } } } return result.filter(function(r) { @@ -451,20 +3145,35 @@ }); } } + function getRootNode(_ref) { + var include = _ref.include, exclude = _ref.exclude; + var selectors = Array.from(include).concat(Array.from(exclude)); + var localDocument = selectors.reduce(function(result, item) { + if (result) { + return result; + } else if (item instanceof Element) { + return item.ownerDocument; + } else if (item instanceof Document) { + return item; + } + }, null); + return (localDocument || document).documentElement; + } function Context(spec) { 'use strict'; - var self = this; + var _this = this; this.frames = []; this.initiator = spec && typeof spec.initiator === 'boolean' ? spec.initiator : true; this.page = false; spec = normalizeContext(spec); + this.flatTree = axe.utils.getFlattenedTree(getRootNode(spec)); this.exclude = spec.exclude; this.include = spec.include; this.include = parseSelectorArray(this, 'include'); this.exclude = parseSelectorArray(this, 'exclude'); axe.utils.select('frame, iframe', this).forEach(function(frame) { - if (isNodeInContext(frame, self)) { - pushUniqueFrame(self.frames, frame.actualNode); + if (isNodeInContext(frame, _this)) { + pushUniqueFrame(_this.frames, frame.actualNode); } }); if (this.include.length === 1 && this.include[0].actualNode === document.documentElement) { @@ -474,6 +3183,10 @@ if (err instanceof Error) { throw err; } + if (!Array.isArray(this.include)) { + this.include = Array.from(this.include); + } + this.include.sort(axe.utils.nodeSorter); } 'use strict'; function RuleResult(rule) { @@ -497,6 +3210,7 @@ this.all = spec.all || []; this.none = spec.none || []; this.tags = spec.tags || []; + this.preload = spec.preload ? true : false; if (spec.matches) { this.matches = createExecutionContext(spec.matches); } @@ -506,16 +3220,34 @@ return true; }; Rule.prototype.gather = function(context) { - 'use strict'; + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var markStart = 'mark_gather_start_' + this.id; + var markEnd = 'mark_gather_end_' + this.id; + var markHiddenStart = 'mark_isHidden_start_' + this.id; + var markHiddenEnd = 'mark_isHidden_end_' + this.id; + if (options.performanceTimer) { + axe.utils.performanceTimer.mark(markStart); + } var elements = axe.utils.select(this.selector, context); if (this.excludeHidden) { - return elements.filter(function(element) { + if (options.performanceTimer) { + axe.utils.performanceTimer.mark(markHiddenStart); + } + elements = elements.filter(function(element) { return !axe.utils.isHidden(element.actualNode); }); + if (options.performanceTimer) { + axe.utils.performanceTimer.mark(markHiddenEnd); + axe.utils.performanceTimer.measure('rule_' + this.id + '#gather_axe.utils.isHidden', markHiddenStart, markHiddenEnd); + } + } + if (options.performanceTimer) { + axe.utils.performanceTimer.mark(markEnd); + axe.utils.performanceTimer.measure('rule_' + this.id + '#gather', markStart, markEnd); } return elements; }; - Rule.prototype.runChecks = function(type, node, options, resolve, reject) { + Rule.prototype.runChecks = function(type, node, options, context, resolve, reject) { 'use strict'; var self = this; var checkQueue = axe.utils.queue(); @@ -523,7 +3255,7 @@ var check = self._audit.checks[c.id || c]; var option = axe.utils.getCheckOption(check, self.id, options); checkQueue.defer(function(res, rej) { - check.run(node, option, res, rej); + check.run(node, option, context, res, rej); }); }); checkQueue.then(function(results) { @@ -534,17 +3266,38 @@ type: type, results: results }); - }).catch(reject); + })['catch'](reject); + }; + Rule.prototype.runChecksSync = function(type, node, options, context) { + 'use strict'; + var self = this; + var results = []; + this[type].forEach(function(c) { + var check = self._audit.checks[c.id || c]; + var option = axe.utils.getCheckOption(check, self.id, options); + results.push(check.runSync(node, option, context)); + }); + results = results.filter(function(check) { + return check; + }); + return { + type: type, + results: results + }; }; - Rule.prototype.run = function(context, options, resolve, reject) { + Rule.prototype.run = function(context) { var _this = this; + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var resolve = arguments.length > 2 ? arguments[2] : undefined; + var reject = arguments.length > 3 ? arguments[3] : undefined; + if (options.performanceTimer) { + this._trackPerformance(); + } var q = axe.utils.queue(); var ruleResult = new RuleResult(this); - var nodes = void 0; + var nodes; try { - nodes = this.gather(context).filter(function(node) { - return _this.matches(node.actualNode, node); - }); + nodes = this.gatherAndMatchNodes(context, options); } catch (error) { reject(new SupportError({ cause: error, @@ -553,49 +3306,126 @@ return; } if (options.performanceTimer) { - axe.log('gather (', nodes.length, '):', axe.utils.performanceTimer.timeElapsed() + 'ms'); + this._logGatherPerformance(nodes); } nodes.forEach(function(node) { q.defer(function(resolveNode, rejectNode) { var checkQueue = axe.utils.queue(); - checkQueue.defer(function(res, rej) { - _this.runChecks('any', node, options, res, rej); - }); - checkQueue.defer(function(res, rej) { - _this.runChecks('all', node, options, res, rej); - }); - checkQueue.defer(function(res, rej) { - _this.runChecks('none', node, options, res, rej); + [ 'any', 'all', 'none' ].forEach(function(type) { + checkQueue.defer(function(res, rej) { + _this.runChecks(type, node, options, context, res, rej); + }); }); checkQueue.then(function(results) { - if (results.length) { - var hasResults = false, result = {}; - results.forEach(function(r) { - var res = r.results.filter(function(result) { - return result; - }); - result[r.type] = res; - if (res.length) { - hasResults = true; - } - }); - if (hasResults) { - result.node = new axe.utils.DqElement(node.actualNode, options); - ruleResult.nodes.push(result); - } + var result = getResult(results); + if (result) { + result.node = new axe.utils.DqElement(node.actualNode, options); + ruleResult.nodes.push(result); } resolveNode(); - }).catch(function(err) { + })['catch'](function(err) { return rejectNode(err); }); }); }); + q.defer(function(resolve) { + return setTimeout(resolve, 0); + }); + if (options.performanceTimer) { + this._logRulePerformance(); + } q.then(function() { return resolve(ruleResult); - }).catch(function(error) { + })['catch'](function(error) { return reject(error); }); }; + Rule.prototype.runSync = function(context) { + var _this2 = this; + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + if (options.performanceTimer) { + this._trackPerformance(); + } + var ruleResult = new RuleResult(this); + var nodes; + try { + nodes = this.gatherAndMatchNodes(context, options); + } catch (error) { + throw new SupportError({ + cause: error, + ruleId: this.id + }); + } + if (options.performanceTimer) { + this._logGatherPerformance(nodes); + } + nodes.forEach(function(node) { + var results = []; + [ 'any', 'all', 'none' ].forEach(function(type) { + results.push(_this2.runChecksSync(type, node, options, context)); + }); + var result = getResult(results); + if (result) { + result.node = node.actualNode ? new axe.utils.DqElement(node.actualNode, options) : null; + ruleResult.nodes.push(result); + } + }); + if (options.performanceTimer) { + this._logRulePerformance(); + } + return ruleResult; + }; + Rule.prototype._trackPerformance = function() { + this._markStart = 'mark_rule_start_' + this.id; + this._markEnd = 'mark_rule_end_' + this.id; + this._markChecksStart = 'mark_runchecks_start_' + this.id; + this._markChecksEnd = 'mark_runchecks_end_' + this.id; + }; + Rule.prototype._logGatherPerformance = function(nodes) { + axe.log('gather (', nodes.length, '):', axe.utils.performanceTimer.timeElapsed() + 'ms'); + axe.utils.performanceTimer.mark(this._markChecksStart); + }; + Rule.prototype._logRulePerformance = function() { + axe.utils.performanceTimer.mark(this._markChecksEnd); + axe.utils.performanceTimer.mark(this._markEnd); + axe.utils.performanceTimer.measure('runchecks_' + this.id, this._markChecksStart, this._markChecksEnd); + axe.utils.performanceTimer.measure('rule_' + this.id, this._markStart, this._markEnd); + }; + function getResult(results) { + if (results.length) { + var hasResults = false, result = {}; + results.forEach(function(r) { + var res = r.results.filter(function(result) { + return result; + }); + result[r.type] = res; + if (res.length) { + hasResults = true; + } + }); + if (hasResults) { + return result; + } + return null; + } + } + Rule.prototype.gatherAndMatchNodes = function(context, options) { + var _this3 = this; + var markMatchesStart = 'mark_matches_start_' + this.id; + var markMatchesEnd = 'mark_matches_end_' + this.id; + var nodes = this.gather(context, options); + if (options.performanceTimer) { + axe.utils.performanceTimer.mark(markMatchesStart); + } + nodes = nodes.filter(function(node) { + return _this3.matches(node.actualNode, node, context); + }); + if (options.performanceTimer) { + axe.utils.performanceTimer.mark(markMatchesEnd); + axe.utils.performanceTimer.measure('rule_' + this.id + '#matches', markMatchesStart, markMatchesEnd); + } + return nodes; + }; function findAfterChecks(rule) { 'use strict'; return axe.utils.getAllChecks(rule).map(function(c) { @@ -697,6 +3527,188 @@ } }; 'use strict'; + function _typeof(obj) { + if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; + }; + } + return _typeof(obj); + } + function _possibleConstructorReturn(self, call) { + if (call && (_typeof(call) === 'object' || typeof call === 'function')) { + return call; + } + return _assertThisInitialized(self); + } + function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); + } + function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError('this hasn\'t been initialised - super() hasn\'t been called'); + } + return self; + } + function _inherits(subClass, superClass) { + if (typeof superClass !== 'function' && superClass !== null) { + throw new TypeError('Super expression must either be null or a function'); + } + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) { + _setPrototypeOf(subClass, superClass); + } + } + function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + return _setPrototypeOf(o, p); + } + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError('Cannot call a class as a function'); + } + } + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ('value' in descriptor) { + descriptor.writable = true; + } + Object.defineProperty(target, descriptor.key, descriptor); + } + } + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) { + _defineProperties(Constructor.prototype, protoProps); + } + if (staticProps) { + _defineProperties(Constructor, staticProps); + } + return Constructor; + } + var whitespaceRegex = /[\t\r\n\f]/g; + var AbstractVirtualNode = function() { + function AbstractVirtualNode() { + _classCallCheck(this, AbstractVirtualNode); + this.children = []; + this.parent = null; + } + _createClass(AbstractVirtualNode, [ { + key: 'hasClass', + value: function hasClass() { + throw new Error('VirtualNode class must have a "hasClass" function'); + } + }, { + key: 'attr', + value: function attr() { + throw new Error('VirtualNode class must have a "attr" function'); + } + }, { + key: 'hasAttr', + value: function hasAttr() { + throw new Error('VirtualNode class must have a "hasAttr" function'); + } + }, { + key: 'props', + get: function get() { + throw new Error('VirtualNode class must have a "props" object consisting ' + 'of "nodeType" and "nodeName" properties'); + } + } ]); + return AbstractVirtualNode; + }(); + var VirtualNode = function(_AbstractVirtualNode) { + _inherits(VirtualNode, _AbstractVirtualNode); + function VirtualNode(node, parent, shadowId) { + var _this; + _classCallCheck(this, VirtualNode); + _this = _possibleConstructorReturn(this, _getPrototypeOf(VirtualNode).call(this)); + _this.shadowId = shadowId; + _this.children = []; + _this.actualNode = node; + _this.parent = parent; + _this._isHidden = null; + _this._cache = {}; + if (axe._cache.get('nodeMap')) { + axe._cache.get('nodeMap').set(node, _assertThisInitialized(_this)); + } + return _this; + } + _createClass(VirtualNode, [ { + key: 'hasClass', + value: function hasClass(className) { + var classAttr = this.attr('class'); + if (!classAttr) { + return false; + } + var selector = ' ' + className + ' '; + return (' ' + classAttr + ' ').replace(whitespaceRegex, ' ').indexOf(selector) >= 0; + } + }, { + key: 'attr', + value: function attr(attrName) { + if (typeof this.actualNode.getAttribute !== 'function') { + return null; + } + return this.actualNode.getAttribute(attrName); + } + }, { + key: 'hasAttr', + value: function hasAttr(attrName) { + if (typeof this.actualNode.hasAttribute !== 'function') { + return false; + } + return this.actualNode.hasAttribute(attrName); + } + }, { + key: 'props', + get: function get() { + var _this$actualNode = this.actualNode, nodeType = _this$actualNode.nodeType, nodeName = _this$actualNode.nodeName, id = _this$actualNode.id, type = _this$actualNode.type; + return { + nodeType: nodeType, + nodeName: nodeName.toLowerCase(), + id: id, + type: type + }; + } + }, { + key: 'isFocusable', + get: function get() { + if (!this._cache.hasOwnProperty('isFocusable')) { + this._cache.isFocusable = axe.commons.dom.isFocusable(this.actualNode); + } + return this._cache.isFocusable; + } + }, { + key: 'tabbableElements', + get: function get() { + if (!this._cache.hasOwnProperty('tabbableElements')) { + this._cache.tabbableElements = axe.commons.dom.getTabbableElements(this); + } + return this._cache.tabbableElements; + } + } ]); + return VirtualNode; + }(AbstractVirtualNode); + axe.AbstractVirtualNode = AbstractVirtualNode; + 'use strict'; (function(axe) { var definitions = [ { name: 'NA', @@ -724,7 +3736,11 @@ results: [], resultGroups: [], resultGroupMap: {}, - impact: Object.freeze([ 'minor', 'moderate', 'serious', 'critical' ]) + impact: Object.freeze([ 'minor', 'moderate', 'serious', 'critical' ]), + preload: Object.freeze({ + assets: [ 'cssom' ], + timeout: 1e4 + }) }; definitions.forEach(function(definition) { var name = definition.name; @@ -750,11 +3766,18 @@ }); })(axe); 'use strict'; - var _typeof = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? function(obj) { - return typeof obj; - } : function(obj) { - return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; - }; + function _typeof(obj) { + if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; + }; + } + return _typeof(obj); + } axe.log = function() { 'use strict'; if ((typeof console === 'undefined' ? 'undefined' : _typeof(console)) === 'object' && console.log) { @@ -762,42 +3785,10 @@ } }; 'use strict'; - var _typeof = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? function(obj) { - return typeof obj; - } : function(obj) { - return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; - }; - axe.a11yCheck = function(context, options, callback) { - 'use strict'; - if (typeof options === 'function') { - callback = options; - options = {}; - } - if (!options || (typeof options === 'undefined' ? 'undefined' : _typeof(options)) !== 'object') { - options = {}; - } - var audit = axe._audit; - if (!audit) { - throw new Error('No audit configured'); - } - options.reporter = options.reporter || audit.reporter || 'v2'; - if (options.performanceTimer) { - axe.utils.performanceTimer.start(); - } - var reporter = axe.getReporter(options.reporter); - axe._runRules(context, options, function(results) { - var res = reporter(results, options, callback); - if (res !== undefined) { - if (options.performanceTimer) { - axe.utils.performanceTimer.end(); - } - callback(res); - } - }, axe.log); - }; - 'use strict'; function cleanupPlugins(resolve, reject) { 'use strict'; + resolve = resolve || function() {}; + reject = reject || axe.log; if (!axe._audit) { throw new Error('No audit configured'); } @@ -816,9 +3807,10 @@ } }); }); - axe.utils.toArray(document.querySelectorAll('frame, iframe')).forEach(function(frame) { + var flattenedTree = axe.utils.getFlattenedTree(document.body); + axe.utils.querySelectorAll(flattenedTree, 'iframe, frame').forEach(function(node) { q.defer(function(res, rej) { - return axe.utils.sendCommandToFrame(frame, { + return axe.utils.sendCommandToFrame(node.actualNode, { command: 'cleanup-plugin' }, res, rej); }); @@ -829,7 +3821,7 @@ } else { reject(cleanupErrors); } - }).catch(reject); + })['catch'](reject); } axe.cleanup = cleanupPlugins; 'use strict'; @@ -848,11 +3840,20 @@ audit.addCheck(check); }); } + var modifiedRules = []; if (spec.rules) { spec.rules.forEach(function(rule) { + modifiedRules.push(rule.id); audit.addRule(rule); }); } + if (spec.disableOtherRules) { + audit.rules.forEach(function(rule) { + if (modifiedRules.includes(rule.id) === false) { + rule.enabled = false; + } + }); + } if (typeof spec.branding !== 'undefined') { audit.setBranding(spec.branding); } else { @@ -861,6 +3862,9 @@ if (spec.tagExclude) { audit.tagExclude = spec.tagExclude; } + if (spec.locale) { + audit.applyLocale(spec.locale); + } } axe.configure = configureChecksRulesAndBranding; 'use strict'; @@ -895,13 +3899,16 @@ callback(err); }; var context = data && data.context || {}; - if (context.include && !context.include.length) { + if (context.hasOwnProperty('include') && !context.include.length) { context.include = [ document ]; } var options = data && data.options || {}; switch (data.command) { case 'rules': - return runRules(context, options, resolve, reject); + return runRules(context, options, function(results, cleanup) { + resolve(results); + cleanup(); + }, reject); case 'cleanup-plugin': return cleanupPlugins(resolve, reject); @@ -994,11 +4001,19 @@ } axe.reset = resetConfiguration; 'use strict'; + function cleanup() { + axe._cache.clear(); + axe._tree = undefined; + axe._selectorData = undefined; + } function runRules(context, options, resolve, reject) { 'use strict'; try { context = new Context(context); + axe._tree = context.flatTree; + axe._selectorData = axe.utils.getSelectorData(context.flatTree); } catch (e) { + cleanup(); return reject(e); } var q = axe.utils.queue(); @@ -1011,23 +4026,24 @@ axe.utils.collectResultsFromFrames(context, options, 'rules', null, res, rej); }); } + var scrollState; q.defer(function(res, rej) { if (options.restoreScroll) { - var scrollState = axe.utils.getScrollState(); - audit.run(context, options, res, rej); - axe.utils.setScrollState(scrollState); - } else { - audit.run(context, options, res, rej); + scrollState = axe.utils.getScrollState(); } + audit.run(context, options, res, rej); }); q.then(function(data) { try { + if (scrollState) { + axe.utils.setScrollState(scrollState); + } if (options.performanceTimer) { axe.utils.performanceTimer.auditEnd(); } - var results = axe.utils.mergeResults(data.map(function(d) { + var results = axe.utils.mergeResults(data.map(function(results) { return { - results: d + results: results }; })); if (context.initiator) { @@ -1036,22 +4052,80 @@ results = results.map(axe.utils.finalizeRuleResult); } try { - resolve(results); + resolve(results, cleanup); } catch (e) { + cleanup(); axe.log(e); } } catch (e) { + cleanup(); reject(e); } - }).catch(reject); + })['catch'](function(e) { + cleanup(); + reject(e); + }); } axe._runRules = runRules; 'use strict'; - var _typeof = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? function(obj) { - return typeof obj; - } : function(obj) { - return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; + function _extends() { + _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + return target; + }; + return _extends.apply(this, arguments); + } + axe.runVirtualRule = function(ruleId, vNode) { + var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + options.reporter = options.reporter || axe._audit.reporter || 'v1'; + axe._selectorData = {}; + var rule = axe._audit.rules.find(function(rule) { + return rule.id === ruleId; + }); + if (!rule) { + throw new Error('unknown rule `' + ruleId + '`'); + } + rule = Object.create(rule, { + excludeHidden: { + value: false + } + }); + var context = { + include: [ vNode ] + }; + var rawResults = rule.runSync(context, options); + axe.utils.publishMetaData(rawResults); + axe.utils.finalizeRuleResult(rawResults); + var results = axe.utils.aggregateResult([ rawResults ]); + results.violations.forEach(function(result) { + return result.nodes.forEach(function(nodeResult) { + nodeResult.failureSummary = helpers.failureSummary(nodeResult); + }); + }); + return _extends({}, helpers.getEnvironmentData(), {}, results, { + toolOptions: options + }); }; + 'use strict'; + function _typeof(obj) { + if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; + }; + } + return _typeof(obj); + } function isContext(potential) { 'use strict'; switch (true) { @@ -1061,7 +4135,7 @@ case NodeList && potential instanceof NodeList: return true; - case (typeof potential === 'undefined' ? 'undefined' : _typeof(potential)) !== 'object': + case _typeof(potential) !== 'object': return false; case potential.include !== undefined: @@ -1085,7 +4159,7 @@ options = context; context = document; } - if ((typeof options === 'undefined' ? 'undefined' : _typeof(options)) !== 'object') { + if (_typeof(options) !== 'object') { if (callback !== undefined) { throw typeErr; } @@ -1114,17 +4188,18 @@ if (options.performanceTimer) { axe.utils.performanceTimer.start(); } - var p = void 0; + var p; var reject = noop; var resolve = noop; - if (window.Promise && callback === noop) { + if (typeof Promise === 'function' && callback === noop) { p = new Promise(function(_resolve, _reject) { reject = _reject; resolve = _resolve; }); } - axe._runRules(context, options, function(rawResults) { + axe._runRules(context, options, function(rawResults, cleanup) { var respond = function respond(results) { + cleanup(); try { callback(null, results); } catch (e) { @@ -1142,6 +4217,7 @@ respond(results); } } catch (err) { + cleanup(); callback(err); reject(err); } @@ -1172,16 +4248,47 @@ }).join('\n\n'); }; 'use strict'; + helpers.getEnvironmentData = function getEnvironmentData() { + var win = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window; + var _win$screen = win.screen, screen = _win$screen === void 0 ? {} : _win$screen, _win$navigator = win.navigator, navigator = _win$navigator === void 0 ? {} : _win$navigator, _win$location = win.location, location = _win$location === void 0 ? {} : _win$location, innerHeight = win.innerHeight, innerWidth = win.innerWidth; + var orientation = screen.msOrientation || screen.orientation || screen.mozOrientation || {}; + return { + testEngine: { + name: 'axe-core', + version: axe.version + }, + testRunner: { + name: axe._audit.brand + }, + testEnvironment: { + userAgent: navigator.userAgent, + windowWidth: innerWidth, + windowHeight: innerHeight, + orientationAngle: orientation.angle, + orientationType: orientation.type + }, + timestamp: new Date().toISOString(), + url: location.href + }; + }; + 'use strict'; helpers.incompleteFallbackMessage = function incompleteFallbackMessage() { 'use strict'; return axe._audit.data.incompleteFallbackMessage(); }; 'use strict'; - var _typeof = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? function(obj) { - return typeof obj; - } : function(obj) { - return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; - }; + function _typeof(obj) { + if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; + }; + } + return _typeof(obj); + } function normalizeRelatedNodes(node, options) { 'use strict'; [ 'any', 'all', 'none' ].forEach(function(type) { @@ -1212,9 +4319,14 @@ var resultKeys = axe.constants.resultGroups; helpers.processAggregate = function(results, options) { var resultObject = axe.utils.aggregateResult(results); - resultObject.timestamp = new Date().toISOString(); - resultObject.url = window.location.href; resultKeys.forEach(function(key) { + if (options.resultTypes && !options.resultTypes.includes(key)) { + (resultObject[key] || []).forEach(function(ruleResult) { + if (Array.isArray(ruleResult.nodes) && ruleResult.nodes.length > 0) { + ruleResult.nodes = [ ruleResult.nodes[0] ]; + } + }); + } resultObject[key] = (resultObject[key] || []).map(function(ruleResult) { ruleResult = Object.assign({}, ruleResult); if (Array.isArray(ruleResult.nodes) && ruleResult.nodes.length > 0) { @@ -1248,46 +4360,135 @@ return resultObject; }; 'use strict'; + function _extends() { + _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + return target; + }; + return _extends.apply(this, arguments); + } axe.addReporter('na', function(results, options, callback) { 'use strict'; + console.warn('"na" reporter will be deprecated in axe v4.0. Use the "v2" reporter instead.'); if (typeof options === 'function') { callback = options; options = {}; } var out = helpers.processAggregate(results, options); - callback({ + callback(_extends({}, helpers.getEnvironmentData(), { + toolOptions: options, violations: out.violations, passes: out.passes, incomplete: out.incomplete, - inapplicable: out.inapplicable, - timestamp: out.timestamp, - url: out.url - }); + inapplicable: out.inapplicable + })); }); 'use strict'; + function _extends() { + _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + return target; + }; + return _extends.apply(this, arguments); + } axe.addReporter('no-passes', function(results, options, callback) { 'use strict'; if (typeof options === 'function') { callback = options; options = {}; } + options.resultTypes = [ 'violations' ]; var out = helpers.processAggregate(results, options); - callback({ - violations: out.violations, - timestamp: out.timestamp, - url: out.url - }); + callback(_extends({}, helpers.getEnvironmentData(), { + toolOptions: options, + violations: out.violations + })); + }); + 'use strict'; + axe.addReporter('rawEnv', function(results, options, callback) { + if (typeof options === 'function') { + callback = options; + options = {}; + } + function rawCallback(raw) { + var env = helpers.getEnvironmentData(); + callback({ + raw: raw, + env: env + }); + } + axe.getReporter('raw')(results, options, rawCallback); }); 'use strict'; + function _extends() { + _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + return target; + }; + return _extends.apply(this, arguments); + } axe.addReporter('raw', function(results, options, callback) { 'use strict'; if (typeof options === 'function') { callback = options; options = {}; } - callback(results); + if (!results || !Array.isArray(results)) { + return callback(results); + } + var transformedResults = results.map(function(result) { + var transformedResult = _extends({}, result); + var types = [ 'passes', 'violations', 'incomplete', 'inapplicable' ]; + for (var _i = 0, _types = types; _i < _types.length; _i++) { + var type = _types[_i]; + if (transformedResult[type] && Array.isArray(transformedResult[type])) { + transformedResult[type] = transformedResult[type].map(function(typeResult) { + return _extends({}, typeResult, { + node: typeResult.node.toJSON() + }); + }); + } + } + return transformedResult; + }); + callback(transformedResults); }); 'use strict'; + function _extends() { + _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + return target; + }; + return _extends.apply(this, arguments); + } axe.addReporter('v1', function(results, options, callback) { 'use strict'; if (typeof options === 'function') { @@ -1300,16 +4501,29 @@ nodeResult.failureSummary = helpers.failureSummary(nodeResult); }); }); - callback({ + callback(_extends({}, helpers.getEnvironmentData(), { + toolOptions: options, violations: out.violations, passes: out.passes, incomplete: out.incomplete, - inapplicable: out.inapplicable, - timestamp: out.timestamp, - url: out.url - }); + inapplicable: out.inapplicable + })); }); 'use strict'; + function _extends() { + _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + return target; + }; + return _extends.apply(this, arguments); + } axe.addReporter('v2', function(results, options, callback) { 'use strict'; if (typeof options === 'function') { @@ -1317,14 +4531,13 @@ options = {}; } var out = helpers.processAggregate(results, options); - callback({ + callback(_extends({}, helpers.getEnvironmentData(), { + toolOptions: options, violations: out.violations, passes: out.passes, incomplete: out.incomplete, - inapplicable: out.inapplicable, - timestamp: out.timestamp, - url: out.url - }); + inapplicable: out.inapplicable + })); }, true); 'use strict'; axe.utils.aggregate = function(map, values, initial) { @@ -1338,6 +4551,7 @@ return map[sorting.pop()]; }; 'use strict'; + var _axe$constants = axe.constants, CANTTELL_PRIO = _axe$constants.CANTTELL_PRIO, FAIL_PRIO = _axe$constants.FAIL_PRIO; var checkMap = []; checkMap[axe.constants.PASS_PRIO] = true; checkMap[axe.constants.CANTTELL_PRIO] = null; @@ -1354,858 +4568,313 @@ axe.utils.aggregateChecks = function(nodeResOriginal) { var nodeResult = Object.assign({}, nodeResOriginal); anyAllNone(nodeResult, function(check, type) { - var i = checkMap.indexOf(check.result); + var i = typeof check.result === 'undefined' ? -1 : checkMap.indexOf(check.result); check.priority = i !== -1 ? i : axe.constants.CANTTELL_PRIO; if (type === 'none') { - check.priority = 4 - check.priority; - } - }); - var priorities = anyAllNone(nodeResult, function(c) { - return c.priority; - }); - nodeResult.priority = Math.max(priorities.all.reduce(function(a, b) { - return Math.max(a, b); - }, 0), priorities.none.reduce(function(a, b) { - return Math.max(a, b); - }, 0), priorities.any.reduce(function(a, b) { - return Math.min(a, b); - }, 4) % 4); - var impacts = []; - checkTypes.forEach(function(type) { - nodeResult[type] = nodeResult[type].filter(function(check) { - return check.priority === nodeResult.priority; - }); - nodeResult[type].forEach(function(check) { - return impacts.push(check.impact); - }); - }); - if (nodeResult.priority === axe.constants.FAIL_PRIO) { - nodeResult.impact = axe.utils.aggregate(axe.constants.impact, impacts); - } else { - nodeResult.impact = null; - } - anyAllNone(nodeResult, function(c) { - delete c.result; - delete c.priority; - }); - nodeResult.result = axe.constants.results[nodeResult.priority]; - delete nodeResult.priority; - return nodeResult; - }; - 'use strict'; - function copyToGroup(resultObject, subResult, group) { - var resultCopy = Object.assign({}, subResult); - resultCopy.nodes = (resultCopy[group] || []).concat(); - axe.constants.resultGroups.forEach(function(group) { - delete resultCopy[group]; - }); - resultObject[group].push(resultCopy); - } - axe.utils.aggregateResult = function(results) { - var resultObject = {}; - axe.constants.resultGroups.forEach(function(groupName) { - return resultObject[groupName] = []; - }); - results.forEach(function(subResult) { - if (subResult.error) { - copyToGroup(resultObject, subResult, axe.constants.CANTTELL_GROUP); - } else if (subResult.result === axe.constants.NA) { - copyToGroup(resultObject, subResult, axe.constants.NA_GROUP); - } else { - axe.constants.resultGroups.forEach(function(group) { - if (Array.isArray(subResult[group]) && subResult[group].length > 0) { - copyToGroup(resultObject, subResult, group); - } - }); - } - }); - return resultObject; - }; - 'use strict'; - (function() { - axe.utils.aggregateRule = function(subResults) { - var ruleResult = {}; - subResults = subResults.map(function(subResult) { - if (subResult.any && subResult.all && subResult.none) { - return axe.utils.aggregateChecks(subResult); - } else if (Array.isArray(subResult.node)) { - return axe.utils.finalizeRuleResult(subResult); - } else { - throw new TypeError('Invalid Result type'); + if (check.priority === axe.constants.PASS_PRIO) { + check.priority = axe.constants.FAIL_PRIO; + } else if (check.priority === axe.constants.FAIL_PRIO) { + check.priority = axe.constants.PASS_PRIO; } - }); - var resultList = subResults.map(function(node) { - return node.result; - }); - ruleResult.result = axe.utils.aggregate(axe.constants.results, resultList, ruleResult.result); - axe.constants.resultGroups.forEach(function(group) { - return ruleResult[group] = []; - }); - subResults.forEach(function(subResult) { - var groupName = axe.constants.resultGroupMap[subResult.result]; - ruleResult[groupName].push(subResult); - }); - var failGroup = axe.constants.FAIL_GROUP; - if (ruleResult[failGroup].length > 0) { - var impactList = ruleResult[failGroup].map(function(failure) { - return failure.impact; - }); - ruleResult.impact = axe.utils.aggregate(axe.constants.impact, impactList) || null; - } else { - ruleResult.impact = null; - } - return ruleResult; - }; - })(); - 'use strict'; - function areStylesSet(el, styles, stopAt) { - 'use strict'; - var styl = window.getComputedStyle(el, null); - var set = false; - if (!styl) { - return false; - } - styles.forEach(function(att) { - if (styl.getPropertyValue(att.property) === att.value) { - set = true; } }); - if (set) { - return true; - } - if (el.nodeName.toUpperCase() === stopAt.toUpperCase() || !el.parentNode) { - return false; - } - return areStylesSet(el.parentNode, styles, stopAt); - } - axe.utils.areStylesSet = areStylesSet; - 'use strict'; - axe.utils.checkHelper = function checkHelper(checkResult, options, resolve, reject) { - 'use strict'; - return { - isAsync: false, - async: function async() { - this.isAsync = true; - return function(result) { - if (result instanceof Error === false) { - checkResult.value = result; - resolve(checkResult); - } else { - reject(result); - } - }; - }, - data: function data(_data) { - checkResult.data = _data; - }, - relatedNodes: function relatedNodes(nodes) { - nodes = nodes instanceof Node ? [ nodes ] : axe.utils.toArray(nodes); - checkResult.relatedNodes = nodes.map(function(element) { - return new axe.utils.DqElement(element, options); - }); - } + var priorities = { + all: nodeResult.all.reduce(function(a, b) { + return Math.max(a, b.priority); + }, 0), + none: nodeResult.none.reduce(function(a, b) { + return Math.max(a, b.priority); + }, 0), + any: nodeResult.any.reduce(function(a, b) { + return Math.min(a, b.priority); + }, 4) % 4 }; - }; - 'use strict'; - var _typeof = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? function(obj) { - return typeof obj; - } : function(obj) { - return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; - }; - axe.utils.clone = function(obj) { - 'use strict'; - var index, length, out = obj; - if (obj !== null && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object') { - if (Array.isArray(obj)) { - out = []; - for (index = 0, length = obj.length; index < length; index++) { - out[index] = axe.utils.clone(obj[index]); - } - } else { - out = {}; - for (index in obj) { - out[index] = axe.utils.clone(obj[index]); - } - } - } - return out; - }; - 'use strict'; - function err(message, node) { - 'use strict'; - return new Error(message + ': ' + axe.utils.getSelector(node)); - } - axe.utils.sendCommandToFrame = function(node, parameters, resolve, reject) { - 'use strict'; - var win = node.contentWindow; - if (!win) { - axe.log('Frame does not have a content window', node); - resolve(null); - return; - } - var timeout = setTimeout(function() { - timeout = setTimeout(function() { - var errMsg = err('No response from frame', node); - if (!parameters.debug) { - axe.log(errMsg); - resolve(null); - } else { - reject(errMsg); - } - }, 0); - }, 500); - axe.utils.respondable(win, 'axe.ping', null, undefined, function() { - clearTimeout(timeout); - timeout = setTimeout(function() { - reject(err('Axe in frame timed out', node)); - }, 3e4); - axe.utils.respondable(win, 'axe.start', parameters, undefined, function(data) { - clearTimeout(timeout); - if (data instanceof Error === false) { - resolve(data); - } else { - reject(data); - } - }); - }); - }; - function collectResultsFromFrames(context, options, command, parameter, resolve, reject) { - 'use strict'; - var q = axe.utils.queue(); - var frames = context.frames; - frames.forEach(function(frame) { - var params = { - options: options, - command: command, - parameter: parameter, - context: { - initiator: false, - page: context.page, - include: frame.include || [], - exclude: frame.exclude || [] - } - }; - q.defer(function(res, rej) { - var node = frame.node; - axe.utils.sendCommandToFrame(node, params, function(data) { - if (data) { - return res({ - results: data, - frameElement: node, - frame: axe.utils.getSelector(node) - }); - } - res(null); - }, rej); - }); - }); - q.then(function(data) { - resolve(axe.utils.mergeResults(data, options)); - }).catch(reject); - } - axe.utils.collectResultsFromFrames = collectResultsFromFrames; - 'use strict'; - axe.utils.contains = function(node, otherNode) { - 'use strict'; - function containsShadowChild(node, otherNode) { - if (node.shadowId === otherNode.shadowId) { - return true; - } - return !!node.children.find(function(child) { - return containsShadowChild(child, otherNode); + nodeResult.priority = Math.max(priorities.all, priorities.none, priorities.any); + var impacts = []; + checkTypes.forEach(function(type) { + nodeResult[type] = nodeResult[type].filter(function(check) { + return check.priority === nodeResult.priority && check.priority === priorities[type]; }); + nodeResult[type].forEach(function(check) { + return impacts.push(check.impact); + }); + }); + if ([ CANTTELL_PRIO, FAIL_PRIO ].includes(nodeResult.priority)) { + nodeResult.impact = axe.utils.aggregate(axe.constants.impact, impacts); + } else { + nodeResult.impact = null; } - if (node.shadowId || otherNode.shadowId) { - return containsShadowChild(node, otherNode); - } - if (typeof node.actualNode.contains === 'function') { - return node.actualNode.contains(otherNode.actualNode); - } - return !!(node.actualNode.compareDocumentPosition(otherNode.actualNode) & 16); + anyAllNone(nodeResult, function(c) { + delete c.result; + delete c.priority; + }); + nodeResult.result = axe.constants.results[nodeResult.priority]; + delete nodeResult.priority; + return nodeResult; }; 'use strict'; - (function(axe) { - /*! - * The copyright below covers the code within this function block only - * - * Copyright (c) 2013 Dulin Marat - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - */ - function CssSelectorParser() { - this.pseudos = {}; - this.attrEqualityMods = {}; - this.ruleNestingOperators = {}; - this.substitutesEnabled = false; - } - CssSelectorParser.prototype.registerSelectorPseudos = function(name) { - for (var j = 0, len = arguments.length; j < len; j++) { - name = arguments[j]; - this.pseudos[name] = 'selector'; - } - return this; - }; - CssSelectorParser.prototype.unregisterSelectorPseudos = function(name) { - for (var j = 0, len = arguments.length; j < len; j++) { - name = arguments[j]; - delete this.pseudos[name]; - } - return this; - }; - CssSelectorParser.prototype.registerNumericPseudos = function(name) { - for (var j = 0, len = arguments.length; j < len; j++) { - name = arguments[j]; - this.pseudos[name] = 'numeric'; - } - return this; - }; - CssSelectorParser.prototype.unregisterNumericPseudos = function(name) { - for (var j = 0, len = arguments.length; j < len; j++) { - name = arguments[j]; - delete this.pseudos[name]; + (function() { + axe.utils.aggregateNodeResults = function(nodeResults) { + var ruleResult = {}; + nodeResults = nodeResults.map(function(nodeResult) { + if (nodeResult.any && nodeResult.all && nodeResult.none) { + return axe.utils.aggregateChecks(nodeResult); + } else if (Array.isArray(nodeResult.node)) { + return axe.utils.finalizeRuleResult(nodeResult); + } else { + throw new TypeError('Invalid Result type'); + } + }); + if (nodeResults && nodeResults.length) { + var resultList = nodeResults.map(function(node) { + return node.result; + }); + ruleResult.result = axe.utils.aggregate(axe.constants.results, resultList, ruleResult.result); + } else { + ruleResult.result = 'inapplicable'; } - return this; - }; - CssSelectorParser.prototype.registerNestingOperators = function(operator) { - for (var j = 0, len = arguments.length; j < len; j++) { - operator = arguments[j]; - this.ruleNestingOperators[operator] = true; + axe.constants.resultGroups.forEach(function(group) { + return ruleResult[group] = []; + }); + nodeResults.forEach(function(nodeResult) { + var groupName = axe.constants.resultGroupMap[nodeResult.result]; + ruleResult[groupName].push(nodeResult); + }); + var impactGroup = axe.constants.FAIL_GROUP; + if (ruleResult[impactGroup].length === 0) { + impactGroup = axe.constants.CANTTELL_GROUP; } - return this; - }; - CssSelectorParser.prototype.unregisterNestingOperators = function(operator) { - for (var j = 0, len = arguments.length; j < len; j++) { - operator = arguments[j]; - delete this.ruleNestingOperators[operator]; + if (ruleResult[impactGroup].length > 0) { + var impactList = ruleResult[impactGroup].map(function(failure) { + return failure.impact; + }); + ruleResult.impact = axe.utils.aggregate(axe.constants.impact, impactList) || null; + } else { + ruleResult.impact = null; } - return this; + return ruleResult; }; - CssSelectorParser.prototype.registerAttrEqualityMods = function(mod) { - for (var j = 0, len = arguments.length; j < len; j++) { - mod = arguments[j]; - this.attrEqualityMods[mod] = true; + })(); + 'use strict'; + function copyToGroup(resultObject, subResult, group) { + var resultCopy = Object.assign({}, subResult); + resultCopy.nodes = (resultCopy[group] || []).concat(); + axe.constants.resultGroups.forEach(function(group) { + delete resultCopy[group]; + }); + resultObject[group].push(resultCopy); + } + axe.utils.aggregateResult = function(results) { + var resultObject = {}; + axe.constants.resultGroups.forEach(function(groupName) { + return resultObject[groupName] = []; + }); + results.forEach(function(subResult) { + if (subResult.error) { + copyToGroup(resultObject, subResult, axe.constants.CANTTELL_GROUP); + } else if (subResult.result === axe.constants.NA) { + copyToGroup(resultObject, subResult, axe.constants.NA_GROUP); + } else { + axe.constants.resultGroups.forEach(function(group) { + if (Array.isArray(subResult[group]) && subResult[group].length > 0) { + copyToGroup(resultObject, subResult, group); + } + }); } - return this; - }; - CssSelectorParser.prototype.unregisterAttrEqualityMods = function(mod) { - for (var j = 0, len = arguments.length; j < len; j++) { - mod = arguments[j]; - delete this.attrEqualityMods[mod]; + }); + return resultObject; + }; + 'use strict'; + function areStylesSet(el, styles, stopAt) { + 'use strict'; + var styl = window.getComputedStyle(el, null); + var set = false; + if (!styl) { + return false; + } + styles.forEach(function(att) { + if (styl.getPropertyValue(att.property) === att.value) { + set = true; } - return this; - }; - CssSelectorParser.prototype.enableSubstitutes = function() { - this.substitutesEnabled = true; - return this; - }; - CssSelectorParser.prototype.disableSubstitutes = function() { - this.substitutesEnabled = false; - return this; - }; - function isIdentStart(c) { - return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c === '-' || c === '_'; - } - function isIdent(c) { - return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || c === '-' || c === '_'; - } - function isHex(c) { - return c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F' || c >= '0' && c <= '9'; - } - function isDecimal(c) { - return c >= '0' && c <= '9'; - } - function isAttrMatchOperator(chr) { - return chr === '=' || chr === '^' || chr === '$' || chr === '*' || chr === '~'; - } - var identSpecialChars = { - '!': true, - '"': true, - '#': true, - $: true, - '%': true, - '&': true, - '\'': true, - '(': true, - ')': true, - '*': true, - '+': true, - ',': true, - '.': true, - '/': true, - ';': true, - '<': true, - '=': true, - '>': true, - '?': true, - '@': true, - '[': true, - '\\': true, - ']': true, - '^': true, - '`': true, - '{': true, - '|': true, - '}': true, - '~': true - }; - var strReplacementsRev = { - '\n': '\\n', - '\r': '\\r', - '\t': '\\t', - '\f': '\\f', - '\v': '\\v' - }; - var singleQuoteEscapeChars = { - n: '\n', - r: '\r', - t: '\t', - f: '\f', - '\\': '\\', - '\'': '\'' - }; - var doubleQuotesEscapeChars = { - n: '\n', - r: '\r', - t: '\t', - f: '\f', - '\\': '\\', - '"': '"' - }; - function ParseContext(str, pos, pseudos, attrEqualityMods, ruleNestingOperators, substitutesEnabled) { - var chr, getIdent, getStr, l, skipWhitespace; - l = str.length; - chr = null; - getStr = function getStr(quote, escapeTable) { - var esc, hex, result; - result = ''; - pos++; - chr = str.charAt(pos); - while (pos < l) { - if (chr === quote) { - pos++; - return result; - } else if (chr === '\\') { - pos++; - chr = str.charAt(pos); - if (chr === quote) { - result += quote; - } else if (esc = escapeTable[chr]) { - result += esc; - } else if (isHex(chr)) { - hex = chr; - pos++; - chr = str.charAt(pos); - while (isHex(chr)) { - hex += chr; - pos++; - chr = str.charAt(pos); - } - if (chr === ' ') { - pos++; - chr = str.charAt(pos); - } - result += String.fromCharCode(parseInt(hex, 16)); - continue; - } else { - result += chr; - } - } else { - result += chr; - } - pos++; - chr = str.charAt(pos); - } - return result; - }; - getIdent = function getIdent() { - var result = ''; - chr = str.charAt(pos); - while (pos < l) { - if (isIdent(chr)) { - result += chr; - } else if (chr === '\\') { - pos++; - if (pos >= l) { - throw Error('Expected symbol but end of file reached.'); - } - chr = str.charAt(pos); - if (identSpecialChars[chr]) { - result += chr; - } else if (isHex(chr)) { - var hex = chr; - pos++; - chr = str.charAt(pos); - while (isHex(chr)) { - hex += chr; - pos++; - chr = str.charAt(pos); - } - if (chr === ' ') { - pos++; - chr = str.charAt(pos); - } - result += String.fromCharCode(parseInt(hex, 16)); - continue; - } else { - result += chr; - } + }); + if (set) { + return true; + } + if (el.nodeName.toUpperCase() === stopAt.toUpperCase() || !el.parentNode) { + return false; + } + return areStylesSet(el.parentNode, styles, stopAt); + } + axe.utils.areStylesSet = areStylesSet; + 'use strict'; + axe.utils.checkHelper = function checkHelper(checkResult, options, resolve, reject) { + 'use strict'; + return { + isAsync: false, + async: function async() { + this.isAsync = true; + return function(result) { + if (result instanceof Error === false) { + checkResult.result = result; + resolve(checkResult); } else { - return result; - } - pos++; - chr = str.charAt(pos); - } - return result; - }; - skipWhitespace = function skipWhitespace() { - chr = str.charAt(pos); - var result = false; - while (chr === ' ' || chr === '\t' || chr === '\n' || chr === '\r' || chr === '\f') { - result = true; - pos++; - chr = str.charAt(pos); - } - return result; - }; - this.parse = function() { - var res = this.parseSelector(); - if (pos < l) { - throw Error('Rule expected but "' + str.charAt(pos) + '" found.'); - } - return res; - }; - this.parseSelector = function() { - var res; - var selector = res = this.parseSingleSelector(); - chr = str.charAt(pos); - while (chr === ',') { - pos++; - skipWhitespace(); - if (res.type !== 'selectors') { - res = { - type: 'selectors', - selectors: [ selector ] - }; - } - selector = this.parseSingleSelector(); - if (!selector) { - throw Error('Rule expected after ",".'); + reject(result); } - res.selectors.push(selector); - } - return res; - }; - this.parseSingleSelector = function() { - skipWhitespace(); - var selector = { - type: 'ruleSet' }; - var rule = this.parseRule(); - if (!rule) { - return null; - } - var currentRule = selector; - while (rule) { - rule.type = 'rule'; - currentRule.rule = rule; - currentRule = rule; - skipWhitespace(); - chr = str.charAt(pos); - if (pos >= l || chr === ',' || chr === ')') { - break; - } - if (ruleNestingOperators[chr]) { - var op = chr; - pos++; - skipWhitespace(); - rule = this.parseRule(); - if (!rule) { - throw Error('Rule expected after "' + op + '".'); - } - rule.nestingOperator = op; - } else { - rule = this.parseRule(); - if (rule) { - rule.nestingOperator = null; - } - } - } - return selector; - }; - this.parseRule = function() { - var rule = null; - while (pos < l) { - chr = str.charAt(pos); - if (chr === '*') { - pos++; - (rule = rule || {}).tagName = '*'; - } else if (isIdentStart(chr) || chr === '\\') { - (rule = rule || {}).tagName = getIdent(); - } else if (chr === '.') { - pos++; - rule = rule || {}; - (rule.classNames = rule.classNames || []).push(getIdent()); - } else if (chr === '#') { - pos++; - (rule = rule || {}).id = getIdent(); - } else if (chr === '[') { - pos++; - skipWhitespace(); - var attr = { - name: getIdent() - }; - skipWhitespace(); - if (chr === ']') { - pos++; - } else { - var operator = ''; - if (attrEqualityMods[chr]) { - operator = chr; - pos++; - chr = str.charAt(pos); - } - if (pos >= l) { - throw Error('Expected "=" but end of file reached.'); - } - if (chr !== '=') { - throw Error('Expected "=" but "' + chr + '" found.'); - } - attr.operator = operator + '='; - pos++; - skipWhitespace(); - var attrValue = ''; - attr.valueType = 'string'; - if (chr === '"') { - attrValue = getStr('"', doubleQuotesEscapeChars); - } else if (chr === '\'') { - attrValue = getStr('\'', singleQuoteEscapeChars); - } else if (substitutesEnabled && chr === '$') { - pos++; - attrValue = getIdent(); - attr.valueType = 'substitute'; - } else { - while (pos < l) { - if (chr === ']') { - break; - } - attrValue += chr; - pos++; - chr = str.charAt(pos); - } - attrValue = attrValue.trim(); - } - skipWhitespace(); - if (pos >= l) { - throw Error('Expected "]" but end of file reached.'); - } - if (chr !== ']') { - throw Error('Expected "]" but "' + chr + '" found.'); - } - pos++; - attr.value = attrValue; - } - rule = rule || {}; - (rule.attrs = rule.attrs || []).push(attr); - } else if (chr === ':') { - pos++; - var pseudoName = getIdent(); - var pseudo = { - name: pseudoName - }; - if (chr === '(') { - pos++; - var value = ''; - skipWhitespace(); - if (pseudos[pseudoName] === 'selector') { - pseudo.valueType = 'selector'; - value = this.parseSelector(); - } else { - pseudo.valueType = pseudos[pseudoName] || 'string'; - if (chr === '"') { - value = getStr('"', doubleQuotesEscapeChars); - } else if (chr === '\'') { - value = getStr('\'', singleQuoteEscapeChars); - } else if (substitutesEnabled && chr === '$') { - pos++; - value = getIdent(); - pseudo.valueType = 'substitute'; - } else { - while (pos < l) { - if (chr === ')') { - break; - } - value += chr; - pos++; - chr = str.charAt(pos); - } - value = value.trim(); - } - skipWhitespace(); - } - if (pos >= l) { - throw Error('Expected ")" but end of file reached.'); - } - if (chr !== ')') { - throw Error('Expected ")" but "' + chr + '" found.'); - } - pos++; - pseudo.value = value; - } - rule = rule || {}; - (rule.pseudos = rule.pseudos || []).push(pseudo); - } else { - break; - } - } - return rule; + }, + data: function data(_data) { + checkResult.data = _data; + }, + relatedNodes: function relatedNodes(nodes) { + nodes = nodes instanceof Node ? [ nodes ] : axe.utils.toArray(nodes); + checkResult.relatedNodes = nodes.map(function(element) { + return new axe.utils.DqElement(element, options); + }); + } + }; + }; + 'use strict'; + function _typeof(obj) { + if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; }; - return this; } - CssSelectorParser.prototype.parse = function(str) { - var context = new ParseContext(str, 0, this.pseudos, this.attrEqualityMods, this.ruleNestingOperators, this.substitutesEnabled); - return context.parse(); - }; - CssSelectorParser.prototype.escapeIdentifier = function(s) { - var result = ''; - var i = 0; - var len = s.length; - while (i < len) { - var chr = s.charAt(i); - if (identSpecialChars[chr]) { - result += '\\' + chr; - } else { - if (!(chr === '_' || chr === '-' || chr >= 'A' && chr <= 'Z' || chr >= 'a' && chr <= 'z' || i !== 0 && chr >= '0' && chr <= '9')) { - var charCode = chr.charCodeAt(0); - if ((charCode & 63488) === 55296) { - var extraCharCode = s.charCodeAt(i++); - if ((charCode & 64512) !== 55296 || (extraCharCode & 64512) !== 56320) { - throw Error('UCS-2(decode): illegal sequence'); - } - charCode = ((charCode & 1023) << 10) + (extraCharCode & 1023) + 65536; - } - result += '\\' + charCode.toString(16) + ' '; - } else { - result += chr; - } + return _typeof(obj); + } + axe.utils.clone = function(obj) { + 'use strict'; + var index, length, out = obj; + if (obj !== null && _typeof(obj) === 'object') { + if (Array.isArray(obj)) { + out = []; + for (index = 0, length = obj.length; index < length; index++) { + out[index] = axe.utils.clone(obj[index]); } - i++; - } - return result; - }; - CssSelectorParser.prototype.escapeStr = function(s) { - var result = ''; - var i = 0; - var len = s.length; - var chr, replacement; - while (i < len) { - chr = s.charAt(i); - if (chr === '"') { - chr = '\\"'; - } else if (chr === '\\') { - chr = '\\\\'; - } else if (replacement = strReplacementsRev[chr]) { - chr = replacement; - } - result += chr; - i++; - } - return '"' + result + '"'; - }; - CssSelectorParser.prototype.render = function(path) { - return this._renderEntity(path).trim(); - }; - CssSelectorParser.prototype._renderEntity = function(entity) { - var currentEntity, parts, res; - res = ''; - switch (entity.type) { - case 'ruleSet': - currentEntity = entity.rule; - parts = []; - while (currentEntity) { - if (currentEntity.nestingOperator) { - parts.push(currentEntity.nestingOperator); - } - parts.push(this._renderEntity(currentEntity)); - currentEntity = currentEntity.rule; - } - res = parts.join(' '); - break; - - case 'selectors': - res = entity.selectors.map(this._renderEntity, this).join(', '); - break; - - case 'rule': - if (entity.tagName) { - if (entity.tagName === '*') { - res = '*'; - } else { - res = this.escapeIdentifier(entity.tagName); - } + } else { + out = {}; + for (index in obj) { + out[index] = axe.utils.clone(obj[index]); } - if (entity.id) { - res += '#' + this.escapeIdentifier(entity.id); + } + } + return out; + }; + 'use strict'; + function err(message, node) { + 'use strict'; + var selector; + if (axe._tree) { + selector = axe.utils.getSelector(node); + } + return new Error(message + ': ' + (selector || node)); + } + axe.utils.sendCommandToFrame = function(node, parameters, resolve, reject) { + 'use strict'; + var win = node.contentWindow; + if (!win) { + axe.log('Frame does not have a content window', node); + resolve(null); + return; + } + var timeout = setTimeout(function() { + timeout = setTimeout(function() { + if (!parameters.debug) { + resolve(null); + } else { + reject(err('No response from frame', node)); } - if (entity.classNames) { - res += entity.classNames.map(function(cn) { - return '.' + this.escapeIdentifier(cn); - }, this).join(''); + }, 0); + }, 500); + axe.utils.respondable(win, 'axe.ping', null, undefined, function() { + clearTimeout(timeout); + var frameWaitTime = parameters.options && parameters.options.frameWaitTime || 6e4; + timeout = setTimeout(function() { + reject(err('Axe in frame timed out', node)); + }, frameWaitTime); + axe.utils.respondable(win, 'axe.start', parameters, undefined, function(data) { + clearTimeout(timeout); + if (data instanceof Error === false) { + resolve(data); + } else { + reject(data); } - if (entity.attrs) { - res += entity.attrs.map(function(attr) { - if (attr.operator) { - if (attr.valueType === 'substitute') { - return '[' + this.escapeIdentifier(attr.name) + attr.operator + '$' + attr.value + ']'; - } else { - return '[' + this.escapeIdentifier(attr.name) + attr.operator + this.escapeStr(attr.value) + ']'; - } - } else { - return '[' + this.escapeIdentifier(attr.name) + ']'; - } - }, this).join(''); - } - if (entity.pseudos) { - res += entity.pseudos.map(function(pseudo) { - if (pseudo.valueType) { - if (pseudo.valueType === 'selector') { - return ':' + this.escapeIdentifier(pseudo.name) + '(' + this._renderEntity(pseudo.value) + ')'; - } else if (pseudo.valueType === 'substitute') { - return ':' + this.escapeIdentifier(pseudo.name) + '($' + pseudo.value + ')'; - } else if (pseudo.valueType === 'numeric') { - return ':' + this.escapeIdentifier(pseudo.name) + '(' + pseudo.value + ')'; - } else { - return ':' + this.escapeIdentifier(pseudo.name) + '(' + this.escapeIdentifier(pseudo.value) + ')'; - } - } else { - return ':' + this.escapeIdentifier(pseudo.name); - } - }, this).join(''); + }); + }); + }; + function collectResultsFromFrames(context, options, command, parameter, resolve, reject) { + 'use strict'; + var q = axe.utils.queue(); + var frames = context.frames; + frames.forEach(function(frame) { + var params = { + options: options, + command: command, + parameter: parameter, + context: { + initiator: false, + page: context.page, + include: frame.include || [], + exclude: frame.exclude || [] } - break; - - default: - throw Error('Unknown entity type: "' + entity.type(+'".')); + }; + q.defer(function(res, rej) { + var node = frame.node; + axe.utils.sendCommandToFrame(node, params, function(data) { + if (data) { + return res({ + results: data, + frameElement: node, + frame: axe.utils.getSelector(node) + }); + } + res(null); + }, rej); + }); + }); + q.then(function(data) { + resolve(axe.utils.mergeResults(data, options)); + })['catch'](reject); + } + axe.utils.collectResultsFromFrames = collectResultsFromFrames; + 'use strict'; + axe.utils.contains = function(vNode, otherVNode) { + 'use strict'; + function containsShadowChild(vNode, otherVNode) { + if (vNode.shadowId === otherVNode.shadowId) { + return true; } - return res; - }; - var parser = new CssSelectorParser(); + return !!vNode.children.find(function(child) { + return containsShadowChild(child, otherVNode); + }); + } + if (vNode.shadowId || otherVNode.shadowId) { + return containsShadowChild(vNode, otherVNode); + } + if (vNode.actualNode) { + if (typeof vNode.actualNode.contains === 'function') { + return vNode.actualNode.contains(otherVNode.actualNode); + } + return !!(vNode.actualNode.compareDocumentPosition(otherVNode.actualNode) & 16); + } else { + do { + if (otherVNode === vNode) { + return true; + } + } while (otherVNode = otherVNode && otherVNode.parent); + } + return false; + }; + 'use strict'; + (function(axe) { + var parser = new axe.imports.CssSelectorParser(); + parser.registerSelectorPseudos('not'); parser.registerNestingOperators('>'); + parser.registerAttrEqualityMods('^', '$', '*'); axe.utils.cssParser = parser; })(axe); 'use strict'; @@ -2267,20 +4936,23 @@ axe.utils.matchesSelector = function() { 'use strict'; var method; - function getMethod(win) { - var index, candidate, elProto = win.Element.prototype, candidates = [ 'matches', 'matchesSelector', 'mozMatchesSelector', 'webkitMatchesSelector', 'msMatchesSelector' ], length = candidates.length; + function getMethod(node) { + var index, candidate, candidates = [ 'matches', 'matchesSelector', 'mozMatchesSelector', 'webkitMatchesSelector', 'msMatchesSelector' ], length = candidates.length; for (index = 0; index < length; index++) { candidate = candidates[index]; - if (elProto[candidate]) { + if (node[candidate]) { return candidate; } } } return function(node, selector) { if (!method || !node[method]) { - method = getMethod(node.ownerDocument.defaultView); + method = getMethod(node); + } + if (node[method]) { + return node[method](selector); } - return node[method](selector); + return false; }; }(); 'use strict'; @@ -2295,13 +4967,14 @@ while (++index < length) { codeUnit = string.charCodeAt(index); if (codeUnit == 0) { - throw new Error('INVALID_CHARACTER_ERR'); + result += '�'; + continue; } - if (codeUnit >= 1 && codeUnit <= 31 || codeUnit >= 127 && codeUnit <= 159 || index == 0 && codeUnit >= 48 && codeUnit <= 57 || index == 1 && codeUnit >= 48 && codeUnit <= 57 && firstCodeUnit == 45) { + if (codeUnit >= 1 && codeUnit <= 31 || codeUnit == 127 || index == 0 && codeUnit >= 48 && codeUnit <= 57 || index == 1 && codeUnit >= 48 && codeUnit <= 57 && firstCodeUnit == 45) { result += '\\' + codeUnit.toString(16) + ' '; continue; } - if (index == 1 && codeUnit == 45 && firstCodeUnit == 45) { + if (index == 0 && length == 1 && codeUnit == 45) { result += '\\' + string.charAt(index); continue; } @@ -2327,20 +5000,27 @@ }; 'use strict'; axe.utils.finalizeRuleResult = function(ruleResult) { - Object.assign(ruleResult, axe.utils.aggregateRule(ruleResult.nodes)); + Object.assign(ruleResult, axe.utils.aggregateNodeResults(ruleResult.nodes)); delete ruleResult.nodes; return ruleResult; }; 'use strict'; - var _typeof = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? function(obj) { - return typeof obj; - } : function(obj) { - return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; - }; + function _typeof(obj) { + if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; + }; + } + return _typeof(obj); + } axe.utils.findBy = function(array, key, value) { if (Array.isArray(array)) { return array.find(function(obj) { - return (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && obj[key] === value; + return _typeof(obj) === 'object' && obj[key] === value; }); } }; @@ -2348,13 +5028,6 @@ var axe = axe || { utils: {} }; - function virtualDOMfromNode(node, shadowId) { - return { - shadowId: shadowId, - children: [], - actualNode: node - }; - } function getSlotChildren(node) { var retVal = []; node = node.firstChild; @@ -2364,10 +5037,10 @@ } return retVal; } - axe.utils.getFlattenedTree = function(node, shadowId) { + function flattenTree(node, shadowId, parent) { var retVal, realArray, nodeName; - function reduceShadowDOM(res, child) { - var replacements = axe.utils.getFlattenedTree(child, shadowId); + function reduceShadowDOM(res, child, parent) { + var replacements = flattenTree(child, shadowId, parent); if (replacements) { res = res.concat(replacements); } @@ -2377,59 +5050,59 @@ node = node.documentElement; } nodeName = node.nodeName.toLowerCase(); - if (node.shadowRoot && nodeName !== 'marquee') { - retVal = virtualDOMfromNode(node, shadowId); + if (axe.utils.isShadowRoot(node)) { + retVal = new VirtualNode(node, parent, shadowId); shadowId = 'a' + Math.random().toString().substring(2); realArray = Array.from(node.shadowRoot.childNodes); - retVal.children = realArray.reduce(reduceShadowDOM, []); + retVal.children = realArray.reduce(function(res, child) { + return reduceShadowDOM(res, child, retVal); + }, []); return [ retVal ]; } else { - if (nodeName === 'content') { + if (nodeName === 'content' && typeof node.getDistributedNodes === 'function') { realArray = Array.from(node.getDistributedNodes()); - return realArray.reduce(reduceShadowDOM, []); - } else if (nodeName === 'slot') { + return realArray.reduce(function(res, child) { + return reduceShadowDOM(res, child, parent); + }, []); + } else if (nodeName === 'slot' && typeof node.assignedNodes === 'function') { realArray = Array.from(node.assignedNodes()); if (!realArray.length) { realArray = getSlotChildren(node); } var styl = window.getComputedStyle(node); if (false && styl.display !== 'contents') { - retVal = virtualDOMfromNode(node, shadowId); - retVal.children = realArray.reduce(reduceShadowDOM, []); + retVal = new VirtualNode(node, parent, shadowId); + retVal.children = realArray.reduce(function(res, child) { + return reduceShadowDOM(res, child, retVal); + }, []); return [ retVal ]; } else { - return realArray.reduce(reduceShadowDOM, []); + return realArray.reduce(function(res, child) { + return reduceShadowDOM(res, child, parent); + }, []); } } else { if (node.nodeType === 1) { - retVal = virtualDOMfromNode(node, shadowId); + retVal = new VirtualNode(node, parent, shadowId); realArray = Array.from(node.childNodes); - retVal.children = realArray.reduce(reduceShadowDOM, []); + retVal.children = realArray.reduce(function(res, child) { + return reduceShadowDOM(res, child, retVal); + }, []); return [ retVal ]; } else if (node.nodeType === 3) { - return [ virtualDOMfromNode(node) ]; + return [ new VirtualNode(node, parent) ]; } return undefined; } } + } + axe.utils.getFlattenedTree = function(node, shadowId) { + axe._cache.set('nodeMap', new WeakMap()); + return flattenTree(node, shadowId); }; axe.utils.getNodeFromTree = function(vNode, node) { - var found; - if (vNode.actualNode === node) { - return vNode; - } - vNode.children.forEach(function(candidate) { - var retVal; - if (candidate.actualNode === node) { - found = candidate; - } else { - retVal = axe.utils.getNodeFromTree(candidate, node); - if (retVal) { - found = retVal; - } - } - }); - return found; + var el = node || vNode; + return axe._cache.get('nodeMap') ? axe._cache.get('nodeMap').get(el) : null; }; 'use strict'; axe.utils.getAllChecks = function getAllChecks(object) { @@ -2438,6 +5111,13 @@ return result.concat(object.any || []).concat(object.all || []).concat(object.none || []); }; 'use strict'; + axe.utils.getBaseLang = function getBaseLang(lang) { + if (!lang) { + return ''; + } + return lang.trim().split('-')[0].toLowerCase(); + }; + 'use strict'; axe.utils.getCheckOption = function(check, ruleID, options) { var ruleCheckOption = ((options.rules && options.rules[ruleID] || {}).checks || {})[check.id]; var checkOption = (options.checks || {})[check.id]; @@ -2466,45 +5146,45 @@ }; }; 'use strict'; - var _slicedToArray = function() { - function sliceIterator(arr, i) { - var _arr = []; - var _n = true; - var _d = false; - var _e = undefined; + function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); + } + function _nonIterableRest() { + throw new TypeError('Invalid attempt to destructure non-iterable instance'); + } + function _iterableToArrayLimit(arr, i) { + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + if (i && _arr.length === i) { + break; + } + } + } catch (err) { + _d = true; + _e = err; + } finally { try { - for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { - _arr.push(_s.value); - if (i && _arr.length === i) { - break; - } + if (!_n && _i['return'] != null) { + _i['return'](); } - } catch (err) { - _d = true; - _e = err; } finally { - try { - if (!_n && _i['return']) { - _i['return'](); - } - } finally { - if (_d) { - throw _e; - } + if (_d) { + throw _e; } } - return _arr; } - return function(arr, i) { - if (Array.isArray(arr)) { - return arr; - } else if (Symbol.iterator in Object(arr)) { - return sliceIterator(arr, i); - } else { - throw new TypeError('Invalid attempt to destructure non-iterable instance'); - } - }; - }(); + return _arr; + } + function _arrayWithHoles(arr) { + if (Array.isArray(arr)) { + return arr; + } + } function isMostlyNumbers() { var str = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; return str.length !== 0 && (str.match(/[0-9]/g) || '').length >= str.length / 2; @@ -2512,6 +5192,9 @@ function splitString(str, splitIndex) { return [ str.substring(0, splitIndex), str.substring(splitIndex) ]; } + function trimRight(str) { + return str.replace(/\s+$/, ''); + } function uriParser(url) { var original = url; var protocol = '', domain = '', port = '', path = '', query = '', hash = ''; @@ -2569,61 +5252,168 @@ if (uri.length <= 1 || uri.substr(0, 5) === 'data:' || uri.substr(0, 11) === 'javascript:' || uri.includes('?')) { return; } - var currentDomain = options.currentDomain, _options$maxLength = options.maxLength, maxLength = _options$maxLength === undefined ? 25 : _options$maxLength; + var currentDomain = options.currentDomain, _options$maxLength = options.maxLength, maxLength = _options$maxLength === void 0 ? 25 : _options$maxLength; var _uriParser = uriParser(uri), path = _uriParser.path, domain = _uriParser.domain, hash = _uriParser.hash; var pathEnd = path.substr(path.substr(0, path.length - 2).lastIndexOf('/') + 1); if (hash) { if (pathEnd && (pathEnd + hash).length <= maxLength) { - return pathEnd + hash; + return trimRight(pathEnd + hash); } else if (pathEnd.length < 2 && hash.length > 2 && hash.length <= maxLength) { - return hash; + return trimRight(hash); } else { return; } } else if (domain && domain.length < maxLength && path.length <= 1) { - return domain + path; + return trimRight(domain + path); } if (path === '/' + pathEnd && domain && currentDomain && domain !== currentDomain && (domain + path).length <= maxLength) { - return domain + path; + return trimRight(domain + path); } var lastDotIndex = pathEnd.lastIndexOf('.'); if ((lastDotIndex === -1 || lastDotIndex > 1) && (lastDotIndex !== -1 || pathEnd.length > 2) && pathEnd.length <= maxLength && !pathEnd.match(/index(\.[a-zA-Z]{2-4})?/) && !isMostlyNumbers(pathEnd)) { - return pathEnd; + return trimRight(pathEnd); } }; 'use strict'; - function _toConsumableArray(arr) { - if (Array.isArray(arr)) { - for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { - arr2[i] = arr[i]; + axe.utils.getNodeAttributes = function getNodeAttributes(node) { + if (node.attributes instanceof window.NamedNodeMap) { + return node.attributes; + } + return node.cloneNode(false).attributes; + }; + 'use strict'; + axe.utils.getRootNode = function getRootNode(node) { + var doc = node.getRootNode && node.getRootNode() || document; + if (doc === node) { + doc = document; + } + return doc; + }; + 'use strict'; + axe.utils.getScroll = function getScroll(elm) { + var buffer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + var overflowX = elm.scrollWidth > elm.clientWidth + buffer; + var overflowY = elm.scrollHeight > elm.clientHeight + buffer; + if (!(overflowX || overflowY)) { + return; + } + var style = window.getComputedStyle(elm); + var overflowXStyle = style.getPropertyValue('overflow-x'); + var overflowYStyle = style.getPropertyValue('overflow-y'); + var scrollableX = overflowXStyle !== 'visible' && overflowXStyle !== 'hidden'; + var scrollableY = overflowYStyle !== 'visible' && overflowYStyle !== 'hidden'; + if (overflowX && scrollableX || overflowY && scrollableY) { + return { + elm: elm, + top: elm.scrollTop, + left: elm.scrollLeft + }; + } + }; + 'use strict'; + var escapeSelector = axe.utils.escapeSelector; + var isXHTML; + var ignoredAttributes = [ 'class', 'style', 'id', 'selected', 'checked', 'disabled', 'tabindex', 'aria-checked', 'aria-selected', 'aria-invalid', 'aria-activedescendant', 'aria-busy', 'aria-disabled', 'aria-expanded', 'aria-grabbed', 'aria-pressed', 'aria-valuenow' ]; + var MAXATTRIBUTELENGTH = 31; + function getAttributeNameValue(node, at) { + var name = at.name; + var atnv; + if (name.indexOf('href') !== -1 || name.indexOf('src') !== -1) { + var friendly = axe.utils.getFriendlyUriEnd(node.getAttribute(name)); + if (friendly) { + var value = encodeURI(friendly); + if (value) { + atnv = escapeSelector(at.name) + '$="' + escapeSelector(value) + '"'; + } else { + return; + } + } else { + atnv = escapeSelector(at.name) + '="' + escapeSelector(node.getAttribute(name)) + '"'; } - return arr2; } else { - return Array.from(arr); + atnv = escapeSelector(name) + '="' + escapeSelector(at.value) + '"'; } + return atnv; } - var escapeSelector = axe.utils.escapeSelector; - function isUncommonClassName(className) { - return ![ 'focus', 'hover', 'hidden', 'visible', 'dirty', 'touched', 'valid', 'disable', 'enable', 'active', 'col-' ].find(function(str) { - return className.includes(str); - }); + function countSort(a, b) { + return a.count < b.count ? -1 : a.count === b.count ? 0 : 1; } - function getDistinctClassList(elm) { - if (!elm.classList || elm.classList.length === 0) { - return []; - } - var siblings = elm.parentNode && Array.from(elm.parentNode.children || '') || []; - return siblings.reduce(function(classList, childElm) { - if (elm === childElm) { - return classList; - } else { - return classList.filter(function(classItem) { - return !childElm.classList.contains(classItem); - }); + function filterAttributes(at) { + return !ignoredAttributes.includes(at.name) && at.name.indexOf(':') === -1 && (!at.value || at.value.length < MAXATTRIBUTELENGTH); + } + axe.utils.getSelectorData = function(domTree) { + var data = { + classes: {}, + tags: {}, + attributes: {} + }; + domTree = Array.isArray(domTree) ? domTree : [ domTree ]; + var currentLevel = domTree.slice(); + var stack = []; + var _loop = function _loop() { + var current = currentLevel.pop(); + var node = current.actualNode; + if (!!node.querySelectorAll) { + var tag = node.nodeName; + if (data.tags[tag]) { + data.tags[tag]++; + } else { + data.tags[tag] = 1; + } + if (node.classList) { + Array.from(node.classList).forEach(function(cl) { + var ind = escapeSelector(cl); + if (data.classes[ind]) { + data.classes[ind]++; + } else { + data.classes[ind] = 1; + } + }); + } + if (node.hasAttributes()) { + Array.from(axe.utils.getNodeAttributes(node)).filter(filterAttributes).forEach(function(at) { + var atnv = getAttributeNameValue(node, at); + if (atnv) { + if (data.attributes[atnv]) { + data.attributes[atnv]++; + } else { + data.attributes[atnv] = 1; + } + } + }); + } + } + if (current.children.length) { + stack.push(currentLevel); + currentLevel = current.children.slice(); + } + while (!currentLevel.length && stack.length) { + currentLevel = stack.pop(); } - }, Array.from(elm.classList).filter(isUncommonClassName)); + }; + while (currentLevel.length) { + _loop(); + } + return data; + }; + function uncommonClasses(node, selectorData) { + var retVal = []; + var classData = selectorData.classes; + var tagData = selectorData.tags; + if (node.classList) { + Array.from(node.classList).forEach(function(cl) { + var ind = escapeSelector(cl); + if (classData[ind] < tagData[node.nodeName]) { + retVal.push({ + name: ind, + count: classData[ind], + species: 'class' + }); + } + }); + } + return retVal.sort(countSort); } - var commonNodes = [ 'div', 'span', 'p', 'b', 'i', 'u', 'strong', 'em', 'h2', 'h3' ]; function getNthChildString(elm, selector) { var siblings = elm.parentNode && Array.from(elm.parentNode.children || '') || []; var hasMatchingSiblings = siblings.find(function(sibling) { @@ -2636,124 +5426,108 @@ return ''; } } - var createSelector = { - getElmId: function getElmId(elm) { - if (!elm.getAttribute('id')) { - return; - } - var doc = elm.getRootNode && elm.getRootNode() || document; - var id = '#' + escapeSelector(elm.getAttribute('id') || ''); - if (!id.match(/player_uid_/) && doc.querySelectorAll(id).length === 1) { - return id; - } - }, - getCustomElm: function getCustomElm(elm, _ref) { - var isCustomElm = _ref.isCustomElm, nodeName = _ref.nodeName; - if (isCustomElm) { - return nodeName; - } - }, - getElmRoleProp: function getElmRoleProp(elm) { - if (elm.hasAttribute('role')) { - return '[role="' + escapeSelector(elm.getAttribute('role')) + '"]'; - } - }, - getUncommonElm: function getUncommonElm(elm, _ref2) { - var isCommonElm = _ref2.isCommonElm, isCustomElm = _ref2.isCustomElm, nodeName = _ref2.nodeName; - if (!isCommonElm && !isCustomElm) { - nodeName = escapeSelector(nodeName); - if (nodeName === 'input' && elm.hasAttribute('type')) { - nodeName += '[type="' + elm.type + '"]'; - } - return nodeName; - } - }, - getElmNameProp: function getElmNameProp(elm) { - if (!elm.hasAttribute('id') && elm.name) { - return '[name="' + escapeSelector(elm.name) + '"]'; - } - }, - getDistinctClass: function getDistinctClass(elm, _ref3) { - var distinctClassList = _ref3.distinctClassList; - if (distinctClassList.length > 0 && distinctClassList.length < 3) { - return '.' + distinctClassList.map(escapeSelector).join('.'); - } - }, - getFileRefProp: function getFileRefProp(elm) { - var attr = void 0; - if (elm.hasAttribute('href')) { - attr = 'href'; - } else if (elm.hasAttribute('src')) { - attr = 'src'; + function getElmId(elm) { + if (!elm.getAttribute('id')) { + return; + } + var doc = elm.getRootNode && elm.getRootNode() || document; + var id = '#' + escapeSelector(elm.getAttribute('id') || ''); + if (!id.match(/player_uid_/) && doc.querySelectorAll(id).length === 1) { + return id; + } + } + function getBaseSelector(elm) { + if (typeof isXHTML === 'undefined') { + isXHTML = axe.utils.isXHTML(document); + } + return escapeSelector(isXHTML ? elm.localName : elm.nodeName.toLowerCase()); + } + function uncommonAttributes(node, selectorData) { + var retVal = []; + var attData = selectorData.attributes; + var tagData = selectorData.tags; + if (node.hasAttributes()) { + Array.from(axe.utils.getNodeAttributes(node)).filter(filterAttributes).forEach(function(at) { + var atnv = getAttributeNameValue(node, at); + if (atnv && attData[atnv] < tagData[node.nodeName]) { + retVal.push({ + name: atnv, + count: attData[atnv], + species: 'attribute' + }); + } + }); + } + return retVal.sort(countSort); + } + function getThreeLeastCommonFeatures(elm, selectorData) { + var selector = ''; + var features; + var clss = uncommonClasses(elm, selectorData); + var atts = uncommonAttributes(elm, selectorData); + if (clss.length && clss[0].count === 1) { + features = [ clss[0] ]; + } else if (atts.length && atts[0].count === 1) { + features = [ atts[0] ]; + selector = getBaseSelector(elm); + } else { + features = clss.concat(atts); + features.sort(countSort); + features = features.slice(0, 3); + if (!features.some(function(feat) { + return feat.species === 'class'; + })) { + selector = getBaseSelector(elm); } else { - return; - } - var friendlyUriEnd = axe.utils.getFriendlyUriEnd(elm.getAttribute(attr)); - if (friendlyUriEnd) { - return '[' + attr + '$="' + encodeURI(friendlyUriEnd) + '"]'; - } - }, - getCommonName: function getCommonName(elm, _ref4) { - var nodeName = _ref4.nodeName, isCommonElm = _ref4.isCommonElm; - if (isCommonElm) { - return nodeName; + features.sort(function(a, b) { + return a.species !== b.species && a.species === 'class' ? -1 : a.species === b.species ? 0 : 1; + }); } } - }; - function getElmFeatures(elm, featureCount) { - var nodeName = elm.nodeName.toLowerCase(); - var classList = Array.from(elm.classList) || []; - var props = { - nodeName: nodeName, - classList: classList, - isCustomElm: nodeName.includes('-'), - isCommonElm: commonNodes.includes(nodeName), - distinctClassList: getDistinctClassList(elm) - }; - return [ createSelector.getCustomElm, createSelector.getElmRoleProp, createSelector.getUncommonElm, createSelector.getElmNameProp, createSelector.getDistinctClass, createSelector.getFileRefProp, createSelector.getCommonName ].reduce(function(features, func) { - if (features.length === featureCount) { - return features; - } - var feature = func(elm, props); - if (feature) { - if (!feature[0].match(/[a-z]/)) { - features.push(feature); - } else { - features.unshift(feature); - } + return selector += features.reduce(function(val, feat) { + switch (feat.species) { + case 'class': + return val + '.' + feat.name; + + case 'attribute': + return val + '[' + feat.name + ']'; } - return features; - }, []); + return val; + }, ''); } function generateSelector(elm, options, doc) { - var selector = void 0, addParent = void 0; - var _options$isUnique = options.isUnique, isUnique = _options$isUnique === undefined ? false : _options$isUnique; - var idSelector = createSelector.getElmId(elm); - var _options$featureCount = options.featureCount, featureCount = _options$featureCount === undefined ? 2 : _options$featureCount, _options$minDepth = options.minDepth, minDepth = _options$minDepth === undefined ? 1 : _options$minDepth, _options$toRoot = options.toRoot, toRoot = _options$toRoot === undefined ? false : _options$toRoot, _options$childSelecto = options.childSelectors, childSelectors = _options$childSelecto === undefined ? [] : _options$childSelecto; - if (idSelector) { - selector = idSelector; - isUnique = true; - } else { - selector = getElmFeatures(elm, featureCount).join(''); - selector += getNthChildString(elm, selector); - isUnique = options.isUnique || doc.querySelectorAll(selector).length === 1; - if (!isUnique && elm === document.documentElement) { - selector += ':root'; - } - addParent = minDepth !== 0 || !isUnique; - } - var selectorParts = [ selector ].concat(_toConsumableArray(childSelectors)); - if (elm.parentElement && elm.parentElement.nodeType !== 11 && (toRoot || addParent)) { - return generateSelector(elm.parentNode, { - toRoot: toRoot, - isUnique: isUnique, - childSelectors: selectorParts, - featureCount: 1, - minDepth: minDepth - 1 - }, doc); - } else { - return selectorParts.join(' > '); + if (!axe._selectorData) { + throw new Error('Expect axe._selectorData to be set up'); + } + var _options$toRoot = options.toRoot, toRoot = _options$toRoot === void 0 ? false : _options$toRoot; + var selector; + var similar; + do { + var features = getElmId(elm); + if (!features) { + features = getThreeLeastCommonFeatures(elm, axe._selectorData); + features += getNthChildString(elm, features); + } + if (selector) { + selector = features + ' > ' + selector; + } else { + selector = features; + } + if (!similar) { + similar = Array.from(doc.querySelectorAll(selector)); + } else { + similar = similar.filter(function(item) { + return axe.utils.matchesSelector(item, selector); + }); + } + elm = elm.parentElement; + } while ((similar.length > 1 || toRoot) && elm && elm.nodeType !== 11); + if (similar.length === 1) { + return selector; + } else if (selector.indexOf(' > ') !== -1) { + return ':root' + selector.substring(selector.indexOf(' > ')); } + return ':root'; } axe.utils.getSelector = function createUniqueSelector(elm) { var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; @@ -2783,6 +5557,30 @@ } }; 'use strict'; + axe.utils.getStyleSheetFactory = function getStyleSheetFactory(dynamicDoc) { + if (!dynamicDoc) { + throw new Error('axe.utils.getStyleSheetFactory should be invoked with an argument'); + } + return function(options) { + var data = options.data, _options$isCrossOrigi = options.isCrossOrigin, isCrossOrigin = _options$isCrossOrigi === void 0 ? false : _options$isCrossOrigi, shadowId = options.shadowId, root = options.root, priority = options.priority, _options$isLink = options.isLink, isLink = _options$isLink === void 0 ? false : _options$isLink; + var style = dynamicDoc.createElement('style'); + if (isLink) { + var text = dynamicDoc.createTextNode('@import "'.concat(data.href, '"')); + style.appendChild(text); + } else { + style.appendChild(dynamicDoc.createTextNode(data)); + } + dynamicDoc.head.appendChild(style); + return { + sheet: style.sheet, + isCrossOrigin: isCrossOrigin, + shadowId: shadowId, + root: root, + priority: priority + }; + }; + }; + 'use strict'; function getXPathArray(node, path) { var sibling, count; if (!node) { @@ -2839,9 +5637,9 @@ function xpathToString(xpathArray) { return xpathArray.reduce(function(str, elm) { if (elm.id) { - return '/' + elm.str + '[@id=\'' + elm.id + '\']'; + return '/'.concat(elm.str, '[@id=\'').concat(elm.id, '\']'); } else { - return str + ('/' + elm.str) + (elm.count > 0 ? '[' + elm.count + ']' : ''); + return str + '/'.concat(elm.str) + (elm.count > 0 ? '['.concat(elm.count, ']') : ''); } }, ''); } @@ -2879,19 +5677,51 @@ 'use strict'; axe.utils.isHidden = function isHidden(el, recursed) { 'use strict'; - var parent; + var node = axe.utils.getNodeFromTree(el); if (el.nodeType === 9) { return false; } if (el.nodeType === 11) { el = el.host; } + if (node && node._isHidden !== null) { + return node._isHidden; + } var style = window.getComputedStyle(el, null); if (!style || !el.parentNode || style.getPropertyValue('display') === 'none' || !recursed && style.getPropertyValue('visibility') === 'hidden' || el.getAttribute('aria-hidden') === 'true') { return true; } - parent = el.assignedSlot ? el.assignedSlot : el.parentNode; - return axe.utils.isHidden(parent, true); + var parent = el.assignedSlot ? el.assignedSlot : el.parentNode; + var isHidden = axe.utils.isHidden(parent, true); + if (node) { + node._isHidden = isHidden; + } + return isHidden; + }; + 'use strict'; + var htmlTags = [ 'a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'math', 'menu', 'menuitem', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'pre', 'progress', 'q', 'rb', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'script', 'section', 'select', 'slot', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'svg', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr' ]; + axe.utils.isHtmlElement = function isHtmlElement(node) { + var tagName = node.nodeName.toLowerCase(); + return htmlTags.includes(tagName) && node.namespaceURI !== 'http://www.w3.org/2000/svg'; + }; + 'use strict'; + var possibleShadowRoots = [ 'article', 'aside', 'blockquote', 'body', 'div', 'footer', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'main', 'nav', 'p', 'section', 'span' ]; + axe.utils.isShadowRoot = function isShadowRoot(node) { + var nodeName = node.nodeName.toLowerCase(); + if (node.shadowRoot) { + if (/^[a-z][a-z0-9_.-]*-[a-z0-9_.-]*$/.test(nodeName) || possibleShadowRoots.includes(nodeName)) { + return true; + } + } + return false; + }; + 'use strict'; + axe.utils.isXHTML = function(doc) { + 'use strict'; + if (!doc.createElement) { + return false; + } + return doc.createElement('A').localName === 'A'; }; 'use strict'; function pushFrame(resultSet, options, frameElement, frameSelector) { @@ -2969,16 +5799,124 @@ return result; }; 'use strict'; - axe.utils.nodeSorter = function nodeSorter(a, b) { - 'use strict'; - if (a.actualNode === b.actualNode) { + axe.utils.nodeSorter = function nodeSorter(nodeA, nodeB) { + nodeA = nodeA.actualNode || nodeA; + nodeB = nodeB.actualNode || nodeB; + if (nodeA === nodeB) { return 0; } - if (a.actualNode.compareDocumentPosition(b.actualNode) & 4) { + if (nodeA.compareDocumentPosition(nodeB) & 4) { return -1; + } else { + return 1; + } + }; + 'use strict'; + axe.utils.parseCrossOriginStylesheet = function parseCrossOriginStylesheet(url, options, priority, importedUrls, isCrossOrigin) { + var axiosOptions = { + method: 'get', + url: url + }; + importedUrls.push(url); + return axe.imports.axios(axiosOptions).then(function(_ref) { + var data = _ref.data; + var result = options.convertDataToStylesheet({ + data: data, + isCrossOrigin: isCrossOrigin, + priority: priority, + root: options.rootNode, + shadowId: options.shadowId + }); + return axe.utils.parseStylesheet(result.sheet, options, priority, importedUrls, result.isCrossOrigin); + }); + }; + 'use strict'; + function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); + } + function _nonIterableSpread() { + throw new TypeError('Invalid attempt to spread non-iterable instance'); + } + function _iterableToArray(iter) { + if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === '[object Arguments]') { + return Array.from(iter); + } + } + function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) { + for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { + arr2[i] = arr[i]; + } + return arr2; + } + } + axe.utils.parseSameOriginStylesheet = function parseSameOriginStylesheet(sheet, options, priority, importedUrls) { + var isCrossOrigin = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false; + var rules = Array.from(sheet.cssRules); + if (!rules) { + return Promise.resolve(); + } + var cssImportRules = rules.filter(function(r) { + return r.type === 3; + }); + if (!cssImportRules.length) { + return Promise.resolve({ + isCrossOrigin: isCrossOrigin, + priority: priority, + root: options.rootNode, + shadowId: options.shadowId, + sheet: sheet + }); + } + var cssImportUrlsNotAlreadyImported = cssImportRules.filter(function(rule) { + return rule.href; + }).map(function(rule) { + return rule.href; + }).filter(function(url) { + return !importedUrls.includes(url); + }); + var promises = cssImportUrlsNotAlreadyImported.map(function(importUrl, cssRuleIndex) { + var newPriority = [].concat(_toConsumableArray(priority), [ cssRuleIndex ]); + var isCrossOriginRequest = /^https?:\/\/|^\/\//i.test(importUrl); + return axe.utils.parseCrossOriginStylesheet(importUrl, options, newPriority, importedUrls, isCrossOriginRequest); + }); + var nonImportCSSRules = rules.filter(function(r) { + return r.type !== 3; + }); + if (!nonImportCSSRules.length) { + return Promise.all(promises); + } + promises.push(Promise.resolve(options.convertDataToStylesheet({ + data: nonImportCSSRules.map(function(rule) { + return rule.cssText; + }).join(), + isCrossOrigin: isCrossOrigin, + priority: priority, + root: options.rootNode, + shadowId: options.shadowId + }))); + return Promise.all(promises); + }; + 'use strict'; + axe.utils.parseStylesheet = function parseStylesheet(sheet, options, priority, importedUrls) { + var isCrossOrigin = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false; + var isSameOrigin = isSameOriginStylesheet(sheet); + if (isSameOrigin) { + return axe.utils.parseSameOriginStylesheet(sheet, options, priority, importedUrls, isCrossOrigin); } - return 1; + return axe.utils.parseCrossOriginStylesheet(sheet.href, options, priority, importedUrls, true); }; + function isSameOriginStylesheet(sheet) { + try { + var rules = sheet.cssRules; + if (!rules && sheet.href) { + return false; + } + return true; + } catch (e) { + return false; + } + } 'use strict'; utils.performanceTimer = function() { 'use strict'; @@ -3021,7 +5959,10 @@ axe.log('Measure ' + req.name + ' took ' + req.duration + 'ms'); } if (window.performance && window.performance.getEntriesByType !== undefined) { - var measures = window.performance.getEntriesByType('measure'); + var axeStart = window.performance.getEntriesByName('mark_axe_start')[0]; + var measures = window.performance.getEntriesByType('measure').filter(function(measure) { + return measure.startTime >= axeStart.startTime; + }); for (var i = 0; i < measures.length; ++i) { var req = measures[i]; if (req.name === measureName) { @@ -3067,25 +6008,27 @@ })(); } if (!Array.prototype.find) { - Array.prototype.find = function(predicate) { - if (this === null) { - throw new TypeError('Array.prototype.find called on null or undefined'); - } - if (typeof predicate !== 'function') { - throw new TypeError('predicate must be a function'); - } - var list = Object(this); - var length = list.length >>> 0; - var thisArg = arguments[1]; - var value; - for (var i = 0; i < length; i++) { - value = list[i]; - if (predicate.call(thisArg, value, i, list)) { - return value; + Object.defineProperty(Array.prototype, 'find', { + value: function value(predicate) { + if (this === null) { + throw new TypeError('Array.prototype.find called on null or undefined'); + } + if (typeof predicate !== 'function') { + throw new TypeError('predicate must be a function'); + } + var list = Object(this); + var length = list.length >>> 0; + var thisArg = arguments[1]; + var value; + for (var i = 0; i < length; i++) { + value = list[i]; + if (predicate.call(thisArg, value, i, list)) { + return value; + } } + return undefined; } - return undefined; - }; + }); } axe.utils.pollyfillElementsFromPoint = function() { if (document.elementsFromPoint) { @@ -3116,6 +6059,10 @@ }); current.style.setProperty(cssProp, cssDisableVal, 'important'); } + if (elements.indexOf(document.documentElement) < elements.length - 1) { + elements.splice(elements.indexOf(document.documentElement), 1); + elements.push(document.documentElement); + } for (i = previousPointerEvents.length; !!(d = previousPointerEvents[--i]); ) { elements[i].style.setProperty(cssProp, d.value ? d.value : '', d.priority); } @@ -3127,108 +6074,114 @@ document.elementsFromPoint = axe.utils.pollyfillElementsFromPoint(); } if (!Array.prototype.includes) { - Array.prototype.includes = function(searchElement) { - 'use strict'; - var O = Object(this); - var len = parseInt(O.length, 10) || 0; - if (len === 0) { - return false; - } - var n = parseInt(arguments[1], 10) || 0; - var k; - if (n >= 0) { - k = n; - } else { - k = len + n; - if (k < 0) { - k = 0; + Object.defineProperty(Array.prototype, 'includes', { + value: function value(searchElement) { + 'use strict'; + var O = Object(this); + var len = parseInt(O.length, 10) || 0; + if (len === 0) { + return false; } - } - var currentElement; - while (k < len) { - currentElement = O[k]; - if (searchElement === currentElement || searchElement !== searchElement && currentElement !== currentElement) { - return true; + var n = parseInt(arguments[1], 10) || 0; + var k; + if (n >= 0) { + k = n; + } else { + k = len + n; + if (k < 0) { + k = 0; + } + } + var currentElement; + while (k < len) { + currentElement = O[k]; + if (searchElement === currentElement || searchElement !== searchElement && currentElement !== currentElement) { + return true; + } + k++; } - k++; + return false; } - return false; - }; + }); } if (!Array.prototype.some) { - Array.prototype.some = function(fun) { - 'use strict'; - if (this == null) { - throw new TypeError('Array.prototype.some called on null or undefined'); - } - if (typeof fun !== 'function') { - throw new TypeError(); - } - var t = Object(this); - var len = t.length >>> 0; - var thisArg = arguments.length >= 2 ? arguments[1] : void 0; - for (var i = 0; i < len; i++) { - if (i in t && fun.call(thisArg, t[i], i, t)) { - return true; + Object.defineProperty(Array.prototype, 'some', { + value: function value(fun) { + 'use strict'; + if (this == null) { + throw new TypeError('Array.prototype.some called on null or undefined'); + } + if (typeof fun !== 'function') { + throw new TypeError(); } + var t = Object(this); + var len = t.length >>> 0; + var thisArg = arguments.length >= 2 ? arguments[1] : void 0; + for (var i = 0; i < len; i++) { + if (i in t && fun.call(thisArg, t[i], i, t)) { + return true; + } + } + return false; } - return false; - }; + }); } if (!Array.from) { - Array.from = function() { - var toStr = Object.prototype.toString; - var isCallable = function isCallable(fn) { - return typeof fn === 'function' || toStr.call(fn) === '[object Function]'; - }; - var toInteger = function toInteger(value) { - var number = Number(value); - if (isNaN(number)) { - return 0; - } - if (number === 0 || !isFinite(number)) { - return number; - } - return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number)); - }; - var maxSafeInteger = Math.pow(2, 53) - 1; - var toLength = function toLength(value) { - var len = toInteger(value); - return Math.min(Math.max(len, 0), maxSafeInteger); - }; - return function from(arrayLike) { - var C = this; - var items = Object(arrayLike); - if (arrayLike == null) { - throw new TypeError('Array.from requires an array-like object - not null or undefined'); - } - var mapFn = arguments.length > 1 ? arguments[1] : void undefined; - var T; - if (typeof mapFn !== 'undefined') { - if (!isCallable(mapFn)) { - throw new TypeError('Array.from: when provided, the second argument must be a function'); + Object.defineProperty(Array, 'from', { + value: function() { + var toStr = Object.prototype.toString; + var isCallable = function isCallable(fn) { + return typeof fn === 'function' || toStr.call(fn) === '[object Function]'; + }; + var toInteger = function toInteger(value) { + var number = Number(value); + if (isNaN(number)) { + return 0; } - if (arguments.length > 2) { - T = arguments[2]; + if (number === 0 || !isFinite(number)) { + return number; } - } - var len = toLength(items.length); - var A = isCallable(C) ? Object(new C(len)) : new Array(len); - var k = 0; - var kValue; - while (k < len) { - kValue = items[k]; - if (mapFn) { - A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k); - } else { - A[k] = kValue; + return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number)); + }; + var maxSafeInteger = Math.pow(2, 53) - 1; + var toLength = function toLength(value) { + var len = toInteger(value); + return Math.min(Math.max(len, 0), maxSafeInteger); + }; + return function from(arrayLike) { + var C = this; + var items = Object(arrayLike); + if (arrayLike == null) { + throw new TypeError('Array.from requires an array-like object - not null or undefined'); } - k += 1; - } - A.length = len; - return A; - }; - }(); + var mapFn = arguments.length > 1 ? arguments[1] : void undefined; + var T; + if (typeof mapFn !== 'undefined') { + if (!isCallable(mapFn)) { + throw new TypeError('Array.from: when provided, the second argument must be a function'); + } + if (arguments.length > 2) { + T = arguments[2]; + } + } + var len = toLength(items.length); + var A = isCallable(C) ? Object(new C(len)) : new Array(len); + var k = 0; + var kValue; + while (k < len) { + kValue = items[k]; + if (mapFn) { + A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k); + } else { + A[k] = kValue; + } + k += 1; + } + A.length = len; + return A; + }; + }() + }); } if (!String.prototype.includes) { String.prototype.includes = function(search, start) { @@ -3243,15 +6196,238 @@ }; } 'use strict'; - var _typeof = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? function(obj) { - return typeof obj; - } : function(obj) { - return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; + axe.utils.preloadCssom = function preloadCssom(_ref) { + var _ref$treeRoot = _ref.treeRoot, treeRoot = _ref$treeRoot === void 0 ? axe._tree[0] : _ref$treeRoot; + var rootNodes = getAllRootNodesInTree(treeRoot); + if (!rootNodes.length) { + return Promise.resolve(); + } + var dynamicDoc = document.implementation.createHTMLDocument('Dynamic document for loading cssom'); + var convertDataToStylesheet = axe.utils.getStyleSheetFactory(dynamicDoc); + return getCssomForAllRootNodes(rootNodes, convertDataToStylesheet).then(function(assets) { + return flattenAssets(assets); + }); + }; + function getAllRootNodesInTree(tree) { + var ids = []; + var rootNodes = axe.utils.querySelectorAllFilter(tree, '*', function(node) { + if (ids.includes(node.shadowId)) { + return false; + } + ids.push(node.shadowId); + return true; + }).map(function(node) { + return { + shadowId: node.shadowId, + rootNode: axe.utils.getRootNode(node.actualNode) + }; + }); + return axe.utils.uniqueArray(rootNodes, []); + } + function getCssomForAllRootNodes(rootNodes, convertDataToStylesheet) { + var promises = []; + rootNodes.forEach(function(_ref2, index) { + var rootNode = _ref2.rootNode, shadowId = _ref2.shadowId; + var sheets = getStylesheetsOfRootNode(rootNode, shadowId, convertDataToStylesheet); + if (!sheets) { + return Promise.all(promises); + } + var rootIndex = index + 1; + var parseOptions = { + rootNode: rootNode, + shadowId: shadowId, + convertDataToStylesheet: convertDataToStylesheet, + rootIndex: rootIndex + }; + var importedUrls = []; + var p = Promise.all(sheets.map(function(sheet, sheetIndex) { + var priority = [ rootIndex, sheetIndex ]; + return axe.utils.parseStylesheet(sheet, parseOptions, priority, importedUrls); + })); + promises.push(p); + }); + return Promise.all(promises); + } + function flattenAssets(assets) { + return assets.reduce(function(acc, val) { + return Array.isArray(val) ? acc.concat(flattenAssets(val)) : acc.concat(val); + }, []); + } + function getStylesheetsOfRootNode(rootNode, shadowId, convertDataToStylesheet) { + var sheets; + if (rootNode.nodeType === 11 && shadowId) { + sheets = getStylesheetsFromDocumentFragment(rootNode, convertDataToStylesheet); + } else { + sheets = getStylesheetsFromDocument(rootNode); + } + return filterStylesheetsWithSameHref(sheets); + } + function getStylesheetsFromDocumentFragment(rootNode, convertDataToStylesheet) { + return Array.from(rootNode.children).filter(filerStyleAndLinkAttributesInDocumentFragment).reduce(function(out, node) { + var nodeName = node.nodeName.toUpperCase(); + var data = nodeName === 'STYLE' ? node.textContent : node; + var isLink = nodeName === 'LINK'; + var stylesheet = convertDataToStylesheet({ + data: data, + isLink: isLink, + root: rootNode + }); + out.push(stylesheet.sheet); + return out; + }, []); + } + function getStylesheetsFromDocument(rootNode) { + return Array.from(rootNode.styleSheets).filter(function(sheet) { + return filterMediaIsPrint(sheet.media.mediaText); + }); + } + function filerStyleAndLinkAttributesInDocumentFragment(node) { + var nodeName = node.nodeName.toUpperCase(); + var linkHref = node.getAttribute('href'); + var linkRel = node.getAttribute('rel'); + var isLink = nodeName === 'LINK' && linkHref && linkRel && node.rel.toUpperCase().includes('STYLESHEET'); + var isStyle = nodeName === 'STYLE'; + return isStyle || isLink && filterMediaIsPrint(node.media); + } + function filterMediaIsPrint(media) { + if (!media) { + return true; + } + return !media.toUpperCase().includes('PRINT'); + } + function filterStylesheetsWithSameHref(sheets) { + var hrefs = []; + return sheets.filter(function(sheet) { + if (!sheet.href) { + return true; + } + if (hrefs.includes(sheet.href)) { + return false; + } + hrefs.push(sheet.href); + return true; + }); + } + 'use strict'; + function _extends() { + _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + return target; + }; + return _extends.apply(this, arguments); + } + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; + } + function _typeof(obj) { + if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; + }; + } + return _typeof(obj); + } + function isValidPreloadObject(preload) { + return _typeof(preload) === 'object' && Array.isArray(preload.assets); + } + axe.utils.shouldPreload = function shouldPreload(options) { + if (!options || options.preload === undefined || options.preload === null) { + return true; + } + if (typeof options.preload === 'boolean') { + return options.preload; + } + return isValidPreloadObject(options.preload); + }; + axe.utils.getPreloadConfig = function getPreloadConfig(options) { + var _axe$constants$preloa = axe.constants.preload, assets = _axe$constants$preloa.assets, timeout = _axe$constants$preloa.timeout; + var config = { + assets: assets, + timeout: timeout + }; + if (!options.preload) { + return config; + } + if (typeof options.preload === 'boolean') { + return config; + } + var areRequestedAssetsValid = options.preload.assets.every(function(a) { + return assets.includes(a.toLowerCase()); + }); + if (!areRequestedAssetsValid) { + throw new Error('Requested assets, not supported. ' + 'Supported assets are: '.concat(assets.join(', '), '.')); + } + config.assets = axe.utils.uniqueArray(options.preload.assets.map(function(a) { + return a.toLowerCase(); + }), []); + if (options.preload.timeout && typeof options.preload.timeout === 'number' && !Number.isNaN(options.preload.timeout)) { + config.timeout = options.preload.timeout; + } + return config; + }; + axe.utils.preload = function preload(options) { + var preloadFunctionsMap = { + cssom: axe.utils.preloadCssom + }; + var shouldPreload = axe.utils.shouldPreload(options); + if (!shouldPreload) { + return Promise.resolve(); + } + return new Promise(function(resolve, reject) { + var _axe$utils$getPreload = axe.utils.getPreloadConfig(options), assets = _axe$utils$getPreload.assets, timeout = _axe$utils$getPreload.timeout; + setTimeout(function() { + return reject('Preload assets timed out.'); + }, timeout); + Promise.all(assets.map(function(asset) { + return preloadFunctionsMap[asset](options).then(function(results) { + return _defineProperty({}, asset, results); + }); + })).then(function(results) { + var preloadAssets = results.reduce(function(out, result) { + return _extends({}, out, {}, result); + }, {}); + resolve(preloadAssets); + }); + }); }; + 'use strict'; + function _typeof(obj) { + if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; + }; + } + return _typeof(obj); + } function getIncompleteReason(checkData, messages) { function getDefaultMsg(messages) { - if (messages.incomplete && messages.incomplete.default) { - return messages.incomplete.default; + if (messages.incomplete && messages.incomplete['default']) { + return messages.incomplete['default']; } else { return helpers.incompleteFallbackMessage(); } @@ -3313,22 +6489,22 @@ 'use strict'; var convertExpressions = function convertExpressions() {}; var matchExpressions = function matchExpressions() {}; - function matchesTag(node, exp) { - return node.nodeType === 1 && (exp.tag === '*' || node.nodeName.toLowerCase() === exp.tag); + function matchesTag(vNode, exp) { + return vNode.props.nodeType === 1 && (exp.tag === '*' || vNode.props.nodeName === exp.tag); } - function matchesClasses(node, exp) { - return !exp.classes || exp.classes.reduce(function(result, cl) { - return result && node.className && node.className.match(cl.regexp); - }, true); + function matchesClasses(vNode, exp) { + return !exp.classes || exp.classes.every(function(cl) { + return vNode.hasClass(cl.value); + }); } - function matchesAttributes(node, exp) { + function matchesAttributes(vNode, exp) { return !exp.attributes || exp.attributes.reduce(function(result, att) { - var nodeAtt = node.getAttribute(att.key); + var nodeAtt = vNode.attr(att.key); return result && nodeAtt !== null && (!att.value || att.test(nodeAtt)); }, true); } - function matchesId(node, exp) { - return !exp.id || node.id === exp.id; + function matchesId(vNode, exp) { + return !exp.id || vNode.props.id === exp.id; } function matchesPseudos(target, exp) { if (!exp.pseudos || exp.pseudos.reduce(function(result, pseudo) { @@ -3341,23 +6517,7 @@ } return false; } - function matchSelector(targets, exp, recurse) { - var result = []; - targets = Array.isArray(targets) ? targets : [ targets ]; - targets.forEach(function(target) { - if (matchesTag(target.actualNode, exp) && matchesClasses(target.actualNode, exp) && matchesAttributes(target.actualNode, exp) && matchesId(target.actualNode, exp) && matchesPseudos(target, exp)) { - result.push(target); - } - if (recurse) { - result = result.concat(matchSelector(target.children.filter(function(child) { - return !exp.id || child.shadowId === target.shadowId; - }), exp, recurse)); - } - }); - return result; - } var escapeRegExp = function() { - /*! Credit: XRegExp 0.6.1 (c) 2007-2008 Steven Levithan MIT License */ var from = /(?=[\-\[\]{}()*+?.\\\^$|,#\s])/g; var to = '\\'; return function(string) { @@ -3366,7 +6526,6 @@ }(); var reUnescape = /\\/g; function convertAttributes(atts) { - /*! Credit Mootools Copyright Mootools, MIT License */ if (!atts) { return; } @@ -3399,7 +6558,7 @@ case '*=': test = function test(value) { - return value && value.indexOf(attributeValue) > -1; + return value && value.includes(attributeValue); }; break; @@ -3450,7 +6609,7 @@ return pseudos.map(function(p) { var expressions; if (p.name === 'not') { - expressions = axe.utils.cssParser.parse(p.value); + expressions = p.value; expressions = expressions.selectors ? expressions.selectors : [ expressions ]; expressions = convertExpressions(expressions); } @@ -3476,37 +6635,90 @@ }); rule = rule.rule; } - return newExp; - }); - }; - matchExpressions = function matchExpressions(domTree, expressions, recurse) { - return expressions.reduce(function(collected, exprArr) { - var candidates = domTree; - exprArr.forEach(function(exp, index) { - recurse = exp.combinator === '>' ? false : recurse; - if ([ ' ', '>' ].indexOf(exp.combinator) === -1) { - throw new Error('axe.utils.querySelectorAll does not support the combinator: ' + exp.combinator); - } - candidates = candidates.reduce(function(result, node) { - return result.concat(matchSelector(index ? node.children : node, exp, recurse)); - }, []); - }); - return collected.concat(candidates); - }, []); + return newExp; + }); + }; + function createLocalVariables(vNodes, anyLevel, thisLevel, parentShadowId) { + var retVal = { + vNodes: vNodes.slice(), + anyLevel: anyLevel, + thisLevel: thisLevel, + parentShadowId: parentShadowId + }; + retVal.vNodes.reverse(); + return retVal; + } + function matchesSelector(vNode, exp) { + return matchesTag(vNode, exp[0]) && matchesClasses(vNode, exp[0]) && matchesAttributes(vNode, exp[0]) && matchesId(vNode, exp[0]) && matchesPseudos(vNode, exp[0]); + } + matchExpressions = function matchExpressions(domTree, expressions, recurse, filter) { + var stack = []; + var vNodes = Array.isArray(domTree) ? domTree : [ domTree ]; + var currentLevel = createLocalVariables(vNodes, expressions, [], domTree[0].shadowId); + var result = []; + while (currentLevel.vNodes.length) { + var vNode = currentLevel.vNodes.pop(); + var childOnly = []; + var childAny = []; + var combined = currentLevel.anyLevel.slice().concat(currentLevel.thisLevel); + var added = false; + for (var i = 0; i < combined.length; i++) { + var exp = combined[i]; + if (matchesSelector(vNode, exp) && (!exp[0].id || vNode.shadowId === currentLevel.parentShadowId)) { + if (exp.length === 1) { + if (!added && (!filter || filter(vNode))) { + result.push(vNode); + added = true; + } + } else { + var rest = exp.slice(1); + if ([ ' ', '>' ].includes(rest[0].combinator) === false) { + throw new Error('axe.utils.querySelectorAll does not support the combinator: ' + exp[1].combinator); + } + if (rest[0].combinator === '>') { + childOnly.push(rest); + } else { + childAny.push(rest); + } + } + } + if (currentLevel.anyLevel.includes(exp) && (!exp[0].id || vNode.shadowId === currentLevel.parentShadowId)) { + childAny.push(exp); + } + } + if (vNode.children && vNode.children.length && recurse) { + stack.push(currentLevel); + currentLevel = createLocalVariables(vNode.children, childAny, childOnly, vNode.shadowId); + } + while (!currentLevel.vNodes.length && stack.length) { + currentLevel = stack.pop(); + } + } + return result; }; axe.utils.querySelectorAll = function(domTree, selector) { + return axe.utils.querySelectorAllFilter(domTree, selector); + }; + axe.utils.querySelectorAllFilter = function(domTree, selector, filter) { domTree = Array.isArray(domTree) ? domTree : [ domTree ]; var expressions = axe.utils.cssParser.parse(selector); expressions = expressions.selectors ? expressions.selectors : [ expressions ]; expressions = convertExpressions(expressions); - return matchExpressions(domTree, expressions, true); + return matchExpressions(domTree, expressions, true, filter); }; 'use strict'; - var _typeof = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? function(obj) { - return typeof obj; - } : function(obj) { - return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; - }; + function _typeof(obj) { + if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; + }; + } + return _typeof(obj); + } (function() { 'use strict'; function noop() {} @@ -3559,10 +6771,10 @@ } var q = { defer: function defer(fn) { - if ((typeof fn === 'undefined' ? 'undefined' : _typeof(fn)) === 'object' && fn.then && fn.catch) { + if (_typeof(fn) === 'object' && fn.then && fn['catch']) { var defer = fn; fn = function fn(resolve, reject) { - defer.then(resolve).catch(reject); + defer.then(resolve)['catch'](reject); }; } funcGuard(fn); @@ -3610,17 +6822,24 @@ axe.utils.queue = queue; })(); 'use strict'; - var _typeof = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? function(obj) { - return typeof obj; - } : function(obj) { - return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; - }; + function _typeof(obj) { + if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; + }; + } + return _typeof(obj); + } (function(exports) { 'use strict'; - var messages = {}, subscribers = {}; + var messages = {}, subscribers = {}, errorTypes = Object.freeze([ 'EvalError', 'RangeError', 'ReferenceError', 'SyntaxError', 'TypeError', 'URIError' ]); function _getSource() { - var application = 'axe', version = '', src; - if (typeof axe !== 'undefined' && axe._audit && !axe._audit.application) { + var application = 'axeAPI', version = '', src; + if (typeof axe !== 'undefined' && axe._audit && axe._audit.application) { application = axe._audit.application; } if (typeof axe !== 'undefined') { @@ -3630,9 +6849,9 @@ return src; } function verify(postedMessage) { - if ((typeof postedMessage === 'undefined' ? 'undefined' : _typeof(postedMessage)) === 'object' && typeof postedMessage.uuid === 'string' && postedMessage._respondable === true) { + if (_typeof(postedMessage) === 'object' && typeof postedMessage.uuid === 'string' && postedMessage._respondable === true) { var messageSource = _getSource(); - return postedMessage._source === messageSource || postedMessage._source === 'axe.x.y.z' || messageSource === 'axe.x.y.z'; + return postedMessage._source === messageSource || postedMessage._source === 'axeAPI.x.y.z' || messageSource === 'axeAPI.x.y.z'; } return false; } @@ -3676,17 +6895,18 @@ post(source, topic, message, uuid, keepalive, callback); }; } - function publish(target, data, keepalive) { + function publish(source, data, keepalive) { var topic = data.topic; var subscriber = subscribers[topic]; if (subscriber) { - var responder = createResponder(target, null, data.uuid); + var responder = createResponder(source, null, data.uuid); subscriber(data.message, keepalive, responder); } } function buildErrorObject(error) { var msg = error.message || 'Unknown error occurred'; - var ErrConstructor = window[error.name] || Error; + var errorName = errorTypes.includes(error.name) ? error.name : 'Error'; + var ErrConstructor = window[errorName] || Error; if (error.stack) { msg += '\n' + error.stack.replace(error.message, ''); } @@ -3743,7 +6963,7 @@ 'use strict'; var include, exclude, matching; var defaultExclude = axe._audit && axe._audit.tagExclude ? axe._audit.tagExclude : []; - if (runOnly.include || runOnly.exclude) { + if (runOnly.hasOwnProperty('include') || runOnly.hasOwnProperty('exclude')) { include = runOnly.include || []; include = Array.isArray(include) ? include : [ include ]; exclude = runOnly.exclude || []; @@ -3785,21 +7005,9 @@ } }; 'use strict'; - function getScroll(elm) { - var style = window.getComputedStyle(elm); - var visibleOverflowY = style.getPropertyValue('overflow-y') === 'visible'; - var visibleOverflowX = style.getPropertyValue('overflow-x') === 'visible'; - if (!visibleOverflowY && elm.scrollHeight > elm.clientHeight || !visibleOverflowX && elm.scrollWidth > elm.clientWidth) { - return { - elm: elm, - top: elm.scrollTop, - left: elm.scrollLeft - }; - } - } function setScroll(elm, top, left) { if (elm === window) { - return elm.scroll(top, left); + return elm.scroll(left, top); } else { elm.scrollTop = top; elm.scrollLeft = left; @@ -3807,7 +7015,7 @@ } function getElmScrollRecursive(root) { return Array.from(root.children).reduce(function(scrolls, elm) { - var scroll = getScroll(elm); + var scroll = axe.utils.getScroll(elm); if (scroll) { scrolls.push(scroll); } @@ -3857,33 +7065,77 @@ } return false; } - function pushNode(result, nodes, context) { + function pushNode(result, nodes) { 'use strict'; + var temp; + if (result.length === 0) { + return nodes; + } + if (result.length < nodes.length) { + temp = result; + result = nodes; + nodes = temp; + } for (var i = 0, l = nodes.length; i < l; i++) { - if (!result.find(function(item) { - return item.actualNode === nodes[i].actualNode; - }) && isNodeInContext(nodes[i], context)) { + if (!result.includes(nodes[i])) { result.push(nodes[i]); } } + return result; + } + function reduceIncludes(includes) { + return includes.reduce(function(res, el) { + if (!res.length || !axe.utils.contains(res[res.length - 1], el)) { + res.push(el); + } + return res; + }, []); } axe.utils.select = function select(selector, context) { 'use strict'; - var result = [], candidate; - for (var i = 0, l = context.include.length; i < l; i++) { - candidate = context.include[i]; - if (candidate.actualNode.nodeType === candidate.actualNode.ELEMENT_NODE && axe.utils.matchesSelector(candidate.actualNode, selector)) { - pushNode(result, [ candidate ], context); + var result = []; + var candidate; + if (axe._selectCache) { + for (var j = 0, l = axe._selectCache.length; j < l; j++) { + var item = axe._selectCache[j]; + if (item.selector === selector) { + return item.result; + } } - pushNode(result, axe.utils.querySelectorAll(candidate, selector), context); } - return result.sort(axe.utils.nodeSorter); + var curried = function(context) { + return function(node) { + return isNodeInContext(node, context); + }; + }(context); + var reducedIncludes = reduceIncludes(context.include); + for (var i = 0; i < reducedIncludes.length; i++) { + candidate = reducedIncludes[i]; + result = pushNode(result, axe.utils.querySelectorAllFilter(candidate, selector, curried)); + } + if (axe._selectCache) { + axe._selectCache.push({ + selector: selector, + result: result + }); + } + return result; }; 'use strict'; axe.utils.toArray = function(thing) { 'use strict'; return Array.prototype.slice.call(thing); }; + axe.utils.uniqueArray = function(arr1, arr2) { + return arr1.concat(arr2).filter(function(elem, pos, arr) { + return arr.indexOf(elem) === pos; + }); + }; + 'use strict'; + axe.utils.tokenList = function(str) { + 'use strict'; + return str.trim().replace(/\s{2,}/g, ' ').split(' '); + }; 'use strict'; var uuid; (function(_global) { @@ -4000,6 +7252,62 @@ uuid.BufferClass = BufferClass; })(window); 'use strict'; + axe.utils.validInputTypes = function validInputTypes() { + 'use strict'; + return [ 'hidden', 'text', 'search', 'tel', 'url', 'email', 'password', 'date', 'month', 'week', 'time', 'datetime-local', 'number', 'range', 'color', 'checkbox', 'radio', 'file', 'submit', 'image', 'reset', 'button' ]; + }; + 'use strict'; + var langs = [ 'aa', 'ab', 'ae', 'af', 'ak', 'am', 'an', 'ar', 'as', 'av', 'ay', 'az', 'ba', 'be', 'bg', 'bh', 'bi', 'bm', 'bn', 'bo', 'br', 'bs', 'ca', 'ce', 'ch', 'co', 'cr', 'cs', 'cu', 'cv', 'cy', 'da', 'de', 'dv', 'dz', 'ee', 'el', 'en', 'eo', 'es', 'et', 'eu', 'fa', 'ff', 'fi', 'fj', 'fo', 'fr', 'fy', 'ga', 'gd', 'gl', 'gn', 'gu', 'gv', 'ha', 'he', 'hi', 'ho', 'hr', 'ht', 'hu', 'hy', 'hz', 'ia', 'id', 'ie', 'ig', 'ii', 'ik', 'in', 'io', 'is', 'it', 'iu', 'iw', 'ja', 'ji', 'jv', 'jw', 'ka', 'kg', 'ki', 'kj', 'kk', 'kl', 'km', 'kn', 'ko', 'kr', 'ks', 'ku', 'kv', 'kw', 'ky', 'la', 'lb', 'lg', 'li', 'ln', 'lo', 'lt', 'lu', 'lv', 'mg', 'mh', 'mi', 'mk', 'ml', 'mn', 'mo', 'mr', 'ms', 'mt', 'my', 'na', 'nb', 'nd', 'ne', 'ng', 'nl', 'nn', 'no', 'nr', 'nv', 'ny', 'oc', 'oj', 'om', 'or', 'os', 'pa', 'pi', 'pl', 'ps', 'pt', 'qu', 'rm', 'rn', 'ro', 'ru', 'rw', 'sa', 'sc', 'sd', 'se', 'sg', 'sh', 'si', 'sk', 'sl', 'sm', 'sn', 'so', 'sq', 'sr', 'ss', 'st', 'su', 'sv', 'sw', 'ta', 'te', 'tg', 'th', 'ti', 'tk', 'tl', 'tn', 'to', 'tr', 'ts', 'tt', 'tw', 'ty', 'ug', 'uk', 'ur', 'uz', 've', 'vi', 'vo', 'wa', 'wo', 'xh', 'yi', 'yo', 'za', 'zh', 'zu', 'aaa', 'aab', 'aac', 'aad', 'aae', 'aaf', 'aag', 'aah', 'aai', 'aak', 'aal', 'aam', 'aan', 'aao', 'aap', 'aaq', 'aas', 'aat', 'aau', 'aav', 'aaw', 'aax', 'aaz', 'aba', 'abb', 'abc', 'abd', 'abe', 'abf', 'abg', 'abh', 'abi', 'abj', 'abl', 'abm', 'abn', 'abo', 'abp', 'abq', 'abr', 'abs', 'abt', 'abu', 'abv', 'abw', 'abx', 'aby', 'abz', 'aca', 'acb', 'acd', 'ace', 'acf', 'ach', 'aci', 'ack', 'acl', 'acm', 'acn', 'acp', 'acq', 'acr', 'acs', 'act', 'acu', 'acv', 'acw', 'acx', 'acy', 'acz', 'ada', 'adb', 'add', 'ade', 'adf', 'adg', 'adh', 'adi', 'adj', 'adl', 'adn', 'ado', 'adp', 'adq', 'adr', 'ads', 'adt', 'adu', 'adw', 'adx', 'ady', 'adz', 'aea', 'aeb', 'aec', 'aed', 'aee', 'aek', 'ael', 'aem', 'aen', 'aeq', 'aer', 'aes', 'aeu', 'aew', 'aey', 'aez', 'afa', 'afb', 'afd', 'afe', 'afg', 'afh', 'afi', 'afk', 'afn', 'afo', 'afp', 'afs', 'aft', 'afu', 'afz', 'aga', 'agb', 'agc', 'agd', 'age', 'agf', 'agg', 'agh', 'agi', 'agj', 'agk', 'agl', 'agm', 'agn', 'ago', 'agp', 'agq', 'agr', 'ags', 'agt', 'agu', 'agv', 'agw', 'agx', 'agy', 'agz', 'aha', 'ahb', 'ahg', 'ahh', 'ahi', 'ahk', 'ahl', 'ahm', 'ahn', 'aho', 'ahp', 'ahr', 'ahs', 'aht', 'aia', 'aib', 'aic', 'aid', 'aie', 'aif', 'aig', 'aih', 'aii', 'aij', 'aik', 'ail', 'aim', 'ain', 'aio', 'aip', 'aiq', 'air', 'ais', 'ait', 'aiw', 'aix', 'aiy', 'aja', 'ajg', 'aji', 'ajn', 'ajp', 'ajt', 'aju', 'ajw', 'ajz', 'akb', 'akc', 'akd', 'ake', 'akf', 'akg', 'akh', 'aki', 'akj', 'akk', 'akl', 'akm', 'ako', 'akp', 'akq', 'akr', 'aks', 'akt', 'aku', 'akv', 'akw', 'akx', 'aky', 'akz', 'ala', 'alc', 'ald', 'ale', 'alf', 'alg', 'alh', 'ali', 'alj', 'alk', 'all', 'alm', 'aln', 'alo', 'alp', 'alq', 'alr', 'als', 'alt', 'alu', 'alv', 'alw', 'alx', 'aly', 'alz', 'ama', 'amb', 'amc', 'ame', 'amf', 'amg', 'ami', 'amj', 'amk', 'aml', 'amm', 'amn', 'amo', 'amp', 'amq', 'amr', 'ams', 'amt', 'amu', 'amv', 'amw', 'amx', 'amy', 'amz', 'ana', 'anb', 'anc', 'and', 'ane', 'anf', 'ang', 'anh', 'ani', 'anj', 'ank', 'anl', 'anm', 'ann', 'ano', 'anp', 'anq', 'anr', 'ans', 'ant', 'anu', 'anv', 'anw', 'anx', 'any', 'anz', 'aoa', 'aob', 'aoc', 'aod', 'aoe', 'aof', 'aog', 'aoh', 'aoi', 'aoj', 'aok', 'aol', 'aom', 'aon', 'aor', 'aos', 'aot', 'aou', 'aox', 'aoz', 'apa', 'apb', 'apc', 'apd', 'ape', 'apf', 'apg', 'aph', 'api', 'apj', 'apk', 'apl', 'apm', 'apn', 'apo', 'app', 'apq', 'apr', 'aps', 'apt', 'apu', 'apv', 'apw', 'apx', 'apy', 'apz', 'aqa', 'aqc', 'aqd', 'aqg', 'aql', 'aqm', 'aqn', 'aqp', 'aqr', 'aqt', 'aqz', 'arb', 'arc', 'ard', 'are', 'arh', 'ari', 'arj', 'ark', 'arl', 'arn', 'aro', 'arp', 'arq', 'arr', 'ars', 'art', 'aru', 'arv', 'arw', 'arx', 'ary', 'arz', 'asa', 'asb', 'asc', 'asd', 'ase', 'asf', 'asg', 'ash', 'asi', 'asj', 'ask', 'asl', 'asn', 'aso', 'asp', 'asq', 'asr', 'ass', 'ast', 'asu', 'asv', 'asw', 'asx', 'asy', 'asz', 'ata', 'atb', 'atc', 'atd', 'ate', 'atg', 'ath', 'ati', 'atj', 'atk', 'atl', 'atm', 'atn', 'ato', 'atp', 'atq', 'atr', 'ats', 'att', 'atu', 'atv', 'atw', 'atx', 'aty', 'atz', 'aua', 'aub', 'auc', 'aud', 'aue', 'auf', 'aug', 'auh', 'aui', 'auj', 'auk', 'aul', 'aum', 'aun', 'auo', 'aup', 'auq', 'aur', 'aus', 'aut', 'auu', 'auw', 'aux', 'auy', 'auz', 'avb', 'avd', 'avi', 'avk', 'avl', 'avm', 'avn', 'avo', 'avs', 'avt', 'avu', 'avv', 'awa', 'awb', 'awc', 'awd', 'awe', 'awg', 'awh', 'awi', 'awk', 'awm', 'awn', 'awo', 'awr', 'aws', 'awt', 'awu', 'awv', 'aww', 'awx', 'awy', 'axb', 'axe', 'axg', 'axk', 'axl', 'axm', 'axx', 'aya', 'ayb', 'ayc', 'ayd', 'aye', 'ayg', 'ayh', 'ayi', 'ayk', 'ayl', 'ayn', 'ayo', 'ayp', 'ayq', 'ayr', 'ays', 'ayt', 'ayu', 'ayx', 'ayy', 'ayz', 'aza', 'azb', 'azc', 'azd', 'azg', 'azj', 'azm', 'azn', 'azo', 'azt', 'azz', 'baa', 'bab', 'bac', 'bad', 'bae', 'baf', 'bag', 'bah', 'bai', 'baj', 'bal', 'ban', 'bao', 'bap', 'bar', 'bas', 'bat', 'bau', 'bav', 'baw', 'bax', 'bay', 'baz', 'bba', 'bbb', 'bbc', 'bbd', 'bbe', 'bbf', 'bbg', 'bbh', 'bbi', 'bbj', 'bbk', 'bbl', 'bbm', 'bbn', 'bbo', 'bbp', 'bbq', 'bbr', 'bbs', 'bbt', 'bbu', 'bbv', 'bbw', 'bbx', 'bby', 'bbz', 'bca', 'bcb', 'bcc', 'bcd', 'bce', 'bcf', 'bcg', 'bch', 'bci', 'bcj', 'bck', 'bcl', 'bcm', 'bcn', 'bco', 'bcp', 'bcq', 'bcr', 'bcs', 'bct', 'bcu', 'bcv', 'bcw', 'bcy', 'bcz', 'bda', 'bdb', 'bdc', 'bdd', 'bde', 'bdf', 'bdg', 'bdh', 'bdi', 'bdj', 'bdk', 'bdl', 'bdm', 'bdn', 'bdo', 'bdp', 'bdq', 'bdr', 'bds', 'bdt', 'bdu', 'bdv', 'bdw', 'bdx', 'bdy', 'bdz', 'bea', 'beb', 'bec', 'bed', 'bee', 'bef', 'beg', 'beh', 'bei', 'bej', 'bek', 'bem', 'beo', 'bep', 'beq', 'ber', 'bes', 'bet', 'beu', 'bev', 'bew', 'bex', 'bey', 'bez', 'bfa', 'bfb', 'bfc', 'bfd', 'bfe', 'bff', 'bfg', 'bfh', 'bfi', 'bfj', 'bfk', 'bfl', 'bfm', 'bfn', 'bfo', 'bfp', 'bfq', 'bfr', 'bfs', 'bft', 'bfu', 'bfw', 'bfx', 'bfy', 'bfz', 'bga', 'bgb', 'bgc', 'bgd', 'bge', 'bgf', 'bgg', 'bgi', 'bgj', 'bgk', 'bgl', 'bgm', 'bgn', 'bgo', 'bgp', 'bgq', 'bgr', 'bgs', 'bgt', 'bgu', 'bgv', 'bgw', 'bgx', 'bgy', 'bgz', 'bha', 'bhb', 'bhc', 'bhd', 'bhe', 'bhf', 'bhg', 'bhh', 'bhi', 'bhj', 'bhk', 'bhl', 'bhm', 'bhn', 'bho', 'bhp', 'bhq', 'bhr', 'bhs', 'bht', 'bhu', 'bhv', 'bhw', 'bhx', 'bhy', 'bhz', 'bia', 'bib', 'bic', 'bid', 'bie', 'bif', 'big', 'bij', 'bik', 'bil', 'bim', 'bin', 'bio', 'bip', 'biq', 'bir', 'bit', 'biu', 'biv', 'biw', 'bix', 'biy', 'biz', 'bja', 'bjb', 'bjc', 'bjd', 'bje', 'bjf', 'bjg', 'bjh', 'bji', 'bjj', 'bjk', 'bjl', 'bjm', 'bjn', 'bjo', 'bjp', 'bjq', 'bjr', 'bjs', 'bjt', 'bju', 'bjv', 'bjw', 'bjx', 'bjy', 'bjz', 'bka', 'bkb', 'bkc', 'bkd', 'bkf', 'bkg', 'bkh', 'bki', 'bkj', 'bkk', 'bkl', 'bkm', 'bkn', 'bko', 'bkp', 'bkq', 'bkr', 'bks', 'bkt', 'bku', 'bkv', 'bkw', 'bkx', 'bky', 'bkz', 'bla', 'blb', 'blc', 'bld', 'ble', 'blf', 'blg', 'blh', 'bli', 'blj', 'blk', 'bll', 'blm', 'bln', 'blo', 'blp', 'blq', 'blr', 'bls', 'blt', 'blv', 'blw', 'blx', 'bly', 'blz', 'bma', 'bmb', 'bmc', 'bmd', 'bme', 'bmf', 'bmg', 'bmh', 'bmi', 'bmj', 'bmk', 'bml', 'bmm', 'bmn', 'bmo', 'bmp', 'bmq', 'bmr', 'bms', 'bmt', 'bmu', 'bmv', 'bmw', 'bmx', 'bmy', 'bmz', 'bna', 'bnb', 'bnc', 'bnd', 'bne', 'bnf', 'bng', 'bni', 'bnj', 'bnk', 'bnl', 'bnm', 'bnn', 'bno', 'bnp', 'bnq', 'bnr', 'bns', 'bnt', 'bnu', 'bnv', 'bnw', 'bnx', 'bny', 'bnz', 'boa', 'bob', 'boe', 'bof', 'bog', 'boh', 'boi', 'boj', 'bok', 'bol', 'bom', 'bon', 'boo', 'bop', 'boq', 'bor', 'bot', 'bou', 'bov', 'bow', 'box', 'boy', 'boz', 'bpa', 'bpb', 'bpd', 'bpg', 'bph', 'bpi', 'bpj', 'bpk', 'bpl', 'bpm', 'bpn', 'bpo', 'bpp', 'bpq', 'bpr', 'bps', 'bpt', 'bpu', 'bpv', 'bpw', 'bpx', 'bpy', 'bpz', 'bqa', 'bqb', 'bqc', 'bqd', 'bqf', 'bqg', 'bqh', 'bqi', 'bqj', 'bqk', 'bql', 'bqm', 'bqn', 'bqo', 'bqp', 'bqq', 'bqr', 'bqs', 'bqt', 'bqu', 'bqv', 'bqw', 'bqx', 'bqy', 'bqz', 'bra', 'brb', 'brc', 'brd', 'brf', 'brg', 'brh', 'bri', 'brj', 'brk', 'brl', 'brm', 'brn', 'bro', 'brp', 'brq', 'brr', 'brs', 'brt', 'bru', 'brv', 'brw', 'brx', 'bry', 'brz', 'bsa', 'bsb', 'bsc', 'bse', 'bsf', 'bsg', 'bsh', 'bsi', 'bsj', 'bsk', 'bsl', 'bsm', 'bsn', 'bso', 'bsp', 'bsq', 'bsr', 'bss', 'bst', 'bsu', 'bsv', 'bsw', 'bsx', 'bsy', 'bta', 'btb', 'btc', 'btd', 'bte', 'btf', 'btg', 'bth', 'bti', 'btj', 'btk', 'btl', 'btm', 'btn', 'bto', 'btp', 'btq', 'btr', 'bts', 'btt', 'btu', 'btv', 'btw', 'btx', 'bty', 'btz', 'bua', 'bub', 'buc', 'bud', 'bue', 'buf', 'bug', 'buh', 'bui', 'buj', 'buk', 'bum', 'bun', 'buo', 'bup', 'buq', 'bus', 'but', 'buu', 'buv', 'buw', 'bux', 'buy', 'buz', 'bva', 'bvb', 'bvc', 'bvd', 'bve', 'bvf', 'bvg', 'bvh', 'bvi', 'bvj', 'bvk', 'bvl', 'bvm', 'bvn', 'bvo', 'bvp', 'bvq', 'bvr', 'bvt', 'bvu', 'bvv', 'bvw', 'bvx', 'bvy', 'bvz', 'bwa', 'bwb', 'bwc', 'bwd', 'bwe', 'bwf', 'bwg', 'bwh', 'bwi', 'bwj', 'bwk', 'bwl', 'bwm', 'bwn', 'bwo', 'bwp', 'bwq', 'bwr', 'bws', 'bwt', 'bwu', 'bww', 'bwx', 'bwy', 'bwz', 'bxa', 'bxb', 'bxc', 'bxd', 'bxe', 'bxf', 'bxg', 'bxh', 'bxi', 'bxj', 'bxk', 'bxl', 'bxm', 'bxn', 'bxo', 'bxp', 'bxq', 'bxr', 'bxs', 'bxu', 'bxv', 'bxw', 'bxx', 'bxz', 'bya', 'byb', 'byc', 'byd', 'bye', 'byf', 'byg', 'byh', 'byi', 'byj', 'byk', 'byl', 'bym', 'byn', 'byo', 'byp', 'byq', 'byr', 'bys', 'byt', 'byv', 'byw', 'byx', 'byy', 'byz', 'bza', 'bzb', 'bzc', 'bzd', 'bze', 'bzf', 'bzg', 'bzh', 'bzi', 'bzj', 'bzk', 'bzl', 'bzm', 'bzn', 'bzo', 'bzp', 'bzq', 'bzr', 'bzs', 'bzt', 'bzu', 'bzv', 'bzw', 'bzx', 'bzy', 'bzz', 'caa', 'cab', 'cac', 'cad', 'cae', 'caf', 'cag', 'cah', 'cai', 'caj', 'cak', 'cal', 'cam', 'can', 'cao', 'cap', 'caq', 'car', 'cas', 'cau', 'cav', 'caw', 'cax', 'cay', 'caz', 'cba', 'cbb', 'cbc', 'cbd', 'cbe', 'cbg', 'cbh', 'cbi', 'cbj', 'cbk', 'cbl', 'cbn', 'cbo', 'cbq', 'cbr', 'cbs', 'cbt', 'cbu', 'cbv', 'cbw', 'cby', 'cca', 'ccc', 'ccd', 'cce', 'ccg', 'cch', 'ccj', 'ccl', 'ccm', 'ccn', 'cco', 'ccp', 'ccq', 'ccr', 'ccs', 'cda', 'cdc', 'cdd', 'cde', 'cdf', 'cdg', 'cdh', 'cdi', 'cdj', 'cdm', 'cdn', 'cdo', 'cdr', 'cds', 'cdy', 'cdz', 'cea', 'ceb', 'ceg', 'cek', 'cel', 'cen', 'cet', 'cfa', 'cfd', 'cfg', 'cfm', 'cga', 'cgc', 'cgg', 'cgk', 'chb', 'chc', 'chd', 'chf', 'chg', 'chh', 'chj', 'chk', 'chl', 'chm', 'chn', 'cho', 'chp', 'chq', 'chr', 'cht', 'chw', 'chx', 'chy', 'chz', 'cia', 'cib', 'cic', 'cid', 'cie', 'cih', 'cik', 'cim', 'cin', 'cip', 'cir', 'ciw', 'ciy', 'cja', 'cje', 'cjh', 'cji', 'cjk', 'cjm', 'cjn', 'cjo', 'cjp', 'cjr', 'cjs', 'cjv', 'cjy', 'cka', 'ckb', 'ckh', 'ckl', 'ckn', 'cko', 'ckq', 'ckr', 'cks', 'ckt', 'cku', 'ckv', 'ckx', 'cky', 'ckz', 'cla', 'clc', 'cld', 'cle', 'clh', 'cli', 'clj', 'clk', 'cll', 'clm', 'clo', 'clt', 'clu', 'clw', 'cly', 'cma', 'cmc', 'cme', 'cmg', 'cmi', 'cmk', 'cml', 'cmm', 'cmn', 'cmo', 'cmr', 'cms', 'cmt', 'cna', 'cnb', 'cnc', 'cng', 'cnh', 'cni', 'cnk', 'cnl', 'cno', 'cnr', 'cns', 'cnt', 'cnu', 'cnw', 'cnx', 'coa', 'cob', 'coc', 'cod', 'coe', 'cof', 'cog', 'coh', 'coj', 'cok', 'col', 'com', 'con', 'coo', 'cop', 'coq', 'cot', 'cou', 'cov', 'cow', 'cox', 'coy', 'coz', 'cpa', 'cpb', 'cpc', 'cpe', 'cpf', 'cpg', 'cpi', 'cpn', 'cpo', 'cpp', 'cps', 'cpu', 'cpx', 'cpy', 'cqd', 'cqu', 'cra', 'crb', 'crc', 'crd', 'crf', 'crg', 'crh', 'cri', 'crj', 'crk', 'crl', 'crm', 'crn', 'cro', 'crp', 'crq', 'crr', 'crs', 'crt', 'crv', 'crw', 'crx', 'cry', 'crz', 'csa', 'csb', 'csc', 'csd', 'cse', 'csf', 'csg', 'csh', 'csi', 'csj', 'csk', 'csl', 'csm', 'csn', 'cso', 'csq', 'csr', 'css', 'cst', 'csu', 'csv', 'csw', 'csy', 'csz', 'cta', 'ctc', 'ctd', 'cte', 'ctg', 'cth', 'ctl', 'ctm', 'ctn', 'cto', 'ctp', 'cts', 'ctt', 'ctu', 'ctz', 'cua', 'cub', 'cuc', 'cug', 'cuh', 'cui', 'cuj', 'cuk', 'cul', 'cum', 'cuo', 'cup', 'cuq', 'cur', 'cus', 'cut', 'cuu', 'cuv', 'cuw', 'cux', 'cuy', 'cvg', 'cvn', 'cwa', 'cwb', 'cwd', 'cwe', 'cwg', 'cwt', 'cya', 'cyb', 'cyo', 'czh', 'czk', 'czn', 'czo', 'czt', 'daa', 'dac', 'dad', 'dae', 'daf', 'dag', 'dah', 'dai', 'daj', 'dak', 'dal', 'dam', 'dao', 'dap', 'daq', 'dar', 'das', 'dau', 'dav', 'daw', 'dax', 'day', 'daz', 'dba', 'dbb', 'dbd', 'dbe', 'dbf', 'dbg', 'dbi', 'dbj', 'dbl', 'dbm', 'dbn', 'dbo', 'dbp', 'dbq', 'dbr', 'dbt', 'dbu', 'dbv', 'dbw', 'dby', 'dcc', 'dcr', 'dda', 'ddd', 'dde', 'ddg', 'ddi', 'ddj', 'ddn', 'ddo', 'ddr', 'dds', 'ddw', 'dec', 'ded', 'dee', 'def', 'deg', 'deh', 'dei', 'dek', 'del', 'dem', 'den', 'dep', 'deq', 'der', 'des', 'dev', 'dez', 'dga', 'dgb', 'dgc', 'dgd', 'dge', 'dgg', 'dgh', 'dgi', 'dgk', 'dgl', 'dgn', 'dgo', 'dgr', 'dgs', 'dgt', 'dgu', 'dgw', 'dgx', 'dgz', 'dha', 'dhd', 'dhg', 'dhi', 'dhl', 'dhm', 'dhn', 'dho', 'dhr', 'dhs', 'dhu', 'dhv', 'dhw', 'dhx', 'dia', 'dib', 'dic', 'did', 'dif', 'dig', 'dih', 'dii', 'dij', 'dik', 'dil', 'dim', 'din', 'dio', 'dip', 'diq', 'dir', 'dis', 'dit', 'diu', 'diw', 'dix', 'diy', 'diz', 'dja', 'djb', 'djc', 'djd', 'dje', 'djf', 'dji', 'djj', 'djk', 'djl', 'djm', 'djn', 'djo', 'djr', 'dju', 'djw', 'dka', 'dkk', 'dkl', 'dkr', 'dks', 'dkx', 'dlg', 'dlk', 'dlm', 'dln', 'dma', 'dmb', 'dmc', 'dmd', 'dme', 'dmg', 'dmk', 'dml', 'dmm', 'dmn', 'dmo', 'dmr', 'dms', 'dmu', 'dmv', 'dmw', 'dmx', 'dmy', 'dna', 'dnd', 'dne', 'dng', 'dni', 'dnj', 'dnk', 'dnn', 'dnr', 'dnt', 'dnu', 'dnv', 'dnw', 'dny', 'doa', 'dob', 'doc', 'doe', 'dof', 'doh', 'doi', 'dok', 'dol', 'don', 'doo', 'dop', 'doq', 'dor', 'dos', 'dot', 'dov', 'dow', 'dox', 'doy', 'doz', 'dpp', 'dra', 'drb', 'drc', 'drd', 'dre', 'drg', 'drh', 'dri', 'drl', 'drn', 'dro', 'drq', 'drr', 'drs', 'drt', 'dru', 'drw', 'dry', 'dsb', 'dse', 'dsh', 'dsi', 'dsl', 'dsn', 'dso', 'dsq', 'dta', 'dtb', 'dtd', 'dth', 'dti', 'dtk', 'dtm', 'dtn', 'dto', 'dtp', 'dtr', 'dts', 'dtt', 'dtu', 'dty', 'dua', 'dub', 'duc', 'dud', 'due', 'duf', 'dug', 'duh', 'dui', 'duj', 'duk', 'dul', 'dum', 'dun', 'duo', 'dup', 'duq', 'dur', 'dus', 'duu', 'duv', 'duw', 'dux', 'duy', 'duz', 'dva', 'dwa', 'dwl', 'dwr', 'dws', 'dwu', 'dww', 'dwy', 'dya', 'dyb', 'dyd', 'dyg', 'dyi', 'dym', 'dyn', 'dyo', 'dyu', 'dyy', 'dza', 'dzd', 'dze', 'dzg', 'dzl', 'dzn', 'eaa', 'ebg', 'ebk', 'ebo', 'ebr', 'ebu', 'ecr', 'ecs', 'ecy', 'eee', 'efa', 'efe', 'efi', 'ega', 'egl', 'ego', 'egx', 'egy', 'ehu', 'eip', 'eit', 'eiv', 'eja', 'eka', 'ekc', 'eke', 'ekg', 'eki', 'ekk', 'ekl', 'ekm', 'eko', 'ekp', 'ekr', 'eky', 'ele', 'elh', 'eli', 'elk', 'elm', 'elo', 'elp', 'elu', 'elx', 'ema', 'emb', 'eme', 'emg', 'emi', 'emk', 'emm', 'emn', 'emo', 'emp', 'ems', 'emu', 'emw', 'emx', 'emy', 'ena', 'enb', 'enc', 'end', 'enf', 'enh', 'enl', 'enm', 'enn', 'eno', 'enq', 'enr', 'enu', 'env', 'enw', 'enx', 'eot', 'epi', 'era', 'erg', 'erh', 'eri', 'erk', 'ero', 'err', 'ers', 'ert', 'erw', 'ese', 'esg', 'esh', 'esi', 'esk', 'esl', 'esm', 'esn', 'eso', 'esq', 'ess', 'esu', 'esx', 'esy', 'etb', 'etc', 'eth', 'etn', 'eto', 'etr', 'ets', 'ett', 'etu', 'etx', 'etz', 'euq', 'eve', 'evh', 'evn', 'ewo', 'ext', 'eya', 'eyo', 'eza', 'eze', 'faa', 'fab', 'fad', 'faf', 'fag', 'fah', 'fai', 'faj', 'fak', 'fal', 'fam', 'fan', 'fap', 'far', 'fat', 'fau', 'fax', 'fay', 'faz', 'fbl', 'fcs', 'fer', 'ffi', 'ffm', 'fgr', 'fia', 'fie', 'fil', 'fip', 'fir', 'fit', 'fiu', 'fiw', 'fkk', 'fkv', 'fla', 'flh', 'fli', 'fll', 'fln', 'flr', 'fly', 'fmp', 'fmu', 'fnb', 'fng', 'fni', 'fod', 'foi', 'fom', 'fon', 'for', 'fos', 'fox', 'fpe', 'fqs', 'frc', 'frd', 'frk', 'frm', 'fro', 'frp', 'frq', 'frr', 'frs', 'frt', 'fse', 'fsl', 'fss', 'fub', 'fuc', 'fud', 'fue', 'fuf', 'fuh', 'fui', 'fuj', 'fum', 'fun', 'fuq', 'fur', 'fut', 'fuu', 'fuv', 'fuy', 'fvr', 'fwa', 'fwe', 'gaa', 'gab', 'gac', 'gad', 'gae', 'gaf', 'gag', 'gah', 'gai', 'gaj', 'gak', 'gal', 'gam', 'gan', 'gao', 'gap', 'gaq', 'gar', 'gas', 'gat', 'gau', 'gav', 'gaw', 'gax', 'gay', 'gaz', 'gba', 'gbb', 'gbc', 'gbd', 'gbe', 'gbf', 'gbg', 'gbh', 'gbi', 'gbj', 'gbk', 'gbl', 'gbm', 'gbn', 'gbo', 'gbp', 'gbq', 'gbr', 'gbs', 'gbu', 'gbv', 'gbw', 'gbx', 'gby', 'gbz', 'gcc', 'gcd', 'gce', 'gcf', 'gcl', 'gcn', 'gcr', 'gct', 'gda', 'gdb', 'gdc', 'gdd', 'gde', 'gdf', 'gdg', 'gdh', 'gdi', 'gdj', 'gdk', 'gdl', 'gdm', 'gdn', 'gdo', 'gdq', 'gdr', 'gds', 'gdt', 'gdu', 'gdx', 'gea', 'geb', 'gec', 'ged', 'geg', 'geh', 'gei', 'gej', 'gek', 'gel', 'gem', 'geq', 'ges', 'gev', 'gew', 'gex', 'gey', 'gez', 'gfk', 'gft', 'gfx', 'gga', 'ggb', 'ggd', 'gge', 'ggg', 'ggk', 'ggl', 'ggn', 'ggo', 'ggr', 'ggt', 'ggu', 'ggw', 'gha', 'ghc', 'ghe', 'ghh', 'ghk', 'ghl', 'ghn', 'gho', 'ghr', 'ghs', 'ght', 'gia', 'gib', 'gic', 'gid', 'gie', 'gig', 'gih', 'gil', 'gim', 'gin', 'gio', 'gip', 'giq', 'gir', 'gis', 'git', 'giu', 'giw', 'gix', 'giy', 'giz', 'gji', 'gjk', 'gjm', 'gjn', 'gjr', 'gju', 'gka', 'gkd', 'gke', 'gkn', 'gko', 'gkp', 'gku', 'glc', 'gld', 'glh', 'gli', 'glj', 'glk', 'gll', 'glo', 'glr', 'glu', 'glw', 'gly', 'gma', 'gmb', 'gmd', 'gme', 'gmg', 'gmh', 'gml', 'gmm', 'gmn', 'gmq', 'gmu', 'gmv', 'gmw', 'gmx', 'gmy', 'gmz', 'gna', 'gnb', 'gnc', 'gnd', 'gne', 'gng', 'gnh', 'gni', 'gnj', 'gnk', 'gnl', 'gnm', 'gnn', 'gno', 'gnq', 'gnr', 'gnt', 'gnu', 'gnw', 'gnz', 'goa', 'gob', 'goc', 'god', 'goe', 'gof', 'gog', 'goh', 'goi', 'goj', 'gok', 'gol', 'gom', 'gon', 'goo', 'gop', 'goq', 'gor', 'gos', 'got', 'gou', 'gow', 'gox', 'goy', 'goz', 'gpa', 'gpe', 'gpn', 'gqa', 'gqi', 'gqn', 'gqr', 'gqu', 'gra', 'grb', 'grc', 'grd', 'grg', 'grh', 'gri', 'grj', 'grk', 'grm', 'gro', 'grq', 'grr', 'grs', 'grt', 'gru', 'grv', 'grw', 'grx', 'gry', 'grz', 'gse', 'gsg', 'gsl', 'gsm', 'gsn', 'gso', 'gsp', 'gss', 'gsw', 'gta', 'gti', 'gtu', 'gua', 'gub', 'guc', 'gud', 'gue', 'guf', 'gug', 'guh', 'gui', 'guk', 'gul', 'gum', 'gun', 'guo', 'gup', 'guq', 'gur', 'gus', 'gut', 'guu', 'guv', 'guw', 'gux', 'guz', 'gva', 'gvc', 'gve', 'gvf', 'gvj', 'gvl', 'gvm', 'gvn', 'gvo', 'gvp', 'gvr', 'gvs', 'gvy', 'gwa', 'gwb', 'gwc', 'gwd', 'gwe', 'gwf', 'gwg', 'gwi', 'gwj', 'gwm', 'gwn', 'gwr', 'gwt', 'gwu', 'gww', 'gwx', 'gxx', 'gya', 'gyb', 'gyd', 'gye', 'gyf', 'gyg', 'gyi', 'gyl', 'gym', 'gyn', 'gyo', 'gyr', 'gyy', 'gza', 'gzi', 'gzn', 'haa', 'hab', 'hac', 'had', 'hae', 'haf', 'hag', 'hah', 'hai', 'haj', 'hak', 'hal', 'ham', 'han', 'hao', 'hap', 'haq', 'har', 'has', 'hav', 'haw', 'hax', 'hay', 'haz', 'hba', 'hbb', 'hbn', 'hbo', 'hbu', 'hca', 'hch', 'hdn', 'hds', 'hdy', 'hea', 'hed', 'heg', 'heh', 'hei', 'hem', 'hgm', 'hgw', 'hhi', 'hhr', 'hhy', 'hia', 'hib', 'hid', 'hif', 'hig', 'hih', 'hii', 'hij', 'hik', 'hil', 'him', 'hio', 'hir', 'hit', 'hiw', 'hix', 'hji', 'hka', 'hke', 'hkk', 'hkn', 'hks', 'hla', 'hlb', 'hld', 'hle', 'hlt', 'hlu', 'hma', 'hmb', 'hmc', 'hmd', 'hme', 'hmf', 'hmg', 'hmh', 'hmi', 'hmj', 'hmk', 'hml', 'hmm', 'hmn', 'hmp', 'hmq', 'hmr', 'hms', 'hmt', 'hmu', 'hmv', 'hmw', 'hmx', 'hmy', 'hmz', 'hna', 'hnd', 'hne', 'hnh', 'hni', 'hnj', 'hnn', 'hno', 'hns', 'hnu', 'hoa', 'hob', 'hoc', 'hod', 'hoe', 'hoh', 'hoi', 'hoj', 'hok', 'hol', 'hom', 'hoo', 'hop', 'hor', 'hos', 'hot', 'hov', 'how', 'hoy', 'hoz', 'hpo', 'hps', 'hra', 'hrc', 'hre', 'hrk', 'hrm', 'hro', 'hrp', 'hrr', 'hrt', 'hru', 'hrw', 'hrx', 'hrz', 'hsb', 'hsh', 'hsl', 'hsn', 'hss', 'hti', 'hto', 'hts', 'htu', 'htx', 'hub', 'huc', 'hud', 'hue', 'huf', 'hug', 'huh', 'hui', 'huj', 'huk', 'hul', 'hum', 'huo', 'hup', 'huq', 'hur', 'hus', 'hut', 'huu', 'huv', 'huw', 'hux', 'huy', 'huz', 'hvc', 'hve', 'hvk', 'hvn', 'hvv', 'hwa', 'hwc', 'hwo', 'hya', 'hyw', 'hyx', 'iai', 'ian', 'iap', 'iar', 'iba', 'ibb', 'ibd', 'ibe', 'ibg', 'ibh', 'ibi', 'ibl', 'ibm', 'ibn', 'ibr', 'ibu', 'iby', 'ica', 'ich', 'icl', 'icr', 'ida', 'idb', 'idc', 'idd', 'ide', 'idi', 'idr', 'ids', 'idt', 'idu', 'ifa', 'ifb', 'ife', 'iff', 'ifk', 'ifm', 'ifu', 'ify', 'igb', 'ige', 'igg', 'igl', 'igm', 'ign', 'igo', 'igs', 'igw', 'ihb', 'ihi', 'ihp', 'ihw', 'iin', 'iir', 'ijc', 'ije', 'ijj', 'ijn', 'ijo', 'ijs', 'ike', 'iki', 'ikk', 'ikl', 'iko', 'ikp', 'ikr', 'iks', 'ikt', 'ikv', 'ikw', 'ikx', 'ikz', 'ila', 'ilb', 'ilg', 'ili', 'ilk', 'ill', 'ilm', 'ilo', 'ilp', 'ils', 'ilu', 'ilv', 'ilw', 'ima', 'ime', 'imi', 'iml', 'imn', 'imo', 'imr', 'ims', 'imy', 'inb', 'inc', 'ine', 'ing', 'inh', 'inj', 'inl', 'inm', 'inn', 'ino', 'inp', 'ins', 'int', 'inz', 'ior', 'iou', 'iow', 'ipi', 'ipo', 'iqu', 'iqw', 'ira', 'ire', 'irh', 'iri', 'irk', 'irn', 'iro', 'irr', 'iru', 'irx', 'iry', 'isa', 'isc', 'isd', 'ise', 'isg', 'ish', 'isi', 'isk', 'ism', 'isn', 'iso', 'isr', 'ist', 'isu', 'itb', 'itc', 'itd', 'ite', 'iti', 'itk', 'itl', 'itm', 'ito', 'itr', 'its', 'itt', 'itv', 'itw', 'itx', 'ity', 'itz', 'ium', 'ivb', 'ivv', 'iwk', 'iwm', 'iwo', 'iws', 'ixc', 'ixl', 'iya', 'iyo', 'iyx', 'izh', 'izi', 'izr', 'izz', 'jaa', 'jab', 'jac', 'jad', 'jae', 'jaf', 'jah', 'jaj', 'jak', 'jal', 'jam', 'jan', 'jao', 'jaq', 'jar', 'jas', 'jat', 'jau', 'jax', 'jay', 'jaz', 'jbe', 'jbi', 'jbj', 'jbk', 'jbn', 'jbo', 'jbr', 'jbt', 'jbu', 'jbw', 'jcs', 'jct', 'jda', 'jdg', 'jdt', 'jeb', 'jee', 'jeg', 'jeh', 'jei', 'jek', 'jel', 'jen', 'jer', 'jet', 'jeu', 'jgb', 'jge', 'jgk', 'jgo', 'jhi', 'jhs', 'jia', 'jib', 'jic', 'jid', 'jie', 'jig', 'jih', 'jii', 'jil', 'jim', 'jio', 'jiq', 'jit', 'jiu', 'jiv', 'jiy', 'jje', 'jjr', 'jka', 'jkm', 'jko', 'jkp', 'jkr', 'jku', 'jle', 'jls', 'jma', 'jmb', 'jmc', 'jmd', 'jmi', 'jml', 'jmn', 'jmr', 'jms', 'jmw', 'jmx', 'jna', 'jnd', 'jng', 'jni', 'jnj', 'jnl', 'jns', 'job', 'jod', 'jog', 'jor', 'jos', 'jow', 'jpa', 'jpr', 'jpx', 'jqr', 'jra', 'jrb', 'jrr', 'jrt', 'jru', 'jsl', 'jua', 'jub', 'juc', 'jud', 'juh', 'jui', 'juk', 'jul', 'jum', 'jun', 'juo', 'jup', 'jur', 'jus', 'jut', 'juu', 'juw', 'juy', 'jvd', 'jvn', 'jwi', 'jya', 'jye', 'jyy', 'kaa', 'kab', 'kac', 'kad', 'kae', 'kaf', 'kag', 'kah', 'kai', 'kaj', 'kak', 'kam', 'kao', 'kap', 'kaq', 'kar', 'kav', 'kaw', 'kax', 'kay', 'kba', 'kbb', 'kbc', 'kbd', 'kbe', 'kbf', 'kbg', 'kbh', 'kbi', 'kbj', 'kbk', 'kbl', 'kbm', 'kbn', 'kbo', 'kbp', 'kbq', 'kbr', 'kbs', 'kbt', 'kbu', 'kbv', 'kbw', 'kbx', 'kby', 'kbz', 'kca', 'kcb', 'kcc', 'kcd', 'kce', 'kcf', 'kcg', 'kch', 'kci', 'kcj', 'kck', 'kcl', 'kcm', 'kcn', 'kco', 'kcp', 'kcq', 'kcr', 'kcs', 'kct', 'kcu', 'kcv', 'kcw', 'kcx', 'kcy', 'kcz', 'kda', 'kdc', 'kdd', 'kde', 'kdf', 'kdg', 'kdh', 'kdi', 'kdj', 'kdk', 'kdl', 'kdm', 'kdn', 'kdo', 'kdp', 'kdq', 'kdr', 'kdt', 'kdu', 'kdv', 'kdw', 'kdx', 'kdy', 'kdz', 'kea', 'keb', 'kec', 'ked', 'kee', 'kef', 'keg', 'keh', 'kei', 'kej', 'kek', 'kel', 'kem', 'ken', 'keo', 'kep', 'keq', 'ker', 'kes', 'ket', 'keu', 'kev', 'kew', 'kex', 'key', 'kez', 'kfa', 'kfb', 'kfc', 'kfd', 'kfe', 'kff', 'kfg', 'kfh', 'kfi', 'kfj', 'kfk', 'kfl', 'kfm', 'kfn', 'kfo', 'kfp', 'kfq', 'kfr', 'kfs', 'kft', 'kfu', 'kfv', 'kfw', 'kfx', 'kfy', 'kfz', 'kga', 'kgb', 'kgc', 'kgd', 'kge', 'kgf', 'kgg', 'kgh', 'kgi', 'kgj', 'kgk', 'kgl', 'kgm', 'kgn', 'kgo', 'kgp', 'kgq', 'kgr', 'kgs', 'kgt', 'kgu', 'kgv', 'kgw', 'kgx', 'kgy', 'kha', 'khb', 'khc', 'khd', 'khe', 'khf', 'khg', 'khh', 'khi', 'khj', 'khk', 'khl', 'khn', 'kho', 'khp', 'khq', 'khr', 'khs', 'kht', 'khu', 'khv', 'khw', 'khx', 'khy', 'khz', 'kia', 'kib', 'kic', 'kid', 'kie', 'kif', 'kig', 'kih', 'kii', 'kij', 'kil', 'kim', 'kio', 'kip', 'kiq', 'kis', 'kit', 'kiu', 'kiv', 'kiw', 'kix', 'kiy', 'kiz', 'kja', 'kjb', 'kjc', 'kjd', 'kje', 'kjf', 'kjg', 'kjh', 'kji', 'kjj', 'kjk', 'kjl', 'kjm', 'kjn', 'kjo', 'kjp', 'kjq', 'kjr', 'kjs', 'kjt', 'kju', 'kjv', 'kjx', 'kjy', 'kjz', 'kka', 'kkb', 'kkc', 'kkd', 'kke', 'kkf', 'kkg', 'kkh', 'kki', 'kkj', 'kkk', 'kkl', 'kkm', 'kkn', 'kko', 'kkp', 'kkq', 'kkr', 'kks', 'kkt', 'kku', 'kkv', 'kkw', 'kkx', 'kky', 'kkz', 'kla', 'klb', 'klc', 'kld', 'kle', 'klf', 'klg', 'klh', 'kli', 'klj', 'klk', 'kll', 'klm', 'kln', 'klo', 'klp', 'klq', 'klr', 'kls', 'klt', 'klu', 'klv', 'klw', 'klx', 'kly', 'klz', 'kma', 'kmb', 'kmc', 'kmd', 'kme', 'kmf', 'kmg', 'kmh', 'kmi', 'kmj', 'kmk', 'kml', 'kmm', 'kmn', 'kmo', 'kmp', 'kmq', 'kmr', 'kms', 'kmt', 'kmu', 'kmv', 'kmw', 'kmx', 'kmy', 'kmz', 'kna', 'knb', 'knc', 'knd', 'kne', 'knf', 'kng', 'kni', 'knj', 'knk', 'knl', 'knm', 'knn', 'kno', 'knp', 'knq', 'knr', 'kns', 'knt', 'knu', 'knv', 'knw', 'knx', 'kny', 'knz', 'koa', 'koc', 'kod', 'koe', 'kof', 'kog', 'koh', 'koi', 'koj', 'kok', 'kol', 'koo', 'kop', 'koq', 'kos', 'kot', 'kou', 'kov', 'kow', 'kox', 'koy', 'koz', 'kpa', 'kpb', 'kpc', 'kpd', 'kpe', 'kpf', 'kpg', 'kph', 'kpi', 'kpj', 'kpk', 'kpl', 'kpm', 'kpn', 'kpo', 'kpp', 'kpq', 'kpr', 'kps', 'kpt', 'kpu', 'kpv', 'kpw', 'kpx', 'kpy', 'kpz', 'kqa', 'kqb', 'kqc', 'kqd', 'kqe', 'kqf', 'kqg', 'kqh', 'kqi', 'kqj', 'kqk', 'kql', 'kqm', 'kqn', 'kqo', 'kqp', 'kqq', 'kqr', 'kqs', 'kqt', 'kqu', 'kqv', 'kqw', 'kqx', 'kqy', 'kqz', 'kra', 'krb', 'krc', 'krd', 'kre', 'krf', 'krh', 'kri', 'krj', 'krk', 'krl', 'krm', 'krn', 'kro', 'krp', 'krr', 'krs', 'krt', 'kru', 'krv', 'krw', 'krx', 'kry', 'krz', 'ksa', 'ksb', 'ksc', 'ksd', 'kse', 'ksf', 'ksg', 'ksh', 'ksi', 'ksj', 'ksk', 'ksl', 'ksm', 'ksn', 'kso', 'ksp', 'ksq', 'ksr', 'kss', 'kst', 'ksu', 'ksv', 'ksw', 'ksx', 'ksy', 'ksz', 'kta', 'ktb', 'ktc', 'ktd', 'kte', 'ktf', 'ktg', 'kth', 'kti', 'ktj', 'ktk', 'ktl', 'ktm', 'ktn', 'kto', 'ktp', 'ktq', 'ktr', 'kts', 'ktt', 'ktu', 'ktv', 'ktw', 'ktx', 'kty', 'ktz', 'kub', 'kuc', 'kud', 'kue', 'kuf', 'kug', 'kuh', 'kui', 'kuj', 'kuk', 'kul', 'kum', 'kun', 'kuo', 'kup', 'kuq', 'kus', 'kut', 'kuu', 'kuv', 'kuw', 'kux', 'kuy', 'kuz', 'kva', 'kvb', 'kvc', 'kvd', 'kve', 'kvf', 'kvg', 'kvh', 'kvi', 'kvj', 'kvk', 'kvl', 'kvm', 'kvn', 'kvo', 'kvp', 'kvq', 'kvr', 'kvs', 'kvt', 'kvu', 'kvv', 'kvw', 'kvx', 'kvy', 'kvz', 'kwa', 'kwb', 'kwc', 'kwd', 'kwe', 'kwf', 'kwg', 'kwh', 'kwi', 'kwj', 'kwk', 'kwl', 'kwm', 'kwn', 'kwo', 'kwp', 'kwq', 'kwr', 'kws', 'kwt', 'kwu', 'kwv', 'kww', 'kwx', 'kwy', 'kwz', 'kxa', 'kxb', 'kxc', 'kxd', 'kxe', 'kxf', 'kxh', 'kxi', 'kxj', 'kxk', 'kxl', 'kxm', 'kxn', 'kxo', 'kxp', 'kxq', 'kxr', 'kxs', 'kxt', 'kxu', 'kxv', 'kxw', 'kxx', 'kxy', 'kxz', 'kya', 'kyb', 'kyc', 'kyd', 'kye', 'kyf', 'kyg', 'kyh', 'kyi', 'kyj', 'kyk', 'kyl', 'kym', 'kyn', 'kyo', 'kyp', 'kyq', 'kyr', 'kys', 'kyt', 'kyu', 'kyv', 'kyw', 'kyx', 'kyy', 'kyz', 'kza', 'kzb', 'kzc', 'kzd', 'kze', 'kzf', 'kzg', 'kzh', 'kzi', 'kzj', 'kzk', 'kzl', 'kzm', 'kzn', 'kzo', 'kzp', 'kzq', 'kzr', 'kzs', 'kzt', 'kzu', 'kzv', 'kzw', 'kzx', 'kzy', 'kzz', 'laa', 'lab', 'lac', 'lad', 'lae', 'laf', 'lag', 'lah', 'lai', 'laj', 'lak', 'lal', 'lam', 'lan', 'lap', 'laq', 'lar', 'las', 'lau', 'law', 'lax', 'lay', 'laz', 'lba', 'lbb', 'lbc', 'lbe', 'lbf', 'lbg', 'lbi', 'lbj', 'lbk', 'lbl', 'lbm', 'lbn', 'lbo', 'lbq', 'lbr', 'lbs', 'lbt', 'lbu', 'lbv', 'lbw', 'lbx', 'lby', 'lbz', 'lcc', 'lcd', 'lce', 'lcf', 'lch', 'lcl', 'lcm', 'lcp', 'lcq', 'lcs', 'lda', 'ldb', 'ldd', 'ldg', 'ldh', 'ldi', 'ldj', 'ldk', 'ldl', 'ldm', 'ldn', 'ldo', 'ldp', 'ldq', 'lea', 'leb', 'lec', 'led', 'lee', 'lef', 'leg', 'leh', 'lei', 'lej', 'lek', 'lel', 'lem', 'len', 'leo', 'lep', 'leq', 'ler', 'les', 'let', 'leu', 'lev', 'lew', 'lex', 'ley', 'lez', 'lfa', 'lfn', 'lga', 'lgb', 'lgg', 'lgh', 'lgi', 'lgk', 'lgl', 'lgm', 'lgn', 'lgq', 'lgr', 'lgt', 'lgu', 'lgz', 'lha', 'lhh', 'lhi', 'lhl', 'lhm', 'lhn', 'lhp', 'lhs', 'lht', 'lhu', 'lia', 'lib', 'lic', 'lid', 'lie', 'lif', 'lig', 'lih', 'lii', 'lij', 'lik', 'lil', 'lio', 'lip', 'liq', 'lir', 'lis', 'liu', 'liv', 'liw', 'lix', 'liy', 'liz', 'lja', 'lje', 'lji', 'ljl', 'ljp', 'ljw', 'ljx', 'lka', 'lkb', 'lkc', 'lkd', 'lke', 'lkh', 'lki', 'lkj', 'lkl', 'lkm', 'lkn', 'lko', 'lkr', 'lks', 'lkt', 'lku', 'lky', 'lla', 'llb', 'llc', 'lld', 'lle', 'llf', 'llg', 'llh', 'lli', 'llj', 'llk', 'lll', 'llm', 'lln', 'llo', 'llp', 'llq', 'lls', 'llu', 'llx', 'lma', 'lmb', 'lmc', 'lmd', 'lme', 'lmf', 'lmg', 'lmh', 'lmi', 'lmj', 'lmk', 'lml', 'lmm', 'lmn', 'lmo', 'lmp', 'lmq', 'lmr', 'lmu', 'lmv', 'lmw', 'lmx', 'lmy', 'lmz', 'lna', 'lnb', 'lnd', 'lng', 'lnh', 'lni', 'lnj', 'lnl', 'lnm', 'lnn', 'lno', 'lns', 'lnu', 'lnw', 'lnz', 'loa', 'lob', 'loc', 'loe', 'lof', 'log', 'loh', 'loi', 'loj', 'lok', 'lol', 'lom', 'lon', 'loo', 'lop', 'loq', 'lor', 'los', 'lot', 'lou', 'lov', 'low', 'lox', 'loy', 'loz', 'lpa', 'lpe', 'lpn', 'lpo', 'lpx', 'lra', 'lrc', 'lre', 'lrg', 'lri', 'lrk', 'lrl', 'lrm', 'lrn', 'lro', 'lrr', 'lrt', 'lrv', 'lrz', 'lsa', 'lsd', 'lse', 'lsg', 'lsh', 'lsi', 'lsl', 'lsm', 'lso', 'lsp', 'lsr', 'lss', 'lst', 'lsy', 'ltc', 'ltg', 'lth', 'lti', 'ltn', 'lto', 'lts', 'ltu', 'lua', 'luc', 'lud', 'lue', 'luf', 'lui', 'luj', 'luk', 'lul', 'lum', 'lun', 'luo', 'lup', 'luq', 'lur', 'lus', 'lut', 'luu', 'luv', 'luw', 'luy', 'luz', 'lva', 'lvk', 'lvs', 'lvu', 'lwa', 'lwe', 'lwg', 'lwh', 'lwl', 'lwm', 'lwo', 'lws', 'lwt', 'lwu', 'lww', 'lya', 'lyg', 'lyn', 'lzh', 'lzl', 'lzn', 'lzz', 'maa', 'mab', 'mad', 'mae', 'maf', 'mag', 'mai', 'maj', 'mak', 'mam', 'man', 'map', 'maq', 'mas', 'mat', 'mau', 'mav', 'maw', 'max', 'maz', 'mba', 'mbb', 'mbc', 'mbd', 'mbe', 'mbf', 'mbh', 'mbi', 'mbj', 'mbk', 'mbl', 'mbm', 'mbn', 'mbo', 'mbp', 'mbq', 'mbr', 'mbs', 'mbt', 'mbu', 'mbv', 'mbw', 'mbx', 'mby', 'mbz', 'mca', 'mcb', 'mcc', 'mcd', 'mce', 'mcf', 'mcg', 'mch', 'mci', 'mcj', 'mck', 'mcl', 'mcm', 'mcn', 'mco', 'mcp', 'mcq', 'mcr', 'mcs', 'mct', 'mcu', 'mcv', 'mcw', 'mcx', 'mcy', 'mcz', 'mda', 'mdb', 'mdc', 'mdd', 'mde', 'mdf', 'mdg', 'mdh', 'mdi', 'mdj', 'mdk', 'mdl', 'mdm', 'mdn', 'mdp', 'mdq', 'mdr', 'mds', 'mdt', 'mdu', 'mdv', 'mdw', 'mdx', 'mdy', 'mdz', 'mea', 'meb', 'mec', 'med', 'mee', 'mef', 'meg', 'meh', 'mei', 'mej', 'mek', 'mel', 'mem', 'men', 'meo', 'mep', 'meq', 'mer', 'mes', 'met', 'meu', 'mev', 'mew', 'mey', 'mez', 'mfa', 'mfb', 'mfc', 'mfd', 'mfe', 'mff', 'mfg', 'mfh', 'mfi', 'mfj', 'mfk', 'mfl', 'mfm', 'mfn', 'mfo', 'mfp', 'mfq', 'mfr', 'mfs', 'mft', 'mfu', 'mfv', 'mfw', 'mfx', 'mfy', 'mfz', 'mga', 'mgb', 'mgc', 'mgd', 'mge', 'mgf', 'mgg', 'mgh', 'mgi', 'mgj', 'mgk', 'mgl', 'mgm', 'mgn', 'mgo', 'mgp', 'mgq', 'mgr', 'mgs', 'mgt', 'mgu', 'mgv', 'mgw', 'mgx', 'mgy', 'mgz', 'mha', 'mhb', 'mhc', 'mhd', 'mhe', 'mhf', 'mhg', 'mhh', 'mhi', 'mhj', 'mhk', 'mhl', 'mhm', 'mhn', 'mho', 'mhp', 'mhq', 'mhr', 'mhs', 'mht', 'mhu', 'mhw', 'mhx', 'mhy', 'mhz', 'mia', 'mib', 'mic', 'mid', 'mie', 'mif', 'mig', 'mih', 'mii', 'mij', 'mik', 'mil', 'mim', 'min', 'mio', 'mip', 'miq', 'mir', 'mis', 'mit', 'miu', 'miw', 'mix', 'miy', 'miz', 'mja', 'mjb', 'mjc', 'mjd', 'mje', 'mjg', 'mjh', 'mji', 'mjj', 'mjk', 'mjl', 'mjm', 'mjn', 'mjo', 'mjp', 'mjq', 'mjr', 'mjs', 'mjt', 'mju', 'mjv', 'mjw', 'mjx', 'mjy', 'mjz', 'mka', 'mkb', 'mkc', 'mke', 'mkf', 'mkg', 'mkh', 'mki', 'mkj', 'mkk', 'mkl', 'mkm', 'mkn', 'mko', 'mkp', 'mkq', 'mkr', 'mks', 'mkt', 'mku', 'mkv', 'mkw', 'mkx', 'mky', 'mkz', 'mla', 'mlb', 'mlc', 'mld', 'mle', 'mlf', 'mlh', 'mli', 'mlj', 'mlk', 'mll', 'mlm', 'mln', 'mlo', 'mlp', 'mlq', 'mlr', 'mls', 'mlu', 'mlv', 'mlw', 'mlx', 'mlz', 'mma', 'mmb', 'mmc', 'mmd', 'mme', 'mmf', 'mmg', 'mmh', 'mmi', 'mmj', 'mmk', 'mml', 'mmm', 'mmn', 'mmo', 'mmp', 'mmq', 'mmr', 'mmt', 'mmu', 'mmv', 'mmw', 'mmx', 'mmy', 'mmz', 'mna', 'mnb', 'mnc', 'mnd', 'mne', 'mnf', 'mng', 'mnh', 'mni', 'mnj', 'mnk', 'mnl', 'mnm', 'mnn', 'mno', 'mnp', 'mnq', 'mnr', 'mns', 'mnt', 'mnu', 'mnv', 'mnw', 'mnx', 'mny', 'mnz', 'moa', 'moc', 'mod', 'moe', 'mof', 'mog', 'moh', 'moi', 'moj', 'mok', 'mom', 'moo', 'mop', 'moq', 'mor', 'mos', 'mot', 'mou', 'mov', 'mow', 'mox', 'moy', 'moz', 'mpa', 'mpb', 'mpc', 'mpd', 'mpe', 'mpg', 'mph', 'mpi', 'mpj', 'mpk', 'mpl', 'mpm', 'mpn', 'mpo', 'mpp', 'mpq', 'mpr', 'mps', 'mpt', 'mpu', 'mpv', 'mpw', 'mpx', 'mpy', 'mpz', 'mqa', 'mqb', 'mqc', 'mqe', 'mqf', 'mqg', 'mqh', 'mqi', 'mqj', 'mqk', 'mql', 'mqm', 'mqn', 'mqo', 'mqp', 'mqq', 'mqr', 'mqs', 'mqt', 'mqu', 'mqv', 'mqw', 'mqx', 'mqy', 'mqz', 'mra', 'mrb', 'mrc', 'mrd', 'mre', 'mrf', 'mrg', 'mrh', 'mrj', 'mrk', 'mrl', 'mrm', 'mrn', 'mro', 'mrp', 'mrq', 'mrr', 'mrs', 'mrt', 'mru', 'mrv', 'mrw', 'mrx', 'mry', 'mrz', 'msb', 'msc', 'msd', 'mse', 'msf', 'msg', 'msh', 'msi', 'msj', 'msk', 'msl', 'msm', 'msn', 'mso', 'msp', 'msq', 'msr', 'mss', 'mst', 'msu', 'msv', 'msw', 'msx', 'msy', 'msz', 'mta', 'mtb', 'mtc', 'mtd', 'mte', 'mtf', 'mtg', 'mth', 'mti', 'mtj', 'mtk', 'mtl', 'mtm', 'mtn', 'mto', 'mtp', 'mtq', 'mtr', 'mts', 'mtt', 'mtu', 'mtv', 'mtw', 'mtx', 'mty', 'mua', 'mub', 'muc', 'mud', 'mue', 'mug', 'muh', 'mui', 'muj', 'muk', 'mul', 'mum', 'mun', 'muo', 'mup', 'muq', 'mur', 'mus', 'mut', 'muu', 'muv', 'mux', 'muy', 'muz', 'mva', 'mvb', 'mvd', 'mve', 'mvf', 'mvg', 'mvh', 'mvi', 'mvk', 'mvl', 'mvm', 'mvn', 'mvo', 'mvp', 'mvq', 'mvr', 'mvs', 'mvt', 'mvu', 'mvv', 'mvw', 'mvx', 'mvy', 'mvz', 'mwa', 'mwb', 'mwc', 'mwd', 'mwe', 'mwf', 'mwg', 'mwh', 'mwi', 'mwj', 'mwk', 'mwl', 'mwm', 'mwn', 'mwo', 'mwp', 'mwq', 'mwr', 'mws', 'mwt', 'mwu', 'mwv', 'mww', 'mwx', 'mwy', 'mwz', 'mxa', 'mxb', 'mxc', 'mxd', 'mxe', 'mxf', 'mxg', 'mxh', 'mxi', 'mxj', 'mxk', 'mxl', 'mxm', 'mxn', 'mxo', 'mxp', 'mxq', 'mxr', 'mxs', 'mxt', 'mxu', 'mxv', 'mxw', 'mxx', 'mxy', 'mxz', 'myb', 'myc', 'myd', 'mye', 'myf', 'myg', 'myh', 'myi', 'myj', 'myk', 'myl', 'mym', 'myn', 'myo', 'myp', 'myq', 'myr', 'mys', 'myt', 'myu', 'myv', 'myw', 'myx', 'myy', 'myz', 'mza', 'mzb', 'mzc', 'mzd', 'mze', 'mzg', 'mzh', 'mzi', 'mzj', 'mzk', 'mzl', 'mzm', 'mzn', 'mzo', 'mzp', 'mzq', 'mzr', 'mzs', 'mzt', 'mzu', 'mzv', 'mzw', 'mzx', 'mzy', 'mzz', 'naa', 'nab', 'nac', 'nad', 'nae', 'naf', 'nag', 'nah', 'nai', 'naj', 'nak', 'nal', 'nam', 'nan', 'nao', 'nap', 'naq', 'nar', 'nas', 'nat', 'naw', 'nax', 'nay', 'naz', 'nba', 'nbb', 'nbc', 'nbd', 'nbe', 'nbf', 'nbg', 'nbh', 'nbi', 'nbj', 'nbk', 'nbm', 'nbn', 'nbo', 'nbp', 'nbq', 'nbr', 'nbs', 'nbt', 'nbu', 'nbv', 'nbw', 'nbx', 'nby', 'nca', 'ncb', 'ncc', 'ncd', 'nce', 'ncf', 'ncg', 'nch', 'nci', 'ncj', 'nck', 'ncl', 'ncm', 'ncn', 'nco', 'ncp', 'ncq', 'ncr', 'ncs', 'nct', 'ncu', 'ncx', 'ncz', 'nda', 'ndb', 'ndc', 'ndd', 'ndf', 'ndg', 'ndh', 'ndi', 'ndj', 'ndk', 'ndl', 'ndm', 'ndn', 'ndp', 'ndq', 'ndr', 'nds', 'ndt', 'ndu', 'ndv', 'ndw', 'ndx', 'ndy', 'ndz', 'nea', 'neb', 'nec', 'ned', 'nee', 'nef', 'neg', 'neh', 'nei', 'nej', 'nek', 'nem', 'nen', 'neo', 'neq', 'ner', 'nes', 'net', 'neu', 'nev', 'new', 'nex', 'ney', 'nez', 'nfa', 'nfd', 'nfl', 'nfr', 'nfu', 'nga', 'ngb', 'ngc', 'ngd', 'nge', 'ngf', 'ngg', 'ngh', 'ngi', 'ngj', 'ngk', 'ngl', 'ngm', 'ngn', 'ngo', 'ngp', 'ngq', 'ngr', 'ngs', 'ngt', 'ngu', 'ngv', 'ngw', 'ngx', 'ngy', 'ngz', 'nha', 'nhb', 'nhc', 'nhd', 'nhe', 'nhf', 'nhg', 'nhh', 'nhi', 'nhk', 'nhm', 'nhn', 'nho', 'nhp', 'nhq', 'nhr', 'nht', 'nhu', 'nhv', 'nhw', 'nhx', 'nhy', 'nhz', 'nia', 'nib', 'nic', 'nid', 'nie', 'nif', 'nig', 'nih', 'nii', 'nij', 'nik', 'nil', 'nim', 'nin', 'nio', 'niq', 'nir', 'nis', 'nit', 'niu', 'niv', 'niw', 'nix', 'niy', 'niz', 'nja', 'njb', 'njd', 'njh', 'nji', 'njj', 'njl', 'njm', 'njn', 'njo', 'njr', 'njs', 'njt', 'nju', 'njx', 'njy', 'njz', 'nka', 'nkb', 'nkc', 'nkd', 'nke', 'nkf', 'nkg', 'nkh', 'nki', 'nkj', 'nkk', 'nkm', 'nkn', 'nko', 'nkp', 'nkq', 'nkr', 'nks', 'nkt', 'nku', 'nkv', 'nkw', 'nkx', 'nkz', 'nla', 'nlc', 'nle', 'nlg', 'nli', 'nlj', 'nlk', 'nll', 'nlm', 'nln', 'nlo', 'nlq', 'nlr', 'nlu', 'nlv', 'nlw', 'nlx', 'nly', 'nlz', 'nma', 'nmb', 'nmc', 'nmd', 'nme', 'nmf', 'nmg', 'nmh', 'nmi', 'nmj', 'nmk', 'nml', 'nmm', 'nmn', 'nmo', 'nmp', 'nmq', 'nmr', 'nms', 'nmt', 'nmu', 'nmv', 'nmw', 'nmx', 'nmy', 'nmz', 'nna', 'nnb', 'nnc', 'nnd', 'nne', 'nnf', 'nng', 'nnh', 'nni', 'nnj', 'nnk', 'nnl', 'nnm', 'nnn', 'nnp', 'nnq', 'nnr', 'nns', 'nnt', 'nnu', 'nnv', 'nnw', 'nnx', 'nny', 'nnz', 'noa', 'noc', 'nod', 'noe', 'nof', 'nog', 'noh', 'noi', 'noj', 'nok', 'nol', 'nom', 'non', 'noo', 'nop', 'noq', 'nos', 'not', 'nou', 'nov', 'now', 'noy', 'noz', 'npa', 'npb', 'npg', 'nph', 'npi', 'npl', 'npn', 'npo', 'nps', 'npu', 'npx', 'npy', 'nqg', 'nqk', 'nql', 'nqm', 'nqn', 'nqo', 'nqq', 'nqy', 'nra', 'nrb', 'nrc', 'nre', 'nrf', 'nrg', 'nri', 'nrk', 'nrl', 'nrm', 'nrn', 'nrp', 'nrr', 'nrt', 'nru', 'nrx', 'nrz', 'nsa', 'nsc', 'nsd', 'nse', 'nsf', 'nsg', 'nsh', 'nsi', 'nsk', 'nsl', 'nsm', 'nsn', 'nso', 'nsp', 'nsq', 'nsr', 'nss', 'nst', 'nsu', 'nsv', 'nsw', 'nsx', 'nsy', 'nsz', 'ntd', 'nte', 'ntg', 'nti', 'ntj', 'ntk', 'ntm', 'nto', 'ntp', 'ntr', 'nts', 'ntu', 'ntw', 'ntx', 'nty', 'ntz', 'nua', 'nub', 'nuc', 'nud', 'nue', 'nuf', 'nug', 'nuh', 'nui', 'nuj', 'nuk', 'nul', 'num', 'nun', 'nuo', 'nup', 'nuq', 'nur', 'nus', 'nut', 'nuu', 'nuv', 'nuw', 'nux', 'nuy', 'nuz', 'nvh', 'nvm', 'nvo', 'nwa', 'nwb', 'nwc', 'nwe', 'nwg', 'nwi', 'nwm', 'nwo', 'nwr', 'nwx', 'nwy', 'nxa', 'nxd', 'nxe', 'nxg', 'nxi', 'nxk', 'nxl', 'nxm', 'nxn', 'nxo', 'nxq', 'nxr', 'nxu', 'nxx', 'nyb', 'nyc', 'nyd', 'nye', 'nyf', 'nyg', 'nyh', 'nyi', 'nyj', 'nyk', 'nyl', 'nym', 'nyn', 'nyo', 'nyp', 'nyq', 'nyr', 'nys', 'nyt', 'nyu', 'nyv', 'nyw', 'nyx', 'nyy', 'nza', 'nzb', 'nzd', 'nzi', 'nzk', 'nzm', 'nzs', 'nzu', 'nzy', 'nzz', 'oaa', 'oac', 'oar', 'oav', 'obi', 'obk', 'obl', 'obm', 'obo', 'obr', 'obt', 'obu', 'oca', 'och', 'oco', 'ocu', 'oda', 'odk', 'odt', 'odu', 'ofo', 'ofs', 'ofu', 'ogb', 'ogc', 'oge', 'ogg', 'ogo', 'ogu', 'oht', 'ohu', 'oia', 'oin', 'ojb', 'ojc', 'ojg', 'ojp', 'ojs', 'ojv', 'ojw', 'oka', 'okb', 'okd', 'oke', 'okg', 'okh', 'oki', 'okj', 'okk', 'okl', 'okm', 'okn', 'oko', 'okr', 'oks', 'oku', 'okv', 'okx', 'ola', 'old', 'ole', 'olk', 'olm', 'olo', 'olr', 'olt', 'olu', 'oma', 'omb', 'omc', 'ome', 'omg', 'omi', 'omk', 'oml', 'omn', 'omo', 'omp', 'omq', 'omr', 'omt', 'omu', 'omv', 'omw', 'omx', 'ona', 'onb', 'one', 'ong', 'oni', 'onj', 'onk', 'onn', 'ono', 'onp', 'onr', 'ons', 'ont', 'onu', 'onw', 'onx', 'ood', 'oog', 'oon', 'oor', 'oos', 'opa', 'opk', 'opm', 'opo', 'opt', 'opy', 'ora', 'orc', 'ore', 'org', 'orh', 'orn', 'oro', 'orr', 'ors', 'ort', 'oru', 'orv', 'orw', 'orx', 'ory', 'orz', 'osa', 'osc', 'osi', 'oso', 'osp', 'ost', 'osu', 'osx', 'ota', 'otb', 'otd', 'ote', 'oti', 'otk', 'otl', 'otm', 'otn', 'oto', 'otq', 'otr', 'ots', 'ott', 'otu', 'otw', 'otx', 'oty', 'otz', 'oua', 'oub', 'oue', 'oui', 'oum', 'oun', 'ovd', 'owi', 'owl', 'oyb', 'oyd', 'oym', 'oyy', 'ozm', 'paa', 'pab', 'pac', 'pad', 'pae', 'paf', 'pag', 'pah', 'pai', 'pak', 'pal', 'pam', 'pao', 'pap', 'paq', 'par', 'pas', 'pat', 'pau', 'pav', 'paw', 'pax', 'pay', 'paz', 'pbb', 'pbc', 'pbe', 'pbf', 'pbg', 'pbh', 'pbi', 'pbl', 'pbm', 'pbn', 'pbo', 'pbp', 'pbr', 'pbs', 'pbt', 'pbu', 'pbv', 'pby', 'pbz', 'pca', 'pcb', 'pcc', 'pcd', 'pce', 'pcf', 'pcg', 'pch', 'pci', 'pcj', 'pck', 'pcl', 'pcm', 'pcn', 'pcp', 'pcr', 'pcw', 'pda', 'pdc', 'pdi', 'pdn', 'pdo', 'pdt', 'pdu', 'pea', 'peb', 'ped', 'pee', 'pef', 'peg', 'peh', 'pei', 'pej', 'pek', 'pel', 'pem', 'peo', 'pep', 'peq', 'pes', 'pev', 'pex', 'pey', 'pez', 'pfa', 'pfe', 'pfl', 'pga', 'pgd', 'pgg', 'pgi', 'pgk', 'pgl', 'pgn', 'pgs', 'pgu', 'pgy', 'pgz', 'pha', 'phd', 'phg', 'phh', 'phi', 'phk', 'phl', 'phm', 'phn', 'pho', 'phq', 'phr', 'pht', 'phu', 'phv', 'phw', 'pia', 'pib', 'pic', 'pid', 'pie', 'pif', 'pig', 'pih', 'pii', 'pij', 'pil', 'pim', 'pin', 'pio', 'pip', 'pir', 'pis', 'pit', 'piu', 'piv', 'piw', 'pix', 'piy', 'piz', 'pjt', 'pka', 'pkb', 'pkc', 'pkg', 'pkh', 'pkn', 'pko', 'pkp', 'pkr', 'pks', 'pkt', 'pku', 'pla', 'plb', 'plc', 'pld', 'ple', 'plf', 'plg', 'plh', 'plj', 'plk', 'pll', 'pln', 'plo', 'plp', 'plq', 'plr', 'pls', 'plt', 'plu', 'plv', 'plw', 'ply', 'plz', 'pma', 'pmb', 'pmc', 'pmd', 'pme', 'pmf', 'pmh', 'pmi', 'pmj', 'pmk', 'pml', 'pmm', 'pmn', 'pmo', 'pmq', 'pmr', 'pms', 'pmt', 'pmu', 'pmw', 'pmx', 'pmy', 'pmz', 'pna', 'pnb', 'pnc', 'pne', 'png', 'pnh', 'pni', 'pnj', 'pnk', 'pnl', 'pnm', 'pnn', 'pno', 'pnp', 'pnq', 'pnr', 'pns', 'pnt', 'pnu', 'pnv', 'pnw', 'pnx', 'pny', 'pnz', 'poc', 'pod', 'poe', 'pof', 'pog', 'poh', 'poi', 'pok', 'pom', 'pon', 'poo', 'pop', 'poq', 'pos', 'pot', 'pov', 'pow', 'pox', 'poy', 'poz', 'ppa', 'ppe', 'ppi', 'ppk', 'ppl', 'ppm', 'ppn', 'ppo', 'ppp', 'ppq', 'ppr', 'pps', 'ppt', 'ppu', 'pqa', 'pqe', 'pqm', 'pqw', 'pra', 'prb', 'prc', 'prd', 'pre', 'prf', 'prg', 'prh', 'pri', 'prk', 'prl', 'prm', 'prn', 'pro', 'prp', 'prq', 'prr', 'prs', 'prt', 'pru', 'prw', 'prx', 'pry', 'prz', 'psa', 'psc', 'psd', 'pse', 'psg', 'psh', 'psi', 'psl', 'psm', 'psn', 'pso', 'psp', 'psq', 'psr', 'pss', 'pst', 'psu', 'psw', 'psy', 'pta', 'pth', 'pti', 'ptn', 'pto', 'ptp', 'ptq', 'ptr', 'ptt', 'ptu', 'ptv', 'ptw', 'pty', 'pua', 'pub', 'puc', 'pud', 'pue', 'puf', 'pug', 'pui', 'puj', 'puk', 'pum', 'puo', 'pup', 'puq', 'pur', 'put', 'puu', 'puw', 'pux', 'puy', 'puz', 'pwa', 'pwb', 'pwg', 'pwi', 'pwm', 'pwn', 'pwo', 'pwr', 'pww', 'pxm', 'pye', 'pym', 'pyn', 'pys', 'pyu', 'pyx', 'pyy', 'pzn', 'qaa..qtz', 'qua', 'qub', 'quc', 'qud', 'quf', 'qug', 'quh', 'qui', 'quk', 'qul', 'qum', 'qun', 'qup', 'quq', 'qur', 'qus', 'quv', 'quw', 'qux', 'quy', 'quz', 'qva', 'qvc', 'qve', 'qvh', 'qvi', 'qvj', 'qvl', 'qvm', 'qvn', 'qvo', 'qvp', 'qvs', 'qvw', 'qvy', 'qvz', 'qwa', 'qwc', 'qwe', 'qwh', 'qwm', 'qws', 'qwt', 'qxa', 'qxc', 'qxh', 'qxl', 'qxn', 'qxo', 'qxp', 'qxq', 'qxr', 'qxs', 'qxt', 'qxu', 'qxw', 'qya', 'qyp', 'raa', 'rab', 'rac', 'rad', 'raf', 'rag', 'rah', 'rai', 'raj', 'rak', 'ral', 'ram', 'ran', 'rao', 'rap', 'raq', 'rar', 'ras', 'rat', 'rau', 'rav', 'raw', 'rax', 'ray', 'raz', 'rbb', 'rbk', 'rbl', 'rbp', 'rcf', 'rdb', 'rea', 'reb', 'ree', 'reg', 'rei', 'rej', 'rel', 'rem', 'ren', 'rer', 'res', 'ret', 'rey', 'rga', 'rge', 'rgk', 'rgn', 'rgr', 'rgs', 'rgu', 'rhg', 'rhp', 'ria', 'rie', 'rif', 'ril', 'rim', 'rin', 'rir', 'rit', 'riu', 'rjg', 'rji', 'rjs', 'rka', 'rkb', 'rkh', 'rki', 'rkm', 'rkt', 'rkw', 'rma', 'rmb', 'rmc', 'rmd', 'rme', 'rmf', 'rmg', 'rmh', 'rmi', 'rmk', 'rml', 'rmm', 'rmn', 'rmo', 'rmp', 'rmq', 'rmr', 'rms', 'rmt', 'rmu', 'rmv', 'rmw', 'rmx', 'rmy', 'rmz', 'rna', 'rnd', 'rng', 'rnl', 'rnn', 'rnp', 'rnr', 'rnw', 'roa', 'rob', 'roc', 'rod', 'roe', 'rof', 'rog', 'rol', 'rom', 'roo', 'rop', 'ror', 'rou', 'row', 'rpn', 'rpt', 'rri', 'rro', 'rrt', 'rsb', 'rsi', 'rsl', 'rsm', 'rtc', 'rth', 'rtm', 'rts', 'rtw', 'rub', 'ruc', 'rue', 'ruf', 'rug', 'ruh', 'rui', 'ruk', 'ruo', 'rup', 'ruq', 'rut', 'ruu', 'ruy', 'ruz', 'rwa', 'rwk', 'rwm', 'rwo', 'rwr', 'rxd', 'rxw', 'ryn', 'rys', 'ryu', 'rzh', 'saa', 'sab', 'sac', 'sad', 'sae', 'saf', 'sah', 'sai', 'saj', 'sak', 'sal', 'sam', 'sao', 'sap', 'saq', 'sar', 'sas', 'sat', 'sau', 'sav', 'saw', 'sax', 'say', 'saz', 'sba', 'sbb', 'sbc', 'sbd', 'sbe', 'sbf', 'sbg', 'sbh', 'sbi', 'sbj', 'sbk', 'sbl', 'sbm', 'sbn', 'sbo', 'sbp', 'sbq', 'sbr', 'sbs', 'sbt', 'sbu', 'sbv', 'sbw', 'sbx', 'sby', 'sbz', 'sca', 'scb', 'sce', 'scf', 'scg', 'sch', 'sci', 'sck', 'scl', 'scn', 'sco', 'scp', 'scq', 'scs', 'sct', 'scu', 'scv', 'scw', 'scx', 'sda', 'sdb', 'sdc', 'sde', 'sdf', 'sdg', 'sdh', 'sdj', 'sdk', 'sdl', 'sdm', 'sdn', 'sdo', 'sdp', 'sdr', 'sds', 'sdt', 'sdu', 'sdv', 'sdx', 'sdz', 'sea', 'seb', 'sec', 'sed', 'see', 'sef', 'seg', 'seh', 'sei', 'sej', 'sek', 'sel', 'sem', 'sen', 'seo', 'sep', 'seq', 'ser', 'ses', 'set', 'seu', 'sev', 'sew', 'sey', 'sez', 'sfb', 'sfe', 'sfm', 'sfs', 'sfw', 'sga', 'sgb', 'sgc', 'sgd', 'sge', 'sgg', 'sgh', 'sgi', 'sgj', 'sgk', 'sgl', 'sgm', 'sgn', 'sgo', 'sgp', 'sgr', 'sgs', 'sgt', 'sgu', 'sgw', 'sgx', 'sgy', 'sgz', 'sha', 'shb', 'shc', 'shd', 'she', 'shg', 'shh', 'shi', 'shj', 'shk', 'shl', 'shm', 'shn', 'sho', 'shp', 'shq', 'shr', 'shs', 'sht', 'shu', 'shv', 'shw', 'shx', 'shy', 'shz', 'sia', 'sib', 'sid', 'sie', 'sif', 'sig', 'sih', 'sii', 'sij', 'sik', 'sil', 'sim', 'sio', 'sip', 'siq', 'sir', 'sis', 'sit', 'siu', 'siv', 'siw', 'six', 'siy', 'siz', 'sja', 'sjb', 'sjd', 'sje', 'sjg', 'sjk', 'sjl', 'sjm', 'sjn', 'sjo', 'sjp', 'sjr', 'sjs', 'sjt', 'sju', 'sjw', 'ska', 'skb', 'skc', 'skd', 'ske', 'skf', 'skg', 'skh', 'ski', 'skj', 'skk', 'skm', 'skn', 'sko', 'skp', 'skq', 'skr', 'sks', 'skt', 'sku', 'skv', 'skw', 'skx', 'sky', 'skz', 'sla', 'slc', 'sld', 'sle', 'slf', 'slg', 'slh', 'sli', 'slj', 'sll', 'slm', 'sln', 'slp', 'slq', 'slr', 'sls', 'slt', 'slu', 'slw', 'slx', 'sly', 'slz', 'sma', 'smb', 'smc', 'smd', 'smf', 'smg', 'smh', 'smi', 'smj', 'smk', 'sml', 'smm', 'smn', 'smp', 'smq', 'smr', 'sms', 'smt', 'smu', 'smv', 'smw', 'smx', 'smy', 'smz', 'snb', 'snc', 'sne', 'snf', 'sng', 'snh', 'sni', 'snj', 'snk', 'snl', 'snm', 'snn', 'sno', 'snp', 'snq', 'snr', 'sns', 'snu', 'snv', 'snw', 'snx', 'sny', 'snz', 'soa', 'sob', 'soc', 'sod', 'soe', 'sog', 'soh', 'soi', 'soj', 'sok', 'sol', 'son', 'soo', 'sop', 'soq', 'sor', 'sos', 'sou', 'sov', 'sow', 'sox', 'soy', 'soz', 'spb', 'spc', 'spd', 'spe', 'spg', 'spi', 'spk', 'spl', 'spm', 'spn', 'spo', 'spp', 'spq', 'spr', 'sps', 'spt', 'spu', 'spv', 'spx', 'spy', 'sqa', 'sqh', 'sqj', 'sqk', 'sqm', 'sqn', 'sqo', 'sqq', 'sqr', 'sqs', 'sqt', 'squ', 'sra', 'srb', 'src', 'sre', 'srf', 'srg', 'srh', 'sri', 'srk', 'srl', 'srm', 'srn', 'sro', 'srq', 'srr', 'srs', 'srt', 'sru', 'srv', 'srw', 'srx', 'sry', 'srz', 'ssa', 'ssb', 'ssc', 'ssd', 'sse', 'ssf', 'ssg', 'ssh', 'ssi', 'ssj', 'ssk', 'ssl', 'ssm', 'ssn', 'sso', 'ssp', 'ssq', 'ssr', 'sss', 'sst', 'ssu', 'ssv', 'ssx', 'ssy', 'ssz', 'sta', 'stb', 'std', 'ste', 'stf', 'stg', 'sth', 'sti', 'stj', 'stk', 'stl', 'stm', 'stn', 'sto', 'stp', 'stq', 'str', 'sts', 'stt', 'stu', 'stv', 'stw', 'sty', 'sua', 'sub', 'suc', 'sue', 'sug', 'sui', 'suj', 'suk', 'sul', 'sum', 'suq', 'sur', 'sus', 'sut', 'suv', 'suw', 'sux', 'suy', 'suz', 'sva', 'svb', 'svc', 'sve', 'svk', 'svm', 'svr', 'svs', 'svx', 'swb', 'swc', 'swf', 'swg', 'swh', 'swi', 'swj', 'swk', 'swl', 'swm', 'swn', 'swo', 'swp', 'swq', 'swr', 'sws', 'swt', 'swu', 'swv', 'sww', 'swx', 'swy', 'sxb', 'sxc', 'sxe', 'sxg', 'sxk', 'sxl', 'sxm', 'sxn', 'sxo', 'sxr', 'sxs', 'sxu', 'sxw', 'sya', 'syb', 'syc', 'syd', 'syi', 'syk', 'syl', 'sym', 'syn', 'syo', 'syr', 'sys', 'syw', 'syx', 'syy', 'sza', 'szb', 'szc', 'szd', 'sze', 'szg', 'szl', 'szn', 'szp', 'szs', 'szv', 'szw', 'taa', 'tab', 'tac', 'tad', 'tae', 'taf', 'tag', 'tai', 'taj', 'tak', 'tal', 'tan', 'tao', 'tap', 'taq', 'tar', 'tas', 'tau', 'tav', 'taw', 'tax', 'tay', 'taz', 'tba', 'tbb', 'tbc', 'tbd', 'tbe', 'tbf', 'tbg', 'tbh', 'tbi', 'tbj', 'tbk', 'tbl', 'tbm', 'tbn', 'tbo', 'tbp', 'tbq', 'tbr', 'tbs', 'tbt', 'tbu', 'tbv', 'tbw', 'tbx', 'tby', 'tbz', 'tca', 'tcb', 'tcc', 'tcd', 'tce', 'tcf', 'tcg', 'tch', 'tci', 'tck', 'tcl', 'tcm', 'tcn', 'tco', 'tcp', 'tcq', 'tcs', 'tct', 'tcu', 'tcw', 'tcx', 'tcy', 'tcz', 'tda', 'tdb', 'tdc', 'tdd', 'tde', 'tdf', 'tdg', 'tdh', 'tdi', 'tdj', 'tdk', 'tdl', 'tdm', 'tdn', 'tdo', 'tdq', 'tdr', 'tds', 'tdt', 'tdu', 'tdv', 'tdx', 'tdy', 'tea', 'teb', 'tec', 'ted', 'tee', 'tef', 'teg', 'teh', 'tei', 'tek', 'tem', 'ten', 'teo', 'tep', 'teq', 'ter', 'tes', 'tet', 'teu', 'tev', 'tew', 'tex', 'tey', 'tez', 'tfi', 'tfn', 'tfo', 'tfr', 'tft', 'tga', 'tgb', 'tgc', 'tgd', 'tge', 'tgf', 'tgg', 'tgh', 'tgi', 'tgj', 'tgn', 'tgo', 'tgp', 'tgq', 'tgr', 'tgs', 'tgt', 'tgu', 'tgv', 'tgw', 'tgx', 'tgy', 'tgz', 'thc', 'thd', 'the', 'thf', 'thh', 'thi', 'thk', 'thl', 'thm', 'thn', 'thp', 'thq', 'thr', 'ths', 'tht', 'thu', 'thv', 'thw', 'thx', 'thy', 'thz', 'tia', 'tic', 'tid', 'tie', 'tif', 'tig', 'tih', 'tii', 'tij', 'tik', 'til', 'tim', 'tin', 'tio', 'tip', 'tiq', 'tis', 'tit', 'tiu', 'tiv', 'tiw', 'tix', 'tiy', 'tiz', 'tja', 'tjg', 'tji', 'tjl', 'tjm', 'tjn', 'tjo', 'tjs', 'tju', 'tjw', 'tka', 'tkb', 'tkd', 'tke', 'tkf', 'tkg', 'tkk', 'tkl', 'tkm', 'tkn', 'tkp', 'tkq', 'tkr', 'tks', 'tkt', 'tku', 'tkv', 'tkw', 'tkx', 'tkz', 'tla', 'tlb', 'tlc', 'tld', 'tlf', 'tlg', 'tlh', 'tli', 'tlj', 'tlk', 'tll', 'tlm', 'tln', 'tlo', 'tlp', 'tlq', 'tlr', 'tls', 'tlt', 'tlu', 'tlv', 'tlw', 'tlx', 'tly', 'tma', 'tmb', 'tmc', 'tmd', 'tme', 'tmf', 'tmg', 'tmh', 'tmi', 'tmj', 'tmk', 'tml', 'tmm', 'tmn', 'tmo', 'tmp', 'tmq', 'tmr', 'tms', 'tmt', 'tmu', 'tmv', 'tmw', 'tmy', 'tmz', 'tna', 'tnb', 'tnc', 'tnd', 'tne', 'tnf', 'tng', 'tnh', 'tni', 'tnk', 'tnl', 'tnm', 'tnn', 'tno', 'tnp', 'tnq', 'tnr', 'tns', 'tnt', 'tnu', 'tnv', 'tnw', 'tnx', 'tny', 'tnz', 'tob', 'toc', 'tod', 'toe', 'tof', 'tog', 'toh', 'toi', 'toj', 'tol', 'tom', 'too', 'top', 'toq', 'tor', 'tos', 'tou', 'tov', 'tow', 'tox', 'toy', 'toz', 'tpa', 'tpc', 'tpe', 'tpf', 'tpg', 'tpi', 'tpj', 'tpk', 'tpl', 'tpm', 'tpn', 'tpo', 'tpp', 'tpq', 'tpr', 'tpt', 'tpu', 'tpv', 'tpw', 'tpx', 'tpy', 'tpz', 'tqb', 'tql', 'tqm', 'tqn', 'tqo', 'tqp', 'tqq', 'tqr', 'tqt', 'tqu', 'tqw', 'tra', 'trb', 'trc', 'trd', 'tre', 'trf', 'trg', 'trh', 'tri', 'trj', 'trk', 'trl', 'trm', 'trn', 'tro', 'trp', 'trq', 'trr', 'trs', 'trt', 'tru', 'trv', 'trw', 'trx', 'try', 'trz', 'tsa', 'tsb', 'tsc', 'tsd', 'tse', 'tsf', 'tsg', 'tsh', 'tsi', 'tsj', 'tsk', 'tsl', 'tsm', 'tsp', 'tsq', 'tsr', 'tss', 'tst', 'tsu', 'tsv', 'tsw', 'tsx', 'tsy', 'tsz', 'tta', 'ttb', 'ttc', 'ttd', 'tte', 'ttf', 'ttg', 'tth', 'tti', 'ttj', 'ttk', 'ttl', 'ttm', 'ttn', 'tto', 'ttp', 'ttq', 'ttr', 'tts', 'ttt', 'ttu', 'ttv', 'ttw', 'tty', 'ttz', 'tua', 'tub', 'tuc', 'tud', 'tue', 'tuf', 'tug', 'tuh', 'tui', 'tuj', 'tul', 'tum', 'tun', 'tuo', 'tup', 'tuq', 'tus', 'tut', 'tuu', 'tuv', 'tuw', 'tux', 'tuy', 'tuz', 'tva', 'tvd', 'tve', 'tvk', 'tvl', 'tvm', 'tvn', 'tvo', 'tvs', 'tvt', 'tvu', 'tvw', 'tvy', 'twa', 'twb', 'twc', 'twd', 'twe', 'twf', 'twg', 'twh', 'twl', 'twm', 'twn', 'two', 'twp', 'twq', 'twr', 'twt', 'twu', 'tww', 'twx', 'twy', 'txa', 'txb', 'txc', 'txe', 'txg', 'txh', 'txi', 'txj', 'txm', 'txn', 'txo', 'txq', 'txr', 'txs', 'txt', 'txu', 'txx', 'txy', 'tya', 'tye', 'tyh', 'tyi', 'tyj', 'tyl', 'tyn', 'typ', 'tyr', 'tys', 'tyt', 'tyu', 'tyv', 'tyx', 'tyz', 'tza', 'tzh', 'tzj', 'tzl', 'tzm', 'tzn', 'tzo', 'tzx', 'uam', 'uan', 'uar', 'uba', 'ubi', 'ubl', 'ubr', 'ubu', 'uby', 'uda', 'ude', 'udg', 'udi', 'udj', 'udl', 'udm', 'udu', 'ues', 'ufi', 'uga', 'ugb', 'uge', 'ugn', 'ugo', 'ugy', 'uha', 'uhn', 'uis', 'uiv', 'uji', 'uka', 'ukg', 'ukh', 'ukk', 'ukl', 'ukp', 'ukq', 'uks', 'uku', 'ukw', 'uky', 'ula', 'ulb', 'ulc', 'ule', 'ulf', 'uli', 'ulk', 'ull', 'ulm', 'uln', 'ulu', 'ulw', 'uma', 'umb', 'umc', 'umd', 'umg', 'umi', 'umm', 'umn', 'umo', 'ump', 'umr', 'ums', 'umu', 'una', 'und', 'une', 'ung', 'unk', 'unm', 'unn', 'unp', 'unr', 'unu', 'unx', 'unz', 'uok', 'upi', 'upv', 'ura', 'urb', 'urc', 'ure', 'urf', 'urg', 'urh', 'uri', 'urj', 'urk', 'url', 'urm', 'urn', 'uro', 'urp', 'urr', 'urt', 'uru', 'urv', 'urw', 'urx', 'ury', 'urz', 'usa', 'ush', 'usi', 'usk', 'usp', 'usu', 'uta', 'ute', 'utp', 'utr', 'utu', 'uum', 'uun', 'uur', 'uuu', 'uve', 'uvh', 'uvl', 'uwa', 'uya', 'uzn', 'uzs', 'vaa', 'vae', 'vaf', 'vag', 'vah', 'vai', 'vaj', 'val', 'vam', 'van', 'vao', 'vap', 'var', 'vas', 'vau', 'vav', 'vay', 'vbb', 'vbk', 'vec', 'ved', 'vel', 'vem', 'veo', 'vep', 'ver', 'vgr', 'vgt', 'vic', 'vid', 'vif', 'vig', 'vil', 'vin', 'vis', 'vit', 'viv', 'vka', 'vki', 'vkj', 'vkk', 'vkl', 'vkm', 'vko', 'vkp', 'vkt', 'vku', 'vlp', 'vls', 'vma', 'vmb', 'vmc', 'vmd', 'vme', 'vmf', 'vmg', 'vmh', 'vmi', 'vmj', 'vmk', 'vml', 'vmm', 'vmp', 'vmq', 'vmr', 'vms', 'vmu', 'vmv', 'vmw', 'vmx', 'vmy', 'vmz', 'vnk', 'vnm', 'vnp', 'vor', 'vot', 'vra', 'vro', 'vrs', 'vrt', 'vsi', 'vsl', 'vsv', 'vto', 'vum', 'vun', 'vut', 'vwa', 'waa', 'wab', 'wac', 'wad', 'wae', 'waf', 'wag', 'wah', 'wai', 'waj', 'wak', 'wal', 'wam', 'wan', 'wao', 'wap', 'waq', 'war', 'was', 'wat', 'wau', 'wav', 'waw', 'wax', 'way', 'waz', 'wba', 'wbb', 'wbe', 'wbf', 'wbh', 'wbi', 'wbj', 'wbk', 'wbl', 'wbm', 'wbp', 'wbq', 'wbr', 'wbs', 'wbt', 'wbv', 'wbw', 'wca', 'wci', 'wdd', 'wdg', 'wdj', 'wdk', 'wdu', 'wdy', 'wea', 'wec', 'wed', 'weg', 'weh', 'wei', 'wem', 'wen', 'weo', 'wep', 'wer', 'wes', 'wet', 'weu', 'wew', 'wfg', 'wga', 'wgb', 'wgg', 'wgi', 'wgo', 'wgu', 'wgw', 'wgy', 'wha', 'whg', 'whk', 'whu', 'wib', 'wic', 'wie', 'wif', 'wig', 'wih', 'wii', 'wij', 'wik', 'wil', 'wim', 'win', 'wir', 'wit', 'wiu', 'wiv', 'wiw', 'wiy', 'wja', 'wji', 'wka', 'wkb', 'wkd', 'wkl', 'wku', 'wkw', 'wky', 'wla', 'wlc', 'wle', 'wlg', 'wli', 'wlk', 'wll', 'wlm', 'wlo', 'wlr', 'wls', 'wlu', 'wlv', 'wlw', 'wlx', 'wly', 'wma', 'wmb', 'wmc', 'wmd', 'wme', 'wmh', 'wmi', 'wmm', 'wmn', 'wmo', 'wms', 'wmt', 'wmw', 'wmx', 'wnb', 'wnc', 'wnd', 'wne', 'wng', 'wni', 'wnk', 'wnm', 'wnn', 'wno', 'wnp', 'wnu', 'wnw', 'wny', 'woa', 'wob', 'woc', 'wod', 'woe', 'wof', 'wog', 'woi', 'wok', 'wom', 'won', 'woo', 'wor', 'wos', 'wow', 'woy', 'wpc', 'wra', 'wrb', 'wrd', 'wrg', 'wrh', 'wri', 'wrk', 'wrl', 'wrm', 'wrn', 'wro', 'wrp', 'wrr', 'wrs', 'wru', 'wrv', 'wrw', 'wrx', 'wry', 'wrz', 'wsa', 'wsg', 'wsi', 'wsk', 'wsr', 'wss', 'wsu', 'wsv', 'wtf', 'wth', 'wti', 'wtk', 'wtm', 'wtw', 'wua', 'wub', 'wud', 'wuh', 'wul', 'wum', 'wun', 'wur', 'wut', 'wuu', 'wuv', 'wux', 'wuy', 'wwa', 'wwb', 'wwo', 'wwr', 'www', 'wxa', 'wxw', 'wya', 'wyb', 'wyi', 'wym', 'wyr', 'wyy', 'xaa', 'xab', 'xac', 'xad', 'xae', 'xag', 'xai', 'xaj', 'xak', 'xal', 'xam', 'xan', 'xao', 'xap', 'xaq', 'xar', 'xas', 'xat', 'xau', 'xav', 'xaw', 'xay', 'xba', 'xbb', 'xbc', 'xbd', 'xbe', 'xbg', 'xbi', 'xbj', 'xbm', 'xbn', 'xbo', 'xbp', 'xbr', 'xbw', 'xbx', 'xby', 'xcb', 'xcc', 'xce', 'xcg', 'xch', 'xcl', 'xcm', 'xcn', 'xco', 'xcr', 'xct', 'xcu', 'xcv', 'xcw', 'xcy', 'xda', 'xdc', 'xdk', 'xdm', 'xdo', 'xdy', 'xeb', 'xed', 'xeg', 'xel', 'xem', 'xep', 'xer', 'xes', 'xet', 'xeu', 'xfa', 'xga', 'xgb', 'xgd', 'xgf', 'xgg', 'xgi', 'xgl', 'xgm', 'xgn', 'xgr', 'xgu', 'xgw', 'xha', 'xhc', 'xhd', 'xhe', 'xhr', 'xht', 'xhu', 'xhv', 'xia', 'xib', 'xii', 'xil', 'xin', 'xip', 'xir', 'xis', 'xiv', 'xiy', 'xjb', 'xjt', 'xka', 'xkb', 'xkc', 'xkd', 'xke', 'xkf', 'xkg', 'xkh', 'xki', 'xkj', 'xkk', 'xkl', 'xkn', 'xko', 'xkp', 'xkq', 'xkr', 'xks', 'xkt', 'xku', 'xkv', 'xkw', 'xkx', 'xky', 'xkz', 'xla', 'xlb', 'xlc', 'xld', 'xle', 'xlg', 'xli', 'xln', 'xlo', 'xlp', 'xls', 'xlu', 'xly', 'xma', 'xmb', 'xmc', 'xmd', 'xme', 'xmf', 'xmg', 'xmh', 'xmj', 'xmk', 'xml', 'xmm', 'xmn', 'xmo', 'xmp', 'xmq', 'xmr', 'xms', 'xmt', 'xmu', 'xmv', 'xmw', 'xmx', 'xmy', 'xmz', 'xna', 'xnb', 'xnd', 'xng', 'xnh', 'xni', 'xnk', 'xnn', 'xno', 'xnr', 'xns', 'xnt', 'xnu', 'xny', 'xnz', 'xoc', 'xod', 'xog', 'xoi', 'xok', 'xom', 'xon', 'xoo', 'xop', 'xor', 'xow', 'xpa', 'xpc', 'xpe', 'xpg', 'xpi', 'xpj', 'xpk', 'xpm', 'xpn', 'xpo', 'xpp', 'xpq', 'xpr', 'xps', 'xpt', 'xpu', 'xpy', 'xqa', 'xqt', 'xra', 'xrb', 'xrd', 'xre', 'xrg', 'xri', 'xrm', 'xrn', 'xrq', 'xrr', 'xrt', 'xru', 'xrw', 'xsa', 'xsb', 'xsc', 'xsd', 'xse', 'xsh', 'xsi', 'xsj', 'xsl', 'xsm', 'xsn', 'xso', 'xsp', 'xsq', 'xsr', 'xss', 'xsu', 'xsv', 'xsy', 'xta', 'xtb', 'xtc', 'xtd', 'xte', 'xtg', 'xth', 'xti', 'xtj', 'xtl', 'xtm', 'xtn', 'xto', 'xtp', 'xtq', 'xtr', 'xts', 'xtt', 'xtu', 'xtv', 'xtw', 'xty', 'xtz', 'xua', 'xub', 'xud', 'xug', 'xuj', 'xul', 'xum', 'xun', 'xuo', 'xup', 'xur', 'xut', 'xuu', 'xve', 'xvi', 'xvn', 'xvo', 'xvs', 'xwa', 'xwc', 'xwd', 'xwe', 'xwg', 'xwj', 'xwk', 'xwl', 'xwo', 'xwr', 'xwt', 'xww', 'xxb', 'xxk', 'xxm', 'xxr', 'xxt', 'xya', 'xyb', 'xyj', 'xyk', 'xyl', 'xyt', 'xyy', 'xzh', 'xzm', 'xzp', 'yaa', 'yab', 'yac', 'yad', 'yae', 'yaf', 'yag', 'yah', 'yai', 'yaj', 'yak', 'yal', 'yam', 'yan', 'yao', 'yap', 'yaq', 'yar', 'yas', 'yat', 'yau', 'yav', 'yaw', 'yax', 'yay', 'yaz', 'yba', 'ybb', 'ybd', 'ybe', 'ybh', 'ybi', 'ybj', 'ybk', 'ybl', 'ybm', 'ybn', 'ybo', 'ybx', 'yby', 'ych', 'ycl', 'ycn', 'ycp', 'yda', 'ydd', 'yde', 'ydg', 'ydk', 'yds', 'yea', 'yec', 'yee', 'yei', 'yej', 'yel', 'yen', 'yer', 'yes', 'yet', 'yeu', 'yev', 'yey', 'yga', 'ygi', 'ygl', 'ygm', 'ygp', 'ygr', 'ygs', 'ygu', 'ygw', 'yha', 'yhd', 'yhl', 'yhs', 'yia', 'yif', 'yig', 'yih', 'yii', 'yij', 'yik', 'yil', 'yim', 'yin', 'yip', 'yiq', 'yir', 'yis', 'yit', 'yiu', 'yiv', 'yix', 'yiy', 'yiz', 'yka', 'ykg', 'yki', 'ykk', 'ykl', 'ykm', 'ykn', 'yko', 'ykr', 'ykt', 'yku', 'yky', 'yla', 'ylb', 'yle', 'ylg', 'yli', 'yll', 'ylm', 'yln', 'ylo', 'ylr', 'ylu', 'yly', 'yma', 'ymb', 'ymc', 'ymd', 'yme', 'ymg', 'ymh', 'ymi', 'ymk', 'yml', 'ymm', 'ymn', 'ymo', 'ymp', 'ymq', 'ymr', 'yms', 'ymt', 'ymx', 'ymz', 'yna', 'ynd', 'yne', 'yng', 'ynh', 'ynk', 'ynl', 'ynn', 'yno', 'ynq', 'yns', 'ynu', 'yob', 'yog', 'yoi', 'yok', 'yol', 'yom', 'yon', 'yos', 'yot', 'yox', 'yoy', 'ypa', 'ypb', 'ypg', 'yph', 'ypk', 'ypm', 'ypn', 'ypo', 'ypp', 'ypz', 'yra', 'yrb', 'yre', 'yri', 'yrk', 'yrl', 'yrm', 'yrn', 'yro', 'yrs', 'yrw', 'yry', 'ysc', 'ysd', 'ysg', 'ysl', 'ysn', 'yso', 'ysp', 'ysr', 'yss', 'ysy', 'yta', 'ytl', 'ytp', 'ytw', 'yty', 'yua', 'yub', 'yuc', 'yud', 'yue', 'yuf', 'yug', 'yui', 'yuj', 'yuk', 'yul', 'yum', 'yun', 'yup', 'yuq', 'yur', 'yut', 'yuu', 'yuw', 'yux', 'yuy', 'yuz', 'yva', 'yvt', 'ywa', 'ywg', 'ywl', 'ywn', 'ywq', 'ywr', 'ywt', 'ywu', 'yww', 'yxa', 'yxg', 'yxl', 'yxm', 'yxu', 'yxy', 'yyr', 'yyu', 'yyz', 'yzg', 'yzk', 'zaa', 'zab', 'zac', 'zad', 'zae', 'zaf', 'zag', 'zah', 'zai', 'zaj', 'zak', 'zal', 'zam', 'zao', 'zap', 'zaq', 'zar', 'zas', 'zat', 'zau', 'zav', 'zaw', 'zax', 'zay', 'zaz', 'zbc', 'zbe', 'zbl', 'zbt', 'zbw', 'zca', 'zch', 'zdj', 'zea', 'zeg', 'zeh', 'zen', 'zga', 'zgb', 'zgh', 'zgm', 'zgn', 'zgr', 'zhb', 'zhd', 'zhi', 'zhn', 'zhw', 'zhx', 'zia', 'zib', 'zik', 'zil', 'zim', 'zin', 'zir', 'ziw', 'ziz', 'zka', 'zkb', 'zkd', 'zkg', 'zkh', 'zkk', 'zkn', 'zko', 'zkp', 'zkr', 'zkt', 'zku', 'zkv', 'zkz', 'zle', 'zlj', 'zlm', 'zln', 'zlq', 'zls', 'zlw', 'zma', 'zmb', 'zmc', 'zmd', 'zme', 'zmf', 'zmg', 'zmh', 'zmi', 'zmj', 'zmk', 'zml', 'zmm', 'zmn', 'zmo', 'zmp', 'zmq', 'zmr', 'zms', 'zmt', 'zmu', 'zmv', 'zmw', 'zmx', 'zmy', 'zmz', 'zna', 'znd', 'zne', 'zng', 'znk', 'zns', 'zoc', 'zoh', 'zom', 'zoo', 'zoq', 'zor', 'zos', 'zpa', 'zpb', 'zpc', 'zpd', 'zpe', 'zpf', 'zpg', 'zph', 'zpi', 'zpj', 'zpk', 'zpl', 'zpm', 'zpn', 'zpo', 'zpp', 'zpq', 'zpr', 'zps', 'zpt', 'zpu', 'zpv', 'zpw', 'zpx', 'zpy', 'zpz', 'zqe', 'zra', 'zrg', 'zrn', 'zro', 'zrp', 'zrs', 'zsa', 'zsk', 'zsl', 'zsm', 'zsr', 'zsu', 'zte', 'ztg', 'ztl', 'ztm', 'ztn', 'ztp', 'ztq', 'zts', 'ztt', 'ztu', 'ztx', 'zty', 'zua', 'zuh', 'zum', 'zun', 'zuy', 'zwa', 'zxx', 'zyb', 'zyg', 'zyj', 'zyn', 'zyp', 'zza', 'zzj' ]; + axe.utils.validLangs = function() { + 'use strict'; + return langs; + }; + 'use strict'; + function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); + } + function _nonIterableSpread() { + throw new TypeError('Invalid attempt to spread non-iterable instance'); + } + function _iterableToArray(iter) { + if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === '[object Arguments]') { + return Array.from(iter); + } + } + function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) { + for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { + arr2[i] = arr[i]; + } + return arr2; + } + } + function _extends() { + _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + return target; + }; + return _extends.apply(this, arguments); + } + function _typeof(obj) { + if (typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol') { + _typeof = function _typeof(obj) { + return typeof obj; + }; + } else { + _typeof = function _typeof(obj) { + return obj && typeof Symbol === 'function' && obj.constructor === Symbol && obj !== Symbol.prototype ? 'symbol' : typeof obj; + }; + } + return _typeof(obj); + } axe._load({ data: { rules: { @@ -4015,10 +7323,26 @@ description: 'Ensures ARIA attributes are allowed for an element\'s role', help: 'Elements must only use allowed ARIA attributes' }, + 'aria-allowed-role': { + description: 'Ensures role attribute has an appropriate value for the element', + help: 'ARIA role must be appropriate for the element' + }, + 'aria-dpub-role-fallback': { + description: 'Ensures unsupported DPUB roles are only used on elements with implicit fallback roles', + help: 'Unsupported DPUB ARIA roles should be used on elements with implicit fallback roles' + }, 'aria-hidden-body': { description: 'Ensures aria-hidden=\'true\' is not present on the document body.', help: 'aria-hidden=\'true\' must not be present on the document body' }, + 'aria-hidden-focus': { + description: 'Ensures aria-hidden elements do not contain focusable elements', + help: 'ARIA hidden element must not contain focusable elements' + }, + 'aria-input-field-name': { + description: 'Ensures every ARIA input field has an accessible name', + help: 'ARIA input fields have an accessible name' + }, 'aria-required-attr': { description: 'Ensures elements with ARIA roles have all required ARIA attributes', help: 'Required ARIA attributes must be provided' @@ -4035,6 +7359,10 @@ description: 'Ensures all elements with a role attribute use a valid value', help: 'ARIA roles used must conform to valid values' }, + 'aria-toggle-field-name': { + description: 'Ensures every ARIA toggle field has an accessible name', + help: 'ARIA toggle fields have an accessible name' + }, 'aria-valid-attr-value': { description: 'Ensures all ARIA attributes have valid values', help: 'ARIA attributes must conform to valid values' @@ -4047,6 +7375,14 @@ description: 'Ensures