axe-core
Version:
Accessibility engine for automated Web UI testing
1,560 lines (1,557 loc) • 896 kB
JavaScript
/*! axe v4.2.4
* Copyright (c) 2021 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
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This entire copyright notice must appear in every copy of this file you
* distribute or in any file that contains substantial portions of this source
* code.
*/
(function axeFunction(window) {
var global = window;
var document = window.document;
'use strict';
function _typeof(obj) {
'@babel/helpers - typeof';
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 = '4.2.4';
if (typeof define === 'function' && define.amd) {
define('axe-core', [], function() {
return axe;
});
}
if ((typeof module === 'undefined' ? 'undefined' : _typeof(module)) === 'object' && module.exports && typeof axeFunction.toString === 'function') {
axe.source = '(' + axeFunction.toString() + ')(typeof window === "object" ? window : this);';
module.exports = axe;
}
if (typeof window.getComputedStyle === 'function') {
window.axe = axe;
}
var commons;
function SupportError(error) {
this.name = 'SupportError';
this.cause = error.cause;
this.message = '`'.concat(error.cause, '` - feature unsupported in your environment.');
if (error.ruleId) {
this.ruleId = error.ruleId;
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 _excluded = [ 'variant' ], _excluded2 = [ 'matches' ], _excluded3 = [ 'chromium' ], _excluded4 = [ 'noImplicit' ], _excluded5 = [ 'noPresentational' ];
function _objectWithoutProperties(source, excluded) {
if (source == null) {
return {};
}
var target = _objectWithoutPropertiesLoose(source, excluded);
var key, i;
if (Object.getOwnPropertySymbols) {
var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
for (i = 0; i < sourceSymbolKeys.length; i++) {
key = sourceSymbolKeys[i];
if (excluded.indexOf(key) >= 0) {
continue;
}
if (!Object.prototype.propertyIsEnumerable.call(source, key)) {
continue;
}
target[key] = source[key];
}
}
return target;
}
function _objectWithoutPropertiesLoose(source, excluded) {
if (source == null) {
return {};
}
var target = {};
var sourceKeys = Object.keys(source);
var key, i;
for (i = 0; i < sourceKeys.length; i++) {
key = sourceKeys[i];
if (excluded.indexOf(key) >= 0) {
continue;
}
target[key] = source[key];
}
return target;
}
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 _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 _createSuper(Derived) {
var hasNativeReflectConstruct = _isNativeReflectConstruct();
return function _createSuperInternal() {
var Super = _getPrototypeOf(Derived), result;
if (hasNativeReflectConstruct) {
var NewTarget = _getPrototypeOf(this).constructor;
result = Reflect.construct(Super, arguments, NewTarget);
} else {
result = Super.apply(this, arguments);
}
return _possibleConstructorReturn(this, result);
};
}
function _possibleConstructorReturn(self, call) {
if (call && (_typeof(call) === 'object' || typeof call === 'function')) {
return call;
}
return _assertThisInitialized(self);
}
function _assertThisInitialized(self) {
if (self === void 0) {
throw new ReferenceError('this hasn\'t been initialised - super() hasn\'t been called');
}
return self;
}
function _isNativeReflectConstruct() {
if (typeof Reflect === 'undefined' || !Reflect.construct) {
return false;
}
if (Reflect.construct.sham) {
return false;
}
if (typeof Proxy === 'function') {
return true;
}
try {
Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
return true;
} catch (e) {
return false;
}
}
function _getPrototypeOf(o) {
_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
return o.__proto__ || Object.getPrototypeOf(o);
};
return _getPrototypeOf(o);
}
function _toConsumableArray(arr) {
return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
}
function _nonIterableSpread() {
throw new TypeError('Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.');
}
function _iterableToArray(iter) {
if (typeof Symbol !== 'undefined' && iter[Symbol.iterator] != null || iter['@@iterator'] != null) {
return Array.from(iter);
}
}
function _arrayWithoutHoles(arr) {
if (Array.isArray(arr)) {
return _arrayLikeToArray(arr);
}
}
function _slicedToArray(arr, i) {
return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
}
function _nonIterableRest() {
throw new TypeError('Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.');
}
function _iterableToArrayLimit(arr, i) {
var _i = arr == null ? null : typeof Symbol !== 'undefined' && arr[Symbol.iterator] || arr['@@iterator'];
if (_i == null) {
return;
}
var _arr = [];
var _n = true;
var _d = false;
var _s, _e;
try {
for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
_arr.push(_s.value);
if (i && _arr.length === i) {
break;
}
}
} catch (err) {
_d = true;
_e = err;
} finally {
try {
if (!_n && _i['return'] != null) {
_i['return']();
}
} finally {
if (_d) {
throw _e;
}
}
}
return _arr;
}
function _arrayWithHoles(arr) {
if (Array.isArray(arr)) {
return arr;
}
}
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 _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;
}
function _createForOfIteratorHelper(o, allowArrayLike) {
var it = typeof Symbol !== 'undefined' && o[Symbol.iterator] || o['@@iterator'];
if (!it) {
if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === 'number') {
if (it) {
o = it;
}
var i = 0;
var F = function F() {};
return {
s: F,
n: function n() {
if (i >= o.length) {
return {
done: true
};
}
return {
done: false,
value: o[i++]
};
},
e: function e(_e2) {
throw _e2;
},
f: F
};
}
throw new TypeError('Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.');
}
var normalCompletion = true, didErr = false, err;
return {
s: function s() {
it = it.call(o);
},
n: function n() {
var step = it.next();
normalCompletion = step.done;
return step;
},
e: function e(_e3) {
didErr = true;
err = _e3;
},
f: function f() {
try {
if (!normalCompletion && it['return'] != null) {
it['return']();
}
} finally {
if (didErr) {
throw err;
}
}
}
};
}
function _unsupportedIterableToArray(o, minLen) {
if (!o) {
return;
}
if (typeof o === 'string') {
return _arrayLikeToArray(o, minLen);
}
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === 'Object' && o.constructor) {
n = o.constructor.name;
}
if (n === 'Map' || n === 'Set') {
return Array.from(o);
}
if (n === 'Arguments' || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) {
return _arrayLikeToArray(o, minLen);
}
}
function _arrayLikeToArray(arr, len) {
if (len == null || len > arr.length) {
len = arr.length;
}
for (var i = 0, arr2 = new Array(len); i < len; i++) {
arr2[i] = arr[i];
}
return arr2;
}
function _typeof(obj) {
'@babel/helpers - typeof';
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() {
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __markAsModule = function __markAsModule(target) {
return __defProp(target, '__esModule', {
value: true
});
};
var __commonJS = function __commonJS(callback, module) {
return function() {
if (!module) {
module = {
exports: {}
};
callback(module.exports, module);
}
return module.exports;
};
};
var __export = function __export(target, all) {
__markAsModule(target);
for (var name in all) {
__defProp(target, name, {
get: all[name],
enumerable: true
});
}
};
var __exportStar = function __exportStar(target, module, desc) {
__markAsModule(target);
if (_typeof(module) === 'object' || typeof module === 'function') {
var _iterator = _createForOfIteratorHelper(__getOwnPropNames(module)), _step;
try {
var _loop = function _loop() {
var key = _step.value;
if (!__hasOwnProp.call(target, key) && key !== 'default') {
__defProp(target, key, {
get: function get() {
return module[key];
},
enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable
});
}
};
for (_iterator.s(); !(_step = _iterator.n()).done; ) {
_loop();
}
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
}
return target;
};
var __toModule = function __toModule(module) {
if (module && module.__esModule) {
return module;
}
return __exportStar(__defProp(__create(__getProtoOf(module)), 'default', {
value: module,
enumerable: true
}), module);
};
var require_utils = __commonJS(function(exports) {
'use strict';
Object.defineProperty(exports, '__esModule', {
value: true
});
function isIdentStart(c) {
return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c === '-' || c === '_';
}
exports.isIdentStart = isIdentStart;
function isIdent(c) {
return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || c === '-' || c === '_';
}
exports.isIdent = isIdent;
function isHex(c) {
return c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F' || c >= '0' && c <= '9';
}
exports.isHex = isHex;
function escapeIdentifier(s) {
var len = s.length;
var result = '';
var i = 0;
while (i < len) {
var chr = s.charAt(i);
if (exports.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;
}
exports.escapeIdentifier = escapeIdentifier;
function escapeStr(s) {
var len = s.length;
var result = '';
var i = 0;
var replacement;
while (i < len) {
var chr = s.charAt(i);
if (chr === '"') {
chr = '\\"';
} else if (chr === '\\') {
chr = '\\\\';
} else if ((replacement = exports.strReplacementsRev[chr]) !== void 0) {
chr = replacement;
}
result += chr;
i++;
}
return '"' + result + '"';
}
exports.escapeStr = escapeStr;
exports.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
};
exports.strReplacementsRev = {
'\n': '\\n',
'\r': '\\r',
'\t': '\\t',
'\f': '\\f',
'\v': '\\v'
};
exports.singleQuoteEscapeChars = {
n: '\n',
r: '\r',
t: '\t',
f: '\f',
'\\': '\\',
'\'': '\''
};
exports.doubleQuotesEscapeChars = {
n: '\n',
r: '\r',
t: '\t',
f: '\f',
'\\': '\\',
'"': '"'
};
});
var require_parser_context = __commonJS(function(exports) {
'use strict';
Object.defineProperty(exports, '__esModule', {
value: true
});
var utils_1 = require_utils();
function parseCssSelector(str, pos, pseudos, attrEqualityMods, ruleNestingOperators, substitutesEnabled) {
var l = str.length;
var chr = '';
function getStr(quote, escapeTable) {
var result = '';
pos++;
chr = str.charAt(pos);
while (pos < l) {
if (chr === quote) {
pos++;
return result;
} else if (chr === '\\') {
pos++;
chr = str.charAt(pos);
var esc = void 0;
if (chr === quote) {
result += quote;
} else if ((esc = escapeTable[chr]) !== void 0) {
result += esc;
} else if (utils_1.isHex(chr)) {
var hex = chr;
pos++;
chr = str.charAt(pos);
while (utils_1.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;
}
function getIdent() {
var result = '';
chr = str.charAt(pos);
while (pos < l) {
if (utils_1.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 (utils_1.identSpecialChars[chr]) {
result += chr;
} else if (utils_1.isHex(chr)) {
var hex = chr;
pos++;
chr = str.charAt(pos);
while (utils_1.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;
}
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;
}
function parse2() {
var res = parseSelector();
if (pos < l) {
throw Error('Rule expected but "' + str.charAt(pos) + '" found.');
}
return res;
}
function parseSelector() {
var selector = parseSingleSelector();
if (!selector) {
return null;
}
var res = selector;
chr = str.charAt(pos);
while (chr === ',') {
pos++;
skipWhitespace();
if (res.type !== 'selectors') {
res = {
type: 'selectors',
selectors: [ selector ]
};
}
selector = parseSingleSelector();
if (!selector) {
throw Error('Rule expected after ",".');
}
res.selectors.push(selector);
}
return res;
}
function parseSingleSelector() {
skipWhitespace();
var selector = {
type: 'ruleSet'
};
var rule3 = parseRule();
if (!rule3) {
return null;
}
var currentRule = selector;
while (rule3) {
rule3.type = 'rule';
currentRule.rule = rule3;
currentRule = rule3;
skipWhitespace();
chr = str.charAt(pos);
if (pos >= l || chr === ',' || chr === ')') {
break;
}
if (ruleNestingOperators[chr]) {
var op = chr;
pos++;
skipWhitespace();
rule3 = parseRule();
if (!rule3) {
throw Error('Rule expected after "' + op + '".');
}
rule3.nestingOperator = op;
} else {
rule3 = parseRule();
if (rule3) {
rule3.nestingOperator = null;
}
}
}
return selector;
}
function parseRule() {
var rule3 = null;
while (pos < l) {
chr = str.charAt(pos);
if (chr === '*') {
pos++;
(rule3 = rule3 || {}).tagName = '*';
} else if (utils_1.isIdentStart(chr) || chr === '\\') {
(rule3 = rule3 || {}).tagName = getIdent();
} else if (chr === '.') {
pos++;
rule3 = rule3 || {};
(rule3.classNames = rule3.classNames || []).push(getIdent());
} else if (chr === '#') {
pos++;
(rule3 = rule3 || {}).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('"', utils_1.doubleQuotesEscapeChars);
} else if (chr === '\'') {
attrValue = getStr('\'', utils_1.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;
}
rule3 = rule3 || {};
(rule3.attrs = rule3.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 = parseSelector();
} else {
pseudo.valueType = pseudos[pseudoName] || 'string';
if (chr === '"') {
value = getStr('"', utils_1.doubleQuotesEscapeChars);
} else if (chr === '\'') {
value = getStr('\'', utils_1.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;
}
rule3 = rule3 || {};
(rule3.pseudos = rule3.pseudos || []).push(pseudo);
} else {
break;
}
}
return rule3;
}
return parse2();
}
exports.parseCssSelector = parseCssSelector;
});
var require_render = __commonJS(function(exports) {
'use strict';
Object.defineProperty(exports, '__esModule', {
value: true
});
var utils_1 = require_utils();
function renderEntity(entity) {
var res = '';
switch (entity.type) {
case 'ruleSet':
var currentEntity = entity.rule;
var parts = [];
while (currentEntity) {
if (currentEntity.nestingOperator) {
parts.push(currentEntity.nestingOperator);
}
parts.push(renderEntity(currentEntity));
currentEntity = currentEntity.rule;
}
res = parts.join(' ');
break;
case 'selectors':
res = entity.selectors.map(renderEntity).join(', ');
break;
case 'rule':
if (entity.tagName) {
if (entity.tagName === '*') {
res = '*';
} else {
res = utils_1.escapeIdentifier(entity.tagName);
}
}
if (entity.id) {
res += '#' + utils_1.escapeIdentifier(entity.id);
}
if (entity.classNames) {
res += entity.classNames.map(function(cn) {
return '.' + utils_1.escapeIdentifier(cn);
}).join('');
}
if (entity.attrs) {
res += entity.attrs.map(function(attr) {
if ('operator' in attr) {
if (attr.valueType === 'substitute') {
return '[' + utils_1.escapeIdentifier(attr.name) + attr.operator + '$' + attr.value + ']';
} else {
return '[' + utils_1.escapeIdentifier(attr.name) + attr.operator + utils_1.escapeStr(attr.value) + ']';
}
} else {
return '[' + utils_1.escapeIdentifier(attr.name) + ']';
}
}).join('');
}
if (entity.pseudos) {
res += entity.pseudos.map(function(pseudo) {
if (pseudo.valueType) {
if (pseudo.valueType === 'selector') {
return ':' + utils_1.escapeIdentifier(pseudo.name) + '(' + renderEntity(pseudo.value) + ')';
} else if (pseudo.valueType === 'substitute') {
return ':' + utils_1.escapeIdentifier(pseudo.name) + '($' + pseudo.value + ')';
} else if (pseudo.valueType === 'numeric') {
return ':' + utils_1.escapeIdentifier(pseudo.name) + '(' + pseudo.value + ')';
} else {
return ':' + utils_1.escapeIdentifier(pseudo.name) + '(' + utils_1.escapeIdentifier(pseudo.value) + ')';
}
} else {
return ':' + utils_1.escapeIdentifier(pseudo.name);
}
}).join('');
}
break;
default:
throw Error('Unknown entity type: "' + entity.type + '".');
}
return res;
}
exports.renderEntity = renderEntity;
});
var require_lib = __commonJS(function(exports) {
'use strict';
Object.defineProperty(exports, '__esModule', {
value: true
});
var parser_context_1 = require_parser_context();
var render_1 = require_render();
var CssSelectorParser3 = function() {
function CssSelectorParser4() {
this.pseudos = {};
this.attrEqualityMods = {};
this.ruleNestingOperators = {};
this.substitutesEnabled = false;
}
CssSelectorParser4.prototype.registerSelectorPseudos = function() {
var pseudos = [];
for (var _i = 0; _i < arguments.length; _i++) {
pseudos[_i] = arguments[_i];
}
for (var _a = 0, pseudos_1 = pseudos; _a < pseudos_1.length; _a++) {
var pseudo = pseudos_1[_a];
this.pseudos[pseudo] = 'selector';
}
return this;
};
CssSelectorParser4.prototype.unregisterSelectorPseudos = function() {
var pseudos = [];
for (var _i = 0; _i < arguments.length; _i++) {
pseudos[_i] = arguments[_i];
}
for (var _a = 0, pseudos_2 = pseudos; _a < pseudos_2.length; _a++) {
var pseudo = pseudos_2[_a];
delete this.pseudos[pseudo];
}
return this;
};
CssSelectorParser4.prototype.registerNumericPseudos = function() {
var pseudos = [];
for (var _i = 0; _i < arguments.length; _i++) {
pseudos[_i] = arguments[_i];
}
for (var _a = 0, pseudos_3 = pseudos; _a < pseudos_3.length; _a++) {
var pseudo = pseudos_3[_a];
this.pseudos[pseudo] = 'numeric';
}
return this;
};
CssSelectorParser4.prototype.unregisterNumericPseudos = function() {
var pseudos = [];
for (var _i = 0; _i < arguments.length; _i++) {
pseudos[_i] = arguments[_i];
}
for (var _a = 0, pseudos_4 = pseudos; _a < pseudos_4.length; _a++) {
var pseudo = pseudos_4[_a];
delete this.pseudos[pseudo];
}
return this;
};
CssSelectorParser4.prototype.registerNestingOperators = function() {
var operators = [];
for (var _i = 0; _i < arguments.length; _i++) {
operators[_i] = arguments[_i];
}
for (var _a = 0, operators_1 = operators; _a < operators_1.length; _a++) {
var operator = operators_1[_a];
this.ruleNestingOperators[operator] = true;
}
return this;
};
CssSelectorParser4.prototype.unregisterNestingOperators = function() {
var operators = [];
for (var _i = 0; _i < arguments.length; _i++) {
operators[_i] = arguments[_i];
}
for (var _a = 0, operators_2 = operators; _a < operators_2.length; _a++) {
var operator = operators_2[_a];
delete this.ruleNestingOperators[operator];
}
return this;
};
CssSelectorParser4.prototype.registerAttrEqualityMods = function() {
var mods = [];
for (var _i = 0; _i < arguments.length; _i++) {
mods[_i] = arguments[_i];
}
for (var _a = 0, mods_1 = mods; _a < mods_1.length; _a++) {
var mod = mods_1[_a];
this.attrEqualityMods[mod] = true;
}
return this;
};
CssSelectorParser4.prototype.unregisterAttrEqualityMods = function() {
var mods = [];
for (var _i = 0; _i < arguments.length; _i++) {
mods[_i] = arguments[_i];
}
for (var _a = 0, mods_2 = mods; _a < mods_2.length; _a++) {
var mod = mods_2[_a];
delete this.attrEqualityMods[mod];
}
return this;
};
CssSelectorParser4.prototype.enableSubstitutes = function() {
this.substitutesEnabled = true;
return this;
};
CssSelectorParser4.prototype.disableSubstitutes = function() {
this.substitutesEnabled = false;
return this;
};
CssSelectorParser4.prototype.parse = function(str) {
return parser_context_1.parseCssSelector(str, 0, this.pseudos, this.attrEqualityMods, this.ruleNestingOperators, this.substitutesEnabled);
};
CssSelectorParser4.prototype.render = function(path) {
return render_1.renderEntity(path).trim();
};
return CssSelectorParser4;
}();
exports.CssSelectorParser = CssSelectorParser3;
});
var require_noop = __commonJS(function(exports, module) {
'use strict';
module.exports = function() {};
});
var require_is_value = __commonJS(function(exports, module) {
'use strict';
var _undefined = require_noop()();
module.exports = function(val) {
return val !== _undefined && val !== null;
};
});
var require_normalize_options = __commonJS(function(exports, module) {
'use strict';
var isValue = require_is_value();
var forEach = Array.prototype.forEach;
var create = Object.create;
var process2 = function process2(src, obj) {
var key;
for (key in src) {
obj[key] = src[key];
}
};
module.exports = function(opts1) {
var result = create(null);
forEach.call(arguments, function(options) {
if (!isValue(options)) {
return;
}
process2(Object(options), result);
});
return result;
};
});
var require_is_implemented = __commonJS(function(exports, module) {
'use strict';
module.exports = function() {
var sign = Math.sign;
if (typeof sign !== 'function') {
return false;
}
return sign(10) === 1 && sign(-20) === -1;
};
});
var require_shim = __commonJS(function(exports, module) {
'use strict';
module.exports = function(value) {
value = Number(value);
if (isNaN(value) || value === 0) {
return value;
}
return value > 0 ? 1 : -1;
};
});
var require_sign = __commonJS(function(exports, module) {
'use strict';
module.exports = require_is_implemented()() ? Math.sign : require_shim();
});
var require_to_integer = __commonJS(function(exports, module) {
'use strict';
var sign = require_sign();
var abs = Math.abs;
var floor = Math.floor;
module.exports = function(value) {
if (isNaN(value)) {
return 0;
}
value = Number(value);
if (value === 0 || !isFinite(value)) {
return value;
}
return sign(value) * floor(abs(value));
};
});
var require_to_pos_integer = __commonJS(function(exports, module) {
'use strict';
var toInteger = require_to_integer();
var max = Math.max;
module.exports = function(value) {
return max(0, toInteger(value));
};
});
var require_resolve_length = __commonJS(function(exports, module) {
'use strict';
var toPosInt = require_to_pos_integer();
module.exports = function(optsLength, fnLength, isAsync) {
var length;
if (isNaN(optsLength)) {
length = fnLength;
if (!(length >= 0)) {
return 1;
}
if (isAsync && length) {
return length - 1;
}
return length;
}
if (optsLength === false) {
return false;
}
return toPosInt(optsLength);
};
});
var require_valid_callable = __commonJS(function(exports, module) {
'use strict';
module.exports = function(fn) {
if (typeof fn !== 'function') {
throw new TypeError(fn + ' is not a function');
}
return fn;
};
});
var require_valid_value = __commonJS(function(exports, module) {
'use strict';
var isValue = require_is_value();
module.exports = function(value) {
if (!isValue(value)) {
throw new TypeError('Cannot use null or undefined');
}
return value;
};
});
var require_iterate = __commonJS(function(exports, module) {
'use strict';
var callable = require_valid_callable();
var value = require_valid_value();
var bind = Function.prototype.bind;
var call = Function.prototype.call;
var keys = Object.keys;
var objPropertyIsEnumerable = Object.prototype.propertyIsEnumerable;
module.exports = function(method, defVal) {
return function(obj, cb) {
var list, thisArg = arguments[2], compareFn = arguments[3];
obj = Object(value(obj));
callable(cb);
list = keys(obj);
if (compareFn) {
list.sort(typeof compareFn === 'function' ? bind.call(compareFn, obj) : void 0);
}
if (typeof method !== 'function') {
method = list[method];
}
return call.call(method, list, function(key, index) {
if (!objPropertyIsEnumerable.call(obj, key)) {
return defVal;
}
return call.call(cb, thisArg, obj[key], key, obj, index);
});
};
};
});
var require_for_each = __commonJS(function(exports, module) {
'use strict';
module.exports = require_iterate()('forEach');
});
var require_registered_extensions = __commonJS(function() {
'use strict';
});
var require_is_implemented2 = __commonJS(function(exports, module) {
'use strict';
module.exports = function() {
var assign = Object.assign, obj;
if (typeof assign !== 'function') {
return false;
}
obj = {
foo: 'raz'
};
assign(obj, {
bar: 'dwa'
}, {
trzy: 'trzy'
});
return obj.foo + obj.bar + obj.trzy === 'razdwatrzy';
};
});
var require_is_implemented3 = __commonJS(function(exports, module) {
'use strict';
module.exports = function() {
try {
Object.keys('primitive');
return true;
} catch (e) {
return false;
}
};
});
var require_shim2 = __commonJS(function(exports, module) {
'use strict';
var isValue = require_is_value();
var keys = Object.keys;
module.exports = function(object) {
return keys(isValue(object) ? Object(object) : object);
};
});
var require_keys = __commonJS(function(exports, module) {
'use strict';
module.exports = require_is_implemented3()() ? Object.keys : require_shim2();
});
var require_shim3 = __commonJS(function(exports, module) {
'use strict';
var keys = require_keys();
var value = require_valid_value();
var max = Math.max;
module.exports = function(dest, src) {
var error, i, length = max(arguments.length, 2), assign;
dest = Object(value(dest));
assign = function assign(key) {
try {
dest[key] = src[key];
} catch (e) {
if (!error) {
error = e;
}
}
};
for (i = 1; i < length; ++i) {
src = arguments[i];
keys(src).forEach(assign);
}
if (error !== void 0) {
throw error;
}
return dest;
};
});
var require_assign = __commonJS(function(exports, module) {
'use strict';
module.exports = require_is_implemented2()() ? Object.assign : require_shim3();
});
var require_is_object = __commonJS(function(exports, module) {
'use strict';
var isValue = require_is_value();
var map = {
function: true,
object: true
};
module.exports = function(value) {
return isValue(value) && map[_typeof(value)] || false;
};
});
var require_custom = __commonJS(function(exports, module) {
'use strict';
var assign = require_assign();
var isObject = require_is_object();
var isValue = require_is_value();
var captureStackTrace = Error.captureStackTrace;
module.exports = function(message) {
var err2 = new Error(message), code = arguments[1], ext = arguments[2];
if (!isValue(ext)) {
if (isObject(code)) {
ext = code;
code = null;
}
}
if (isValue(ext)) {
assign(err2, ext);
}
if (isValue(code)) {
err2.code = code;
}
if (captureStackTrace) {
captureStackTrace(err2, module.exports);
}
return err2;
};
});
var require_mixin = __commonJS(function(exports, module) {
'use strict';
var value = require_valid_value();
var defineProperty = Object.defineProperty;
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
var getOwnPropertyNames = Object.getOwnPropertyNames;
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
module.exports = function(target, source) {
var error, sourceObject = Object(value(source));
target = Object(value(target));
getOwnPropertyNames(sourceObject).forEach(function(name) {
try {
defineProperty(target, name, getOwnPropertyDescriptor(source, name));
} catch (e) {
error = e;
}
});
if (typeof getOwnPropertySymbols === 'function') {
getOwnPropertySymbols(sourceObject).forEach(function(symbol) {
try {
defineProperty(target, symbol, getOwnPropertyDescriptor(source, symbol));
} catch (e) {
error = e;
}
});
}
if (error !== void 0) {
throw error;
}
return target;
};
});
var require_define_length = __commonJS(function(exports, module) {
'use strict';
var toPosInt = require_to_pos_integer();
var test = function test(arg1, arg2) {
return arg2;
};
var desc;
var defineProperty;
var generate;
var mixin;
try {
Object.defineProperty(test, 'length', {
configurable: true,
writable: false,
enumerable: false,
value: 1
});
} catch (ignore) {}
if (test.length === 1) {
desc = {
configurable: true,
writable: false,
enumerable: false
};
defineProperty = Object.defineProperty;
module.exports = function(fn, length) {
length = toPosInt(length);
if (fn.length === length) {
return fn;
}
desc.value = length;
return defineProperty(fn, 'length', desc);
};
} else {
mixin = require_mixin();
generate = function() {
var cache20 = [];
return function(length) {
var args, i = 0;
if (cache20[length]) {
return cache20[length];
}
args = [];
while (length--) {
args.push('a' + (++i).toString(36));
}
return new Function('fn', 'return function (' + args.join(', ') + ') { return fn.apply(this, arguments); };');
};
}();
module.exports = function(src, length) {
var target;
length = toPosInt(length);
if (src.length === length) {
return src;
}
target = generate(length)(src);
try {
mixin(target, src);
} catch (ignore) {}
return target;
};
}
});
var require_is = __commonJS(function(exports, module) {
'use strict';
var _undefined = void 0;
module.exports = function(value) {
return value !== _undefined && value !== null;
};
});
var require_is2 = __commonJS(function(exports, module) {
'use strict';
var isValue = require_is();
var possibleTypes = {
object: true,
function: true,
undefined: true
};
module.exports = function(value) {
if (!isValue(value)) {
return false;
}
return hasOwnProperty.call(possibleTypes, _typeof(value));
};
});
var require_is3 = __commonJS(function(exports, module) {
'use strict';
var isObject = require_is2();
module.exports = function(value) {
if (!isObject(value)) {
return false;
}
try {
if (!value.constructor) {
return false;
}
return value.constructor.prototype === value;
} catch (error) {
return false;
}
};
});
var require_is4 = __commonJS(function(exports, module) {
'use strict';
var isPrototype = require_is3();
module.exports = function(value) {
if (typeof value !== 'function') {
return false;
}
if (!hasOwnProperty.call(value, 'length')) {
return false;
}
try {
if (typeof value.length !== 'number') {
return false;
}
if (typeof value.call !== 'function') {
return false;
}
if (typeof value.apply !== 'function') {
return false;
}
} catch (error) {
return false;
}
return !isPrototype(value);
};
});
var require_is5 = __commonJS(function(exports, module) {
'use strict';
var isFunction = require_is4();
var classRe = /^\s*class[\s{/}]/;
var functionToString = Function.prototype.toString;
module.exports = function(value) {
if (!isFunction(value)) {
return false;
}
if (classRe.test(functionToString.call(value))) {
return false;
}
return true;
};
});
var require_is_implemented4 = __commonJS(function(exports, module) {
'use strict';
var str = 'razdwatrzy';
module.exports = function() {
if (typeof str.contains !== 'function') {
return false;
}
return str.contains('dwa') === true && str.contains('foo') === false;
};
});
var require_shim4 = __commonJS(function(exports, module) {
'use strict';
var indexOf = String.prototype.indexOf;
module.exports = function(searchString) {
return indexOf.call(this, searchString, arguments[1]) > -1;
};
});
var require_contains = __commonJS(function(exports, module) {
'use strict';
module.exports = require_is_implemented4()() ? String.prototype.contains : require_shim4();
});
var require_d = __commonJS(function(exports, module) {
'use strict';
var isValue = require_is();
var isPlainFunction = require_is5();
var assign = require_assign();
var normalizeOpts = require_normalize_options();
var contains6 = require_contains();
var d = module.exports = function(dscr, value) {
var c, e, w, options, desc;
if (arguments.length < 2 || typeof dscr !== 'string') {
options = value;
value = dscr;
dscr = null;
} else {
options = arguments[2];
}
if (isValue(dscr)) {
c = contains6.call(dscr, 'c');
e = contains6.call(dscr, 'e');
w = contains6.call(dscr, 'w');
} else {
c = w = true;
e = false;
}
desc = {
value: value,
configurable: c,
enumerable: e,
writable: w
};
return !options ? desc : assign(normalizeOpts(options), desc);
};
d.gs = function(dscr, get, set) {
var c, e, options, desc;
if (typeof dscr !== 'string') {
options = set;
set = get;