Skip to content

Instantly share code, notes, and snippets.

@skimi

skimi/$regeneratePollyjsRecordId.js

Last active February 16, 2021 09:58
Show Gist options
  • Save skimi/79f26f1ac502ac2102119347a4aca11f to your computer and use it in GitHub Desktop.
Save skimi/79f26f1ac502ac2102119347a4aca11f to your computer and use it in GitHub Desktop.
Download ZIP
Dirty script to regenerate PollyJS record id after a manual edit
Raw
$regeneratePollyjsRecordId.js
// This is a dirty hack of pollyJS to regenerate the har ids so we can modify
// a file by hand and just run this script
// The script executes like this: `find your-recordings-path -name "*.har" | xargs node scripts/regenerateRecordId`
// or `node scripts/regenerateRecordId your-folder/your-recording.har`
// But read the comments below. This is might not work anymore, it requires a lot of copy/paste & maintenance if pollyJS changes
const keys = require('lodash/keys');
const fs = require('fs');
const md5 = require('blueimp-md5');
const stringify = require('fast-json-stable-stringify');
// You might need to update this file if the version of pollyjs changed
// NormalizeRequest is a copy paste of `node_modules/@pollyjs/core/dist/cjs/pollyjs-core.js` and edited to
// to export `module.exports = { NormalizeRequest };`. To update, find the `var NormalizeRequest`
// remove everyrthing below it and export it as shown.
const { NormalizeRequest } = require('./NormalizeRequest');
// This is your pollyJs config
const matchRequestsBy = require('./pollyConf');
const isDryRun = process.argv.includes('--dry-run');
const filePaths = process.argv.slice(2).filter((arg) => !arg.startsWith('-'));
filePaths.forEach((filePath, index) => {
const file = JSON.parse(fs.readFileSync(filePath, 'utf8'));
let hasChanges = false;
file.log.entries = file.log.entries.map((entry) => {
const identifiers = {};
// This is roughly what PollyJS does to identify each request
// See https://github.com/Netflix/pollyjs/blob/v5.0.0/packages/@pollyjs/core/src/-private/request.js#L249
// It's a bit different to make sure the output keeps outputing objects and not array
// Might need some work if pollyjs has channged their way of identifying a request
keys(NormalizeRequest).forEach((key) => {
if (matchRequestsBy[key]) {
if (key === 'body') {
if (entry.request.bodySize > 0) {
identifiers[key] = NormalizeRequest[key](
entry.request.postData.text,
matchRequestsBy[key],
);
}
} else if (key === 'headers') {
if (entry.request.headers) {
identifiers[key] = NormalizeRequest[key](
entry.request.headers.reduce(
(carry, val) => ({
...carry,
[val.name]: val.value,
}),
{},
),
matchRequestsBy[key],
);
}
} else {
identifiers[key] = NormalizeRequest[key](entry.request[key], matchRequestsBy[key]);
}
}
});
const newId = md5(stringify(identifiers));
if (entry._id !== newId) {
console.log(`from ${entry._id} to ${newId}`);
hasChanges = true;
}
return {
...entry,
_id: md5(stringify(identifiers)),
};
});
if (hasChanges && !isDryRun) {
console.log(`[${index + 1}/${filePaths.length}] file ${filePath}`);
fs.writeFileSync(filePath, JSON.stringify(file, null, 2));
}
});
Raw
NormalizeRequest.js
/*
* Created for `regenerateRecordId` script
* Copy paste of `node_modules/@pollyjs/core/dist/cjs/pollyjs-core.js` and edited to
* to export `module.exports = { NormalizeRequest };`. To update, find the `var NormalizeRequest`
* remove everyrthing below it and export it as shown.
*/
/**
* @pollyjs/core v4.3.0
*
* https://github.com/netflix/pollyjs
*
* Released under the Apache-2.0 License.
*/
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
function _interopDefault(ex) {
return ex && typeof ex === 'object' && 'default' in ex ? ex['default'] : ex;
}
var utils = require('@pollyjs/utils');
var md5 = _interopDefault(require('blueimp-md5'));
var stringify = _interopDefault(require('fast-json-stable-stringify'));
var isAbsoluteUrl = _interopDefault(require('is-absolute-url'));
var fnv1a = _interopDefault(require('@sindresorhus/fnv1a'));
var slugify = _interopDefault(require('slugify'));
var RouteRecognizer = _interopDefault(require('route-recognizer'));
var es6_object_toString = /*#__PURE__*/ Object.freeze({});
// 7.1.4 ToInteger
var ceil = Math.ceil;
var floor = Math.floor;
var _toInteger = function (it) {
return isNaN((it = +it)) ? 0 : (it > 0 ? floor : ceil)(it);
};
// 7.2.1 RequireObjectCoercible(argument)
var _defined = function (it) {
if (it == undefined) throw TypeError("Can't call method on " + it);
return it;
};
// true -> String#at
// false -> String#codePointAt
var _stringAt = function (TO_STRING) {
return function (that, pos) {
var s = String(_defined(that));
var i = _toInteger(pos);
var l = s.length;
var a, b;
if (i < 0 || i >= l) return TO_STRING ? '' : undefined;
a = s.charCodeAt(i);
return a < 0xd800 ||
a > 0xdbff ||
i + 1 === l ||
(b = s.charCodeAt(i + 1)) < 0xdc00 ||
b > 0xdfff
? TO_STRING
? s.charAt(i)
: a
: TO_STRING
? s.slice(i, i + 2)
: ((a - 0xd800) << 10) + (b - 0xdc00) + 0x10000;
};
};
var _library = true;
function createCommonjsModule(fn, module) {
return (module = { exports: {} }), fn(module, module.exports), module.exports;
}
function getCjsExportFromNamespace(n) {
return (n && n['default']) || n;
}
var _global = createCommonjsModule(function (module) {
// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
var global = (module.exports =
typeof window != 'undefined' && window.Math == Math
? window
: typeof self != 'undefined' && self.Math == Math
? self
: // eslint-disable-next-line no-new-func
Function('return this')());
if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef
});
var _core = createCommonjsModule(function (module) {
var core = (module.exports = { version: '2.6.9' });
if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef
});
var _core_1 = _core.version;
var _aFunction = function (it) {
if (typeof it != 'function') throw TypeError(it + ' is not a function!');
return it;
};
// optional / simple context binding
var _ctx = function (fn, that, length) {
_aFunction(fn);
if (that === undefined) return fn;
switch (length) {
case 1:
return function (a) {
return fn.call(that, a);
};
case 2:
return function (a, b) {
return fn.call(that, a, b);
};
case 3:
return function (a, b, c) {
return fn.call(that, a, b, c);
};
}
return function (/* ...args */) {
return fn.apply(that, arguments);
};
};
var _isObject = function (it) {
return typeof it === 'object' ? it !== null : typeof it === 'function';
};
var _anObject = function (it) {
if (!_isObject(it)) throw TypeError(it + ' is not an object!');
return it;
};
var _fails = function (exec) {
try {
return !!exec();
} catch (e) {
return true;
}
};
// Thank's IE8 for his funny defineProperty
var _descriptors = !_fails(function () {
return (
Object.defineProperty({}, 'a', {
get: function () {
return 7;
},
}).a != 7
);
});
var document$1 = _global.document;
// typeof document.createElement is 'object' in old IE
var is = _isObject(document$1) && _isObject(document$1.createElement);
var _domCreate = function (it) {
return is ? document$1.createElement(it) : {};
};
var _ie8DomDefine =
!_descriptors &&
!_fails(function () {
return (
Object.defineProperty(_domCreate('div'), 'a', {
get: function () {
return 7;
},
}).a != 7
);
});
// 7.1.1 ToPrimitive(input [, PreferredType])
// instead of the ES6 spec version, we didn't implement @@toPrimitive case
// and the second argument - flag - preferred type is a string
var _toPrimitive = function (it, S) {
if (!_isObject(it)) return it;
var fn, val;
if (S && typeof (fn = it.toString) == 'function' && !_isObject((val = fn.call(it)))) return val;
if (typeof (fn = it.valueOf) == 'function' && !_isObject((val = fn.call(it)))) return val;
if (!S && typeof (fn = it.toString) == 'function' && !_isObject((val = fn.call(it)))) return val;
throw TypeError("Can't convert object to primitive value");
};
var dP = Object.defineProperty;
var f = _descriptors
? Object.defineProperty
: function defineProperty(O, P, Attributes) {
_anObject(O);
P = _toPrimitive(P, true);
_anObject(Attributes);
if (_ie8DomDefine)
try {
return dP(O, P, Attributes);
} catch (e) {
/* empty */
}
if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
if ('value' in Attributes) O[P] = Attributes.value;
return O;
};
var _objectDp = {
f: f,
};
var _propertyDesc = function (bitmap, value) {
return {
enumerable: !(bitmap & 1),
configurable: !(bitmap & 2),
writable: !(bitmap & 4),
value: value,
};
};
var _hide = _descriptors
? function (object, key, value) {
return _objectDp.f(object, key, _propertyDesc(1, value));
}
: function (object, key, value) {
object[key] = value;
return object;
};
var hasOwnProperty = {}.hasOwnProperty;
var _has = function (it, key) {
return hasOwnProperty.call(it, key);
};
var PROTOTYPE = 'prototype';
var $export = function (type, name, source) {
var IS_FORCED = type & $export.F;
var IS_GLOBAL = type & $export.G;
var IS_STATIC = type & $export.S;
var IS_PROTO = type & $export.P;
var IS_BIND = type & $export.B;
var IS_WRAP = type & $export.W;
var exports = IS_GLOBAL ? _core : _core[name] || (_core[name] = {});
var expProto = exports[PROTOTYPE];
var target = IS_GLOBAL ? _global : IS_STATIC ? _global[name] : (_global[name] || {})[PROTOTYPE];
var key, own, out;
if (IS_GLOBAL) source = name;
for (key in source) {
// contains in native
own = !IS_FORCED && target && target[key] !== undefined;
if (own && _has(exports, key)) continue;
// export native or passed
out = own ? target[key] : source[key];
// prevent global pollution for namespaces
exports[key] =
IS_GLOBAL && typeof target[key] != 'function'
? source[key]
: // bind timers to global for call from export context
IS_BIND && own
? _ctx(out, _global)
: // wrap global constructors for prevent change them in library
IS_WRAP && target[key] == out
? (function (C) {
var F = function (a, b, c) {
if (this instanceof C) {
switch (arguments.length) {
case 0:
return new C();
case 1:
return new C(a);
case 2:
return new C(a, b);
}
return new C(a, b, c);
}
return C.apply(this, arguments);
};
F[PROTOTYPE] = C[PROTOTYPE];
return F;
// make static versions for prototype methods
})(out)
: IS_PROTO && typeof out == 'function'
? _ctx(Function.call, out)
: out;
// export proto methods to core.%CONSTRUCTOR%.methods.%NAME%
if (IS_PROTO) {
(exports.virtual || (exports.virtual = {}))[key] = out;
// export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%
if (type & $export.R && expProto && !expProto[key]) _hide(expProto, key, out);
}
}
};
// type bitmap
$export.F = 1; // forced
$export.G = 2; // global
$export.S = 4; // static
$export.P = 8; // proto
$export.B = 16; // bind
$export.W = 32; // wrap
$export.U = 64; // safe
$export.R = 128; // real proto method for `library`
var _export = $export;
var _redefine = _hide;
var _iterators = {};
var toString = {}.toString;
var _cof = function (it) {
return toString.call(it).slice(8, -1);
};
// fallback for non-array-like ES3 and non-enumerable old V8 strings
// eslint-disable-next-line no-prototype-builtins
var _iobject = Object('z').propertyIsEnumerable(0)
? Object
: function (it) {
return _cof(it) == 'String' ? it.split('') : Object(it);
};
// to indexed object, toObject with fallback for non-array-like ES3 strings
var _toIobject = function (it) {
return _iobject(_defined(it));
};
// 7.1.15 ToLength
var min = Math.min;
var _toLength = function (it) {
return it > 0 ? min(_toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
};
var max = Math.max;
var min$1 = Math.min;
var _toAbsoluteIndex = function (index, length) {
index = _toInteger(index);
return index < 0 ? max(index + length, 0) : min$1(index, length);
};
// false -> Array#indexOf
// true -> Array#includes
var _arrayIncludes = function (IS_INCLUDES) {
return function ($this, el, fromIndex) {
var O = _toIobject($this);
var length = _toLength(O.length);
var index = _toAbsoluteIndex(fromIndex, length);
var value;
// Array#includes uses SameValueZero equality algorithm
// eslint-disable-next-line no-self-compare
if (IS_INCLUDES && el != el)
while (length > index) {
value = O[index++];
// eslint-disable-next-line no-self-compare
if (value != value) return true;
// Array#indexOf ignores holes, Array#includes - not
}
else
for (; length > index; index++)
if (IS_INCLUDES || index in O) {
if (O[index] === el) return IS_INCLUDES || index || 0;
}
return !IS_INCLUDES && -1;
};
};
var _shared = createCommonjsModule(function (module) {
var SHARED = '__core-js_shared__';
var store = _global[SHARED] || (_global[SHARED] = {});
(module.exports = function (key, value) {
return store[key] || (store[key] = value !== undefined ? value : {});
})('versions', []).push({
version: _core.version,
mode: 'pure',
copyright: '© 2019 Denis Pushkarev (zloirock.ru)',
});
});
var id = 0;
var px = Math.random();
var _uid = function (key) {
return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
};
var shared = _shared('keys');
var _sharedKey = function (key) {
return shared[key] || (shared[key] = _uid(key));
};
var arrayIndexOf = _arrayIncludes(false);
var IE_PROTO = _sharedKey('IE_PROTO');
var _objectKeysInternal = function (object, names) {
var O = _toIobject(object);
var i = 0;
var result = [];
var key;
for (key in O) if (key != IE_PROTO) _has(O, key) && result.push(key);
// Don't enum bug & hidden keys
while (names.length > i)
if (_has(O, (key = names[i++]))) {
~arrayIndexOf(result, key) || result.push(key);
}
return result;
};
// IE 8- don't enum bug keys
var _enumBugKeys = 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'.split(
',',
);
// 19.1.2.14 / 15.2.3.14 Object.keys(O)
var _objectKeys =
Object.keys ||
function keys(O) {
return _objectKeysInternal(O, _enumBugKeys);
};
var _objectDps = _descriptors
? Object.defineProperties
: function defineProperties(O, Properties) {
_anObject(O);
var keys = _objectKeys(Properties);
var length = keys.length;
var i = 0;
var P;
while (length > i) _objectDp.f(O, (P = keys[i++]), Properties[P]);
return O;
};
var document$2 = _global.document;
var _html = document$2 && document$2.documentElement;
// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
var IE_PROTO$1 = _sharedKey('IE_PROTO');
var Empty = function () {
/* empty */
};
var PROTOTYPE$1 = 'prototype';
// Create object with fake `null` prototype: use iframe Object with cleared prototype
var createDict = function () {
// Thrash, waste and sodomy: IE GC bug
var iframe = _domCreate('iframe');
var i = _enumBugKeys.length;
var lt = '<';
var gt = '>';
var iframeDocument;
iframe.style.display = 'none';
_html.appendChild(iframe);
iframe.src = 'javascript:'; // eslint-disable-line no-script-url
// createDict = iframe.contentWindow.Object;
// html.removeChild(iframe);
iframeDocument = iframe.contentWindow.document;
iframeDocument.open();
iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
iframeDocument.close();
createDict = iframeDocument.F;
while (i--) delete createDict[PROTOTYPE$1][_enumBugKeys[i]];
return createDict();
};
var _objectCreate =
Object.create ||
function create(O, Properties) {
var result;
if (O !== null) {
Empty[PROTOTYPE$1] = _anObject(O);
result = new Empty();
Empty[PROTOTYPE$1] = null;
// add "__proto__" for Object.getPrototypeOf polyfill
result[IE_PROTO$1] = O;
} else result = createDict();
return Properties === undefined ? result : _objectDps(result, Properties);
};
var _wks = createCommonjsModule(function (module) {
var store = _shared('wks');
var Symbol = _global.Symbol;
var USE_SYMBOL = typeof Symbol == 'function';
var $exports = (module.exports = function (name) {
return (
store[name] ||
(store[name] = (USE_SYMBOL && Symbol[name]) || (USE_SYMBOL ? Symbol : _uid)('Symbol.' + name))
);
});
$exports.store = store;
});
var def = _objectDp.f;
var TAG = _wks('toStringTag');
var _setToStringTag = function (it, tag, stat) {
if (it && !_has((it = stat ? it : it.prototype), TAG))
def(it, TAG, { configurable: true, value: tag });
};
var IteratorPrototype = {};
// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
_hide(IteratorPrototype, _wks('iterator'), function () {
return this;
});
var _iterCreate = function (Constructor, NAME, next) {
Constructor.prototype = _objectCreate(IteratorPrototype, { next: _propertyDesc(1, next) });
_setToStringTag(Constructor, NAME + ' Iterator');
};
// 7.1.13 ToObject(argument)
var _toObject = function (it) {
return Object(_defined(it));
};
// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
var IE_PROTO$2 = _sharedKey('IE_PROTO');
var ObjectProto = Object.prototype;
var _objectGpo =
Object.getPrototypeOf ||
function (O) {
O = _toObject(O);
if (_has(O, IE_PROTO$2)) return O[IE_PROTO$2];
if (typeof O.constructor == 'function' && O instanceof O.constructor) {
return O.constructor.prototype;
}
return O instanceof Object ? ObjectProto : null;
};
var ITERATOR = _wks('iterator');
var BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`
var FF_ITERATOR = '@@iterator';
var KEYS = 'keys';
var VALUES = 'values';
var returnThis = function () {
return this;
};
var _iterDefine = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {
_iterCreate(Constructor, NAME, next);
var getMethod = function (kind) {
if (!BUGGY && kind in proto) return proto[kind];
switch (kind) {
case KEYS:
return function keys() {
return new Constructor(this, kind);
};
case VALUES:
return function values() {
return new Constructor(this, kind);
};
}
return function entries() {
return new Constructor(this, kind);
};
};
var TAG = NAME + ' Iterator';
var DEF_VALUES = DEFAULT == VALUES;
var VALUES_BUG = false;
var proto = Base.prototype;
var $native = proto[ITERATOR] || proto[FF_ITERATOR] || (DEFAULT && proto[DEFAULT]);
var $default = $native || getMethod(DEFAULT);
var $entries = DEFAULT ? (!DEF_VALUES ? $default : getMethod('entries')) : undefined;
var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;
var methods, key, IteratorPrototype;
// Fix native
if ($anyNative) {
IteratorPrototype = _objectGpo($anyNative.call(new Base()));
if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {
// Set @@toStringTag to native iterators
_setToStringTag(IteratorPrototype, TAG, true);
}
}
// fix Array#{values, @@iterator}.name in V8 / FF
if (DEF_VALUES && $native && $native.name !== VALUES) {
VALUES_BUG = true;
$default = function values() {
return $native.call(this);
};
}
// Define iterator
if (FORCED && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {
_hide(proto, ITERATOR, $default);
}
// Plug for library
_iterators[NAME] = $default;
_iterators[TAG] = returnThis;
if (DEFAULT) {
methods = {
values: DEF_VALUES ? $default : getMethod(VALUES),
keys: IS_SET ? $default : getMethod(KEYS),
entries: $entries,
};
if (FORCED)
for (key in methods) {
if (!(key in proto)) _redefine(proto, key, methods[key]);
}
else _export(_export.P + _export.F * (BUGGY || VALUES_BUG), NAME, methods);
}
return methods;
};
var $at = _stringAt(true);
// 21.1.3.27 String.prototype[@@iterator]()
_iterDefine(
String,
'String',
function (iterated) {
this._t = String(iterated); // target
this._i = 0; // next index
// 21.1.5.2.1 %StringIteratorPrototype%.next()
},
function () {
var O = this._t;
var index = this._i;
var point;
if (index >= O.length) return { value: undefined, done: true };
point = $at(O, index);
this._i += point.length;
return { value: point, done: false };
},
);
var _iterStep = function (done, value) {
return { value: value, done: !!done };
};
// 22.1.3.4 Array.prototype.entries()
// 22.1.3.13 Array.prototype.keys()
// 22.1.3.29 Array.prototype.values()
// 22.1.3.30 Array.prototype[@@iterator]()
var es6_array_iterator = _iterDefine(
Array,
'Array',
function (iterated, kind) {
this._t = _toIobject(iterated); // target
this._i = 0; // next index
this._k = kind; // kind
// 22.1.5.2.1 %ArrayIteratorPrototype%.next()
},
function () {
var O = this._t;
var kind = this._k;
var index = this._i++;
if (!O || index >= O.length) {
this._t = undefined;
return _iterStep(1);
}
if (kind == 'keys') return _iterStep(0, index);
if (kind == 'values') return _iterStep(0, O[index]);
return _iterStep(0, [index, O[index]]);
},
'values',
);
// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
_iterators.Arguments = _iterators.Array;
var TO_STRING_TAG = _wks('toStringTag');
var DOMIterables = (
'CSSRuleList,CSSStyleDeclaration,CSSValueList,ClientRectList,DOMRectList,DOMStringList,' +
'DOMTokenList,DataTransferItemList,FileList,HTMLAllCollection,HTMLCollection,HTMLFormElement,HTMLSelectElement,' +
'MediaList,MimeTypeArray,NamedNodeMap,NodeList,PaintRequestList,Plugin,PluginArray,SVGLengthList,SVGNumberList,' +
'SVGPathSegList,SVGPointList,SVGStringList,SVGTransformList,SourceBufferList,StyleSheetList,TextTrackCueList,' +
'TextTrackList,TouchList'
).split(',');
for (var i = 0; i < DOMIterables.length; i++) {
var NAME = DOMIterables[i];
var Collection = _global[NAME];
var proto = Collection && Collection.prototype;
if (proto && !proto[TO_STRING_TAG]) _hide(proto, TO_STRING_TAG, NAME);
_iterators[NAME] = _iterators.Array;
}
// getting tag from 19.1.3.6 Object.prototype.toString()
var TAG$1 = _wks('toStringTag');
// ES3 wrong here
var ARG =
_cof(
(function () {
return arguments;
})(),
) == 'Arguments';
// fallback for IE11 Script Access Denied error
var tryGet = function (it, key) {
try {
return it[key];
} catch (e) {
/* empty */
}
};
var _classof = function (it) {
var O, T, B;
return it === undefined
? 'Undefined'
: it === null
? 'Null'
: // @@toStringTag case
typeof (T = tryGet((O = Object(it)), TAG$1)) == 'string'
? T
: // builtinTag case
ARG
? _cof(O)
: // ES3 arguments fallback
(B = _cof(O)) == 'Object' && typeof O.callee == 'function'
? 'Arguments'
: B;
};
var _anInstance = function (it, Constructor, name, forbiddenField) {
if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {
throw TypeError(name + ': incorrect invocation!');
}
return it;
};
// call something on iterator step with safe closing on error
var _iterCall = function (iterator, fn, value, entries) {
try {
return entries ? fn(_anObject(value)[0], value[1]) : fn(value);
// 7.4.6 IteratorClose(iterator, completion)
} catch (e) {
var ret = iterator['return'];
if (ret !== undefined) _anObject(ret.call(iterator));
throw e;
}
};
// check on default Array iterator
var ITERATOR$1 = _wks('iterator');
var ArrayProto = Array.prototype;
var _isArrayIter = function (it) {
return it !== undefined && (_iterators.Array === it || ArrayProto[ITERATOR$1] === it);
};
var ITERATOR$2 = _wks('iterator');
var core_getIteratorMethod = (_core.getIteratorMethod = function (it) {
if (it != undefined) return it[ITERATOR$2] || it['@@iterator'] || _iterators[_classof(it)];
});
var _forOf = createCommonjsModule(function (module) {
var BREAK = {};
var RETURN = {};
var exports = (module.exports = function (iterable, entries, fn, that, ITERATOR) {
var iterFn = ITERATOR
? function () {
return iterable;
}
: core_getIteratorMethod(iterable);
var f = _ctx(fn, that, entries ? 2 : 1);
var index = 0;
var length, step, iterator, result;
if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');
// fast case for arrays with default iterator
if (_isArrayIter(iterFn))
for (length = _toLength(iterable.length); length > index; index++) {
result = entries ? f(_anObject((step = iterable[index]))[0], step[1]) : f(iterable[index]);
if (result === BREAK || result === RETURN) return result;
}
else
for (iterator = iterFn.call(iterable); !(step = iterator.next()).done; ) {
result = _iterCall(iterator, f, step.value, entries);
if (result === BREAK || result === RETURN) return result;
}
});
exports.BREAK = BREAK;
exports.RETURN = RETURN;
});
// 7.3.20 SpeciesConstructor(O, defaultConstructor)
var SPECIES = _wks('species');
var _speciesConstructor = function (O, D) {
var C = _anObject(O).constructor;
var S;
return C === undefined || (S = _anObject(C)[SPECIES]) == undefined ? D : _aFunction(S);
};
// fast apply, http://jsperf.lnkit.com/fast-apply/5
var _invoke = function (fn, args, that) {
var un = that === undefined;
switch (args.length) {
case 0:
return un ? fn() : fn.call(that);
case 1:
return un ? fn(args[0]) : fn.call(that, args[0]);
case 2:
return un ? fn(args[0], args[1]) : fn.call(that, args[0], args[1]);
case 3:
return un ? fn(args[0], args[1], args[2]) : fn.call(that, args[0], args[1], args[2]);
case 4:
return un
? fn(args[0], args[1], args[2], args[3])
: fn.call(that, args[0], args[1], args[2], args[3]);
}
return fn.apply(that, args);
};
var process = _global.process;
var setTask = _global.setImmediate;
var clearTask = _global.clearImmediate;
var MessageChannel = _global.MessageChannel;
var Dispatch = _global.Dispatch;
var counter = 0;
var queue = {};
var ONREADYSTATECHANGE = 'onreadystatechange';
var defer, channel, port;
var run = function () {
var id = +this;
// eslint-disable-next-line no-prototype-builtins
if (queue.hasOwnProperty(id)) {
var fn = queue[id];
delete queue[id];
fn();
}
};
var listener = function (event) {
run.call(event.data);
};
// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
if (!setTask || !clearTask) {
setTask = function setImmediate(fn) {
var args = [];
var i = 1;
while (arguments.length > i) args.push(arguments[i++]);
queue[++counter] = function () {
// eslint-disable-next-line no-new-func
_invoke(typeof fn == 'function' ? fn : Function(fn), args);
};
defer(counter);
return counter;
};
clearTask = function clearImmediate(id) {
delete queue[id];
};
// Node.js 0.8-
if (_cof(process) == 'process') {
defer = function (id) {
process.nextTick(_ctx(run, id, 1));
};
// Sphere (JS game engine) Dispatch API
} else if (Dispatch && Dispatch.now) {
defer = function (id) {
Dispatch.now(_ctx(run, id, 1));
};
// Browsers with MessageChannel, includes WebWorkers
} else if (MessageChannel) {
channel = new MessageChannel();
port = channel.port2;
channel.port1.onmessage = listener;
defer = _ctx(port.postMessage, port, 1);
// Browsers with postMessage, skip WebWorkers
// IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
} else if (
_global.addEventListener &&
typeof postMessage == 'function' &&
!_global.importScripts
) {
defer = function (id) {
_global.postMessage(id + '', '*');
};
_global.addEventListener('message', listener, false);
// IE8-
} else if (ONREADYSTATECHANGE in _domCreate('script')) {
defer = function (id) {
_html.appendChild(_domCreate('script'))[ONREADYSTATECHANGE] = function () {
_html.removeChild(this);
run.call(id);
};
};
// Rest old browsers
} else {
defer = function (id) {
setTimeout(_ctx(run, id, 1), 0);
};
}
}
var _task = {
set: setTask,
clear: clearTask,
};
var macrotask = _task.set;
var Observer = _global.MutationObserver || _global.WebKitMutationObserver;
var process$1 = _global.process;
var Promise = _global.Promise;
var isNode = _cof(process$1) == 'process';
var _microtask = function () {
var head, last, notify;
var flush = function () {
var parent, fn;
if (isNode && (parent = process$1.domain)) parent.exit();
while (head) {
fn = head.fn;
head = head.next;
try {
fn();
} catch (e) {
if (head) notify();
else last = undefined;
throw e;
}
}
last = undefined;
if (parent) parent.enter();
};
// Node.js
if (isNode) {
notify = function () {
process$1.nextTick(flush);
};
// browsers with MutationObserver, except iOS Safari - https://github.com/zloirock/core-js/issues/339
} else if (Observer && !(_global.navigator && _global.navigator.standalone)) {
var toggle = true;
var node = document.createTextNode('');
new Observer(flush).observe(node, { characterData: true }); // eslint-disable-line no-new
notify = function () {
node.data = toggle = !toggle;
};
// environments with maybe non-completely correct, but existent Promise
} else if (Promise && Promise.resolve) {
// Promise.resolve without an argument throws an error in LG WebOS 2
var promise = Promise.resolve(undefined);
notify = function () {
promise.then(flush);
};
// for other environments - macrotask based on:
// - setImmediate
// - MessageChannel
// - window.postMessag
// - onreadystatechange
// - setTimeout
} else {
notify = function () {
// strange IE + webpack dev server bug - use .call(global)
macrotask.call(_global, flush);
};
}
return function (fn) {
var task = { fn: fn, next: undefined };
if (last) last.next = task;
if (!head) {
head = task;
notify();
}
last = task;
};
};
// 25.4.1.5 NewPromiseCapability(C)
function PromiseCapability(C) {
var resolve, reject;
this.promise = new C(function ($$resolve, $$reject) {
if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
resolve = $$resolve;
reject = $$reject;
});
this.resolve = _aFunction(resolve);
this.reject = _aFunction(reject);
}
var f$1 = function (C) {
return new PromiseCapability(C);
};
var _newPromiseCapability = {
f: f$1,
};
var _perform = function (exec) {
try {
return { e: false, v: exec() };
} catch (e) {
return { e: true, v: e };
}
};
var navigator = _global.navigator;
var _userAgent = (navigator && navigator.userAgent) || '';
var _promiseResolve = function (C, x) {
_anObject(C);
if (_isObject(x) && x.constructor === C) return x;
var promiseCapability = _newPromiseCapability.f(C);
var resolve = promiseCapability.resolve;
resolve(x);
return promiseCapability.promise;
};
var _redefineAll = function (target, src, safe) {
for (var key in src) {
if (safe && target[key]) target[key] = src[key];
else _hide(target, key, src[key]);
}
return target;
};
var SPECIES$1 = _wks('species');
var _setSpecies = function (KEY) {
var C = typeof _core[KEY] == 'function' ? _core[KEY] : _global[KEY];
if (_descriptors && C && !C[SPECIES$1])
_objectDp.f(C, SPECIES$1, {
configurable: true,
get: function () {
return this;
},
});
};
var ITERATOR$3 = _wks('iterator');
var SAFE_CLOSING = false;
try {
var riter = [7][ITERATOR$3]();
riter['return'] = function () {
SAFE_CLOSING = true;
};
// eslint-disable-next-line no-throw-literal
Array.from(riter, function () {
throw 2;
});
} catch (e) {
/* empty */
}
var _iterDetect = function (exec, skipClosing) {
if (!skipClosing && !SAFE_CLOSING) return false;
var safe = false;
try {
var arr = [7];
var iter = arr[ITERATOR$3]();
iter.next = function () {
return { done: (safe = true) };
};
arr[ITERATOR$3] = function () {
return iter;
};
exec(arr);
} catch (e) {
/* empty */
}
return safe;
};
var task = _task.set;
var microtask = _microtask();
var PROMISE = 'Promise';
var TypeError$1 = _global.TypeError;
var process$2 = _global.process;
var versions = process$2 && process$2.versions;
var v8 = (versions && versions.v8) || '';
var $Promise = _global[PROMISE];
var isNode$1 = _classof(process$2) == 'process';
var empty = function () {
/* empty */
};
var Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper;
var newPromiseCapability = (newGenericPromiseCapability = _newPromiseCapability.f);
var USE_NATIVE = !!(function () {
try {
// correct subclassing with @@species support
var promise = $Promise.resolve(1);
var FakePromise = ((promise.constructor = {})[_wks('species')] = function (exec) {
exec(empty, empty);
});
// unhandled rejections tracking support, NodeJS Promise without it fails @@species test
return (
(isNode$1 || typeof PromiseRejectionEvent == 'function') &&
promise.then(empty) instanceof FakePromise &&
// v8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
// https://bugs.chromium.org/p/chromium/issues/detail?id=830565
// we can't detect it synchronously, so just check versions
v8.indexOf('6.6') !== 0 &&
_userAgent.indexOf('Chrome/66') === -1
);
} catch (e) {
/* empty */
}
})();
// helpers
var isThenable = function (it) {
var then;
return _isObject(it) && typeof (then = it.then) == 'function' ? then : false;
};
var notify = function (promise, isReject) {
if (promise._n) return;
promise._n = true;
var chain = promise._c;
microtask(function () {
var value = promise._v;
var ok = promise._s == 1;
var i = 0;
var run = function (reaction) {
var handler = ok ? reaction.ok : reaction.fail;
var resolve = reaction.resolve;
var reject = reaction.reject;
var domain = reaction.domain;
var result, then, exited;
try {
if (handler) {
if (!ok) {
if (promise._h == 2) onHandleUnhandled(promise);
promise._h = 1;
}
if (handler === true) result = value;
else {
if (domain) domain.enter();
result = handler(value); // may throw
if (domain) {
domain.exit();
exited = true;
}
}
if (result === reaction.promise) {
reject(TypeError$1('Promise-chain cycle'));
} else if ((then = isThenable(result))) {
then.call(result, resolve, reject);
} else resolve(result);
} else reject(value);
} catch (e) {
if (domain && !exited) domain.exit();
reject(e);
}
};
while (chain.length > i) run(chain[i++]); // variable length - can't use forEach
promise._c = [];
promise._n = false;
if (isReject && !promise._h) onUnhandled(promise);
});
};
var onUnhandled = function (promise) {
task.call(_global, function () {
var value = promise._v;
var unhandled = isUnhandled(promise);
var result, handler, console;
if (unhandled) {
result = _perform(function () {
if (isNode$1) {
process$2.emit('unhandledRejection', value, promise);
} else if ((handler = _global.onunhandledrejection)) {
handler({ promise: promise, reason: value });
} else if ((console = _global.console) && console.error) {
console.error('Unhandled promise rejection', value);
}
});
// Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
promise._h = isNode$1 || isUnhandled(promise) ? 2 : 1;
}
promise._a = undefined;
if (unhandled && result.e) throw result.v;
});
};
var isUnhandled = function (promise) {
return promise._h !== 1 && (promise._a || promise._c).length === 0;
};
var onHandleUnhandled = function (promise) {
task.call(_global, function () {
var handler;
if (isNode$1) {
process$2.emit('rejectionHandled', promise);
} else if ((handler = _global.onrejectionhandled)) {
handler({ promise: promise, reason: promise._v });
}
});
};
var $reject = function (value) {
var promise = this;
if (promise._d) return;
promise._d = true;
promise = promise._w || promise; // unwrap
promise._v = value;
promise._s = 2;
if (!promise._a) promise._a = promise._c.slice();
notify(promise, true);
};
var $resolve = function (value) {
var promise = this;
var then;
if (promise._d) return;
promise._d = true;
promise = promise._w || promise; // unwrap
try {
if (promise === value) throw TypeError$1("Promise can't be resolved itself");
if ((then = isThenable(value))) {
microtask(function () {
var wrapper = { _w: promise, _d: false }; // wrap
try {
then.call(value, _ctx($resolve, wrapper, 1), _ctx($reject, wrapper, 1));
} catch (e) {
$reject.call(wrapper, e);
}
});
} else {
promise._v = value;
promise._s = 1;
notify(promise, false);
}
} catch (e) {
$reject.call({ _w: promise, _d: false }, e); // wrap
}
};
// constructor polyfill
if (!USE_NATIVE) {
// 25.4.3.1 Promise(executor)
$Promise = function Promise(executor) {
_anInstance(this, $Promise, PROMISE, '_h');
_aFunction(executor);
Internal.call(this);
try {
executor(_ctx($resolve, this, 1), _ctx($reject, this, 1));
} catch (err) {
$reject.call(this, err);
}
};
// eslint-disable-next-line no-unused-vars
Internal = function Promise(executor) {
this._c = []; // <- awaiting reactions
this._a = undefined; // <- checked in isUnhandled reactions
this._s = 0; // <- state
this._d = false; // <- done
this._v = undefined; // <- value
this._h = 0; // <- rejection state, 0 - default, 1 - handled, 2 - unhandled
this._n = false; // <- notify
};
Internal.prototype = _redefineAll($Promise.prototype, {
// 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)
then: function then(onFulfilled, onRejected) {
var reaction = newPromiseCapability(_speciesConstructor(this, $Promise));
reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
reaction.fail = typeof onRejected == 'function' && onRejected;
reaction.domain = isNode$1 ? process$2.domain : undefined;
this._c.push(reaction);
if (this._a) this._a.push(reaction);
if (this._s) notify(this, false);
return reaction.promise;
},
// 25.4.5.1 Promise.prototype.catch(onRejected)
catch: function (onRejected) {
return this.then(undefined, onRejected);
},
});
OwnPromiseCapability = function () {
var promise = new Internal();
this.promise = promise;
this.resolve = _ctx($resolve, promise, 1);
this.reject = _ctx($reject, promise, 1);
};
_newPromiseCapability.f = newPromiseCapability = function (C) {
return C === $Promise || C === Wrapper
? new OwnPromiseCapability(C)
: newGenericPromiseCapability(C);
};
}
_export(_export.G + _export.W + _export.F * !USE_NATIVE, { Promise: $Promise });
_setToStringTag($Promise, PROMISE);
_setSpecies(PROMISE);
Wrapper = _core[PROMISE];
// statics
_export(_export.S + _export.F * !USE_NATIVE, PROMISE, {
// 25.4.4.5 Promise.reject(r)
reject: function reject(r) {
var capability = newPromiseCapability(this);
var $$reject = capability.reject;
$$reject(r);
return capability.promise;
},
});
_export(_export.S + _export.F * _library, PROMISE, {
// 25.4.4.6 Promise.resolve(x)
resolve: function resolve(x) {
return _promiseResolve(this === Wrapper ? $Promise : this, x);
},
});
_export(
_export.S +
_export.F *
!(
USE_NATIVE &&
_iterDetect(function (iter) {
$Promise.all(iter)['catch'](empty);
})
),
PROMISE,
{
// 25.4.4.1 Promise.all(iterable)
all: function all(iterable) {
var C = this;
var capability = newPromiseCapability(C);
var resolve = capability.resolve;
var reject = capability.reject;
var result = _perform(function () {
var values = [];
var index = 0;
var remaining = 1;
_forOf(iterable, false, function (promise) {
var $index = index++;
var alreadyCalled = false;
values.push(undefined);
remaining++;
C.resolve(promise).then(function (value) {
if (alreadyCalled) return;
alreadyCalled = true;
values[$index] = value;
--remaining || resolve(values);
}, reject);
});
--remaining || resolve(values);
});
if (result.e) reject(result.v);
return capability.promise;
},
// 25.4.4.4 Promise.race(iterable)
race: function race(iterable) {
var C = this;
var capability = newPromiseCapability(C);
var reject = capability.reject;
var result = _perform(function () {
_forOf(iterable, false, function (promise) {
C.resolve(promise).then(capability.resolve, reject);
});
});
if (result.e) reject(result.v);
return capability.promise;
},
},
);
_export(_export.P + _export.R, 'Promise', {
finally: function (onFinally) {
var C = _speciesConstructor(this, _core.Promise || _global.Promise);
var isFunction = typeof onFinally == 'function';
return this.then(
isFunction
? function (x) {
return _promiseResolve(C, onFinally()).then(function () {
return x;
});
}
: onFinally,
isFunction
? function (e) {
return _promiseResolve(C, onFinally()).then(function () {
throw e;
});
}
: onFinally,
);
},
});
// https://github.com/tc39/proposal-promise-try
_export(_export.S, 'Promise', {
try: function (callbackfn) {
var promiseCapability = _newPromiseCapability.f(this);
var result = _perform(callbackfn);
(result.e ? promiseCapability.reject : promiseCapability.resolve)(result.v);
return promiseCapability.promise;
},
});
getCjsExportFromNamespace(es6_object_toString);
var promise = _core.Promise;
var promise$1 = promise;
var f$2 = {}.propertyIsEnumerable;
var _objectPie = {
f: f$2,
};
var isEnum = _objectPie.f;
var _objectToArray = function (isEntries) {
return function (it) {
var O = _toIobject(it);
var keys = _objectKeys(O);
var length = keys.length;
var i = 0;
var result = [];
var key;
while (length > i) {
key = keys[i++];
if (!_descriptors || isEnum.call(O, key)) {
result.push(isEntries ? [key, O[key]] : O[key]);
}
}
return result;
};
};
// https://github.com/tc39/proposal-object-values-entries
var $values = _objectToArray(false);
_export(_export.S, 'Object', {
values: function values(it) {
return $values(it);
},
});
var values = _core.Object.values;
var values$1 = values;
var _meta = createCommonjsModule(function (module) {
var META = _uid('meta');
var setDesc = _objectDp.f;
var id = 0;
var isExtensible =
Object.isExtensible ||
function () {
return true;
};
var FREEZE = !_fails(function () {
return isExtensible(Object.preventExtensions({}));
});
var setMeta = function (it) {
setDesc(it, META, {
value: {
i: 'O' + ++id, // object ID
w: {}, // weak collections IDs
},
});
};
var fastKey = function (it, create) {
// return primitive with prefix
if (!_isObject(it))
return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
if (!_has(it, META)) {
// can't set metadata to uncaught frozen object
if (!isExtensible(it)) return 'F';
// not necessary to add metadata
if (!create) return 'E';
// add missing metadata
setMeta(it);
// return object ID
}
return it[META].i;
};
var getWeak = function (it, create) {
if (!_has(it, META)) {
// can't set metadata to uncaught frozen object
if (!isExtensible(it)) return true;
// not necessary to add metadata
if (!create) return false;
// add missing metadata
setMeta(it);
// return hash weak collections IDs
}
return it[META].w;
};
// add metadata on freeze-family methods calling
var onFreeze = function (it) {
if (FREEZE && meta.NEED && isExtensible(it) && !_has(it, META)) setMeta(it);
return it;
};
var meta = (module.exports = {
KEY: META,
NEED: false,
fastKey: fastKey,
getWeak: getWeak,
onFreeze: onFreeze,
});
});
var _meta_1 = _meta.KEY;
var _meta_2 = _meta.NEED;
var _meta_3 = _meta.fastKey;
var _meta_4 = _meta.getWeak;
var _meta_5 = _meta.onFreeze;
var _validateCollection = function (it, TYPE) {
if (!_isObject(it) || it._t !== TYPE)
throw TypeError('Incompatible receiver, ' + TYPE + ' required!');
return it;
};
var dP$1 = _objectDp.f;
var fastKey = _meta.fastKey;
var SIZE = _descriptors ? '_s' : 'size';
var getEntry = function (that, key) {
// fast case
var index = fastKey(key);
var entry;
if (index !== 'F') return that._i[index];
// frozen object case
for (entry = that._f; entry; entry = entry.n) {
if (entry.k == key) return entry;
}
};
var _collectionStrong = {
getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {
var C = wrapper(function (that, iterable) {
_anInstance(that, C, NAME, '_i');
that._t = NAME; // collection type
that._i = _objectCreate(null); // index
that._f = undefined; // first entry
that._l = undefined; // last entry
that[SIZE] = 0; // size
if (iterable != undefined) _forOf(iterable, IS_MAP, that[ADDER], that);
});
_redefineAll(C.prototype, {
// 23.1.3.1 Map.prototype.clear()
// 23.2.3.2 Set.prototype.clear()
clear: function clear() {
for (
var that = _validateCollection(this, NAME), data = that._i, entry = that._f;
entry;
entry = entry.n
) {
entry.r = true;
if (entry.p) entry.p = entry.p.n = undefined;
delete data[entry.i];
}
that._f = that._l = undefined;
that[SIZE] = 0;
},
// 23.1.3.3 Map.prototype.delete(key)
// 23.2.3.4 Set.prototype.delete(value)
delete: function (key) {
var that = _validateCollection(this, NAME);
var entry = getEntry(that, key);
if (entry) {
var next = entry.n;
var prev = entry.p;
delete that._i[entry.i];
entry.r = true;
if (prev) prev.n = next;
if (next) next.p = prev;
if (that._f == entry) that._f = next;
if (that._l == entry) that._l = prev;
that[SIZE]--;
}
return !!entry;
},
// 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)
// 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)
forEach: function forEach(callbackfn /* , that = undefined */) {
_validateCollection(this, NAME);
var f = _ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
var entry;
while ((entry = entry ? entry.n : this._f)) {
f(entry.v, entry.k, this);
// revert to the last existing entry
while (entry && entry.r) entry = entry.p;
}
},
// 23.1.3.7 Map.prototype.has(key)
// 23.2.3.7 Set.prototype.has(value)
has: function has(key) {
return !!getEntry(_validateCollection(this, NAME), key);
},
});
if (_descriptors)
dP$1(C.prototype, 'size', {
get: function () {
return _validateCollection(this, NAME)[SIZE];
},
});
return C;
},
def: function (that, key, value) {
var entry = getEntry(that, key);
var prev, index;
// change existing entry
if (entry) {
entry.v = value;
// create new entry
} else {
that._l = entry = {
i: (index = fastKey(key, true)), // <- index
k: key, // <- key
v: value, // <- value
p: (prev = that._l), // <- previous entry
n: undefined, // <- next entry
r: false, // <- removed
};
if (!that._f) that._f = entry;
if (prev) prev.n = entry;
that[SIZE]++;
// add to index
if (index !== 'F') that._i[index] = entry;
}
return that;
},
getEntry: getEntry,
setStrong: function (C, NAME, IS_MAP) {
// add .keys, .values, .entries, [@@iterator]
// 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11
_iterDefine(
C,
NAME,
function (iterated, kind) {
this._t = _validateCollection(iterated, NAME); // target
this._k = kind; // kind
this._l = undefined; // previous
},
function () {
var that = this;
var kind = that._k;
var entry = that._l;
// revert to the last existing entry
while (entry && entry.r) entry = entry.p;
// get next entry
if (!that._t || !(that._l = entry = entry ? entry.n : that._t._f)) {
// or finish the iteration
that._t = undefined;
return _iterStep(1);
}
// return step by kind
if (kind == 'keys') return _iterStep(0, entry.k);
if (kind == 'values') return _iterStep(0, entry.v);
return _iterStep(0, [entry.k, entry.v]);
},
IS_MAP ? 'entries' : 'values',
!IS_MAP,
true,
);
// add [@@species], 23.1.2.2, 23.2.2.2
_setSpecies(NAME);
},
};
// 7.2.2 IsArray(argument)
var _isArray =
Array.isArray ||
function isArray(arg) {
return _cof(arg) == 'Array';
};
var SPECIES$2 = _wks('species');
var _arraySpeciesConstructor = function (original) {
var C;
if (_isArray(original)) {
C = original.constructor;
// cross-realm fallback
if (typeof C == 'function' && (C === Array || _isArray(C.prototype))) C = undefined;
if (_isObject(C)) {
C = C[SPECIES$2];
if (C === null) C = undefined;
}
}
return C === undefined ? Array : C;
};
// 9.4.2.3 ArraySpeciesCreate(originalArray, length)
var _arraySpeciesCreate = function (original, length) {
return new (_arraySpeciesConstructor(original))(length);
};
// 0 -> Array#forEach
// 1 -> Array#map
// 2 -> Array#filter
// 3 -> Array#some
// 4 -> Array#every
// 5 -> Array#find
// 6 -> Array#findIndex
var _arrayMethods = function (TYPE, $create) {
var IS_MAP = TYPE == 1;
var IS_FILTER = TYPE == 2;
var IS_SOME = TYPE == 3;
var IS_EVERY = TYPE == 4;
var IS_FIND_INDEX = TYPE == 6;
var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
var create = $create || _arraySpeciesCreate;
return function ($this, callbackfn, that) {
var O = _toObject($this);
var self = _iobject(O);
var f = _ctx(callbackfn, that, 3);
var length = _toLength(self.length);
var index = 0;
var result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;
var val, res;
for (; length > index; index++)
if (NO_HOLES || index in self) {
val = self[index];
res = f(val, index, O);
if (TYPE) {
if (IS_MAP) result[index] = res;
// map
else if (res)
switch (TYPE) {
case 3:
return true; // some
case 5:
return val; // find
case 6:
return index; // findIndex
case 2:
result.push(val); // filter
}
else if (IS_EVERY) return false; // every
}
}
return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
};
};
var dP$2 = _objectDp.f;
var each = _arrayMethods(0);
var _collection = function (NAME, wrapper, methods, common, IS_MAP, IS_WEAK) {
var Base = _global[NAME];
var C = Base;
var ADDER = IS_MAP ? 'set' : 'add';
var proto = C && C.prototype;
var O = {};
if (
!_descriptors ||
typeof C != 'function' ||
!(
IS_WEAK ||
(proto.forEach &&
!_fails(function () {
new C().entries().next();
}))
)
) {
// create collection constructor
C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
_redefineAll(C.prototype, methods);
_meta.NEED = true;
} else {
C = wrapper(function (target, iterable) {
_anInstance(target, C, NAME, '_c');
target._c = new Base();
if (iterable != undefined) _forOf(iterable, IS_MAP, target[ADDER], target);
});
each('add,clear,delete,forEach,get,has,set,keys,values,entries,toJSON'.split(','), function (
KEY,
) {
var IS_ADDER = KEY == 'add' || KEY == 'set';
if (KEY in proto && !(IS_WEAK && KEY == 'clear'))
_hide(C.prototype, KEY, function (a, b) {
_anInstance(this, C, KEY);
if (!IS_ADDER && IS_WEAK && !_isObject(a)) return KEY == 'get' ? undefined : false;
var result = this._c[KEY](a === 0 ? 0 : a, b);
return IS_ADDER ? this : result;
});
});
IS_WEAK ||
dP$2(C.prototype, 'size', {
get: function () {
return this._c.size;
},
});
}
_setToStringTag(C, NAME);
O[NAME] = C;
_export(_export.G + _export.W + _export.F, O);
if (!IS_WEAK) common.setStrong(C, NAME, IS_MAP);
return C;
};
var MAP = 'Map';
// 23.1 Map Objects
var es6_map = _collection(
MAP,
function (get) {
return function Map() {
return get(this, arguments.length > 0 ? arguments[0] : undefined);
};
},
{
// 23.1.3.6 Map.prototype.get(key)
get: function get(key) {
var entry = _collectionStrong.getEntry(_validateCollection(this, MAP), key);
return entry && entry.v;
},
// 23.1.3.9 Map.prototype.set(key, value)
set: function set(key, value) {
return _collectionStrong.def(_validateCollection(this, MAP), key === 0 ? 0 : key, value);
},
},
_collectionStrong,
true,
);
var _arrayFromIterable = function (iter, ITERATOR) {
var result = [];
_forOf(iter, false, result.push, result, ITERATOR);
return result;
};
// https://github.com/DavidBruant/Map-Set.prototype.toJSON
var _collectionToJson = function (NAME) {
return function toJSON() {
if (_classof(this) != NAME) throw TypeError(NAME + "#toJSON isn't generic");
return _arrayFromIterable(this);
};
};
// https://github.com/DavidBruant/Map-Set.prototype.toJSON
_export(_export.P + _export.R, 'Map', { toJSON: _collectionToJson('Map') });
// https://tc39.github.io/proposal-setmap-offrom/
var _setCollectionOf = function (COLLECTION) {
_export(_export.S, COLLECTION, {
of: function of() {
var length = arguments.length;
var A = new Array(length);
while (length--) A[length] = arguments[length];
return new this(A);
},
});
};
// https://tc39.github.io/proposal-setmap-offrom/#sec-map.of
_setCollectionOf('Map');
// https://tc39.github.io/proposal-setmap-offrom/
var _setCollectionFrom = function (COLLECTION) {
_export(_export.S, COLLECTION, {
from: function from(source /* , mapFn, thisArg */) {
var mapFn = arguments[1];
var mapping, A, n, cb;
_aFunction(this);
mapping = mapFn !== undefined;
if (mapping) _aFunction(mapFn);
if (source == undefined) return new this();
A = [];
if (mapping) {
n = 0;
cb = _ctx(mapFn, arguments[2], 2);
_forOf(source, false, function (nextItem) {
A.push(cb(nextItem, n++));
});
} else {
_forOf(source, false, A.push, A);
}
return new this(A);
},
});
};
// https://tc39.github.io/proposal-setmap-offrom/#sec-map.from
_setCollectionFrom('Map');
var map = _core.Map;
var map$1 = map;
var f$3 = Object.getOwnPropertySymbols;
var _objectGops = {
f: f$3,
};
// 19.1.2.1 Object.assign(target, source, ...)
var $assign = Object.assign;
// should work with symbols and should have deterministic property order (V8 bug)
var _objectAssign =
!$assign ||
_fails(function () {
var A = {};
var B = {};
// eslint-disable-next-line no-undef
var S = Symbol();
var K = 'abcdefghijklmnopqrst';
A[S] = 7;
K.split('').forEach(function (k) {
B[k] = k;
});
return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
})
? function assign(target, source) {
// eslint-disable-line no-unused-vars
var T = _toObject(target);
var aLen = arguments.length;
var index = 1;
var getSymbols = _objectGops.f;
var isEnum = _objectPie.f;
while (aLen > index) {
var S = _iobject(arguments[index++]);
var keys = getSymbols ? _objectKeys(S).concat(getSymbols(S)) : _objectKeys(S);
var length = keys.length;
var j = 0;
var key;
while (length > j) {
key = keys[j++];
if (!_descriptors || isEnum.call(S, key)) T[key] = S[key];
}
}
return T;
}
: $assign;
var getWeak = _meta.getWeak;
var arrayFind = _arrayMethods(5);
var arrayFindIndex = _arrayMethods(6);
var id$1 = 0;
// fallback for uncaught frozen keys
var uncaughtFrozenStore = function (that) {
return that._l || (that._l = new UncaughtFrozenStore());
};
var UncaughtFrozenStore = function () {
this.a = [];
};
var findUncaughtFrozen = function (store, key) {
return arrayFind(store.a, function (it) {
return it[0] === key;
});
};
UncaughtFrozenStore.prototype = {
get: function (key) {
var entry = findUncaughtFrozen(this, key);
if (entry) return entry[1];
},
has: function (key) {
return !!findUncaughtFrozen(this, key);
},
set: function (key, value) {
var entry = findUncaughtFrozen(this, key);
if (entry) entry[1] = value;
else this.a.push([key, value]);
},
delete: function (key) {
var index = arrayFindIndex(this.a, function (it) {
return it[0] === key;
});
if (~index) this.a.splice(index, 1);
return !!~index;
},
};
var _collectionWeak = {
getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {
var C = wrapper(function (that, iterable) {
_anInstance(that, C, NAME, '_i');
that._t = NAME; // collection type
that._i = id$1++; // collection id
that._l = undefined; // leak store for uncaught frozen objects
if (iterable != undefined) _forOf(iterable, IS_MAP, that[ADDER], that);
});
_redefineAll(C.prototype, {
// 23.3.3.2 WeakMap.prototype.delete(key)
// 23.4.3.3 WeakSet.prototype.delete(value)
delete: function (key) {
if (!_isObject(key)) return false;
var data = getWeak(key);
if (data === true)
return uncaughtFrozenStore(_validateCollection(this, NAME))['delete'](key);
return data && _has(data, this._i) && delete data[this._i];
},
// 23.3.3.4 WeakMap.prototype.has(key)
// 23.4.3.4 WeakSet.prototype.has(value)
has: function has(key) {
if (!_isObject(key)) return false;
var data = getWeak(key);
if (data === true) return uncaughtFrozenStore(_validateCollection(this, NAME)).has(key);
return data && _has(data, this._i);
},
});
return C;
},
def: function (that, key, value) {
var data = getWeak(_anObject(key), true);
if (data === true) uncaughtFrozenStore(that).set(key, value);
else data[that._i] = value;
return that;
},
ufstore: uncaughtFrozenStore,
};
var es6_weakMap = createCommonjsModule(function (module) {
var each = _arrayMethods(0);
var NATIVE_WEAK_MAP = _validateCollection;
var IS_IE11 = !_global.ActiveXObject && 'ActiveXObject' in _global;
var WEAK_MAP = 'WeakMap';
var getWeak = _meta.getWeak;
var isExtensible = Object.isExtensible;
var uncaughtFrozenStore = _collectionWeak.ufstore;
var InternalMap;
var wrapper = function (get) {
return function WeakMap() {
return get(this, arguments.length > 0 ? arguments[0] : undefined);
};
};
var methods = {
// 23.3.3.3 WeakMap.prototype.get(key)
get: function get(key) {
if (_isObject(key)) {
var data = getWeak(key);
if (data === true) return uncaughtFrozenStore(_validateCollection(this, WEAK_MAP)).get(key);
return data ? data[this._i] : undefined;
}
},
// 23.3.3.5 WeakMap.prototype.set(key, value)
set: function set(key, value) {
return _collectionWeak.def(_validateCollection(this, WEAK_MAP), key, value);
},
};
// 23.3 WeakMap Objects
var $WeakMap = (module.exports = _collection(
WEAK_MAP,
wrapper,
methods,
_collectionWeak,
true,
true,
));
// IE11 WeakMap frozen keys fix
if (NATIVE_WEAK_MAP && IS_IE11) {
InternalMap = _collectionWeak.getConstructor(wrapper, WEAK_MAP);
_objectAssign(InternalMap.prototype, methods);
_meta.NEED = true;
each(['delete', 'has', 'get', 'set'], function (key) {
var proto = $WeakMap.prototype;
var method = proto[key];
_redefine(proto, key, function (a, b) {
// store frozen objects on internal weakmap shim
if (_isObject(a) && !isExtensible(a)) {
if (!this._f) this._f = new InternalMap();
var result = this._f[key](a, b);
return key == 'set' ? this : result;
// store all the rest on native weakmap
}
return method.call(this, a, b);
});
});
}
});
// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.of
_setCollectionOf('WeakMap');
// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.from
_setCollectionFrom('WeakMap');
var weakMap = _core.WeakMap;
var weakMap$1 = weakMap;
var f$4 = _wks;
var _wksExt = {
f: f$4,
};
var defineProperty = _objectDp.f;
var _wksDefine = function (name) {
var $Symbol = _core.Symbol || (_core.Symbol = {});
if (name.charAt(0) != '_' && !(name in $Symbol))
defineProperty($Symbol, name, { value: _wksExt.f(name) });
};
// all enumerable object keys, includes symbols
var _enumKeys = function (it) {
var result = _objectKeys(it);
var getSymbols = _objectGops.f;
if (getSymbols) {
var symbols = getSymbols(it);
var isEnum = _objectPie.f;
var i = 0;
var key;
while (symbols.length > i) if (isEnum.call(it, (key = symbols[i++]))) result.push(key);
}
return result;
};
// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
var hiddenKeys = _enumBugKeys.concat('length', 'prototype');
var f$5 =
Object.getOwnPropertyNames ||
function getOwnPropertyNames(O) {
return _objectKeysInternal(O, hiddenKeys);
};
var _objectGopn = {
f: f$5,
};
// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
var gOPN = _objectGopn.f;
var toString$1 = {}.toString;
var windowNames =
typeof window == 'object' && window && Object.getOwnPropertyNames
? Object.getOwnPropertyNames(window)
: [];
var getWindowNames = function (it) {
try {
return gOPN(it);
} catch (e) {
return windowNames.slice();
}
};
var f$6 = function getOwnPropertyNames(it) {
return windowNames && toString$1.call(it) == '[object Window]'
? getWindowNames(it)
: gOPN(_toIobject(it));
};
var _objectGopnExt = {
f: f$6,
};
var gOPD = Object.getOwnPropertyDescriptor;
var f$7 = _descriptors
? gOPD
: function getOwnPropertyDescriptor(O, P) {
O = _toIobject(O);
P = _toPrimitive(P, true);
if (_ie8DomDefine)
try {
return gOPD(O, P);
} catch (e) {
/* empty */
}
if (_has(O, P)) return _propertyDesc(!_objectPie.f.call(O, P), O[P]);
};
var _objectGopd = {
f: f$7,
};
// ECMAScript 6 symbols shim
var META = _meta.KEY;
var gOPD$1 = _objectGopd.f;
var dP$3 = _objectDp.f;
var gOPN$1 = _objectGopnExt.f;
var $Symbol = _global.Symbol;
var $JSON = _global.JSON;
var _stringify = $JSON && $JSON.stringify;
var PROTOTYPE$2 = 'prototype';
var HIDDEN = _wks('_hidden');
var TO_PRIMITIVE = _wks('toPrimitive');
var isEnum$1 = {}.propertyIsEnumerable;
var SymbolRegistry = _shared('symbol-registry');
var AllSymbols = _shared('symbols');
var OPSymbols = _shared('op-symbols');
var ObjectProto$1 = Object[PROTOTYPE$2];
var USE_NATIVE$1 = typeof $Symbol == 'function' && !!_objectGops.f;
var QObject = _global.QObject;
// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
var setter = !QObject || !QObject[PROTOTYPE$2] || !QObject[PROTOTYPE$2].findChild;
// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
var setSymbolDesc =
_descriptors &&
_fails(function () {
return (
_objectCreate(
dP$3({}, 'a', {
get: function () {
return dP$3(this, 'a', { value: 7 }).a;
},
}),
).a != 7
);
})
? function (it, key, D) {
var protoDesc = gOPD$1(ObjectProto$1, key);
if (protoDesc) delete ObjectProto$1[key];
dP$3(it, key, D);
if (protoDesc && it !== ObjectProto$1) dP$3(ObjectProto$1, key, protoDesc);
}
: dP$3;
var wrap = function (tag) {
var sym = (AllSymbols[tag] = _objectCreate($Symbol[PROTOTYPE$2]));
sym._k = tag;
return sym;
};
var isSymbol =
USE_NATIVE$1 && typeof $Symbol.iterator == 'symbol'
? function (it) {
return typeof it == 'symbol';
}
: function (it) {
return it instanceof $Symbol;
};
var $defineProperty = function defineProperty(it, key, D) {
if (it === ObjectProto$1) $defineProperty(OPSymbols, key, D);
_anObject(it);
key = _toPrimitive(key, true);
_anObject(D);
if (_has(AllSymbols, key)) {
if (!D.enumerable) {
if (!_has(it, HIDDEN)) dP$3(it, HIDDEN, _propertyDesc(1, {}));
it[HIDDEN][key] = true;
} else {
if (_has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false;
D = _objectCreate(D, { enumerable: _propertyDesc(0, false) });
}
return setSymbolDesc(it, key, D);
}
return dP$3(it, key, D);
};
var $defineProperties = function defineProperties(it, P) {
_anObject(it);
var keys = _enumKeys((P = _toIobject(P)));
var i = 0;
var l = keys.length;
var key;
while (l > i) $defineProperty(it, (key = keys[i++]), P[key]);
return it;
};
var $create = function create(it, P) {
return P === undefined ? _objectCreate(it) : $defineProperties(_objectCreate(it), P);
};
var $propertyIsEnumerable = function propertyIsEnumerable(key) {
var E = isEnum$1.call(this, (key = _toPrimitive(key, true)));
if (this === ObjectProto$1 && _has(AllSymbols, key) && !_has(OPSymbols, key)) return false;
return E ||
!_has(this, key) ||
!_has(AllSymbols, key) ||
(_has(this, HIDDEN) && this[HIDDEN][key])
? E
: true;
};
var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) {
it = _toIobject(it);
key = _toPrimitive(key, true);
if (it === ObjectProto$1 && _has(AllSymbols, key) && !_has(OPSymbols, key)) return;
var D = gOPD$1(it, key);
if (D && _has(AllSymbols, key) && !(_has(it, HIDDEN) && it[HIDDEN][key])) D.enumerable = true;
return D;
};
var $getOwnPropertyNames = function getOwnPropertyNames(it) {
var names = gOPN$1(_toIobject(it));
var result = [];
var i = 0;
var key;
while (names.length > i) {
if (!_has(AllSymbols, (key = names[i++])) && key != HIDDEN && key != META) result.push(key);
}
return result;
};
var $getOwnPropertySymbols = function getOwnPropertySymbols(it) {
var IS_OP = it === ObjectProto$1;
var names = gOPN$1(IS_OP ? OPSymbols : _toIobject(it));
var result = [];
var i = 0;
var key;
while (names.length > i) {
if (_has(AllSymbols, (key = names[i++])) && (IS_OP ? _has(ObjectProto$1, key) : true))
result.push(AllSymbols[key]);
}
return result;
};
// 19.4.1.1 Symbol([description])
if (!USE_NATIVE$1) {
$Symbol = function Symbol() {
if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor!');
var tag = _uid(arguments.length > 0 ? arguments[0] : undefined);
var $set = function (value) {
if (this === ObjectProto$1) $set.call(OPSymbols, value);
if (_has(this, HIDDEN) && _has(this[HIDDEN], tag)) this[HIDDEN][tag] = false;
setSymbolDesc(this, tag, _propertyDesc(1, value));
};
if (_descriptors && setter)
setSymbolDesc(ObjectProto$1, tag, { configurable: true, set: $set });
return wrap(tag);
};
_redefine($Symbol[PROTOTYPE$2], 'toString', function toString() {
return this._k;
});
_objectGopd.f = $getOwnPropertyDescriptor;
_objectDp.f = $defineProperty;
_objectGopn.f = _objectGopnExt.f = $getOwnPropertyNames;
_objectPie.f = $propertyIsEnumerable;
_objectGops.f = $getOwnPropertySymbols;
if (_descriptors && !_library) {
_redefine(ObjectProto$1, 'propertyIsEnumerable', $propertyIsEnumerable, true);
}
_wksExt.f = function (name) {
return wrap(_wks(name));
};
}
_export(_export.G + _export.W + _export.F * !USE_NATIVE$1, { Symbol: $Symbol });
for (
var es6Symbols = 'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'.split(
// 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14
',',
),
j = 0;
es6Symbols.length > j;
)
_wks(es6Symbols[j++]);
for (var wellKnownSymbols = _objectKeys(_wks.store), k = 0; wellKnownSymbols.length > k; )
_wksDefine(wellKnownSymbols[k++]);
_export(_export.S + _export.F * !USE_NATIVE$1, 'Symbol', {
// 19.4.2.1 Symbol.for(key)
for: function (key) {
return _has(SymbolRegistry, (key += ''))
? SymbolRegistry[key]
: (SymbolRegistry[key] = $Symbol(key));
},
// 19.4.2.5 Symbol.keyFor(sym)
keyFor: function keyFor(sym) {
if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol!');
for (var key in SymbolRegistry) if (SymbolRegistry[key] === sym) return key;
},
useSetter: function () {
setter = true;
},
useSimple: function () {
setter = false;
},
});
_export(_export.S + _export.F * !USE_NATIVE$1, 'Object', {
// 19.1.2.2 Object.create(O [, Properties])
create: $create,
// 19.1.2.4 Object.defineProperty(O, P, Attributes)
defineProperty: $defineProperty,
// 19.1.2.3 Object.defineProperties(O, Properties)
defineProperties: $defineProperties,
// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
// 19.1.2.7 Object.getOwnPropertyNames(O)
getOwnPropertyNames: $getOwnPropertyNames,
// 19.1.2.8 Object.getOwnPropertySymbols(O)
getOwnPropertySymbols: $getOwnPropertySymbols,
});
// Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives
// https://bugs.chromium.org/p/v8/issues/detail?id=3443
var FAILS_ON_PRIMITIVES = _fails(function () {
_objectGops.f(1);
});
_export(_export.S + _export.F * FAILS_ON_PRIMITIVES, 'Object', {
getOwnPropertySymbols: function getOwnPropertySymbols(it) {
return _objectGops.f(_toObject(it));
},
});
// 24.3.2 JSON.stringify(value [, replacer [, space]])
$JSON &&
_export(
_export.S +
_export.F *
(!USE_NATIVE$1 ||
_fails(function () {
var S = $Symbol();
// MS Edge converts symbol values to JSON as {}
// WebKit converts symbol values to JSON as null
// V8 throws on boxed symbols
return (
_stringify([S]) != '[null]' ||
_stringify({ a: S }) != '{}' ||
_stringify(Object(S)) != '{}'
);
})),
'JSON',
{
stringify: function stringify(it) {
var args = [it];
var i = 1;
var replacer, $replacer;
while (arguments.length > i) args.push(arguments[i++]);
$replacer = replacer = args[1];
if ((!_isObject(replacer) && it === undefined) || isSymbol(it)) return; // IE8 returns string on undefined
if (!_isArray(replacer))
replacer = function (key, value) {
if (typeof $replacer == 'function') value = $replacer.call(this, key, value);
if (!isSymbol(value)) return value;
};
args[1] = replacer;
return _stringify.apply($JSON, args);
},
},
);
// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)
$Symbol[PROTOTYPE$2][TO_PRIMITIVE] ||
_hide($Symbol[PROTOTYPE$2], TO_PRIMITIVE, $Symbol[PROTOTYPE$2].valueOf);
// 19.4.3.5 Symbol.prototype[@@toStringTag]
_setToStringTag($Symbol, 'Symbol');
// 20.2.1.9 Math[@@toStringTag]
_setToStringTag(Math, 'Math', true);
// 24.3.3 JSON[@@toStringTag]
_setToStringTag(_global.JSON, 'JSON', true);
_wksDefine('asyncIterator');
_wksDefine('observable');
var symbol = _core.Symbol;
var symbol$1 = symbol;
var version = '4.3.0';
const FORMATTED_ACTIONS = {
[utils.ACTIONS.RECORD]: 'Recorded',
[utils.ACTIONS.REPLAY]: 'Replayed',
[utils.ACTIONS.INTERCEPT]: 'Intercepted',
[utils.ACTIONS.PASSTHROUGH]: 'Passthrough',
};
class Logger {
constructor(polly) {
this.polly = polly;
this.groupName = null;
}
connect() {
this._middleware = this.polly.server
.any()
.on('error', (...args) => this.logError(...args))
.on('response', (...args) => this.logRequest(...args));
}
disconnect() {
this.groupEnd();
this._middleware.off('error');
this._middleware.off('response');
}
groupStart(groupName) {
// If the provided groupName is different, end the current group so a new one
// can be started.
if (this.groupName && this.groupName !== groupName) {
this.groupEnd();
this.groupName = null;
} // Create a new console group for the provided groupName if one
// doesn't already exist.
if (!this.groupName) {
this.groupName = groupName;
console.group(this.groupName);
}
}
groupEnd() {
if (this.groupName) {
console.groupEnd();
}
}
logRequest(request) {
if (request.config.logging) {
this.groupStart(request.recordingName);
console.groupCollapsed(
`${FORMATTED_ACTIONS[request.action]} ➞ ${request.method} ${request.url} ${
request.response.statusCode
} • ${request.responseTime}ms`,
);
console.log('Request:', request);
console.log('Response:', request.response);
console.log('Identifiers:', request.identifiers);
console.groupEnd();
}
}
logError(request, error) {
this.groupStart(request.recordingName);
console.group(`Errored ➞ ${request.method} ${request.url}`);
console.error(error);
console.log('Request:', request);
if (request.didRespond) {
console.log('Response:', request.response);
}
console.log('Identifiers:', request.identifiers);
console.groupEnd();
}
}
function keyFor(Factory) {
return `${Factory.type}:${utils.getFactoryId(Factory)}`;
}
class Container {
constructor() {
this._registry = new map$1();
}
/**
* Register a factory onto the container.
*
* @param {Function} Factory
*/
register(Factory) {
utils.assert(
`Attempted to register ${Factory} but invalid factory provided. Expected function, received: "${typeof Factory}"`,
typeof Factory === 'function',
);
const { type } = Factory;
const name = utils.getFactoryId(Factory);
utils.assert(
`Invalid registration id provided. Expected string, received: "${typeof name}"`,
typeof name === 'string',
);
utils.assert(
`Invalid registration type provided. Expected string, received: "${typeof type}"`,
typeof type === 'string',
);
this._registry.set(keyFor(Factory), Factory);
}
/**
* Unregister a factory from the container via a key (e.g. `adapter:fetch`)
* or Factory class.
*
* @param {String|Function} keyOrFactory
*/
unregister(keyOrFactory) {
const { _registry: registry } = this;
const key = typeof keyOrFactory === 'function' ? keyFor(keyOrFactory) : keyOrFactory;
registry.delete(key);
}
/**
* Lookup a factory by the given key (e.g. `adapter:fetch`)
*
* @param {String} key
* @returns {Function}
*/
lookup(key) {
return this._registry.get(key) || null;
}
/**
* Check if a factory has been registered via a key (e.g. `adapter:fetch`)
* or Factory class.
*
* @param {String|Function} keyOrFactory
* @returns {Boolean}
*/
has(keyOrFactory) {
const { _registry: registry } = this;
const key = typeof keyOrFactory === 'function' ? keyFor(keyOrFactory) : keyOrFactory;
return registry.has(key);
}
}
var Timing = {
fixed(ms) {
return () => utils.timeout(ms);
},
relative(ratio) {
return (ms) => utils.timeout(ratio * ms);
},
};
var DefaultConfig = {
mode: utils.MODES.REPLAY,
adapters: [],
adapterOptions: {},
persister: null,
persisterOptions: {
keepUnusedRequests: false,
disableSortingHarEntries: false,
},
logging: false,
flushRequestsOnStop: false,
recordIfMissing: true,
recordFailedRequests: false,
expiresIn: null,
expiryStrategy: utils.EXPIRY_STRATEGIES.WARN,
timing: Timing.fixed(0),
matchRequestsBy: {
method: true,
headers: true,
body: true,
order: true,
url: {
protocol: true,
username: true,
password: true,
hostname: true,
port: true,
pathname: true,
query: true,
hash: false,
},
},
};
/**
* Checks if `value` is object-like. A value is object-like if it's not `null`
* and has a `typeof` result of "object".
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
* @example
*
* _.isObjectLike({});
* // => true
*
* _.isObjectLike([1, 2, 3]);
* // => true
*
* _.isObjectLike(_.noop);
* // => false
*
* _.isObjectLike(null);
* // => false
*/
function isObjectLike(value) {
return value != null && typeof value == 'object';
}
/**
* Remove the host, protocol, and slashes from a URL instance.
*
* @param {URL} url
*/
function removeHostFromUrl(url) {
url.set('protocol', '');
url.set('host', '');
url.set('slashes', false);
return url;
}
/**
* Creates an exact representation of the passed url string with url-parse.
*
* @param {String} url
* @param {...args} args Arguments to pass through to the URL constructor
* @returns {URL} A url-parse URL instance
*/
function parseUrl(url, ...args) {
const parsedUrl = new utils.URL(url, ...args);
if (!isAbsoluteUrl(url)) {
if (url.startsWith('//')) {
/*
If the url is protocol-relative, strip out the protocol
*/
parsedUrl.set('protocol', '');
} else {
/*
If the url is relative, setup the parsed url to reflect just that
by removing the host. By default URL sets the host via window.location if
it does not exist.
*/
removeHostFromUrl(parsedUrl);
}
}
return parsedUrl;
}
const { keys } = Object;
const HANDLER = {
get(obj, prop) {
// `prop` can be a Symbol so only lower-case string based props.
return obj[typeof prop === 'string' ? prop.toLowerCase() : prop];
},
set(obj, prop, value) {
if (typeof prop !== 'string') {
return false;
}
if (value === null || typeof value === 'undefined') {
delete obj[prop.toLowerCase()];
} else {
obj[prop.toLowerCase()] = value;
}
return true;
},
deleteProperty(obj, prop) {
if (typeof prop !== 'string') {
return false;
}
delete obj[prop.toLowerCase()];
return true;
},
};
function HTTPHeaders(headers) {
const proxy = new Proxy({}, HANDLER);
if (isObjectLike(headers)) {
keys(headers).forEach((h) => (proxy[h] = headers[h]));
}
return proxy;
}
const { keys: keys$1 } = Object;
const { isArray } = Array;
const { parse } = JSON;
function isFunction(fn) {
return typeof fn === 'function';
}
function method(method, config, req) {
return isFunction(config) ? config(method, req) : method.toUpperCase();
}
function url(url, config, req) {
let parsedUrl = parseUrl(url, true);
if (isFunction(config)) {
parsedUrl = parseUrl(config(url, req), true);
} else {
// Remove any url properties that have been disabled via the config
keys$1(config || {}).forEach((key) => {
if (isFunction(config[key])) {
parsedUrl.set(key, config[key](parsedUrl[key], req));
} else if (!config[key]) {
parsedUrl.set(key, '');
}
});
} // Sort Query Params
if (isObjectLike(parsedUrl.query)) {
parsedUrl.set('query', parse(stringify(parsedUrl.query)));
}
return parsedUrl.href;
}
function headers(headers, config, req) {
const normalizedHeaders = new HTTPHeaders(headers);
if (isFunction(config)) {
return config(normalizedHeaders, req);
}
if (isObjectLike(config) && isArray(config.exclude)) {
config.exclude.forEach((header) => delete normalizedHeaders[header]);
}
return normalizedHeaders;
}
function body(body, config, req) {
return isFunction(config) ? config(body, req) : body;
}
var NormalizeRequest = {
headers,
method,
body,
url,
};
module.exports = { NormalizeRequest };
Raw
pollyConf.js
// Default pollyJS config
var defaultConfig = {
method: true,
headers: true,
body: true,
order: true,
url: {
protocol: true,
username: true,
password: true,
hostname: true,
port: true,
pathname: true,
query: true,
hash: false,
},
};
module.exports = {
...defaultConfig,
// Merge your own config here
};
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment