fast_axecore
Version:
A high performance rewrite of axecore
1,485 lines (1,479 loc) • 859 kB
JavaScript
/*! axe v4.6.35
* Copyright (c) 2024 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;
var axe = axe || {};
axe.version = '4.6.35';
if (typeof define === 'function' && define.amd) {
define('axe-core', [], () => axe);
}
if (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;
}
function SupportError(error) {
this.name = 'SupportError';
this.cause = error.cause;
this.message = `\`${error.cause}\` - feature unsupported in your environment.`;
if (error.ruleId) {
this.ruleId = error.ruleId;
this.message += ` Skipping ${this.ruleId} rule.`;
}
this.stack = new Error().stack;
}
SupportError.prototype = Object.create(Error.prototype);
SupportError.prototype.constructor = SupportError;
(() => {
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = {
exports: {}
}).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all) {
__defProp(target, name, {
get: all[name],
enumerable: true
});
}
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === 'object' || typeof from === 'function') {
for (let key of __getOwnPropNames(from)) {
if (!__hasOwnProp.call(to, key) && key !== except) {
__defProp(to, key, {
get: () => from[key],
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
});
}
}
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {},
__copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, 'default', {
value: mod,
enumerable: true
}) : target, mod));
var require_utils = __commonJS({
'../node_modules/css-selector-parser/lib/utils.js'(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({
'../node_modules/css-selector-parser/lib/parser-context.js'(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 rule = 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 = parseRule();
if (!rule) {
throw Error('Rule expected after "' + op + '".');
}
rule.nestingOperator = op;
} else {
rule = parseRule();
if (rule) {
rule.nestingOperator = null;
}
}
}
return selector;
}
function parseRule() {
var rule = null;
while (pos < l) {
chr = str.charAt(pos);
if (chr === '*') {
pos++;
(rule = rule || {}).tagName = '*';
} else if (utils_1.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('"', 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;
}
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 = 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;
}
rule = rule || {};
(rule.pseudos = rule.pseudos || []).push(pseudo);
} else {
break;
}
}
return rule;
}
return parse2();
}
exports.parseCssSelector = parseCssSelector;
}
});
var require_render = __commonJS({
'../node_modules/css-selector-parser/lib/render.js'(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({
'../node_modules/css-selector-parser/lib/index.js'(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({
'../node_modules/es5-ext/function/noop.js'(exports, module) {
'use strict';
module.exports = function() {};
}
});
var require_is_value = __commonJS({
'../node_modules/es5-ext/object/is-value.js'(exports, module) {
'use strict';
var _undefined = require_noop()();
module.exports = function(val) {
return val !== _undefined && val !== null;
};
}
});
var require_normalize_options = __commonJS({
'../node_modules/es5-ext/object/normalize-options.js'(exports, module) {
'use strict';
var isValue = require_is_value();
var forEach = Array.prototype.forEach;
var create = Object.create;
var process2 = function(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({
'../node_modules/es5-ext/math/sign/is-implemented.js'(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({
'../node_modules/es5-ext/math/sign/shim.js'(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({
'../node_modules/es5-ext/math/sign/index.js'(exports, module) {
'use strict';
module.exports = require_is_implemented()() ? Math.sign : require_shim();
}
});
var require_to_integer = __commonJS({
'../node_modules/es5-ext/number/to-integer.js'(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({
'../node_modules/es5-ext/number/to-pos-integer.js'(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({
'../node_modules/memoizee/lib/resolve-length.js'(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({
'../node_modules/es5-ext/object/valid-callable.js'(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({
'../node_modules/es5-ext/object/valid-value.js'(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({
'../node_modules/es5-ext/object/_iterate.js'(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({
'../node_modules/es5-ext/object/for-each.js'(exports, module) {
'use strict';
module.exports = require_iterate()('forEach');
}
});
var require_registered_extensions = __commonJS({
'../node_modules/memoizee/lib/registered-extensions.js'() {
'use strict';
}
});
var require_is_implemented2 = __commonJS({
'../node_modules/es5-ext/object/assign/is-implemented.js'(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({
'../node_modules/es5-ext/object/keys/is-implemented.js'(exports, module) {
'use strict';
module.exports = function() {
try {
Object.keys('primitive');
return true;
} catch (e) {
return false;
}
};
}
});
var require_shim2 = __commonJS({
'../node_modules/es5-ext/object/keys/shim.js'(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({
'../node_modules/es5-ext/object/keys/index.js'(exports, module) {
'use strict';
module.exports = require_is_implemented3()() ? Object.keys : require_shim2();
}
});
var require_shim3 = __commonJS({
'../node_modules/es5-ext/object/assign/shim.js'(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(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({
'../node_modules/es5-ext/object/assign/index.js'(exports, module) {
'use strict';
module.exports = require_is_implemented2()() ? Object.assign : require_shim3();
}
});
var require_is_object = __commonJS({
'../node_modules/es5-ext/object/is-object.js'(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({
'../node_modules/es5-ext/error/custom.js'(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({
'../node_modules/es5-ext/object/mixin.js'(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({
'../node_modules/es5-ext/function/_define-length.js'(exports, module) {
'use strict';
var toPosInt = require_to_pos_integer();
var test = function(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 cache2 = [];
return function(length) {
var args, i = 0;
if (cache2[length]) {
return cache2[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({
'../node_modules/type/value/is.js'(exports, module) {
'use strict';
var _undefined = void 0;
module.exports = function(value) {
return value !== _undefined && value !== null;
};
}
});
var require_is2 = __commonJS({
'../node_modules/type/object/is.js'(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({
'../node_modules/type/prototype/is.js'(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({
'../node_modules/type/function/is.js'(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({
'../node_modules/type/plain-function/is.js'(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({
'../node_modules/es5-ext/string/#/contains/is-implemented.js'(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({
'../node_modules/es5-ext/string/#/contains/shim.js'(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({
'../node_modules/es5-ext/string/#/contains/index.js'(exports, module) {
'use strict';
module.exports = require_is_implemented4()() ? String.prototype.contains : require_shim4();
}
});
var require_d = __commonJS({
'../node_modules/d/index.js'(exports, module) {
'use strict';
var isValue = require_is();
var isPlainFunction = require_is5();
var assign = require_assign();
var normalizeOpts = require_normalize_options();
var contains3 = 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 = contains3.call(dscr, 'c');
e = contains3.call(dscr, 'e');
w = contains3.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;
get = dscr;
dscr = null;
} else {
options = arguments[3];
}
if (!isValue(get)) {
get = void 0;
} else if (!isPlainFunction(get)) {
options = get;
get = set = void 0;
} else if (!isValue(set)) {
set = void 0;
} else if (!isPlainFunction(set)) {
options = set;
set = void 0;
}
if (isValue(dscr)) {
c = contains3.call(dscr, 'c');
e = contains3.call(dscr, 'e');
} else {
c = true;
e = false;
}
desc = {
get: get,
set: set,
configurable: c,
enumerable: e
};
return !options ? desc : assign(normalizeOpts(options), desc);
};
}
});
var require_event_emitter = __commonJS({
'../node_modules/event-emitter/index.js'(exports, module) {
'use strict';
var d = require_d();
var callable = require_valid_callable();
var apply = Function.prototype.apply;
var call = Function.prototype.call;
var create = Object.create;
var defineProperty = Object.defineProperty;
var defineProperties = Object.defineProperties;
var hasOwnProperty2 = Object.prototype.hasOwnProperty;
var descriptor = {
configurable: true,
enumerable: false,
writable: true
};
var on;
var once;
var off;
var emit;
var methods;
var descriptors;
var base;
on = function(type, listener) {
var data2;
callable(listener);
if (!hasOwnProperty2.call(this, '__ee__')) {
data2 = descriptor.value = create(null);
defineProperty(this, '__ee__', descriptor);
descriptor.value = null;
} else {
data2 = this.__ee__;
}
if (!data2[type]) {
data2[type] = listener;
} else if (typeof data2[type] === 'object') {
data2[type].push(listener);
} else {
data2[type] = [ data2[type], listener ];
}
return this;
};
once = function(type, listener) {
var once2, self2;
callable(listener);
self2 = this;
on.call(this, type, once2 = function() {
off.call(self2, type, once2);
apply.call(listener, this, arguments);
});
once2.__eeOnceListener__ = listener;
return this;
};
off = function(type, listener) {
var data2, listeners, candidate, i;
callable(listener);
if (!hasOwnProperty2.call(this, '__ee__')) {
return this;
}
data2 = this.__ee__;
if (!data2[type]) {
return this;
}
listeners = data2[type];
if (typeof listeners === 'object') {
for (i = 0; candidate = listeners[i]; ++i) {
if (candidate === listener || candidate.__eeOnceListener__ === listener) {
if (listeners.length === 2) {
data2[type] = listeners[i ? 0 : 1];
} else {
listeners.splice(i, 1);
}
}
}
} else {
if (listeners === listener || listeners.__eeOnceListener__ === listener) {
delete data2[type];
}
}
return this;
};
emit = function(type) {
var i, l, listener, listeners, args;
if (!hasOwnProperty2.call(this, '__ee__')) {
return;
}
listeners = this.__ee__[type];
if (!listeners) {
return;
}
if (typeof listeners === 'object') {
l = arguments.length;
args = new Array(l - 1);
for (i = 1; i < l; ++i) {
args[i - 1] = arguments[i];
}
listeners = listeners.slice();
for (i = 0; listener = listeners[i]; ++i) {
apply.call(listener, this, args);
}
} else {
switch (arguments.length) {
case 1:
call.call(listeners, this);
break;
case 2:
call.call(listeners, this, arguments[1]);
break;
case 3:
call.call(listeners, this, arguments[1], arguments[2]);
break;
default:
l = arguments.length;
args = new Array(l - 1);
for (i = 1; i < l; ++i) {
args[i - 1] = arguments[i];
}
apply.call(listeners, this, args);
}
}
};
methods = {
on: on,
once: once,
off: off,
emit: emit
};
descriptors = {
on: d(on),
once: d(once),
off: d(off),
emit: d(emit)
};
base = defineProperties({}, descriptors);
module.exports = exports = function(o) {
return o == null ? create(base) : defineProperties(Object(o), descriptors);
};
exports.methods = methods;
}
});
var require_is_implemented5 = __commonJS({
'../node_modules/es5-ext/array/from/is-implemented.js'(exports, module) {
'use strict';
module.exports = function() {
var from = Array.from, arr, result;
if (typeof from !== 'function') {
return false;
}
arr = [ 'raz', 'dwa' ];
result = from(arr);
return Boolean(result && result !== arr && result[1] === 'dwa');
};
}
});
var require_is_implemented6 = __commonJS({
'../node_modules/ext/global-this/is-implemented.js'(exports, module) {
'use strict';
module.exports = function() {
if (typeof globalThis !== 'object') {
return false;
}
if (!globalThis) {
return false;
}
return globalThis.Array === Array;
};
}
});
var require_implementation = __commonJS({
'../node_modules/ext/global-this/implementation.js'(exports, module) {
var naiveFallback = function() {
if (typeof self === 'object' && self) {
return self;
}
if (typeof window === 'object' && window) {
return window;
}
throw new Error('Unable to resolve global `this`');
};
module.exports =