donobu
Version:
Create browser automations with an LLM agent and replay them as Playwright scripts.
1,732 lines (1,728 loc) • 1.41 MB
JavaScript
/*! axe v4.10.0
* Copyright (c) 2015 - 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;
('use strict');
function _typeof(o) {
'@babel/helpers - typeof';
return (
(_typeof =
'function' == typeof Symbol && 'symbol' == typeof Symbol.iterator
? function (o) {
return typeof o;
}
: function (o) {
return o &&
'function' == typeof Symbol &&
o.constructor === Symbol &&
o !== Symbol.prototype
? 'symbol'
: typeof o;
}),
_typeof(o)
);
}
var axe = axe || {};
axe.version = '4.10.0';
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 = ['node'],
_excluded2 = ['relatedNodes'],
_excluded3 = ['node'],
_excluded4 = ['variant'],
_excluded5 = ['matches'],
_excluded6 = ['chromium'],
_excluded7 = ['noImplicit'],
_excluded8 = ['noPresentational'],
_excluded9 = ['precision', 'format', 'inGamut'],
_excluded10 = ['space'],
_excluded11 = ['algorithm'],
_excluded12 = ['method'],
_excluded13 = ['maxDeltaE', 'deltaEMethod', 'steps', 'maxSteps'],
_excluded14 = ['node'],
_excluded15 = ['environmentData'],
_excluded16 = ['environmentData'],
_excluded17 = ['environmentData'],
_excluded18 = ['environmentData'],
_excluded19 = ['environmentData'];
function _toArray(r) {
return (
_arrayWithHoles(r) ||
_iterableToArray(r) ||
_unsupportedIterableToArray(r) ||
_nonIterableRest()
);
}
function _defineProperty(e, r, t) {
return (
(r = _toPropertyKey(r)) in e
? Object.defineProperty(e, r, {
value: t,
enumerable: !0,
configurable: !0,
writable: !0,
})
: (e[r] = t),
e
);
}
function _construct(t, e, r) {
if (_isNativeReflectConstruct()) {
return Reflect.construct.apply(null, arguments);
}
var o = [null];
o.push.apply(o, e);
var p = new (t.bind.apply(t, o))();
return r && _setPrototypeOf(p, r.prototype), p;
}
function _callSuper(t, o, e) {
return (
(o = _getPrototypeOf(o)),
_possibleConstructorReturn(
t,
_isNativeReflectConstruct()
? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor)
: o.apply(t, e),
)
);
}
function _possibleConstructorReturn(t, e) {
if (e && ('object' == _typeof(e) || 'function' == typeof e)) {
return e;
}
if (void 0 !== e) {
throw new TypeError(
'Derived constructors may only return object or undefined',
);
}
return _assertThisInitialized(t);
}
function _assertThisInitialized(e) {
if (void 0 === e) {
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
}
return e;
}
function _isNativeReflectConstruct() {
try {
var t = !Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
);
} catch (t) {}
return (_isNativeReflectConstruct = function _isNativeReflectConstruct() {
return !!t;
})();
}
function _getPrototypeOf(t) {
return (
(_getPrototypeOf = Object.setPrototypeOf
? Object.getPrototypeOf.bind()
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
}),
_getPrototypeOf(t)
);
}
function _inherits(t, e) {
if ('function' != typeof e && null !== e) {
throw new TypeError('Super expression must either be null or a function');
}
(t.prototype = Object.create(e && e.prototype, {
constructor: {
value: t,
writable: !0,
configurable: !0,
},
})),
Object.defineProperty(t, 'prototype', {
writable: !1,
}),
e && _setPrototypeOf(t, e);
}
function _setPrototypeOf(t, e) {
return (
(_setPrototypeOf = Object.setPrototypeOf
? Object.setPrototypeOf.bind()
: function (t, e) {
return (t.__proto__ = e), t;
}),
_setPrototypeOf(t, e)
);
}
function _classPrivateFieldInitSpec(e, t, a) {
_checkPrivateRedeclaration(e, t), t.set(e, a);
}
function _classPrivateMethodInitSpec(e, a) {
_checkPrivateRedeclaration(e, a), a.add(e);
}
function _checkPrivateRedeclaration(e, t) {
if (t.has(e)) {
throw new TypeError(
'Cannot initialize the same private elements twice on an object',
);
}
}
function _classPrivateFieldGet(s, a) {
return s.get(_assertClassBrand(s, a));
}
function _classPrivateFieldSet(s, a, r) {
return s.set(_assertClassBrand(s, a), r), r;
}
function _assertClassBrand(e, t, n) {
if ('function' == typeof e ? e === t : e.has(t)) {
return arguments.length < 3 ? t : n;
}
throw new TypeError('Private element is not present on this object');
}
function _objectWithoutProperties(e, t) {
if (null == e) {
return {};
}
var o,
r,
i = _objectWithoutPropertiesLoose(e, t);
if (Object.getOwnPropertySymbols) {
var n = Object.getOwnPropertySymbols(e);
for (r = 0; r < n.length; r++) {
(o = n[r]),
t.indexOf(o) >= 0 ||
({}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]));
}
}
return i;
}
function _objectWithoutPropertiesLoose(r, e) {
if (null == r) {
return {};
}
var t = {};
for (var n in r) {
if ({}.hasOwnProperty.call(r, n)) {
if (e.indexOf(n) >= 0) {
continue;
}
t[n] = r[n];
}
}
return t;
}
function _toConsumableArray(r) {
return (
_arrayWithoutHoles(r) ||
_iterableToArray(r) ||
_unsupportedIterableToArray(r) ||
_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(r) {
if (
('undefined' != typeof Symbol && null != r[Symbol.iterator]) ||
null != r['@@iterator']
) {
return Array.from(r);
}
}
function _arrayWithoutHoles(r) {
if (Array.isArray(r)) {
return _arrayLikeToArray(r);
}
}
function _extends() {
return (
(_extends = Object.assign
? Object.assign.bind()
: function (n) {
for (var e = 1; e < arguments.length; e++) {
var t = arguments[e];
for (var r in t) {
({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
}
}
return n;
}),
_extends.apply(null, arguments)
);
}
function _slicedToArray(r, e) {
return (
_arrayWithHoles(r) ||
_iterableToArrayLimit(r, e) ||
_unsupportedIterableToArray(r, e) ||
_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(r, l) {
var t =
null == r
? null
: ('undefined' != typeof Symbol && r[Symbol.iterator]) ||
r['@@iterator'];
if (null != t) {
var e,
n,
i,
u,
a = [],
f = !0,
o = !1;
try {
if (((i = (t = t.call(r)).next), 0 === l)) {
if (Object(t) !== t) {
return;
}
f = !1;
} else {
for (
;
!(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l);
f = !0
) {}
}
} catch (r) {
(o = !0), (n = r);
} finally {
try {
if (
!f &&
null != t['return'] &&
((u = t['return']()), Object(u) !== u)
) {
return;
}
} finally {
if (o) {
throw n;
}
}
}
return a;
}
}
function _arrayWithHoles(r) {
if (Array.isArray(r)) {
return r;
}
}
function _classCallCheck(a, n) {
if (!(a instanceof n)) {
throw new TypeError('Cannot call a class as a function');
}
}
function _defineProperties(e, r) {
for (var t = 0; t < r.length; t++) {
var o = r[t];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
'value' in o && (o.writable = !0),
Object.defineProperty(e, _toPropertyKey(o.key), o);
}
}
function _createClass(e, r, t) {
return (
r && _defineProperties(e.prototype, r),
t && _defineProperties(e, t),
Object.defineProperty(e, 'prototype', {
writable: !1,
}),
e
);
}
function _toPropertyKey(t) {
var i = _toPrimitive(t, 'string');
return 'symbol' == _typeof(i) ? i : i + '';
}
function _toPrimitive(t, r) {
if ('object' != _typeof(t) || !t) {
return t;
}
var e = t[Symbol.toPrimitive];
if (void 0 !== e) {
var i = e.call(t, r || 'default');
if ('object' != _typeof(i)) {
return i;
}
throw new TypeError('@@toPrimitive must return a primitive value.');
}
return ('string' === r ? String : Number)(t);
}
function _createForOfIteratorHelper(r, e) {
var t =
('undefined' != typeof Symbol && r[Symbol.iterator]) || r['@@iterator'];
if (!t) {
if (
Array.isArray(r) ||
(t = _unsupportedIterableToArray(r)) ||
(e && r && 'number' == typeof r.length)
) {
t && (r = t);
var _n = 0,
F = function F() {};
return {
s: F,
n: function n() {
return _n >= r.length
? {
done: !0,
}
: {
done: !1,
value: r[_n++],
};
},
e: function e(r) {
throw r;
},
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 o,
a = !0,
u = !1;
return {
s: function s() {
t = t.call(r);
},
n: function n() {
var r = t.next();
return (a = r.done), r;
},
e: function e(r) {
(u = !0), (o = r);
},
f: function f() {
try {
a || null == t['return'] || t['return']();
} finally {
if (u) {
throw o;
}
}
},
};
}
function _unsupportedIterableToArray(r, a) {
if (r) {
if ('string' == typeof r) {
return _arrayLikeToArray(r, a);
}
var t = {}.toString.call(r).slice(8, -1);
return (
'Object' === t && r.constructor && (t = r.constructor.name),
'Map' === t || 'Set' === t
? Array.from(r)
: 'Arguments' === t ||
/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)
? _arrayLikeToArray(r, a)
: void 0
);
}
}
function _arrayLikeToArray(r, a) {
(null == a || a > r.length) && (a = r.length);
for (var e = 0, n = Array(a); e < a; e++) {
n[e] = r[e];
}
return n;
}
function _typeof(o) {
'@babel/helpers - typeof';
return (
(_typeof =
'function' == typeof Symbol && 'symbol' == typeof Symbol.iterator
? function (o) {
return typeof o;
}
: function (o) {
return o &&
'function' == typeof Symbol &&
o.constructor === Symbol &&
o !== Symbol.prototype
? 'symbol'
: typeof o;
}),
_typeof(o)
);
}
(function (
_Class_brand,
_path,
_CSS,
_space,
_r,
_g,
_b,
_red,
_green,
_blue,
_Class3_brand,
) {
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 __defNormalProp = function __defNormalProp(obj, key, value) {
return key in obj
? __defProp(obj, key, {
enumerable: true,
configurable: true,
writable: true,
value: value,
})
: (obj[key] = value);
};
var __markAsModule = function __markAsModule(target) {
return __defProp(target, '__esModule', {
value: true,
});
};
var __commonJS = function __commonJS(cb, mod) {
return function () {
return (
mod ||
cb(
(mod = {
exports: {},
}).exports,
mod,
),
mod.exports
);
};
};
var __export = function __export(target, all) {
for (var name in all) {
__defProp(target, name, {
get: all[name],
enumerable: true,
});
}
};
var __exportStar = function __exportStar(target, module, desc) {
if (
(module && _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) {
return __exportStar(
__markAsModule(
__defProp(
module != null ? __create(__getProtoOf(module)) : {},
'default',
module && module.__esModule && 'default' in module
? {
get: function get() {
return module['default'];
},
enumerable: true,
}
: {
value: module,
enumerable: true,
},
),
),
module,
);
};
var __publicField = function __publicField(obj, key, value) {
__defNormalProp(obj, _typeof(key) !== 'symbol' ? key + '' : key, value);
return value;
};
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 max2 = Math.max;
module.exports = function (value) {
return max2(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 max2 = Math.max;
module.exports = function (dest, src) {
var error,
i,
length = max2(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 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(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 contains3 = require_contains();
var d2 = (module.exports = function (dscr, value) {
var c4, e, w, options, desc;
if (arguments.length < 2 || typeof dscr !== 'string') {
options = value;
value = dscr;
dscr = null;
} else {
options = arguments[2];
}
if (isValue(dscr)) {
c4 = contains3.call(dscr, 'c');
e = contains3.call(dscr, 'e');
w = contains3.call(dscr, 'w');
} else {
c4 = w = true;
e = false;
}
desc = {
value: value,
configurable: c4,
enumerable: e,
writable: w,
};
return !options ? desc : assign(normalizeOpts(options), desc);
});
d2.gs = function (dscr, get2, set2) {
var c4, e, options, desc;
if (typeof dscr !== 'string') {
options = set2;
set2 = get2;
get2 = dscr;
dscr = null;
} else {
options = arguments[3];
}
if (!isValue(get2)) {
get2 = void 0;
} else if (!isPlainFunction(get2)) {
options = get2;
get2 = set2 = void 0;
} else if (!isValue(set2)) {
set2 = void 0;
} else if (!isPlainFunction(set2)) {
options = set2;
set2 = void 0;
}
if (isValue(dscr)) {
c4 = contains3.call(dscr, 'c');
e = contains3.call(dscr, 'e');
} else {
c4 = true;
e = false;
}
desc = {
get: get2,
set: set2,
configurable: c4,
enumerable: e,
};
return !options ? desc : assign(normalizeOpts(options), desc);
};
});
var require_event_emitter = __commonJS(function (exports, module) {
'use strict';
var d2 = 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 on(type2, listener) {
var data;
callable(listener);
if (!hasOwnProperty2.call(this, '__ee__')) {
data = descriptor.value = create(null);
defineProperty(this, '__ee__', descriptor);
descriptor.value = null;
} else {
data = this.__ee__;
}
if (!data[type2]) {
data[type2] = listener;
} else if (_typeof(data[type2]) === 'object') {
data[type2].push(listener);
} else {
data[type2] = [data[type2], listener];
}
return this;
};
once = function once(type2, listener) {
var _once, self2;
callable(listener);
self2 = this;
on.call(
this,
type2,
(_once = function once2() {
off.call(self2, type2, _once);
apply.call(listener, this, arguments);
}),
);
_once.__eeOnceListener__ = listener;
return this;
};
off = function off(type2, listener) {
var data, listeners, candidate, i;
callable(listener);
if (!hasOwnProperty2.call(this, '__ee__')) {
return this;
}
data = this.__ee__;
if (!data[type2]) {
return this;
}
listeners = data[type2];
if (_typeof(listeners) === 'object') {
for (i = 0; (candidate = listeners[i]); ++i) {
if (
candidate === listener ||
candidate.__eeOnceListener__ === listener
) {
if (listeners.length === 2) {
data[type2] = listeners[i ? 0 : 1];
} else {
listeners.splice(i, 1);
}
}
}
} else {
if (
listeners === listener ||
listeners.__eeOnceListener__ === listener
) {
delete data[type2];
}
}
return this;
};
emit = function emit(type2) {
var i, l, listener, listeners, args;
if (!hasOwnProperty2.call(this, '__ee__')) {
return;
}
listeners = this.__ee__[type2];
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: d2(on),
once: d2(once),
off: d2(off),
emit: d2(emit),
};
base = defineProperties({}, descriptors);
module.exports = exports = function exports(o) {
return o == null
? create(base)
: defineProperties(Object(o), descriptors);
};
exports.methods = methods;
});
var require_is_implemented5 = __commonJS(function (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(function (exports, module) {
'use strict';
module.exports = function () {
if (
(typeof globalThis === 'undefined'
? 'undefined'
: _typeof(globalThis)) !== 'object'
) {
return false;
}
if (!globalThis) {
return false;
}
return globalThis.Array === Array;
};
});
var require_implementation = __commonJS(function (exports, module) {
var naiveFallback = function naiveFallback() {
if (
(typeof self === 'undefined' ? 'undefined' : _typeof(self)) ===
'object' &&
self
) {
return self;
}
if (
(typeof window === 'undefined' ? 'undefined' : _typeof(window)) ===
'object' &&
window
) {
return window;
}
throw new Error('Unable to resolve global `this`');
};
module.exports = (function () {
if (this) {
return this;
}
try {
Object.defineProperty(Object.prototype, '__global__', {
get: function get() {
return this;
},
configurable: true,
});
} catch (error) {
return naiveFallback();
}
try {
if (!__global__) {
return naiveFallback();
}
return __global__;
} finally {
delete Object.prototype.__global__;
}
})();
});
var require_global_this = __commonJS(function (exports, module) {
'use strict';
module.exports = require_is_implemented6()()
? globalThis
: require_implementation();
});
var require_is_implemented7 = __commonJS(function (exports, module) {
'use strict';
var global2 = require_global_this();
var validTypes = {
object: true,
symbol: true,
};
module.exports = function () {
var Symbol2 = global2.Symbol;
var symbol;
if (typeof Symbol2 !== 'function') {
return false;
}
symbol = Symbol2('test symbol');
try {
String(symbol);
} catch (e) {
return false;
}
if (!validTypes[_typeof(Symbol2.iterator)]) {
return false;
}
if (!validTypes[_typeof(Symbol2.toPrimitive)]) {
return false;
}
if (!validTypes[_typeof(Symbol2.toStringTag)]) {
return false;
}
return true;
};
});
var require_is_symbol = __commonJS(function (exports, module) {
'use strict';
module.exports = function (value) {
if (!value) {
return false;
}
if (_typeof(value) === 'symbol') {
return true;
}
if (!value.constructor) {
return false;
}
if (value.constructor.name !== 'Symbol') {
return false;
}
return value[value.constructor.toStringTag] === 'Symbol';
};
});
var require_validate_symbol = __commonJS(function (exports, module) {
'use strict';
var isSymbol = require_is_symbol();
module.exports = function (value) {
if (!isSymbol(value)) {
throw new TypeError(value + ' is not a symbol');
}
return value;
};
});
var require_generate_name = __commonJS(function (exports, module) {
'use strict';
var d2 = require_d();
var create = Object.create;
var defineProperty = Object.defineProperty;
var objPrototype = Object.prototype;
var created = create(null);
module.exports = function (desc) {
var postfix = 0,
name,
ie11BugWorkaround;
while (created[desc + (postfix || '')]) {
++postfix;
}
desc += postfix || '';
created[desc] = true;
name = '@@' + desc;
defineProperty(
objPrototype,
name,
d2.gs(null, function (value) {
if (ie11BugWorkaround) {
return;
}
ie11BugWorkaround = true;
defineProperty(this, name, d2(value));
ie11BugWorkaround = false;
}),
);
return name;
};
});
var require_standard_symbols = __commonJS(function (exports, module) {
'use strict';
var d2 = require_d();
var NativeSymbol = require_global_this().Symbol;
module.exports = function (SymbolPolyfill) {
return Object.defineProperties(SymbolPolyfill, {
hasInstance: d2(
'',
(NativeSymbol && NativeSymbol.hasInstance) ||
SymbolPolyfill('hasInstance'),
),
isConcatSpreadable: d2(
'',
(NativeSymbol && NativeSymbol.isConcatSpreadable) ||
SymbolPolyfill('isConcatSpreadable'),
),
iterator: d2(
'',
(NativeSymbol && NativeSymbol.iterator) ||
SymbolPolyfill('iterator'),
),
match: d2(
'',
(NativeSymbol && NativeSymbol.match) || SymbolPolyfill('match'),
),
replace: d2(
'',
(NativeSymbol && NativeSymbol.replace) || SymbolPolyfill('replace'),
),
search: d2(
'',
(NativeSymbol && NativeSymbol.search) || SymbolPolyfill('search'),
),
species: d2(
'',
(NativeSymbol && NativeSymbol.species) || SymbolPolyfill('species'),
),
split: d2(
'',
(NativeSymbol && NativeSymbol.split) || SymbolPolyfill('split'),
),
toPrimitive: d2(
'',
(NativeSymbol && NativeSymbol.toPrimitive) ||
SymbolPolyfill('toPrimitive'),
),
toStringTag: d2(
'',
(NativeSymbol && NativeSymbol.toStringTag) ||
SymbolPolyfill('toStringTag'),
),
unscopables: d2(
'',
(NativeSymbol && NativeSymbol.unscopables) ||
SymbolPolyfill('unscopables'),
),
});
};
});
var require_symbol_registry = __commonJS(function (exports, module) {
'use strict';
var d2 = require_d();
var validateSymbol = require_validate_symbol();
var registry = Object.create(null);
module.exports = function (SymbolPolyfill) {
return Object.defineProperties(SymbolPolyfill, {
for: d2(function (key) {
if (registry[key]) {
return registry[key];
}
return (registry[key] = SymbolPolyfill(String(key)));
}),
keyFor: d2(function (symbol) {
var key;
validateSymbol(symbol);
for (key in registry) {
if (registry[key] === symbol) {
return key;
}
}
return void 0;
}),
});
};
});
var require_polyfill = __commonJS(function (exports, module) {
'use strict';
var d2 = require_d();
var validateSymbol = require_validate_symbol();
var NativeSymbol = require_global_this().Symbol;
var generateName = require_generate_name();
var setupStandardSymbols = require_standard_symbols();
var setupSymbolRegistry = require_symbol_registry();
var create = Object.create;
var defineProperties = Object.defineProperties;
var defineProperty = Object.defineProperty;
var SymbolPolyfill;
var HiddenSymbol;
var isNativeSafe;
if (typeof NativeSymbol === 'function') {
try {
String(NativeSymbol());
isNativeSafe = true;
} catch (ignore) {}
} else {
NativeSymbol = null;
}
HiddenSymbol = function Symbol2(description) {
if (this instanceof HiddenSymbol) {
throw new TypeError('Symbol is not a constructor');
}
return SymbolPolyfill(description);
};
module.exports = SymbolPolyfill = function Symbol2(description) {
var symbol;
if (this instanceof Symbol2) {
throw new TypeError('Symbol is not a constructor');
}
if (isNativeSafe) {
return NativeSymbol(description);
}
symbol = create(HiddenSymbol.prototype);
description = description === void 0 ? '' : String(description);
return defineProperties(symbol, {
__description__: d2('', description),
__name__: d2('', generateName(description)),
});
};
setupStandardSymbols(SymbolPolyfill);
setupSymbolRegistry(SymbolPolyfill);
defineProperties(HiddenSymbol.prototype, {
constructor: d2(SymbolPolyfill),
toString: d2('', function () {
return this.__name__;
}),
});
defineProperties(SymbolPolyfill.prototype, {
toString: d2(function () {
return 'Symbol (' + validateSymbol(this).__description__ + ')';
}),
valueOf: d2(function () {
return validateSymbol(this);
}),
});
defineProperty(
SymbolPolyfill.prototype,
SymbolPolyfill.toPrimitive,
d2('', function () {
var symbol = validateSymbol(this);
if (_typeof(symbol) === 'symbol') {
return symbol;
}
return symbol.toString();
}),
);
defineProperty(
SymbolPolyfill.prototype,
SymbolPolyfill.toStringTag,
d2('c', 'Symbol'),
);
defineProperty(
HiddenSymbol.prototype,
SymbolPolyfill.toStringTag,
d2('c', SymbolPolyfill.prototype[SymbolPolyfill.toStringTag]),
);
defineProperty(
HiddenSymbol.prototype,
SymbolPolyfill.toPrimitive,
d2('c', SymbolPolyfill.prototype[SymbolPolyfill.toPrimitive]),
);
});
var require_es6_symbol = __commonJS(function (exports, module) {
'use strict';
module.exports = require_is_implemented7()()
? require_global_this().Symbol
: require_polyfill();
});
var require_is_arguments = __commonJS(function (exports, module) {
'use strict';
var objToString = Object.prototype.toString;
var id = objToString.call(
(function () {
return arguments;
})(),
);
module.exports = function (value) {
return objToString.call(value) === id;
};
});
var require_is_function = __commonJS(function (exports, module) {
'use strict';
var objToString = Object.prototype.toString;
var isFunctionStringTag = RegExp.prototype.test.bind(
/^[object [A-Za-z0-9]*Function]$/,
);
module.exports = function (value) {
return (
typeof value === 'function' &&
isFunctionStringTag(objToString.call(value))
);
};
});
var require_is_string = __commonJS(function (exports, module) {
'use strict';
var objToString = Object.prototype.toString;
var id = objToString.call('');
module.exports = function (value) {
return (
typeof value === 'string' ||
(value &&
_typeof(value) === 'object' &&
(value instanceof String || objToString.call(value) === id)) ||
false
);
};
});
var require_shim5 = __commonJS(function (exports, module) {
'use strict';
var iteratorSymbol = require_es6_symbol().iterator;
var isArguments = require_is_arguments();
var isFunction = require_is_function();
var toPosInt = require_to_pos_integer();