, but guard against overflow.
var handledCPCountPlusOne = handledCPCount + 1;
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
throw RangeError(OVERFLOW_ERROR);
}
delta += (m - n) * handledCPCountPlusOne;
n = m;
for (i = 0; i < input.length; i++) {
currentValue = input[i];
if (currentValue < n && ++delta > maxInt) {
throw RangeError(OVERFLOW_ERROR);
}
if (currentValue == n) {
// Represent delta as a generalized variable-length integer.
var q = delta;
for (var k = base; /* no condition */; k += base) {
var t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
if (q < t) break;
var qMinusT = q - t;
var baseMinusT = base - t;
output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT)));
q = floor(qMinusT / baseMinusT);
}
output.push(stringFromCharCode(digitToBasic(q)));
bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
delta = 0;
++handledCPCount;
}
}
++delta;
++n;
}
return output.join('');
};
module.exports = function (input) {
var encoded = [];
var labels = input.toLowerCase().replace(regexSeparators, '\u002E').split('.');
var i, label;
for (i = 0; i < labels.length; i++) {
label = labels[i];
encoded.push(regexNonASCII.test(label) ? 'xn--' + encode(label) : label);
}
return encoded.join('.');
};
core-js-3.6.1/packages/core-js/internals/redefine-all.js 0000664 0000000 0000000 00000000272 13600575677 0023110 0 ustar 00root root 0000000 0000000 var redefine = require('../internals/redefine');
module.exports = function (target, src, options) {
for (var key in src) redefine(target, key, src[key], options);
return target;
};
core-js-3.6.1/packages/core-js/internals/redefine.js 0000664 0000000 0000000 00000002746 13600575677 0022352 0 ustar 00root root 0000000 0000000 var global = require('../internals/global');
var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
var has = require('../internals/has');
var setGlobal = require('../internals/set-global');
var inspectSource = require('../internals/inspect-source');
var InternalStateModule = require('../internals/internal-state');
var getInternalState = InternalStateModule.get;
var enforceInternalState = InternalStateModule.enforce;
var TEMPLATE = String(String).split('String');
(module.exports = function (O, key, value, options) {
var unsafe = options ? !!options.unsafe : false;
var simple = options ? !!options.enumerable : false;
var noTargetGet = options ? !!options.noTargetGet : false;
if (typeof value == 'function') {
if (typeof key == 'string' && !has(value, 'name')) createNonEnumerableProperty(value, 'name', key);
enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : '');
}
if (O === global) {
if (simple) O[key] = value;
else setGlobal(key, value);
return;
} else if (!unsafe) {
delete O[key];
} else if (!noTargetGet && O[key]) {
simple = true;
}
if (simple) O[key] = value;
else createNonEnumerableProperty(O, key, value);
// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
})(Function.prototype, 'toString', function toString() {
return typeof this == 'function' && getInternalState(this).source || inspectSource(this);
});
core-js-3.6.1/packages/core-js/internals/reflect-metadata.js 0000664 0000000 0000000 00000003534 13600575677 0023767 0 ustar 00root root 0000000 0000000 // TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
var Map = require('../modules/es.map');
var WeakMap = require('../modules/es.weak-map');
var shared = require('../internals/shared');
var metadata = shared('metadata');
var store = metadata.store || (metadata.store = new WeakMap());
var getOrCreateMetadataMap = function (target, targetKey, create) {
var targetMetadata = store.get(target);
if (!targetMetadata) {
if (!create) return;
store.set(target, targetMetadata = new Map());
}
var keyMetadata = targetMetadata.get(targetKey);
if (!keyMetadata) {
if (!create) return;
targetMetadata.set(targetKey, keyMetadata = new Map());
} return keyMetadata;
};
var ordinaryHasOwnMetadata = function (MetadataKey, O, P) {
var metadataMap = getOrCreateMetadataMap(O, P, false);
return metadataMap === undefined ? false : metadataMap.has(MetadataKey);
};
var ordinaryGetOwnMetadata = function (MetadataKey, O, P) {
var metadataMap = getOrCreateMetadataMap(O, P, false);
return metadataMap === undefined ? undefined : metadataMap.get(MetadataKey);
};
var ordinaryDefineOwnMetadata = function (MetadataKey, MetadataValue, O, P) {
getOrCreateMetadataMap(O, P, true).set(MetadataKey, MetadataValue);
};
var ordinaryOwnMetadataKeys = function (target, targetKey) {
var metadataMap = getOrCreateMetadataMap(target, targetKey, false);
var keys = [];
if (metadataMap) metadataMap.forEach(function (_, key) { keys.push(key); });
return keys;
};
var toMetadataKey = function (it) {
return it === undefined || typeof it == 'symbol' ? it : String(it);
};
module.exports = {
store: store,
getMap: getOrCreateMetadataMap,
has: ordinaryHasOwnMetadata,
get: ordinaryGetOwnMetadata,
set: ordinaryDefineOwnMetadata,
keys: ordinaryOwnMetadataKeys,
toKey: toMetadataKey
};
core-js-3.6.1/packages/core-js/internals/regexp-exec-abstract.js 0000664 0000000 0000000 00000001126 13600575677 0024575 0 ustar 00root root 0000000 0000000 var classof = require('./classof-raw');
var regexpExec = require('./regexp-exec');
// `RegExpExec` abstract operation
// https://tc39.github.io/ecma262/#sec-regexpexec
module.exports = function (R, S) {
var exec = R.exec;
if (typeof exec === 'function') {
var result = exec.call(R, S);
if (typeof result !== 'object') {
throw TypeError('RegExp exec method returned something other than an Object or null');
}
return result;
}
if (classof(R) !== 'RegExp') {
throw TypeError('RegExp#exec called on incompatible receiver');
}
return regexpExec.call(R, S);
};
core-js-3.6.1/packages/core-js/internals/regexp-exec.js 0000664 0000000 0000000 00000005400 13600575677 0022773 0 ustar 00root root 0000000 0000000 'use strict';
var regexpFlags = require('./regexp-flags');
var stickyHelpers = require('./regexp-sticky-helpers');
var nativeExec = RegExp.prototype.exec;
// This always refers to the native implementation, because the
// String#replace polyfill uses ./fix-regexp-well-known-symbol-logic.js,
// which loads this file before patching the method.
var nativeReplace = String.prototype.replace;
var patchedExec = nativeExec;
var UPDATES_LAST_INDEX_WRONG = (function () {
var re1 = /a/;
var re2 = /b*/g;
nativeExec.call(re1, 'a');
nativeExec.call(re2, 'a');
return re1.lastIndex !== 0 || re2.lastIndex !== 0;
})();
var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y || stickyHelpers.BROKEN_CARET;
// nonparticipating capturing group, copied from es5-shim's String#split patch.
var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;
var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y;
if (PATCH) {
patchedExec = function exec(str) {
var re = this;
var lastIndex, reCopy, match, i;
var sticky = UNSUPPORTED_Y && re.sticky;
var flags = regexpFlags.call(re);
var source = re.source;
var charsAdded = 0;
var strCopy = str;
if (sticky) {
flags = flags.replace('y', '');
if (flags.indexOf('g') === -1) {
flags += 'g';
}
strCopy = String(str).slice(re.lastIndex);
// Support anchored sticky behavior.
if (re.lastIndex > 0 && (!re.multiline || re.multiline && str[re.lastIndex - 1] !== '\n')) {
source = '(?: ' + source + ')';
strCopy = ' ' + strCopy;
charsAdded++;
}
// ^(? + rx + ) is needed, in combination with some str slicing, to
// simulate the 'y' flag.
reCopy = new RegExp('^(?:' + source + ')', flags);
}
if (NPCG_INCLUDED) {
reCopy = new RegExp('^' + source + '$(?!\\s)', flags);
}
if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
match = nativeExec.call(sticky ? reCopy : re, strCopy);
if (sticky) {
if (match) {
match.input = match.input.slice(charsAdded);
match[0] = match[0].slice(charsAdded);
match.index = re.lastIndex;
re.lastIndex += match[0].length;
} else re.lastIndex = 0;
} else if (UPDATES_LAST_INDEX_WRONG && match) {
re.lastIndex = re.global ? match.index + match[0].length : lastIndex;
}
if (NPCG_INCLUDED && match && match.length > 1) {
// Fix browsers whose `exec` methods don't consistently return `undefined`
// for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/
nativeReplace.call(match[0], reCopy, function () {
for (i = 1; i < arguments.length - 2; i++) {
if (arguments[i] === undefined) match[i] = undefined;
}
});
}
return match;
};
}
module.exports = patchedExec;
core-js-3.6.1/packages/core-js/internals/regexp-flags.js 0000664 0000000 0000000 00000000754 13600575677 0023152 0 ustar 00root root 0000000 0000000 'use strict';
var anObject = require('../internals/an-object');
// `RegExp.prototype.flags` getter implementation
// https://tc39.github.io/ecma262/#sec-get-regexp.prototype.flags
module.exports = function () {
var that = anObject(this);
var result = '';
if (that.global) result += 'g';
if (that.ignoreCase) result += 'i';
if (that.multiline) result += 'm';
if (that.dotAll) result += 's';
if (that.unicode) result += 'u';
if (that.sticky) result += 'y';
return result;
};
core-js-3.6.1/packages/core-js/internals/regexp-sticky-helpers.js 0000664 0000000 0000000 00000001134 13600575677 0025015 0 ustar 00root root 0000000 0000000 'use strict';
var fails = require('./fails');
// babel-minify transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError,
// so we use an intermediate function.
function RE(s, f) {
return RegExp(s, f);
}
exports.UNSUPPORTED_Y = fails(function () {
// babel-minify transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
var re = RE('a', 'y');
re.lastIndex = 2;
return re.exec('abcd') != null;
});
exports.BROKEN_CARET = fails(function () {
// https://bugzilla.mozilla.org/show_bug.cgi?id=773687
var re = RE('^r', 'gy');
re.lastIndex = 2;
return re.exec('str') != null;
});
core-js-3.6.1/packages/core-js/internals/require-object-coercible.js 0000664 0000000 0000000 00000000344 13600575677 0025426 0 ustar 00root root 0000000 0000000 // `RequireObjectCoercible` abstract operation
// https://tc39.github.io/ecma262/#sec-requireobjectcoercible
module.exports = function (it) {
if (it == undefined) throw TypeError("Can't call method on " + it);
return it;
};
core-js-3.6.1/packages/core-js/internals/same-value-zero.js 0000664 0000000 0000000 00000000325 13600575677 0023574 0 ustar 00root root 0000000 0000000 // `SameValueZero` abstract operation
// https://tc39.github.io/ecma262/#sec-samevaluezero
module.exports = function (x, y) {
// eslint-disable-next-line no-self-compare
return x === y || x != x && y != y;
};
core-js-3.6.1/packages/core-js/internals/same-value.js 0000664 0000000 0000000 00000000370 13600575677 0022617 0 ustar 00root root 0000000 0000000 // `SameValue` abstract operation
// https://tc39.github.io/ecma262/#sec-samevalue
module.exports = Object.is || function is(x, y) {
// eslint-disable-next-line no-self-compare
return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y;
};
core-js-3.6.1/packages/core-js/internals/set-global.js 0000664 0000000 0000000 00000000460 13600575677 0022611 0 ustar 00root root 0000000 0000000 var global = require('../internals/global');
var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
module.exports = function (key, value) {
try {
createNonEnumerableProperty(global, key, value);
} catch (error) {
global[key] = value;
} return value;
};
core-js-3.6.1/packages/core-js/internals/set-species.js 0000664 0000000 0000000 00000001176 13600575677 0023011 0 ustar 00root root 0000000 0000000 'use strict';
var getBuiltIn = require('../internals/get-built-in');
var definePropertyModule = require('../internals/object-define-property');
var wellKnownSymbol = require('../internals/well-known-symbol');
var DESCRIPTORS = require('../internals/descriptors');
var SPECIES = wellKnownSymbol('species');
module.exports = function (CONSTRUCTOR_NAME) {
var Constructor = getBuiltIn(CONSTRUCTOR_NAME);
var defineProperty = definePropertyModule.f;
if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {
defineProperty(Constructor, SPECIES, {
configurable: true,
get: function () { return this; }
});
}
};
core-js-3.6.1/packages/core-js/internals/set-to-string-tag.js 0000664 0000000 0000000 00000000651 13600575677 0024052 0 ustar 00root root 0000000 0000000 var defineProperty = require('../internals/object-define-property').f;
var has = require('../internals/has');
var wellKnownSymbol = require('../internals/well-known-symbol');
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
module.exports = function (it, TAG, STATIC) {
if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {
defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG });
}
};
core-js-3.6.1/packages/core-js/internals/shared-key.js 0000664 0000000 0000000 00000000304 13600575677 0022611 0 ustar 00root root 0000000 0000000 var shared = require('../internals/shared');
var uid = require('../internals/uid');
var keys = shared('keys');
module.exports = function (key) {
return keys[key] || (keys[key] = uid(key));
};
core-js-3.6.1/packages/core-js/internals/shared-store.js 0000664 0000000 0000000 00000000323 13600575677 0023156 0 ustar 00root root 0000000 0000000 var global = require('../internals/global');
var setGlobal = require('../internals/set-global');
var SHARED = '__core-js_shared__';
var store = global[SHARED] || setGlobal(SHARED, {});
module.exports = store;
core-js-3.6.1/packages/core-js/internals/shared.js 0000664 0000000 0000000 00000000540 13600575677 0022025 0 ustar 00root root 0000000 0000000 var IS_PURE = require('../internals/is-pure');
var store = require('../internals/shared-store');
(module.exports = function (key, value) {
return store[key] || (store[key] = value !== undefined ? value : {});
})('versions', []).push({
version: '3.6.1',
mode: IS_PURE ? 'pure' : 'global',
copyright: '© 2019 Denis Pushkarev (zloirock.ru)'
});
core-js-3.6.1/packages/core-js/internals/sloppy-array-method.js 0000664 0000000 0000000 00000000501 13600575677 0024474 0 ustar 00root root 0000000 0000000 'use strict';
var fails = require('../internals/fails');
module.exports = function (METHOD_NAME, argument) {
var method = [][METHOD_NAME];
return !method || !fails(function () {
// eslint-disable-next-line no-useless-call,no-throw-literal
method.call(null, argument || function () { throw 1; }, 1);
});
};
core-js-3.6.1/packages/core-js/internals/species-constructor.js 0000664 0000000 0000000 00000001004 13600575677 0024571 0 ustar 00root root 0000000 0000000 var anObject = require('../internals/an-object');
var aFunction = require('../internals/a-function');
var wellKnownSymbol = require('../internals/well-known-symbol');
var SPECIES = wellKnownSymbol('species');
// `SpeciesConstructor` abstract operation
// https://tc39.github.io/ecma262/#sec-speciesconstructor
module.exports = function (O, defaultConstructor) {
var C = anObject(O).constructor;
var S;
return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? defaultConstructor : aFunction(S);
};
core-js-3.6.1/packages/core-js/internals/string-multibyte.js 0000664 0000000 0000000 00000002176 13600575677 0024110 0 ustar 00root root 0000000 0000000 var toInteger = require('../internals/to-integer');
var requireObjectCoercible = require('../internals/require-object-coercible');
// `String.prototype.{ codePointAt, at }` methods implementation
var createMethod = function (CONVERT_TO_STRING) {
return function ($this, pos) {
var S = String(requireObjectCoercible($this));
var position = toInteger(pos);
var size = S.length;
var first, second;
if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
first = S.charCodeAt(position);
return first < 0xD800 || first > 0xDBFF || position + 1 === size
|| (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF
? CONVERT_TO_STRING ? S.charAt(position) : first
: CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
};
};
module.exports = {
// `String.prototype.codePointAt` method
// https://tc39.github.io/ecma262/#sec-string.prototype.codepointat
codeAt: createMethod(false),
// `String.prototype.at` method
// https://github.com/mathiasbynens/String.prototype.at
charAt: createMethod(true)
};
core-js-3.6.1/packages/core-js/internals/string-pad.js 0000664 0000000 0000000 00000002365 13600575677 0022636 0 ustar 00root root 0000000 0000000 // https://github.com/tc39/proposal-string-pad-start-end
var toLength = require('../internals/to-length');
var repeat = require('../internals/string-repeat');
var requireObjectCoercible = require('../internals/require-object-coercible');
var ceil = Math.ceil;
// `String.prototype.{ padStart, padEnd }` methods implementation
var createMethod = function (IS_END) {
return function ($this, maxLength, fillString) {
var S = String(requireObjectCoercible($this));
var stringLength = S.length;
var fillStr = fillString === undefined ? ' ' : String(fillString);
var intMaxLength = toLength(maxLength);
var fillLen, stringFiller;
if (intMaxLength <= stringLength || fillStr == '') return S;
fillLen = intMaxLength - stringLength;
stringFiller = repeat.call(fillStr, ceil(fillLen / fillStr.length));
if (stringFiller.length > fillLen) stringFiller = stringFiller.slice(0, fillLen);
return IS_END ? S + stringFiller : stringFiller + S;
};
};
module.exports = {
// `String.prototype.padStart` method
// https://tc39.github.io/ecma262/#sec-string.prototype.padstart
start: createMethod(false),
// `String.prototype.padEnd` method
// https://tc39.github.io/ecma262/#sec-string.prototype.padend
end: createMethod(true)
};
core-js-3.6.1/packages/core-js/internals/string-repeat.js 0000664 0000000 0000000 00000001104 13600575677 0023340 0 ustar 00root root 0000000 0000000 'use strict';
var toInteger = require('../internals/to-integer');
var requireObjectCoercible = require('../internals/require-object-coercible');
// `String.prototype.repeat` method implementation
// https://tc39.github.io/ecma262/#sec-string.prototype.repeat
module.exports = ''.repeat || function repeat(count) {
var str = String(requireObjectCoercible(this));
var result = '';
var n = toInteger(count);
if (n < 0 || n == Infinity) throw RangeError('Wrong number of repetitions');
for (;n > 0; (n >>>= 1) && (str += str)) if (n & 1) result += str;
return result;
};
core-js-3.6.1/packages/core-js/internals/string-trim.js 0000664 0000000 0000000 00000002067 13600575677 0023044 0 ustar 00root root 0000000 0000000 var requireObjectCoercible = require('../internals/require-object-coercible');
var whitespaces = require('../internals/whitespaces');
var whitespace = '[' + whitespaces + ']';
var ltrim = RegExp('^' + whitespace + whitespace + '*');
var rtrim = RegExp(whitespace + whitespace + '*$');
// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation
var createMethod = function (TYPE) {
return function ($this) {
var string = String(requireObjectCoercible($this));
if (TYPE & 1) string = string.replace(ltrim, '');
if (TYPE & 2) string = string.replace(rtrim, '');
return string;
};
};
module.exports = {
// `String.prototype.{ trimLeft, trimStart }` methods
// https://tc39.github.io/ecma262/#sec-string.prototype.trimstart
start: createMethod(1),
// `String.prototype.{ trimRight, trimEnd }` methods
// https://tc39.github.io/ecma262/#sec-string.prototype.trimend
end: createMethod(2),
// `String.prototype.trim` method
// https://tc39.github.io/ecma262/#sec-string.prototype.trim
trim: createMethod(3)
};
core-js-3.6.1/packages/core-js/internals/task.js 0000664 0000000 0000000 00000005526 13600575677 0021532 0 ustar 00root root 0000000 0000000 var global = require('../internals/global');
var fails = require('../internals/fails');
var classof = require('../internals/classof-raw');
var bind = require('../internals/bind-context');
var html = require('../internals/html');
var createElement = require('../internals/document-create-element');
var IS_IOS = require('../internals/is-ios');
var location = global.location;
var set = global.setImmediate;
var clear = global.clearImmediate;
var process = global.process;
var MessageChannel = global.MessageChannel;
var Dispatch = global.Dispatch;
var counter = 0;
var queue = {};
var ONREADYSTATECHANGE = 'onreadystatechange';
var defer, channel, port;
var run = function (id) {
// eslint-disable-next-line no-prototype-builtins
if (queue.hasOwnProperty(id)) {
var fn = queue[id];
delete queue[id];
fn();
}
};
var runner = function (id) {
return function () {
run(id);
};
};
var listener = function (event) {
run(event.data);
};
var post = function (id) {
// old engines have not location.origin
global.postMessage(id + '', location.protocol + '//' + location.host);
};
// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
if (!set || !clear) {
set = 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
(typeof fn == 'function' ? fn : Function(fn)).apply(undefined, args);
};
defer(counter);
return counter;
};
clear = function clearImmediate(id) {
delete queue[id];
};
// Node.js 0.8-
if (classof(process) == 'process') {
defer = function (id) {
process.nextTick(runner(id));
};
// Sphere (JS game engine) Dispatch API
} else if (Dispatch && Dispatch.now) {
defer = function (id) {
Dispatch.now(runner(id));
};
// Browsers with MessageChannel, includes WebWorkers
// except iOS - https://github.com/zloirock/core-js/issues/624
} else if (MessageChannel && !IS_IOS) {
channel = new MessageChannel();
port = channel.port2;
channel.port1.onmessage = listener;
defer = bind(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 && !fails(post)) {
defer = post;
global.addEventListener('message', listener, false);
// IE8-
} else if (ONREADYSTATECHANGE in createElement('script')) {
defer = function (id) {
html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
html.removeChild(this);
run(id);
};
};
// Rest old browsers
} else {
defer = function (id) {
setTimeout(runner(id), 0);
};
}
}
module.exports = {
set: set,
clear: clear
};
core-js-3.6.1/packages/core-js/internals/this-number-value.js 0000664 0000000 0000000 00000000474 13600575677 0024134 0 ustar 00root root 0000000 0000000 var classof = require('../internals/classof-raw');
// `thisNumberValue` abstract operation
// https://tc39.github.io/ecma262/#sec-thisnumbervalue
module.exports = function (value) {
if (typeof value != 'number' && classof(value) != 'Number') {
throw TypeError('Incorrect invocation');
}
return +value;
};
core-js-3.6.1/packages/core-js/internals/to-absolute-index.js 0000664 0000000 0000000 00000000667 13600575677 0024134 0 ustar 00root root 0000000 0000000 var toInteger = require('../internals/to-integer');
var max = Math.max;
var min = Math.min;
// Helper for a popular repeating case of the spec:
// Let integer be ? ToInteger(index).
// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
module.exports = function (index, length) {
var integer = toInteger(index);
return integer < 0 ? max(integer + length, 0) : min(integer, length);
};
core-js-3.6.1/packages/core-js/internals/to-index.js 0000664 0000000 0000000 00000000620 13600575677 0022305 0 ustar 00root root 0000000 0000000 var toInteger = require('../internals/to-integer');
var toLength = require('../internals/to-length');
// `ToIndex` abstract operation
// https://tc39.github.io/ecma262/#sec-toindex
module.exports = function (it) {
if (it === undefined) return 0;
var number = toInteger(it);
var length = toLength(number);
if (number !== length) throw RangeError('Wrong length or index');
return length;
};
core-js-3.6.1/packages/core-js/internals/to-indexed-object.js 0000664 0000000 0000000 00000000435 13600575677 0024066 0 ustar 00root root 0000000 0000000 // toObject with fallback for non-array-like ES3 strings
var IndexedObject = require('../internals/indexed-object');
var requireObjectCoercible = require('../internals/require-object-coercible');
module.exports = function (it) {
return IndexedObject(requireObjectCoercible(it));
};
core-js-3.6.1/packages/core-js/internals/to-integer.js 0000664 0000000 0000000 00000000400 13600575677 0022627 0 ustar 00root root 0000000 0000000 var ceil = Math.ceil;
var floor = Math.floor;
// `ToInteger` abstract operation
// https://tc39.github.io/ecma262/#sec-tointeger
module.exports = function (argument) {
return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
};
core-js-3.6.1/packages/core-js/internals/to-length.js 0000664 0000000 0000000 00000000460 13600575677 0022461 0 ustar 00root root 0000000 0000000 var toInteger = require('../internals/to-integer');
var min = Math.min;
// `ToLength` abstract operation
// https://tc39.github.io/ecma262/#sec-tolength
module.exports = function (argument) {
return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
};
core-js-3.6.1/packages/core-js/internals/to-object.js 0000664 0000000 0000000 00000000376 13600575677 0022454 0 ustar 00root root 0000000 0000000 var requireObjectCoercible = require('../internals/require-object-coercible');
// `ToObject` abstract operation
// https://tc39.github.io/ecma262/#sec-toobject
module.exports = function (argument) {
return Object(requireObjectCoercible(argument));
};
core-js-3.6.1/packages/core-js/internals/to-offset.js 0000664 0000000 0000000 00000000340 13600575677 0022463 0 ustar 00root root 0000000 0000000 var toPositiveInteger = require('../internals/to-positive-integer');
module.exports = function (it, BYTES) {
var offset = toPositiveInteger(it);
if (offset % BYTES) throw RangeError('Wrong offset');
return offset;
};
core-js-3.6.1/packages/core-js/internals/to-positive-integer.js 0000664 0000000 0000000 00000000321 13600575677 0024471 0 ustar 00root root 0000000 0000000 var toInteger = require('../internals/to-integer');
module.exports = function (it) {
var result = toInteger(it);
if (result < 0) throw RangeError("The argument can't be less than 0");
return result;
};
core-js-3.6.1/packages/core-js/internals/to-primitive.js 0000664 0000000 0000000 00000001413 13600575677 0023207 0 ustar 00root root 0000000 0000000 var isObject = require('../internals/is-object');
// `ToPrimitive` abstract operation
// https://tc39.github.io/ecma262/#sec-toprimitive
// instead of the ES6 spec version, we didn't implement @@toPrimitive case
// and the second argument - flag - preferred type is a string
module.exports = function (input, PREFERRED_STRING) {
if (!isObject(input)) return input;
var fn, val;
if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;
if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;
if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;
throw TypeError("Can't convert object to primitive value");
};
core-js-3.6.1/packages/core-js/internals/to-string-tag-support.js 0000664 0000000 0000000 00000000322 13600575677 0024766 0 ustar 00root root 0000000 0000000 var wellKnownSymbol = require('../internals/well-known-symbol');
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
var test = {};
test[TO_STRING_TAG] = 'z';
module.exports = String(test) === '[object z]';
core-js-3.6.1/packages/core-js/internals/typed-array-constructor.js 0000664 0000000 0000000 00000022730 13600575677 0025410 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var global = require('../internals/global');
var DESCRIPTORS = require('../internals/descriptors');
var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = require('../internals/typed-arrays-constructors-requires-wrappers');
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var ArrayBufferModule = require('../internals/array-buffer');
var anInstance = require('../internals/an-instance');
var createPropertyDescriptor = require('../internals/create-property-descriptor');
var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
var toLength = require('../internals/to-length');
var toIndex = require('../internals/to-index');
var toOffset = require('../internals/to-offset');
var toPrimitive = require('../internals/to-primitive');
var has = require('../internals/has');
var classof = require('../internals/classof');
var isObject = require('../internals/is-object');
var create = require('../internals/object-create');
var setPrototypeOf = require('../internals/object-set-prototype-of');
var getOwnPropertyNames = require('../internals/object-get-own-property-names').f;
var typedArrayFrom = require('../internals/typed-array-from');
var forEach = require('../internals/array-iteration').forEach;
var setSpecies = require('../internals/set-species');
var definePropertyModule = require('../internals/object-define-property');
var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
var InternalStateModule = require('../internals/internal-state');
var inheritIfRequired = require('../internals/inherit-if-required');
var getInternalState = InternalStateModule.get;
var setInternalState = InternalStateModule.set;
var nativeDefineProperty = definePropertyModule.f;
var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
var round = Math.round;
var RangeError = global.RangeError;
var ArrayBuffer = ArrayBufferModule.ArrayBuffer;
var DataView = ArrayBufferModule.DataView;
var NATIVE_ARRAY_BUFFER_VIEWS = ArrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS;
var TYPED_ARRAY_TAG = ArrayBufferViewCore.TYPED_ARRAY_TAG;
var TypedArray = ArrayBufferViewCore.TypedArray;
var TypedArrayPrototype = ArrayBufferViewCore.TypedArrayPrototype;
var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor;
var isTypedArray = ArrayBufferViewCore.isTypedArray;
var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT';
var WRONG_LENGTH = 'Wrong length';
var fromList = function (C, list) {
var index = 0;
var length = list.length;
var result = new (aTypedArrayConstructor(C))(length);
while (length > index) result[index] = list[index++];
return result;
};
var addGetter = function (it, key) {
nativeDefineProperty(it, key, { get: function () {
return getInternalState(this)[key];
} });
};
var isArrayBuffer = function (it) {
var klass;
return it instanceof ArrayBuffer || (klass = classof(it)) == 'ArrayBuffer' || klass == 'SharedArrayBuffer';
};
var isTypedArrayIndex = function (target, key) {
return isTypedArray(target)
&& typeof key != 'symbol'
&& key in target
&& String(+key) == String(key);
};
var wrappedGetOwnPropertyDescriptor = function getOwnPropertyDescriptor(target, key) {
return isTypedArrayIndex(target, key = toPrimitive(key, true))
? createPropertyDescriptor(2, target[key])
: nativeGetOwnPropertyDescriptor(target, key);
};
var wrappedDefineProperty = function defineProperty(target, key, descriptor) {
if (isTypedArrayIndex(target, key = toPrimitive(key, true))
&& isObject(descriptor)
&& has(descriptor, 'value')
&& !has(descriptor, 'get')
&& !has(descriptor, 'set')
// TODO: add validation descriptor w/o calling accessors
&& !descriptor.configurable
&& (!has(descriptor, 'writable') || descriptor.writable)
&& (!has(descriptor, 'enumerable') || descriptor.enumerable)
) {
target[key] = descriptor.value;
return target;
} return nativeDefineProperty(target, key, descriptor);
};
if (DESCRIPTORS) {
if (!NATIVE_ARRAY_BUFFER_VIEWS) {
getOwnPropertyDescriptorModule.f = wrappedGetOwnPropertyDescriptor;
definePropertyModule.f = wrappedDefineProperty;
addGetter(TypedArrayPrototype, 'buffer');
addGetter(TypedArrayPrototype, 'byteOffset');
addGetter(TypedArrayPrototype, 'byteLength');
addGetter(TypedArrayPrototype, 'length');
}
$({ target: 'Object', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS }, {
getOwnPropertyDescriptor: wrappedGetOwnPropertyDescriptor,
defineProperty: wrappedDefineProperty
});
module.exports = function (TYPE, wrapper, CLAMPED) {
var BYTES = TYPE.match(/\d+$/)[0] / 8;
var CONSTRUCTOR_NAME = TYPE + (CLAMPED ? 'Clamped' : '') + 'Array';
var GETTER = 'get' + TYPE;
var SETTER = 'set' + TYPE;
var NativeTypedArrayConstructor = global[CONSTRUCTOR_NAME];
var TypedArrayConstructor = NativeTypedArrayConstructor;
var TypedArrayConstructorPrototype = TypedArrayConstructor && TypedArrayConstructor.prototype;
var exported = {};
var getter = function (that, index) {
var data = getInternalState(that);
return data.view[GETTER](index * BYTES + data.byteOffset, true);
};
var setter = function (that, index, value) {
var data = getInternalState(that);
if (CLAMPED) value = (value = round(value)) < 0 ? 0 : value > 0xFF ? 0xFF : value & 0xFF;
data.view[SETTER](index * BYTES + data.byteOffset, value, true);
};
var addElement = function (that, index) {
nativeDefineProperty(that, index, {
get: function () {
return getter(this, index);
},
set: function (value) {
return setter(this, index, value);
},
enumerable: true
});
};
if (!NATIVE_ARRAY_BUFFER_VIEWS) {
TypedArrayConstructor = wrapper(function (that, data, offset, $length) {
anInstance(that, TypedArrayConstructor, CONSTRUCTOR_NAME);
var index = 0;
var byteOffset = 0;
var buffer, byteLength, length;
if (!isObject(data)) {
length = toIndex(data);
byteLength = length * BYTES;
buffer = new ArrayBuffer(byteLength);
} else if (isArrayBuffer(data)) {
buffer = data;
byteOffset = toOffset(offset, BYTES);
var $len = data.byteLength;
if ($length === undefined) {
if ($len % BYTES) throw RangeError(WRONG_LENGTH);
byteLength = $len - byteOffset;
if (byteLength < 0) throw RangeError(WRONG_LENGTH);
} else {
byteLength = toLength($length) * BYTES;
if (byteLength + byteOffset > $len) throw RangeError(WRONG_LENGTH);
}
length = byteLength / BYTES;
} else if (isTypedArray(data)) {
return fromList(TypedArrayConstructor, data);
} else {
return typedArrayFrom.call(TypedArrayConstructor, data);
}
setInternalState(that, {
buffer: buffer,
byteOffset: byteOffset,
byteLength: byteLength,
length: length,
view: new DataView(buffer)
});
while (index < length) addElement(that, index++);
});
if (setPrototypeOf) setPrototypeOf(TypedArrayConstructor, TypedArray);
TypedArrayConstructorPrototype = TypedArrayConstructor.prototype = create(TypedArrayPrototype);
} else if (TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS) {
TypedArrayConstructor = wrapper(function (dummy, data, typedArrayOffset, $length) {
anInstance(dummy, TypedArrayConstructor, CONSTRUCTOR_NAME);
return inheritIfRequired(function () {
if (!isObject(data)) return new NativeTypedArrayConstructor(toIndex(data));
if (isArrayBuffer(data)) return $length !== undefined
? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES), $length)
: typedArrayOffset !== undefined
? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES))
: new NativeTypedArrayConstructor(data);
if (isTypedArray(data)) return fromList(TypedArrayConstructor, data);
return typedArrayFrom.call(TypedArrayConstructor, data);
}(), dummy, TypedArrayConstructor);
});
if (setPrototypeOf) setPrototypeOf(TypedArrayConstructor, TypedArray);
forEach(getOwnPropertyNames(NativeTypedArrayConstructor), function (key) {
if (!(key in TypedArrayConstructor)) {
createNonEnumerableProperty(TypedArrayConstructor, key, NativeTypedArrayConstructor[key]);
}
});
TypedArrayConstructor.prototype = TypedArrayConstructorPrototype;
}
if (TypedArrayConstructorPrototype.constructor !== TypedArrayConstructor) {
createNonEnumerableProperty(TypedArrayConstructorPrototype, 'constructor', TypedArrayConstructor);
}
if (TYPED_ARRAY_TAG) {
createNonEnumerableProperty(TypedArrayConstructorPrototype, TYPED_ARRAY_TAG, CONSTRUCTOR_NAME);
}
exported[CONSTRUCTOR_NAME] = TypedArrayConstructor;
$({
global: true, forced: TypedArrayConstructor != NativeTypedArrayConstructor, sham: !NATIVE_ARRAY_BUFFER_VIEWS
}, exported);
if (!(BYTES_PER_ELEMENT in TypedArrayConstructor)) {
createNonEnumerableProperty(TypedArrayConstructor, BYTES_PER_ELEMENT, BYTES);
}
if (!(BYTES_PER_ELEMENT in TypedArrayConstructorPrototype)) {
createNonEnumerableProperty(TypedArrayConstructorPrototype, BYTES_PER_ELEMENT, BYTES);
}
setSpecies(CONSTRUCTOR_NAME);
};
} else module.exports = function () { /* empty */ };
core-js-3.6.1/packages/core-js/internals/typed-array-from.js 0000664 0000000 0000000 00000002331 13600575677 0023761 0 ustar 00root root 0000000 0000000 var toObject = require('../internals/to-object');
var toLength = require('../internals/to-length');
var getIteratorMethod = require('../internals/get-iterator-method');
var isArrayIteratorMethod = require('../internals/is-array-iterator-method');
var bind = require('../internals/bind-context');
var aTypedArrayConstructor = require('../internals/array-buffer-view-core').aTypedArrayConstructor;
module.exports = function from(source /* , mapfn, thisArg */) {
var O = toObject(source);
var argumentsLength = arguments.length;
var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
var mapping = mapfn !== undefined;
var iteratorMethod = getIteratorMethod(O);
var i, length, result, step, iterator, next;
if (iteratorMethod != undefined && !isArrayIteratorMethod(iteratorMethod)) {
iterator = iteratorMethod.call(O);
next = iterator.next;
O = [];
while (!(step = next.call(iterator)).done) {
O.push(step.value);
}
}
if (mapping && argumentsLength > 2) {
mapfn = bind(mapfn, arguments[2], 2);
}
length = toLength(O.length);
result = new (aTypedArrayConstructor(this))(length);
for (i = 0; length > i; i++) {
result[i] = mapping ? mapfn(O[i], i) : O[i];
}
return result;
};
core-js-3.6.1/packages/core-js/internals/typed-arrays-constructors-requires-wrappers.js 0000664 0000000 0000000 00000001534 13600575677 0031453 0 ustar 00root root 0000000 0000000 /* eslint-disable no-new */
var global = require('../internals/global');
var fails = require('../internals/fails');
var checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');
var NATIVE_ARRAY_BUFFER_VIEWS = require('../internals/array-buffer-view-core').NATIVE_ARRAY_BUFFER_VIEWS;
var ArrayBuffer = global.ArrayBuffer;
var Int8Array = global.Int8Array;
module.exports = !NATIVE_ARRAY_BUFFER_VIEWS || !fails(function () {
Int8Array(1);
}) || !fails(function () {
new Int8Array(-1);
}) || !checkCorrectnessOfIteration(function (iterable) {
new Int8Array();
new Int8Array(null);
new Int8Array(1.5);
new Int8Array(iterable);
}, true) || fails(function () {
// Safari (11+) bug - a reason why even Safari 13 should load a typed array polyfill
return new Int8Array(new ArrayBuffer(2), 1, undefined).length !== 1;
});
core-js-3.6.1/packages/core-js/internals/uid.js 0000664 0000000 0000000 00000000261 13600575677 0021340 0 ustar 00root root 0000000 0000000 var id = 0;
var postfix = Math.random();
module.exports = function (key) {
return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);
};
core-js-3.6.1/packages/core-js/internals/use-symbol-as-uid.js 0000664 0000000 0000000 00000000344 13600575677 0024040 0 ustar 00root root 0000000 0000000 var NATIVE_SYMBOL = require('../internals/native-symbol');
module.exports = NATIVE_SYMBOL
// eslint-disable-next-line no-undef
&& !Symbol.sham
// eslint-disable-next-line no-undef
&& typeof Symbol.iterator == 'symbol';
core-js-3.6.1/packages/core-js/internals/user-agent.js 0000664 0000000 0000000 00000000165 13600575677 0022634 0 ustar 00root root 0000000 0000000 var getBuiltIn = require('../internals/get-built-in');
module.exports = getBuiltIn('navigator', 'userAgent') || '';
core-js-3.6.1/packages/core-js/internals/v8-version.js 0000664 0000000 0000000 00000001011 13600575677 0022571 0 ustar 00root root 0000000 0000000 var global = require('../internals/global');
var userAgent = require('../internals/user-agent');
var process = global.process;
var versions = process && process.versions;
var v8 = versions && versions.v8;
var match, version;
if (v8) {
match = v8.split('.');
version = match[0] + match[1];
} else if (userAgent) {
match = userAgent.match(/Edge\/(\d+)/);
if (!match || match[1] >= 74) {
match = userAgent.match(/Chrome\/(\d+)/);
if (match) version = match[1];
}
}
module.exports = version && +version;
core-js-3.6.1/packages/core-js/internals/webkit-string-pad-bug.js 0000664 0000000 0000000 00000000360 13600575677 0024665 0 ustar 00root root 0000000 0000000 // https://github.com/zloirock/core-js/issues/280
var userAgent = require('../internals/user-agent');
// eslint-disable-next-line unicorn/no-unsafe-regex
module.exports = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(userAgent);
core-js-3.6.1/packages/core-js/internals/well-known-symbol.js 0000664 0000000 0000000 00000001360 13600575677 0024160 0 ustar 00root root 0000000 0000000 var global = require('../internals/global');
var shared = require('../internals/shared');
var has = require('../internals/has');
var uid = require('../internals/uid');
var NATIVE_SYMBOL = require('../internals/native-symbol');
var USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');
var WellKnownSymbolsStore = shared('wks');
var Symbol = global.Symbol;
var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;
module.exports = function (name) {
if (!has(WellKnownSymbolsStore, name)) {
if (NATIVE_SYMBOL && has(Symbol, name)) WellKnownSymbolsStore[name] = Symbol[name];
else WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);
} return WellKnownSymbolsStore[name];
};
core-js-3.6.1/packages/core-js/internals/whitespaces.js 0000664 0000000 0000000 00000000374 13600575677 0023103 0 ustar 00root root 0000000 0000000 // a string of all valid unicode whitespaces
// eslint-disable-next-line max-len
module.exports = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
core-js-3.6.1/packages/core-js/internals/wrapped-well-known-symbol.js 0000664 0000000 0000000 00000000137 13600575677 0025621 0 ustar 00root root 0000000 0000000 var wellKnownSymbol = require('../internals/well-known-symbol');
exports.f = wellKnownSymbol;
core-js-3.6.1/packages/core-js/modules/ 0000775 0000000 0000000 00000000000 13600575677 0017673 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/modules/README.md 0000664 0000000 0000000 00000000244 13600575677 0021152 0 ustar 00root root 0000000 0000000 This folder contains implementations of polyfills. It's not recommended to include in your projects directly if you don't completely understand what are you doing.
core-js-3.6.1/packages/core-js/modules/es.array-buffer.constructor.js 0000664 0000000 0000000 00000001063 13600575677 0025610 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var global = require('../internals/global');
var arrayBufferModule = require('../internals/array-buffer');
var setSpecies = require('../internals/set-species');
var ARRAY_BUFFER = 'ArrayBuffer';
var ArrayBuffer = arrayBufferModule[ARRAY_BUFFER];
var NativeArrayBuffer = global[ARRAY_BUFFER];
// `ArrayBuffer` constructor
// https://tc39.github.io/ecma262/#sec-arraybuffer-constructor
$({ global: true, forced: NativeArrayBuffer !== ArrayBuffer }, {
ArrayBuffer: ArrayBuffer
});
setSpecies(ARRAY_BUFFER);
core-js-3.6.1/packages/core-js/modules/es.array-buffer.is-view.js 0000664 0000000 0000000 00000000624 13600575677 0024610 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var NATIVE_ARRAY_BUFFER_VIEWS = ArrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS;
// `ArrayBuffer.isView` method
// https://tc39.github.io/ecma262/#sec-arraybuffer.isview
$({ target: 'ArrayBuffer', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS }, {
isView: ArrayBufferViewCore.isView
});
core-js-3.6.1/packages/core-js/modules/es.array-buffer.slice.js 0000664 0000000 0000000 00000002742 13600575677 0024327 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var fails = require('../internals/fails');
var ArrayBufferModule = require('../internals/array-buffer');
var anObject = require('../internals/an-object');
var toAbsoluteIndex = require('../internals/to-absolute-index');
var toLength = require('../internals/to-length');
var speciesConstructor = require('../internals/species-constructor');
var ArrayBuffer = ArrayBufferModule.ArrayBuffer;
var DataView = ArrayBufferModule.DataView;
var nativeArrayBufferSlice = ArrayBuffer.prototype.slice;
var INCORRECT_SLICE = fails(function () {
return !new ArrayBuffer(2).slice(1, undefined).byteLength;
});
// `ArrayBuffer.prototype.slice` method
// https://tc39.github.io/ecma262/#sec-arraybuffer.prototype.slice
$({ target: 'ArrayBuffer', proto: true, unsafe: true, forced: INCORRECT_SLICE }, {
slice: function slice(start, end) {
if (nativeArrayBufferSlice !== undefined && end === undefined) {
return nativeArrayBufferSlice.call(anObject(this), start); // FF fix
}
var length = anObject(this).byteLength;
var first = toAbsoluteIndex(start, length);
var fin = toAbsoluteIndex(end === undefined ? length : end, length);
var result = new (speciesConstructor(this, ArrayBuffer))(toLength(fin - first));
var viewSource = new DataView(this);
var viewTarget = new DataView(result);
var index = 0;
while (first < fin) {
viewTarget.setUint8(index++, viewSource.getUint8(first++));
} return result;
}
});
core-js-3.6.1/packages/core-js/modules/es.array.concat.js 0000664 0000000 0000000 00000004532 13600575677 0023227 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var fails = require('../internals/fails');
var isArray = require('../internals/is-array');
var isObject = require('../internals/is-object');
var toObject = require('../internals/to-object');
var toLength = require('../internals/to-length');
var createProperty = require('../internals/create-property');
var arraySpeciesCreate = require('../internals/array-species-create');
var arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');
var wellKnownSymbol = require('../internals/well-known-symbol');
var V8_VERSION = require('../internals/v8-version');
var IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable');
var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF;
var MAXIMUM_ALLOWED_INDEX_EXCEEDED = 'Maximum allowed index exceeded';
// We can't use this feature detection in V8 since it causes
// deoptimization and serious performance degradation
// https://github.com/zloirock/core-js/issues/679
var IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails(function () {
var array = [];
array[IS_CONCAT_SPREADABLE] = false;
return array.concat()[0] !== array;
});
var SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('concat');
var isConcatSpreadable = function (O) {
if (!isObject(O)) return false;
var spreadable = O[IS_CONCAT_SPREADABLE];
return spreadable !== undefined ? !!spreadable : isArray(O);
};
var FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !SPECIES_SUPPORT;
// `Array.prototype.concat` method
// https://tc39.github.io/ecma262/#sec-array.prototype.concat
// with adding support of @@isConcatSpreadable and @@species
$({ target: 'Array', proto: true, forced: FORCED }, {
concat: function concat(arg) { // eslint-disable-line no-unused-vars
var O = toObject(this);
var A = arraySpeciesCreate(O, 0);
var n = 0;
var i, k, length, len, E;
for (i = -1, length = arguments.length; i < length; i++) {
E = i === -1 ? O : arguments[i];
if (isConcatSpreadable(E)) {
len = toLength(E.length);
if (n + len > MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED);
for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]);
} else {
if (n >= MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED);
createProperty(A, n++, E);
}
}
A.length = n;
return A;
}
});
core-js-3.6.1/packages/core-js/modules/es.array.copy-within.js 0000664 0000000 0000000 00000000672 13600575677 0024233 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var copyWithin = require('../internals/array-copy-within');
var addToUnscopables = require('../internals/add-to-unscopables');
// `Array.prototype.copyWithin` method
// https://tc39.github.io/ecma262/#sec-array.prototype.copywithin
$({ target: 'Array', proto: true }, {
copyWithin: copyWithin
});
// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables('copyWithin');
core-js-3.6.1/packages/core-js/modules/es.array.every.js 0000664 0000000 0000000 00000000765 13600575677 0023116 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var $every = require('../internals/array-iteration').every;
var sloppyArrayMethod = require('../internals/sloppy-array-method');
// `Array.prototype.every` method
// https://tc39.github.io/ecma262/#sec-array.prototype.every
$({ target: 'Array', proto: true, forced: sloppyArrayMethod('every') }, {
every: function every(callbackfn /* , thisArg */) {
return $every(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
}
});
core-js-3.6.1/packages/core-js/modules/es.array.fill.js 0000664 0000000 0000000 00000000617 13600575677 0022706 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var fill = require('../internals/array-fill');
var addToUnscopables = require('../internals/add-to-unscopables');
// `Array.prototype.fill` method
// https://tc39.github.io/ecma262/#sec-array.prototype.fill
$({ target: 'Array', proto: true }, {
fill: fill
});
// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables('fill');
core-js-3.6.1/packages/core-js/modules/es.array.filter.js 0000664 0000000 0000000 00000001517 13600575677 0023245 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var $filter = require('../internals/array-iteration').filter;
var fails = require('../internals/fails');
var arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');
var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter');
// Edge 14- issue
var USES_TO_LENGTH = HAS_SPECIES_SUPPORT && !fails(function () {
[].filter.call({ length: -1, 0: 1 }, function (it) { throw it; });
});
// `Array.prototype.filter` method
// https://tc39.github.io/ecma262/#sec-array.prototype.filter
// with adding support of @@species
$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT || !USES_TO_LENGTH }, {
filter: function filter(callbackfn /* , thisArg */) {
return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
}
});
core-js-3.6.1/packages/core-js/modules/es.array.find-index.js 0000664 0000000 0000000 00000001417 13600575677 0024004 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var $findIndex = require('../internals/array-iteration').findIndex;
var addToUnscopables = require('../internals/add-to-unscopables');
var FIND_INDEX = 'findIndex';
var SKIPS_HOLES = true;
// Shouldn't skip holes
if (FIND_INDEX in []) Array(1)[FIND_INDEX](function () { SKIPS_HOLES = false; });
// `Array.prototype.findIndex` method
// https://tc39.github.io/ecma262/#sec-array.prototype.findindex
$({ target: 'Array', proto: true, forced: SKIPS_HOLES }, {
findIndex: function findIndex(callbackfn /* , that = undefined */) {
return $findIndex(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
}
});
// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables(FIND_INDEX);
core-js-3.6.1/packages/core-js/modules/es.array.find.js 0000664 0000000 0000000 00000001317 13600575677 0022676 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var $find = require('../internals/array-iteration').find;
var addToUnscopables = require('../internals/add-to-unscopables');
var FIND = 'find';
var SKIPS_HOLES = true;
// Shouldn't skip holes
if (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES = false; });
// `Array.prototype.find` method
// https://tc39.github.io/ecma262/#sec-array.prototype.find
$({ target: 'Array', proto: true, forced: SKIPS_HOLES }, {
find: function find(callbackfn /* , that = undefined */) {
return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
}
});
// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables(FIND);
core-js-3.6.1/packages/core-js/modules/es.array.flat-map.js 0000664 0000000 0000000 00000001443 13600575677 0023457 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var flattenIntoArray = require('../internals/flatten-into-array');
var toObject = require('../internals/to-object');
var toLength = require('../internals/to-length');
var aFunction = require('../internals/a-function');
var arraySpeciesCreate = require('../internals/array-species-create');
// `Array.prototype.flatMap` method
// https://github.com/tc39/proposal-flatMap
$({ target: 'Array', proto: true }, {
flatMap: function flatMap(callbackfn /* , thisArg */) {
var O = toObject(this);
var sourceLen = toLength(O.length);
var A;
aFunction(callbackfn);
A = arraySpeciesCreate(O, 0);
A.length = flattenIntoArray(A, O, O, sourceLen, 0, 1, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
return A;
}
});
core-js-3.6.1/packages/core-js/modules/es.array.flat.js 0000664 0000000 0000000 00000001442 13600575677 0022703 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var flattenIntoArray = require('../internals/flatten-into-array');
var toObject = require('../internals/to-object');
var toLength = require('../internals/to-length');
var toInteger = require('../internals/to-integer');
var arraySpeciesCreate = require('../internals/array-species-create');
// `Array.prototype.flat` method
// https://github.com/tc39/proposal-flatMap
$({ target: 'Array', proto: true }, {
flat: function flat(/* depthArg = 1 */) {
var depthArg = arguments.length ? arguments[0] : undefined;
var O = toObject(this);
var sourceLen = toLength(O.length);
var A = arraySpeciesCreate(O, 0);
A.length = flattenIntoArray(A, O, O, sourceLen, 0, depthArg === undefined ? 1 : toInteger(depthArg));
return A;
}
});
core-js-3.6.1/packages/core-js/modules/es.array.for-each.js 0000664 0000000 0000000 00000000454 13600575677 0023443 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var forEach = require('../internals/array-for-each');
// `Array.prototype.forEach` method
// https://tc39.github.io/ecma262/#sec-array.prototype.foreach
$({ target: 'Array', proto: true, forced: [].forEach != forEach }, {
forEach: forEach
});
core-js-3.6.1/packages/core-js/modules/es.array.from.js 0000664 0000000 0000000 00000000670 13600575677 0022722 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var from = require('../internals/array-from');
var checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');
var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {
Array.from(iterable);
});
// `Array.from` method
// https://tc39.github.io/ecma262/#sec-array.from
$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {
from: from
});
core-js-3.6.1/packages/core-js/modules/es.array.includes.js 0000664 0000000 0000000 00000001075 13600575677 0023565 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var $includes = require('../internals/array-includes').includes;
var addToUnscopables = require('../internals/add-to-unscopables');
// `Array.prototype.includes` method
// https://tc39.github.io/ecma262/#sec-array.prototype.includes
$({ target: 'Array', proto: true }, {
includes: function includes(el /* , fromIndex = 0 */) {
return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
}
});
// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables('includes');
core-js-3.6.1/packages/core-js/modules/es.array.index-of.js 0000664 0000000 0000000 00000001413 13600575677 0023464 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var $indexOf = require('../internals/array-includes').indexOf;
var sloppyArrayMethod = require('../internals/sloppy-array-method');
var nativeIndexOf = [].indexOf;
var NEGATIVE_ZERO = !!nativeIndexOf && 1 / [1].indexOf(1, -0) < 0;
var SLOPPY_METHOD = sloppyArrayMethod('indexOf');
// `Array.prototype.indexOf` method
// https://tc39.github.io/ecma262/#sec-array.prototype.indexof
$({ target: 'Array', proto: true, forced: NEGATIVE_ZERO || SLOPPY_METHOD }, {
indexOf: function indexOf(searchElement /* , fromIndex = 0 */) {
return NEGATIVE_ZERO
// convert -0 to +0
? nativeIndexOf.apply(this, arguments) || 0
: $indexOf(this, searchElement, arguments.length > 1 ? arguments[1] : undefined);
}
});
core-js-3.6.1/packages/core-js/modules/es.array.is-array.js 0000664 0000000 0000000 00000000344 13600575677 0023504 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var isArray = require('../internals/is-array');
// `Array.isArray` method
// https://tc39.github.io/ecma262/#sec-array.isarray
$({ target: 'Array', stat: true }, {
isArray: isArray
});
core-js-3.6.1/packages/core-js/modules/es.array.iterator.js 0000664 0000000 0000000 00000004250 13600575677 0023606 0 ustar 00root root 0000000 0000000 'use strict';
var toIndexedObject = require('../internals/to-indexed-object');
var addToUnscopables = require('../internals/add-to-unscopables');
var Iterators = require('../internals/iterators');
var InternalStateModule = require('../internals/internal-state');
var defineIterator = require('../internals/define-iterator');
var ARRAY_ITERATOR = 'Array Iterator';
var setInternalState = InternalStateModule.set;
var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);
// `Array.prototype.entries` method
// https://tc39.github.io/ecma262/#sec-array.prototype.entries
// `Array.prototype.keys` method
// https://tc39.github.io/ecma262/#sec-array.prototype.keys
// `Array.prototype.values` method
// https://tc39.github.io/ecma262/#sec-array.prototype.values
// `Array.prototype[@@iterator]` method
// https://tc39.github.io/ecma262/#sec-array.prototype-@@iterator
// `CreateArrayIterator` internal method
// https://tc39.github.io/ecma262/#sec-createarrayiterator
module.exports = defineIterator(Array, 'Array', function (iterated, kind) {
setInternalState(this, {
type: ARRAY_ITERATOR,
target: toIndexedObject(iterated), // target
index: 0, // next index
kind: kind // kind
});
// `%ArrayIteratorPrototype%.next` method
// https://tc39.github.io/ecma262/#sec-%arrayiteratorprototype%.next
}, function () {
var state = getInternalState(this);
var target = state.target;
var kind = state.kind;
var index = state.index++;
if (!target || index >= target.length) {
state.target = undefined;
return { value: undefined, done: true };
}
if (kind == 'keys') return { value: index, done: false };
if (kind == 'values') return { value: target[index], done: false };
return { value: [index, target[index]], done: false };
}, 'values');
// argumentsList[@@iterator] is %ArrayProto_values%
// https://tc39.github.io/ecma262/#sec-createunmappedargumentsobject
// https://tc39.github.io/ecma262/#sec-createmappedargumentsobject
Iterators.Arguments = Iterators.Array;
// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables('keys');
addToUnscopables('values');
addToUnscopables('entries');
core-js-3.6.1/packages/core-js/modules/es.array.join.js 0000664 0000000 0000000 00000001246 13600575677 0022716 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IndexedObject = require('../internals/indexed-object');
var toIndexedObject = require('../internals/to-indexed-object');
var sloppyArrayMethod = require('../internals/sloppy-array-method');
var nativeJoin = [].join;
var ES3_STRINGS = IndexedObject != Object;
var SLOPPY_METHOD = sloppyArrayMethod('join', ',');
// `Array.prototype.join` method
// https://tc39.github.io/ecma262/#sec-array.prototype.join
$({ target: 'Array', proto: true, forced: ES3_STRINGS || SLOPPY_METHOD }, {
join: function join(separator) {
return nativeJoin.call(toIndexedObject(this), separator === undefined ? ',' : separator);
}
});
core-js-3.6.1/packages/core-js/modules/es.array.last-index-of.js 0000664 0000000 0000000 00000000500 13600575677 0024421 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var lastIndexOf = require('../internals/array-last-index-of');
// `Array.prototype.lastIndexOf` method
// https://tc39.github.io/ecma262/#sec-array.prototype.lastindexof
$({ target: 'Array', proto: true, forced: lastIndexOf !== [].lastIndexOf }, {
lastIndexOf: lastIndexOf
});
core-js-3.6.1/packages/core-js/modules/es.array.map.js 0000664 0000000 0000000 00000001461 13600575677 0022533 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var $map = require('../internals/array-iteration').map;
var fails = require('../internals/fails');
var arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');
var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('map');
// FF49- issue
var USES_TO_LENGTH = HAS_SPECIES_SUPPORT && !fails(function () {
[].map.call({ length: -1, 0: 1 }, function (it) { throw it; });
});
// `Array.prototype.map` method
// https://tc39.github.io/ecma262/#sec-array.prototype.map
// with adding support of @@species
$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT || !USES_TO_LENGTH }, {
map: function map(callbackfn /* , thisArg */) {
return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
}
});
core-js-3.6.1/packages/core-js/modules/es.array.of.js 0000664 0000000 0000000 00000001402 13600575677 0022355 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var fails = require('../internals/fails');
var createProperty = require('../internals/create-property');
var ISNT_GENERIC = fails(function () {
function F() { /* empty */ }
return !(Array.of.call(F) instanceof F);
});
// `Array.of` method
// https://tc39.github.io/ecma262/#sec-array.of
// WebKit Array.of isn't generic
$({ target: 'Array', stat: true, forced: ISNT_GENERIC }, {
of: function of(/* ...args */) {
var index = 0;
var argumentsLength = arguments.length;
var result = new (typeof this == 'function' ? this : Array)(argumentsLength);
while (argumentsLength > index) createProperty(result, index, arguments[index++]);
result.length = argumentsLength;
return result;
}
});
core-js-3.6.1/packages/core-js/modules/es.array.reduce-right.js 0000664 0000000 0000000 00000001063 13600575677 0024336 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var $reduceRight = require('../internals/array-reduce').right;
var sloppyArrayMethod = require('../internals/sloppy-array-method');
// `Array.prototype.reduceRight` method
// https://tc39.github.io/ecma262/#sec-array.prototype.reduceright
$({ target: 'Array', proto: true, forced: sloppyArrayMethod('reduceRight') }, {
reduceRight: function reduceRight(callbackfn /* , initialValue */) {
return $reduceRight(this, callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined);
}
});
core-js-3.6.1/packages/core-js/modules/es.array.reduce.js 0000664 0000000 0000000 00000001017 13600575677 0023222 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var $reduce = require('../internals/array-reduce').left;
var sloppyArrayMethod = require('../internals/sloppy-array-method');
// `Array.prototype.reduce` method
// https://tc39.github.io/ecma262/#sec-array.prototype.reduce
$({ target: 'Array', proto: true, forced: sloppyArrayMethod('reduce') }, {
reduce: function reduce(callbackfn /* , initialValue */) {
return $reduce(this, callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined);
}
});
core-js-3.6.1/packages/core-js/modules/es.array.reverse.js 0000664 0000000 0000000 00000001120 13600575677 0023421 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var isArray = require('../internals/is-array');
var nativeReverse = [].reverse;
var test = [1, 2];
// `Array.prototype.reverse` method
// https://tc39.github.io/ecma262/#sec-array.prototype.reverse
// fix for Safari 12.0 bug
// https://bugs.webkit.org/show_bug.cgi?id=188794
$({ target: 'Array', proto: true, forced: String(test) === String(test.reverse()) }, {
reverse: function reverse() {
// eslint-disable-next-line no-self-assign
if (isArray(this)) this.length = this.length;
return nativeReverse.call(this);
}
});
core-js-3.6.1/packages/core-js/modules/es.array.slice.js 0000664 0000000 0000000 00000003632 13600575677 0023057 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var isObject = require('../internals/is-object');
var isArray = require('../internals/is-array');
var toAbsoluteIndex = require('../internals/to-absolute-index');
var toLength = require('../internals/to-length');
var toIndexedObject = require('../internals/to-indexed-object');
var createProperty = require('../internals/create-property');
var arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');
var wellKnownSymbol = require('../internals/well-known-symbol');
var SPECIES = wellKnownSymbol('species');
var nativeSlice = [].slice;
var max = Math.max;
// `Array.prototype.slice` method
// https://tc39.github.io/ecma262/#sec-array.prototype.slice
// fallback for not array-like ES3 strings and DOM objects
$({ target: 'Array', proto: true, forced: !arrayMethodHasSpeciesSupport('slice') }, {
slice: function slice(start, end) {
var O = toIndexedObject(this);
var length = toLength(O.length);
var k = toAbsoluteIndex(start, length);
var fin = toAbsoluteIndex(end === undefined ? length : end, length);
// inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible
var Constructor, result, n;
if (isArray(O)) {
Constructor = O.constructor;
// cross-realm fallback
if (typeof Constructor == 'function' && (Constructor === Array || isArray(Constructor.prototype))) {
Constructor = undefined;
} else if (isObject(Constructor)) {
Constructor = Constructor[SPECIES];
if (Constructor === null) Constructor = undefined;
}
if (Constructor === Array || Constructor === undefined) {
return nativeSlice.call(O, k, fin);
}
}
result = new (Constructor === undefined ? Array : Constructor)(max(fin - k, 0));
for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]);
result.length = n;
return result;
}
});
core-js-3.6.1/packages/core-js/modules/es.array.some.js 0000664 0000000 0000000 00000000755 13600575677 0022726 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var $some = require('../internals/array-iteration').some;
var sloppyArrayMethod = require('../internals/sloppy-array-method');
// `Array.prototype.some` method
// https://tc39.github.io/ecma262/#sec-array.prototype.some
$({ target: 'Array', proto: true, forced: sloppyArrayMethod('some') }, {
some: function some(callbackfn /* , thisArg */) {
return $some(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
}
});
core-js-3.6.1/packages/core-js/modules/es.array.sort.js 0000664 0000000 0000000 00000001636 13600575677 0022751 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var aFunction = require('../internals/a-function');
var toObject = require('../internals/to-object');
var fails = require('../internals/fails');
var sloppyArrayMethod = require('../internals/sloppy-array-method');
var test = [];
var nativeSort = test.sort;
// IE8-
var FAILS_ON_UNDEFINED = fails(function () {
test.sort(undefined);
});
// V8 bug
var FAILS_ON_NULL = fails(function () {
test.sort(null);
});
// Old WebKit
var SLOPPY_METHOD = sloppyArrayMethod('sort');
var FORCED = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || SLOPPY_METHOD;
// `Array.prototype.sort` method
// https://tc39.github.io/ecma262/#sec-array.prototype.sort
$({ target: 'Array', proto: true, forced: FORCED }, {
sort: function sort(comparefn) {
return comparefn === undefined
? nativeSort.call(toObject(this))
: nativeSort.call(toObject(this), aFunction(comparefn));
}
});
core-js-3.6.1/packages/core-js/modules/es.array.species.js 0000664 0000000 0000000 00000000244 13600575677 0023407 0 ustar 00root root 0000000 0000000 var setSpecies = require('../internals/set-species');
// `Array[@@species]` getter
// https://tc39.github.io/ecma262/#sec-get-array-@@species
setSpecies('Array');
core-js-3.6.1/packages/core-js/modules/es.array.splice.js 0000664 0000000 0000000 00000005046 13600575677 0023240 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var toAbsoluteIndex = require('../internals/to-absolute-index');
var toInteger = require('../internals/to-integer');
var toLength = require('../internals/to-length');
var toObject = require('../internals/to-object');
var arraySpeciesCreate = require('../internals/array-species-create');
var createProperty = require('../internals/create-property');
var arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');
var max = Math.max;
var min = Math.min;
var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF;
var MAXIMUM_ALLOWED_LENGTH_EXCEEDED = 'Maximum allowed length exceeded';
// `Array.prototype.splice` method
// https://tc39.github.io/ecma262/#sec-array.prototype.splice
// with adding support of @@species
$({ target: 'Array', proto: true, forced: !arrayMethodHasSpeciesSupport('splice') }, {
splice: function splice(start, deleteCount /* , ...items */) {
var O = toObject(this);
var len = toLength(O.length);
var actualStart = toAbsoluteIndex(start, len);
var argumentsLength = arguments.length;
var insertCount, actualDeleteCount, A, k, from, to;
if (argumentsLength === 0) {
insertCount = actualDeleteCount = 0;
} else if (argumentsLength === 1) {
insertCount = 0;
actualDeleteCount = len - actualStart;
} else {
insertCount = argumentsLength - 2;
actualDeleteCount = min(max(toInteger(deleteCount), 0), len - actualStart);
}
if (len + insertCount - actualDeleteCount > MAX_SAFE_INTEGER) {
throw TypeError(MAXIMUM_ALLOWED_LENGTH_EXCEEDED);
}
A = arraySpeciesCreate(O, actualDeleteCount);
for (k = 0; k < actualDeleteCount; k++) {
from = actualStart + k;
if (from in O) createProperty(A, k, O[from]);
}
A.length = actualDeleteCount;
if (insertCount < actualDeleteCount) {
for (k = actualStart; k < len - actualDeleteCount; k++) {
from = k + actualDeleteCount;
to = k + insertCount;
if (from in O) O[to] = O[from];
else delete O[to];
}
for (k = len; k > len - actualDeleteCount + insertCount; k--) delete O[k - 1];
} else if (insertCount > actualDeleteCount) {
for (k = len - actualDeleteCount; k > actualStart; k--) {
from = k + actualDeleteCount - 1;
to = k + insertCount - 1;
if (from in O) O[to] = O[from];
else delete O[to];
}
}
for (k = 0; k < insertCount; k++) {
O[k + actualStart] = arguments[k + 2];
}
O.length = len - actualDeleteCount + insertCount;
return A;
}
});
core-js-3.6.1/packages/core-js/modules/es.array.unscopables.flat-map.js 0000664 0000000 0000000 00000000330 13600575677 0025766 0 ustar 00root root 0000000 0000000 // this method was added to unscopables after implementation
// in popular engines, so it's moved to a separate module
var addToUnscopables = require('../internals/add-to-unscopables');
addToUnscopables('flatMap');
core-js-3.6.1/packages/core-js/modules/es.array.unscopables.flat.js 0000664 0000000 0000000 00000000325 13600575677 0025217 0 ustar 00root root 0000000 0000000 // this method was added to unscopables after implementation
// in popular engines, so it's moved to a separate module
var addToUnscopables = require('../internals/add-to-unscopables');
addToUnscopables('flat');
core-js-3.6.1/packages/core-js/modules/es.data-view.js 0000664 0000000 0000000 00000000572 13600575677 0022524 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var ArrayBufferModule = require('../internals/array-buffer');
var NATIVE_ARRAY_BUFFER = require('../internals/array-buffer-view-core').NATIVE_ARRAY_BUFFER;
// `DataView` constructor
// https://tc39.github.io/ecma262/#sec-dataview-constructor
$({ global: true, forced: !NATIVE_ARRAY_BUFFER }, {
DataView: ArrayBufferModule.DataView
});
core-js-3.6.1/packages/core-js/modules/es.date.now.js 0000664 0000000 0000000 00000000323 13600575677 0022354 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
// `Date.now` method
// https://tc39.github.io/ecma262/#sec-date.now
$({ target: 'Date', stat: true }, {
now: function now() {
return new Date().getTime();
}
});
core-js-3.6.1/packages/core-js/modules/es.date.to-iso-string.js 0000664 0000000 0000000 00000000577 13600575677 0024302 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var toISOString = require('../internals/date-to-iso-string');
// `Date.prototype.toISOString` method
// https://tc39.github.io/ecma262/#sec-date.prototype.toisostring
// PhantomJS / old WebKit has a broken implementations
$({ target: 'Date', proto: true, forced: Date.prototype.toISOString !== toISOString }, {
toISOString: toISOString
});
core-js-3.6.1/packages/core-js/modules/es.date.to-json.js 0000664 0000000 0000000 00000001337 13600575677 0023150 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var fails = require('../internals/fails');
var toObject = require('../internals/to-object');
var toPrimitive = require('../internals/to-primitive');
var FORCED = fails(function () {
return new Date(NaN).toJSON() !== null
|| Date.prototype.toJSON.call({ toISOString: function () { return 1; } }) !== 1;
});
// `Date.prototype.toJSON` method
// https://tc39.github.io/ecma262/#sec-date.prototype.tojson
$({ target: 'Date', proto: true, forced: FORCED }, {
// eslint-disable-next-line no-unused-vars
toJSON: function toJSON(key) {
var O = toObject(this);
var pv = toPrimitive(O);
return typeof pv == 'number' && !isFinite(pv) ? null : O.toISOString();
}
});
core-js-3.6.1/packages/core-js/modules/es.date.to-primitive.js 0000664 0000000 0000000 00000001032 13600575677 0024177 0 ustar 00root root 0000000 0000000 var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
var dateToPrimitive = require('../internals/date-to-primitive');
var wellKnownSymbol = require('../internals/well-known-symbol');
var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
var DatePrototype = Date.prototype;
// `Date.prototype[@@toPrimitive]` method
// https://tc39.github.io/ecma262/#sec-date.prototype-@@toprimitive
if (!(TO_PRIMITIVE in DatePrototype)) {
createNonEnumerableProperty(DatePrototype, TO_PRIMITIVE, dateToPrimitive);
}
core-js-3.6.1/packages/core-js/modules/es.date.to-string.js 0000664 0000000 0000000 00000001135 13600575677 0023501 0 ustar 00root root 0000000 0000000 var redefine = require('../internals/redefine');
var DatePrototype = Date.prototype;
var INVALID_DATE = 'Invalid Date';
var TO_STRING = 'toString';
var nativeDateToString = DatePrototype[TO_STRING];
var getTime = DatePrototype.getTime;
// `Date.prototype.toString` method
// https://tc39.github.io/ecma262/#sec-date.prototype.tostring
if (new Date(NaN) + '' != INVALID_DATE) {
redefine(DatePrototype, TO_STRING, function toString() {
var value = getTime.call(this);
// eslint-disable-next-line no-self-compare
return value === value ? nativeDateToString.call(this) : INVALID_DATE;
});
}
core-js-3.6.1/packages/core-js/modules/es.function.bind.js 0000664 0000000 0000000 00000000370 13600575677 0023377 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var bind = require('../internals/function-bind');
// `Function.prototype.bind` method
// https://tc39.github.io/ecma262/#sec-function.prototype.bind
$({ target: 'Function', proto: true }, {
bind: bind
});
core-js-3.6.1/packages/core-js/modules/es.function.has-instance.js 0000664 0000000 0000000 00000001645 13600575677 0025046 0 ustar 00root root 0000000 0000000 'use strict';
var isObject = require('../internals/is-object');
var definePropertyModule = require('../internals/object-define-property');
var getPrototypeOf = require('../internals/object-get-prototype-of');
var wellKnownSymbol = require('../internals/well-known-symbol');
var HAS_INSTANCE = wellKnownSymbol('hasInstance');
var FunctionPrototype = Function.prototype;
// `Function.prototype[@@hasInstance]` method
// https://tc39.github.io/ecma262/#sec-function.prototype-@@hasinstance
if (!(HAS_INSTANCE in FunctionPrototype)) {
definePropertyModule.f(FunctionPrototype, HAS_INSTANCE, { value: function (O) {
if (typeof this != 'function' || !isObject(O)) return false;
if (!isObject(this.prototype)) return O instanceof this;
// for environment w/o native `@@hasInstance` logic enough `instanceof`, but add this:
while (O = getPrototypeOf(O)) if (this.prototype === O) return true;
return false;
} });
}
core-js-3.6.1/packages/core-js/modules/es.function.name.js 0000664 0000000 0000000 00000001250 13600575677 0023401 0 ustar 00root root 0000000 0000000 var DESCRIPTORS = require('../internals/descriptors');
var defineProperty = require('../internals/object-define-property').f;
var FunctionPrototype = Function.prototype;
var FunctionPrototypeToString = FunctionPrototype.toString;
var nameRE = /^\s*function ([^ (]*)/;
var NAME = 'name';
// Function instances `.name` property
// https://tc39.github.io/ecma262/#sec-function-instances-name
if (DESCRIPTORS && !(NAME in FunctionPrototype)) {
defineProperty(FunctionPrototype, NAME, {
configurable: true,
get: function () {
try {
return FunctionPrototypeToString.call(this).match(nameRE)[1];
} catch (error) {
return '';
}
}
});
}
core-js-3.6.1/packages/core-js/modules/es.global-this.js 0000664 0000000 0000000 00000000307 13600575677 0023044 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var global = require('../internals/global');
// `globalThis` object
// https://github.com/tc39/proposal-global
$({ global: true }, {
globalThis: global
});
core-js-3.6.1/packages/core-js/modules/es.json.stringify.js 0000664 0000000 0000000 00000002075 13600575677 0023631 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var getBuiltIn = require('../internals/get-built-in');
var fails = require('../internals/fails');
var $stringify = getBuiltIn('JSON', 'stringify');
var re = /[\uD800-\uDFFF]/g;
var low = /^[\uD800-\uDBFF]$/;
var hi = /^[\uDC00-\uDFFF]$/;
var fix = function (match, offset, string) {
var prev = string.charAt(offset - 1);
var next = string.charAt(offset + 1);
if ((low.test(match) && !hi.test(next)) || (hi.test(match) && !low.test(prev))) {
return '\\u' + match.charCodeAt(0).toString(16);
} return match;
};
var FORCED = fails(function () {
return $stringify('\uDF06\uD834') !== '"\\udf06\\ud834"'
|| $stringify('\uDEAD') !== '"\\udead"';
});
if ($stringify) {
// https://github.com/tc39/proposal-well-formed-stringify
$({ target: 'JSON', stat: true, forced: FORCED }, {
// eslint-disable-next-line no-unused-vars
stringify: function stringify(it, replacer, space) {
var result = $stringify.apply(null, arguments);
return typeof result == 'string' ? result.replace(re, fix) : result;
}
});
}
core-js-3.6.1/packages/core-js/modules/es.json.to-string-tag.js 0000664 0000000 0000000 00000000363 13600575677 0024310 0 ustar 00root root 0000000 0000000 var global = require('../internals/global');
var setToStringTag = require('../internals/set-to-string-tag');
// JSON[@@toStringTag] property
// https://tc39.github.io/ecma262/#sec-json-@@tostringtag
setToStringTag(global.JSON, 'JSON', true);
core-js-3.6.1/packages/core-js/modules/es.map.js 0000664 0000000 0000000 00000000566 13600575677 0021423 0 ustar 00root root 0000000 0000000 'use strict';
var collection = require('../internals/collection');
var collectionStrong = require('../internals/collection-strong');
// `Map` constructor
// https://tc39.github.io/ecma262/#sec-map-objects
module.exports = collection('Map', function (init) {
return function Map() { return init(this, arguments.length ? arguments[0] : undefined); };
}, collectionStrong);
core-js-3.6.1/packages/core-js/modules/es.math.acosh.js 0000664 0000000 0000000 00000001300 13600575677 0022656 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var log1p = require('../internals/math-log1p');
var nativeAcosh = Math.acosh;
var log = Math.log;
var sqrt = Math.sqrt;
var LN2 = Math.LN2;
var FORCED = !nativeAcosh
// V8 bug: https://code.google.com/p/v8/issues/detail?id=3509
|| Math.floor(nativeAcosh(Number.MAX_VALUE)) != 710
// Tor Browser bug: Math.acosh(Infinity) -> NaN
|| nativeAcosh(Infinity) != Infinity;
// `Math.acosh` method
// https://tc39.github.io/ecma262/#sec-math.acosh
$({ target: 'Math', stat: true, forced: FORCED }, {
acosh: function acosh(x) {
return (x = +x) < 1 ? NaN : x > 94906265.62425156
? log(x) + LN2
: log1p(x - 1 + sqrt(x - 1) * sqrt(x + 1));
}
});
core-js-3.6.1/packages/core-js/modules/es.math.asinh.js 0000664 0000000 0000000 00000000675 13600575677 0022701 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var nativeAsinh = Math.asinh;
var log = Math.log;
var sqrt = Math.sqrt;
function asinh(x) {
return !isFinite(x = +x) || x == 0 ? x : x < 0 ? -asinh(-x) : log(x + sqrt(x * x + 1));
}
// `Math.asinh` method
// https://tc39.github.io/ecma262/#sec-math.asinh
// Tor Browser bug: Math.asinh(0) -> -0
$({ target: 'Math', stat: true, forced: !(nativeAsinh && 1 / nativeAsinh(0) > 0) }, {
asinh: asinh
});
core-js-3.6.1/packages/core-js/modules/es.math.atanh.js 0000664 0000000 0000000 00000000604 13600575677 0022662 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var nativeAtanh = Math.atanh;
var log = Math.log;
// `Math.atanh` method
// https://tc39.github.io/ecma262/#sec-math.atanh
// Tor Browser bug: Math.atanh(-0) -> 0
$({ target: 'Math', stat: true, forced: !(nativeAtanh && 1 / nativeAtanh(-0) < 0) }, {
atanh: function atanh(x) {
return (x = +x) == 0 ? x : log((1 + x) / (1 - x)) / 2;
}
});
core-js-3.6.1/packages/core-js/modules/es.math.cbrt.js 0000664 0000000 0000000 00000000474 13600575677 0022526 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var sign = require('../internals/math-sign');
var abs = Math.abs;
var pow = Math.pow;
// `Math.cbrt` method
// https://tc39.github.io/ecma262/#sec-math.cbrt
$({ target: 'Math', stat: true }, {
cbrt: function cbrt(x) {
return sign(x = +x) * pow(abs(x), 1 / 3);
}
});
core-js-3.6.1/packages/core-js/modules/es.math.clz32.js 0000664 0000000 0000000 00000000477 13600575677 0022534 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var floor = Math.floor;
var log = Math.log;
var LOG2E = Math.LOG2E;
// `Math.clz32` method
// https://tc39.github.io/ecma262/#sec-math.clz32
$({ target: 'Math', stat: true }, {
clz32: function clz32(x) {
return (x >>>= 0) ? 31 - floor(log(x + 0.5) * LOG2E) : 32;
}
});
core-js-3.6.1/packages/core-js/modules/es.math.cosh.js 0000664 0000000 0000000 00000000654 13600575677 0022530 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var expm1 = require('../internals/math-expm1');
var nativeCosh = Math.cosh;
var abs = Math.abs;
var E = Math.E;
// `Math.cosh` method
// https://tc39.github.io/ecma262/#sec-math.cosh
$({ target: 'Math', stat: true, forced: !nativeCosh || nativeCosh(710) === Infinity }, {
cosh: function cosh(x) {
var t = expm1(abs(x) - 1) + 1;
return (t + 1 / (t * E * E)) * (E / 2);
}
});
core-js-3.6.1/packages/core-js/modules/es.math.expm1.js 0000664 0000000 0000000 00000000364 13600575677 0022624 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var expm1 = require('../internals/math-expm1');
// `Math.expm1` method
// https://tc39.github.io/ecma262/#sec-math.expm1
$({ target: 'Math', stat: true, forced: expm1 != Math.expm1 }, { expm1: expm1 });
core-js-3.6.1/packages/core-js/modules/es.math.fround.js 0000664 0000000 0000000 00000000335 13600575677 0023065 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var fround = require('../internals/math-fround');
// `Math.fround` method
// https://tc39.github.io/ecma262/#sec-math.fround
$({ target: 'Math', stat: true }, { fround: fround });
core-js-3.6.1/packages/core-js/modules/es.math.hypot.js 0000664 0000000 0000000 00000001570 13600575677 0022735 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var $hypot = Math.hypot;
var abs = Math.abs;
var sqrt = Math.sqrt;
// Chrome 77 bug
// https://bugs.chromium.org/p/v8/issues/detail?id=9546
var BUGGY = !!$hypot && $hypot(Infinity, NaN) !== Infinity;
// `Math.hypot` method
// https://tc39.github.io/ecma262/#sec-math.hypot
$({ target: 'Math', stat: true, forced: BUGGY }, {
hypot: function hypot(value1, value2) { // eslint-disable-line no-unused-vars
var sum = 0;
var i = 0;
var aLen = arguments.length;
var larg = 0;
var arg, div;
while (i < aLen) {
arg = abs(arguments[i++]);
if (larg < arg) {
div = larg / arg;
sum = sum * div * div + 1;
larg = arg;
} else if (arg > 0) {
div = arg / larg;
sum += div * div;
} else sum += arg;
}
return larg === Infinity ? Infinity : larg * sqrt(sum);
}
});
core-js-3.6.1/packages/core-js/modules/es.math.imul.js 0000664 0000000 0000000 00000001216 13600575677 0022535 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var fails = require('../internals/fails');
var nativeImul = Math.imul;
var FORCED = fails(function () {
return nativeImul(0xFFFFFFFF, 5) != -5 || nativeImul.length != 2;
});
// `Math.imul` method
// https://tc39.github.io/ecma262/#sec-math.imul
// some WebKit versions fails with big numbers, some has wrong arity
$({ target: 'Math', stat: true, forced: FORCED }, {
imul: function imul(x, y) {
var UINT16 = 0xFFFF;
var xn = +x;
var yn = +y;
var xl = UINT16 & xn;
var yl = UINT16 & yn;
return 0 | xl * yl + ((UINT16 & xn >>> 16) * yl + xl * (UINT16 & yn >>> 16) << 16 >>> 0);
}
});
core-js-3.6.1/packages/core-js/modules/es.math.log10.js 0000664 0000000 0000000 00000000406 13600575677 0022511 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var log = Math.log;
var LOG10E = Math.LOG10E;
// `Math.log10` method
// https://tc39.github.io/ecma262/#sec-math.log10
$({ target: 'Math', stat: true }, {
log10: function log10(x) {
return log(x) * LOG10E;
}
});
core-js-3.6.1/packages/core-js/modules/es.math.log1p.js 0000664 0000000 0000000 00000000327 13600575677 0022613 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var log1p = require('../internals/math-log1p');
// `Math.log1p` method
// https://tc39.github.io/ecma262/#sec-math.log1p
$({ target: 'Math', stat: true }, { log1p: log1p });
core-js-3.6.1/packages/core-js/modules/es.math.log2.js 0000664 0000000 0000000 00000000371 13600575677 0022433 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var log = Math.log;
var LN2 = Math.LN2;
// `Math.log2` method
// https://tc39.github.io/ecma262/#sec-math.log2
$({ target: 'Math', stat: true }, {
log2: function log2(x) {
return log(x) / LN2;
}
});
core-js-3.6.1/packages/core-js/modules/es.math.sign.js 0000664 0000000 0000000 00000000323 13600575677 0022525 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var sign = require('../internals/math-sign');
// `Math.sign` method
// https://tc39.github.io/ecma262/#sec-math.sign
$({ target: 'Math', stat: true }, {
sign: sign
});
core-js-3.6.1/packages/core-js/modules/es.math.sinh.js 0000664 0000000 0000000 00000001104 13600575677 0022524 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var fails = require('../internals/fails');
var expm1 = require('../internals/math-expm1');
var abs = Math.abs;
var exp = Math.exp;
var E = Math.E;
var FORCED = fails(function () {
return Math.sinh(-2e-17) != -2e-17;
});
// `Math.sinh` method
// https://tc39.github.io/ecma262/#sec-math.sinh
// V8 near Chromium 38 has a problem with very small numbers
$({ target: 'Math', stat: true, forced: FORCED }, {
sinh: function sinh(x) {
return abs(x = +x) < 1 ? (expm1(x) - expm1(-x)) / 2 : (exp(x - 1) - exp(-x - 1)) * (E / 2);
}
});
core-js-3.6.1/packages/core-js/modules/es.math.tanh.js 0000664 0000000 0000000 00000000600 13600575677 0022515 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var expm1 = require('../internals/math-expm1');
var exp = Math.exp;
// `Math.tanh` method
// https://tc39.github.io/ecma262/#sec-math.tanh
$({ target: 'Math', stat: true }, {
tanh: function tanh(x) {
var a = expm1(x = +x);
var b = expm1(-x);
return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (exp(x) + exp(-x));
}
});
core-js-3.6.1/packages/core-js/modules/es.math.to-string-tag.js 0000664 0000000 0000000 00000000277 13600575677 0024274 0 ustar 00root root 0000000 0000000 var setToStringTag = require('../internals/set-to-string-tag');
// Math[@@toStringTag] property
// https://tc39.github.io/ecma262/#sec-math-@@tostringtag
setToStringTag(Math, 'Math', true);
core-js-3.6.1/packages/core-js/modules/es.math.trunc.js 0000664 0000000 0000000 00000000423 13600575677 0022721 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var ceil = Math.ceil;
var floor = Math.floor;
// `Math.trunc` method
// https://tc39.github.io/ecma262/#sec-math.trunc
$({ target: 'Math', stat: true }, {
trunc: function trunc(it) {
return (it > 0 ? floor : ceil)(it);
}
});
core-js-3.6.1/packages/core-js/modules/es.number.constructor.js 0000664 0000000 0000000 00000006714 13600575677 0024523 0 ustar 00root root 0000000 0000000 'use strict';
var DESCRIPTORS = require('../internals/descriptors');
var global = require('../internals/global');
var isForced = require('../internals/is-forced');
var redefine = require('../internals/redefine');
var has = require('../internals/has');
var classof = require('../internals/classof-raw');
var inheritIfRequired = require('../internals/inherit-if-required');
var toPrimitive = require('../internals/to-primitive');
var fails = require('../internals/fails');
var create = require('../internals/object-create');
var getOwnPropertyNames = require('../internals/object-get-own-property-names').f;
var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
var defineProperty = require('../internals/object-define-property').f;
var trim = require('../internals/string-trim').trim;
var NUMBER = 'Number';
var NativeNumber = global[NUMBER];
var NumberPrototype = NativeNumber.prototype;
// Opera ~12 has broken Object#toString
var BROKEN_CLASSOF = classof(create(NumberPrototype)) == NUMBER;
// `ToNumber` abstract operation
// https://tc39.github.io/ecma262/#sec-tonumber
var toNumber = function (argument) {
var it = toPrimitive(argument, false);
var first, third, radix, maxCode, digits, length, index, code;
if (typeof it == 'string' && it.length > 2) {
it = trim(it);
first = it.charCodeAt(0);
if (first === 43 || first === 45) {
third = it.charCodeAt(2);
if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix
} else if (first === 48) {
switch (it.charCodeAt(1)) {
case 66: case 98: radix = 2; maxCode = 49; break; // fast equal of /^0b[01]+$/i
case 79: case 111: radix = 8; maxCode = 55; break; // fast equal of /^0o[0-7]+$/i
default: return +it;
}
digits = it.slice(2);
length = digits.length;
for (index = 0; index < length; index++) {
code = digits.charCodeAt(index);
// parseInt parses a string to a first unavailable symbol
// but ToNumber should return NaN if a string contains unavailable symbols
if (code < 48 || code > maxCode) return NaN;
} return parseInt(digits, radix);
}
} return +it;
};
// `Number` constructor
// https://tc39.github.io/ecma262/#sec-number-constructor
if (isForced(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumber('+0x1'))) {
var NumberWrapper = function Number(value) {
var it = arguments.length < 1 ? 0 : value;
var dummy = this;
return dummy instanceof NumberWrapper
// check on 1..constructor(foo) case
&& (BROKEN_CLASSOF ? fails(function () { NumberPrototype.valueOf.call(dummy); }) : classof(dummy) != NUMBER)
? inheritIfRequired(new NativeNumber(toNumber(it)), dummy, NumberWrapper) : toNumber(it);
};
for (var keys = DESCRIPTORS ? getOwnPropertyNames(NativeNumber) : (
// ES3:
'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' +
// ES2015 (in case, if modules with ES2015 Number statics required before):
'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' +
'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger'
).split(','), j = 0, key; keys.length > j; j++) {
if (has(NativeNumber, key = keys[j]) && !has(NumberWrapper, key)) {
defineProperty(NumberWrapper, key, getOwnPropertyDescriptor(NativeNumber, key));
}
}
NumberWrapper.prototype = NumberPrototype;
NumberPrototype.constructor = NumberWrapper;
redefine(global, NUMBER, NumberWrapper);
}
core-js-3.6.1/packages/core-js/modules/es.number.epsilon.js 0000664 0000000 0000000 00000000302 13600575677 0023572 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
// `Number.EPSILON` constant
// https://tc39.github.io/ecma262/#sec-number.epsilon
$({ target: 'Number', stat: true }, {
EPSILON: Math.pow(2, -52)
});
core-js-3.6.1/packages/core-js/modules/es.number.is-finite.js 0000664 0000000 0000000 00000000376 13600575677 0024023 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var numberIsFinite = require('../internals/number-is-finite');
// `Number.isFinite` method
// https://tc39.github.io/ecma262/#sec-number.isfinite
$({ target: 'Number', stat: true }, { isFinite: numberIsFinite });
core-js-3.6.1/packages/core-js/modules/es.number.is-integer.js 0000664 0000000 0000000 00000000363 13600575677 0024176 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var isInteger = require('../internals/is-integer');
// `Number.isInteger` method
// https://tc39.github.io/ecma262/#sec-number.isinteger
$({ target: 'Number', stat: true }, {
isInteger: isInteger
});
core-js-3.6.1/packages/core-js/modules/es.number.is-nan.js 0000664 0000000 0000000 00000000423 13600575677 0023312 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
// `Number.isNaN` method
// https://tc39.github.io/ecma262/#sec-number.isnan
$({ target: 'Number', stat: true }, {
isNaN: function isNaN(number) {
// eslint-disable-next-line no-self-compare
return number != number;
}
});
core-js-3.6.1/packages/core-js/modules/es.number.is-safe-integer.js 0000664 0000000 0000000 00000000560 13600575677 0025111 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var isInteger = require('../internals/is-integer');
var abs = Math.abs;
// `Number.isSafeInteger` method
// https://tc39.github.io/ecma262/#sec-number.issafeinteger
$({ target: 'Number', stat: true }, {
isSafeInteger: function isSafeInteger(number) {
return isInteger(number) && abs(number) <= 0x1FFFFFFFFFFFFF;
}
});
core-js-3.6.1/packages/core-js/modules/es.number.max-safe-integer.js 0000664 0000000 0000000 00000000335 13600575677 0025263 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
// `Number.MAX_SAFE_INTEGER` constant
// https://tc39.github.io/ecma262/#sec-number.max_safe_integer
$({ target: 'Number', stat: true }, {
MAX_SAFE_INTEGER: 0x1FFFFFFFFFFFFF
});
core-js-3.6.1/packages/core-js/modules/es.number.min-safe-integer.js 0000664 0000000 0000000 00000000336 13600575677 0025262 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
// `Number.MIN_SAFE_INTEGER` constant
// https://tc39.github.io/ecma262/#sec-number.min_safe_integer
$({ target: 'Number', stat: true }, {
MIN_SAFE_INTEGER: -0x1FFFFFFFFFFFFF
});
core-js-3.6.1/packages/core-js/modules/es.number.parse-float.js 0000664 0000000 0000000 00000000442 13600575677 0024343 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var parseFloat = require('../internals/parse-float');
// `Number.parseFloat` method
// https://tc39.github.io/ecma262/#sec-number.parseFloat
$({ target: 'Number', stat: true, forced: Number.parseFloat != parseFloat }, {
parseFloat: parseFloat
});
core-js-3.6.1/packages/core-js/modules/es.number.parse-int.js 0000664 0000000 0000000 00000000422 13600575677 0024026 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var parseInt = require('../internals/parse-int');
// `Number.parseInt` method
// https://tc39.github.io/ecma262/#sec-number.parseint
$({ target: 'Number', stat: true, forced: Number.parseInt != parseInt }, {
parseInt: parseInt
});
core-js-3.6.1/packages/core-js/modules/es.number.to-fixed.js 0000664 0000000 0000000 00000006477 13600575677 0023663 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var toInteger = require('../internals/to-integer');
var thisNumberValue = require('../internals/this-number-value');
var repeat = require('../internals/string-repeat');
var fails = require('../internals/fails');
var nativeToFixed = 1.0.toFixed;
var floor = Math.floor;
var pow = function (x, n, acc) {
return n === 0 ? acc : n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc);
};
var log = function (x) {
var n = 0;
var x2 = x;
while (x2 >= 4096) {
n += 12;
x2 /= 4096;
}
while (x2 >= 2) {
n += 1;
x2 /= 2;
} return n;
};
var FORCED = nativeToFixed && (
0.00008.toFixed(3) !== '0.000' ||
0.9.toFixed(0) !== '1' ||
1.255.toFixed(2) !== '1.25' ||
1000000000000000128.0.toFixed(0) !== '1000000000000000128'
) || !fails(function () {
// V8 ~ Android 4.3-
nativeToFixed.call({});
});
// `Number.prototype.toFixed` method
// https://tc39.github.io/ecma262/#sec-number.prototype.tofixed
$({ target: 'Number', proto: true, forced: FORCED }, {
// eslint-disable-next-line max-statements
toFixed: function toFixed(fractionDigits) {
var number = thisNumberValue(this);
var fractDigits = toInteger(fractionDigits);
var data = [0, 0, 0, 0, 0, 0];
var sign = '';
var result = '0';
var e, z, j, k;
var multiply = function (n, c) {
var index = -1;
var c2 = c;
while (++index < 6) {
c2 += n * data[index];
data[index] = c2 % 1e7;
c2 = floor(c2 / 1e7);
}
};
var divide = function (n) {
var index = 6;
var c = 0;
while (--index >= 0) {
c += data[index];
data[index] = floor(c / n);
c = (c % n) * 1e7;
}
};
var dataToString = function () {
var index = 6;
var s = '';
while (--index >= 0) {
if (s !== '' || index === 0 || data[index] !== 0) {
var t = String(data[index]);
s = s === '' ? t : s + repeat.call('0', 7 - t.length) + t;
}
} return s;
};
if (fractDigits < 0 || fractDigits > 20) throw RangeError('Incorrect fraction digits');
// eslint-disable-next-line no-self-compare
if (number != number) return 'NaN';
if (number <= -1e21 || number >= 1e21) return String(number);
if (number < 0) {
sign = '-';
number = -number;
}
if (number > 1e-21) {
e = log(number * pow(2, 69, 1)) - 69;
z = e < 0 ? number * pow(2, -e, 1) : number / pow(2, e, 1);
z *= 0x10000000000000;
e = 52 - e;
if (e > 0) {
multiply(0, z);
j = fractDigits;
while (j >= 7) {
multiply(1e7, 0);
j -= 7;
}
multiply(pow(10, j, 1), 0);
j = e - 1;
while (j >= 23) {
divide(1 << 23);
j -= 23;
}
divide(1 << j);
multiply(1, 1);
divide(2);
result = dataToString();
} else {
multiply(0, z);
multiply(1 << -e, 0);
result = dataToString() + repeat.call('0', fractDigits);
}
}
if (fractDigits > 0) {
k = result.length;
result = sign + (k <= fractDigits
? '0.' + repeat.call('0', fractDigits - k) + result
: result.slice(0, k - fractDigits) + '.' + result.slice(k - fractDigits));
} else {
result = sign + result;
} return result;
}
});
core-js-3.6.1/packages/core-js/modules/es.number.to-precision.js 0000664 0000000 0000000 00000001374 13600575677 0024546 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var fails = require('../internals/fails');
var thisNumberValue = require('../internals/this-number-value');
var nativeToPrecision = 1.0.toPrecision;
var FORCED = fails(function () {
// IE7-
return nativeToPrecision.call(1, undefined) !== '1';
}) || !fails(function () {
// V8 ~ Android 4.3-
nativeToPrecision.call({});
});
// `Number.prototype.toPrecision` method
// https://tc39.github.io/ecma262/#sec-number.prototype.toprecision
$({ target: 'Number', proto: true, forced: FORCED }, {
toPrecision: function toPrecision(precision) {
return precision === undefined
? nativeToPrecision.call(thisNumberValue(this))
: nativeToPrecision.call(thisNumberValue(this), precision);
}
});
core-js-3.6.1/packages/core-js/modules/es.object.assign.js 0000664 0000000 0000000 00000000411 13600575677 0023364 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var assign = require('../internals/object-assign');
// `Object.assign` method
// https://tc39.github.io/ecma262/#sec-object.assign
$({ target: 'Object', stat: true, forced: Object.assign !== assign }, {
assign: assign
});
core-js-3.6.1/packages/core-js/modules/es.object.create.js 0000664 0000000 0000000 00000000462 13600575677 0023351 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var DESCRIPTORS = require('../internals/descriptors');
var create = require('../internals/object-create');
// `Object.create` method
// https://tc39.github.io/ecma262/#sec-object.create
$({ target: 'Object', stat: true, sham: !DESCRIPTORS }, {
create: create
});
core-js-3.6.1/packages/core-js/modules/es.object.define-getter.js 0000664 0000000 0000000 00000001360 13600575677 0024626 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var DESCRIPTORS = require('../internals/descriptors');
var FORCED = require('../internals/forced-object-prototype-accessors-methods');
var toObject = require('../internals/to-object');
var aFunction = require('../internals/a-function');
var definePropertyModule = require('../internals/object-define-property');
// `Object.prototype.__defineGetter__` method
// https://tc39.github.io/ecma262/#sec-object.prototype.__defineGetter__
if (DESCRIPTORS) {
$({ target: 'Object', proto: true, forced: FORCED }, {
__defineGetter__: function __defineGetter__(P, getter) {
definePropertyModule.f(toObject(this), P, { get: aFunction(getter), enumerable: true, configurable: true });
}
});
}
core-js-3.6.1/packages/core-js/modules/es.object.define-properties.js 0000664 0000000 0000000 00000000605 13600575677 0025531 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var DESCRIPTORS = require('../internals/descriptors');
var defineProperties = require('../internals/object-define-properties');
// `Object.defineProperties` method
// https://tc39.github.io/ecma262/#sec-object.defineproperties
$({ target: 'Object', stat: true, forced: !DESCRIPTORS, sham: !DESCRIPTORS }, {
defineProperties: defineProperties
});
core-js-3.6.1/packages/core-js/modules/es.object.define-property.js 0000664 0000000 0000000 00000000623 13600575677 0025221 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var DESCRIPTORS = require('../internals/descriptors');
var objectDefinePropertyModile = require('../internals/object-define-property');
// `Object.defineProperty` method
// https://tc39.github.io/ecma262/#sec-object.defineproperty
$({ target: 'Object', stat: true, forced: !DESCRIPTORS, sham: !DESCRIPTORS }, {
defineProperty: objectDefinePropertyModile.f
});
core-js-3.6.1/packages/core-js/modules/es.object.define-setter.js 0000664 0000000 0000000 00000001360 13600575677 0024642 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var DESCRIPTORS = require('../internals/descriptors');
var FORCED = require('../internals/forced-object-prototype-accessors-methods');
var toObject = require('../internals/to-object');
var aFunction = require('../internals/a-function');
var definePropertyModule = require('../internals/object-define-property');
// `Object.prototype.__defineSetter__` method
// https://tc39.github.io/ecma262/#sec-object.prototype.__defineSetter__
if (DESCRIPTORS) {
$({ target: 'Object', proto: true, forced: FORCED }, {
__defineSetter__: function __defineSetter__(P, setter) {
definePropertyModule.f(toObject(this), P, { set: aFunction(setter), enumerable: true, configurable: true });
}
});
}
core-js-3.6.1/packages/core-js/modules/es.object.entries.js 0000664 0000000 0000000 00000000441 13600575677 0023554 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var $entries = require('../internals/object-to-array').entries;
// `Object.entries` method
// https://tc39.github.io/ecma262/#sec-object.entries
$({ target: 'Object', stat: true }, {
entries: function entries(O) {
return $entries(O);
}
});
core-js-3.6.1/packages/core-js/modules/es.object.freeze.js 0000664 0000000 0000000 00000001166 13600575677 0023370 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var FREEZING = require('../internals/freezing');
var fails = require('../internals/fails');
var isObject = require('../internals/is-object');
var onFreeze = require('../internals/internal-metadata').onFreeze;
var nativeFreeze = Object.freeze;
var FAILS_ON_PRIMITIVES = fails(function () { nativeFreeze(1); });
// `Object.freeze` method
// https://tc39.github.io/ecma262/#sec-object.freeze
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !FREEZING }, {
freeze: function freeze(it) {
return nativeFreeze && isObject(it) ? nativeFreeze(onFreeze(it)) : it;
}
});
core-js-3.6.1/packages/core-js/modules/es.object.from-entries.js 0000664 0000000 0000000 00000000717 13600575677 0024523 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var iterate = require('../internals/iterate');
var createProperty = require('../internals/create-property');
// `Object.fromEntries` method
// https://github.com/tc39/proposal-object-from-entries
$({ target: 'Object', stat: true }, {
fromEntries: function fromEntries(iterable) {
var obj = {};
iterate(iterable, function (k, v) {
createProperty(obj, k, v);
}, undefined, true);
return obj;
}
});
core-js-3.6.1/packages/core-js/modules/es.object.get-own-property-descriptor.js 0000664 0000000 0000000 00000001412 13600575677 0027520 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var fails = require('../internals/fails');
var toIndexedObject = require('../internals/to-indexed-object');
var nativeGetOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
var DESCRIPTORS = require('../internals/descriptors');
var FAILS_ON_PRIMITIVES = fails(function () { nativeGetOwnPropertyDescriptor(1); });
var FORCED = !DESCRIPTORS || FAILS_ON_PRIMITIVES;
// `Object.getOwnPropertyDescriptor` method
// https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor
$({ target: 'Object', stat: true, forced: FORCED, sham: !DESCRIPTORS }, {
getOwnPropertyDescriptor: function getOwnPropertyDescriptor(it, key) {
return nativeGetOwnPropertyDescriptor(toIndexedObject(it), key);
}
});
core-js-3.6.1/packages/core-js/modules/es.object.get-own-property-descriptors.js 0000664 0000000 0000000 00000002004 13600575677 0027701 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var DESCRIPTORS = require('../internals/descriptors');
var ownKeys = require('../internals/own-keys');
var toIndexedObject = require('../internals/to-indexed-object');
var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
var createProperty = require('../internals/create-property');
// `Object.getOwnPropertyDescriptors` method
// https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptors
$({ target: 'Object', stat: true, sham: !DESCRIPTORS }, {
getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object) {
var O = toIndexedObject(object);
var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
var keys = ownKeys(O);
var result = {};
var index = 0;
var key, descriptor;
while (keys.length > index) {
descriptor = getOwnPropertyDescriptor(O, key = keys[index++]);
if (descriptor !== undefined) createProperty(result, key, descriptor);
}
return result;
}
});
core-js-3.6.1/packages/core-js/modules/es.object.get-own-property-names.js 0000664 0000000 0000000 00000000761 13600575677 0026453 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var fails = require('../internals/fails');
var nativeGetOwnPropertyNames = require('../internals/object-get-own-property-names-external').f;
var FAILS_ON_PRIMITIVES = fails(function () { return !Object.getOwnPropertyNames(1); });
// `Object.getOwnPropertyNames` method
// https://tc39.github.io/ecma262/#sec-object.getownpropertynames
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {
getOwnPropertyNames: nativeGetOwnPropertyNames
});
core-js-3.6.1/packages/core-js/modules/es.object.get-prototype-of.js 0000664 0000000 0000000 00000001232 13600575677 0025326 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var fails = require('../internals/fails');
var toObject = require('../internals/to-object');
var nativeGetPrototypeOf = require('../internals/object-get-prototype-of');
var CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');
var FAILS_ON_PRIMITIVES = fails(function () { nativeGetPrototypeOf(1); });
// `Object.getPrototypeOf` method
// https://tc39.github.io/ecma262/#sec-object.getprototypeof
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !CORRECT_PROTOTYPE_GETTER }, {
getPrototypeOf: function getPrototypeOf(it) {
return nativeGetPrototypeOf(toObject(it));
}
});
core-js-3.6.1/packages/core-js/modules/es.object.is-extensible.js 0000664 0000000 0000000 00000001046 13600575677 0024660 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var fails = require('../internals/fails');
var isObject = require('../internals/is-object');
var nativeIsExtensible = Object.isExtensible;
var FAILS_ON_PRIMITIVES = fails(function () { nativeIsExtensible(1); });
// `Object.isExtensible` method
// https://tc39.github.io/ecma262/#sec-object.isextensible
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {
isExtensible: function isExtensible(it) {
return isObject(it) ? nativeIsExtensible ? nativeIsExtensible(it) : true : false;
}
});
core-js-3.6.1/packages/core-js/modules/es.object.is-frozen.js 0000664 0000000 0000000 00000001002 13600575677 0024011 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var fails = require('../internals/fails');
var isObject = require('../internals/is-object');
var nativeIsFrozen = Object.isFrozen;
var FAILS_ON_PRIMITIVES = fails(function () { nativeIsFrozen(1); });
// `Object.isFrozen` method
// https://tc39.github.io/ecma262/#sec-object.isfrozen
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {
isFrozen: function isFrozen(it) {
return isObject(it) ? nativeIsFrozen ? nativeIsFrozen(it) : false : true;
}
});
core-js-3.6.1/packages/core-js/modules/es.object.is-sealed.js 0000664 0000000 0000000 00000001002 13600575677 0023743 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var fails = require('../internals/fails');
var isObject = require('../internals/is-object');
var nativeIsSealed = Object.isSealed;
var FAILS_ON_PRIMITIVES = fails(function () { nativeIsSealed(1); });
// `Object.isSealed` method
// https://tc39.github.io/ecma262/#sec-object.issealed
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {
isSealed: function isSealed(it) {
return isObject(it) ? nativeIsSealed ? nativeIsSealed(it) : false : true;
}
});
core-js-3.6.1/packages/core-js/modules/es.object.is.js 0000664 0000000 0000000 00000000320 13600575677 0022512 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var is = require('../internals/same-value');
// `Object.is` method
// https://tc39.github.io/ecma262/#sec-object.is
$({ target: 'Object', stat: true }, {
is: is
});
core-js-3.6.1/packages/core-js/modules/es.object.keys.js 0000664 0000000 0000000 00000000725 13600575677 0023063 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var toObject = require('../internals/to-object');
var nativeKeys = require('../internals/object-keys');
var fails = require('../internals/fails');
var FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); });
// `Object.keys` method
// https://tc39.github.io/ecma262/#sec-object.keys
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {
keys: function keys(it) {
return nativeKeys(toObject(it));
}
});
core-js-3.6.1/packages/core-js/modules/es.object.lookup-getter.js 0000664 0000000 0000000 00000001635 13600575677 0024712 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var DESCRIPTORS = require('../internals/descriptors');
var FORCED = require('../internals/forced-object-prototype-accessors-methods');
var toObject = require('../internals/to-object');
var toPrimitive = require('../internals/to-primitive');
var getPrototypeOf = require('../internals/object-get-prototype-of');
var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
// `Object.prototype.__lookupGetter__` method
// https://tc39.github.io/ecma262/#sec-object.prototype.__lookupGetter__
if (DESCRIPTORS) {
$({ target: 'Object', proto: true, forced: FORCED }, {
__lookupGetter__: function __lookupGetter__(P) {
var O = toObject(this);
var key = toPrimitive(P, true);
var desc;
do {
if (desc = getOwnPropertyDescriptor(O, key)) return desc.get;
} while (O = getPrototypeOf(O));
}
});
}
core-js-3.6.1/packages/core-js/modules/es.object.lookup-setter.js 0000664 0000000 0000000 00000001635 13600575677 0024726 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var DESCRIPTORS = require('../internals/descriptors');
var FORCED = require('../internals/forced-object-prototype-accessors-methods');
var toObject = require('../internals/to-object');
var toPrimitive = require('../internals/to-primitive');
var getPrototypeOf = require('../internals/object-get-prototype-of');
var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
// `Object.prototype.__lookupSetter__` method
// https://tc39.github.io/ecma262/#sec-object.prototype.__lookupSetter__
if (DESCRIPTORS) {
$({ target: 'Object', proto: true, forced: FORCED }, {
__lookupSetter__: function __lookupSetter__(P) {
var O = toObject(this);
var key = toPrimitive(P, true);
var desc;
do {
if (desc = getOwnPropertyDescriptor(O, key)) return desc.set;
} while (O = getPrototypeOf(O));
}
});
}
core-js-3.6.1/packages/core-js/modules/es.object.prevent-extensions.js 0000664 0000000 0000000 00000001331 13600575677 0025762 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var isObject = require('../internals/is-object');
var onFreeze = require('../internals/internal-metadata').onFreeze;
var FREEZING = require('../internals/freezing');
var fails = require('../internals/fails');
var nativePreventExtensions = Object.preventExtensions;
var FAILS_ON_PRIMITIVES = fails(function () { nativePreventExtensions(1); });
// `Object.preventExtensions` method
// https://tc39.github.io/ecma262/#sec-object.preventextensions
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !FREEZING }, {
preventExtensions: function preventExtensions(it) {
return nativePreventExtensions && isObject(it) ? nativePreventExtensions(onFreeze(it)) : it;
}
});
core-js-3.6.1/packages/core-js/modules/es.object.seal.js 0000664 0000000 0000000 00000001144 13600575677 0023030 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var isObject = require('../internals/is-object');
var onFreeze = require('../internals/internal-metadata').onFreeze;
var FREEZING = require('../internals/freezing');
var fails = require('../internals/fails');
var nativeSeal = Object.seal;
var FAILS_ON_PRIMITIVES = fails(function () { nativeSeal(1); });
// `Object.seal` method
// https://tc39.github.io/ecma262/#sec-object.seal
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !FREEZING }, {
seal: function seal(it) {
return nativeSeal && isObject(it) ? nativeSeal(onFreeze(it)) : it;
}
});
core-js-3.6.1/packages/core-js/modules/es.object.set-prototype-of.js 0000664 0000000 0000000 00000000431 13600575677 0025342 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var setPrototypeOf = require('../internals/object-set-prototype-of');
// `Object.setPrototypeOf` method
// https://tc39.github.io/ecma262/#sec-object.setprototypeof
$({ target: 'Object', stat: true }, {
setPrototypeOf: setPrototypeOf
});
core-js-3.6.1/packages/core-js/modules/es.object.to-string.js 0000664 0000000 0000000 00000000603 13600575677 0024031 0 ustar 00root root 0000000 0000000 var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');
var redefine = require('../internals/redefine');
var toString = require('../internals/object-to-string');
// `Object.prototype.toString` method
// https://tc39.github.io/ecma262/#sec-object.prototype.tostring
if (!TO_STRING_TAG_SUPPORT) {
redefine(Object.prototype, 'toString', toString, { unsafe: true });
}
core-js-3.6.1/packages/core-js/modules/es.object.values.js 0000664 0000000 0000000 00000000432 13600575677 0023402 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var $values = require('../internals/object-to-array').values;
// `Object.values` method
// https://tc39.github.io/ecma262/#sec-object.values
$({ target: 'Object', stat: true }, {
values: function values(O) {
return $values(O);
}
});
core-js-3.6.1/packages/core-js/modules/es.parse-float.js 0000664 0000000 0000000 00000000456 13600575677 0023061 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var parseFloatImplementation = require('../internals/parse-float');
// `parseFloat` method
// https://tc39.github.io/ecma262/#sec-parsefloat-string
$({ global: true, forced: parseFloat != parseFloatImplementation }, {
parseFloat: parseFloatImplementation
});
core-js-3.6.1/packages/core-js/modules/es.parse-int.js 0000664 0000000 0000000 00000000444 13600575677 0022543 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var parseIntImplementation = require('../internals/parse-int');
// `parseInt` method
// https://tc39.github.io/ecma262/#sec-parseint-string-radix
$({ global: true, forced: parseInt != parseIntImplementation }, {
parseInt: parseIntImplementation
});
core-js-3.6.1/packages/core-js/modules/es.promise.all-settled.js 0000664 0000000 0000000 00000002747 13600575677 0024540 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var aFunction = require('../internals/a-function');
var newPromiseCapabilityModule = require('../internals/new-promise-capability');
var perform = require('../internals/perform');
var iterate = require('../internals/iterate');
// `Promise.allSettled` method
// https://github.com/tc39/proposal-promise-allSettled
$({ target: 'Promise', stat: true }, {
allSettled: function allSettled(iterable) {
var C = this;
var capability = newPromiseCapabilityModule.f(C);
var resolve = capability.resolve;
var reject = capability.reject;
var result = perform(function () {
var promiseResolve = aFunction(C.resolve);
var values = [];
var counter = 0;
var remaining = 1;
iterate(iterable, function (promise) {
var index = counter++;
var alreadyCalled = false;
values.push(undefined);
remaining++;
promiseResolve.call(C, promise).then(function (value) {
if (alreadyCalled) return;
alreadyCalled = true;
values[index] = { status: 'fulfilled', value: value };
--remaining || resolve(values);
}, function (e) {
if (alreadyCalled) return;
alreadyCalled = true;
values[index] = { status: 'rejected', reason: e };
--remaining || resolve(values);
});
});
--remaining || resolve(values);
});
if (result.error) reject(result.value);
return capability.promise;
}
});
core-js-3.6.1/packages/core-js/modules/es.promise.finally.js 0000664 0000000 0000000 00000003035 13600575677 0023753 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var NativePromise = require('../internals/native-promise-constructor');
var fails = require('../internals/fails');
var getBuiltIn = require('../internals/get-built-in');
var speciesConstructor = require('../internals/species-constructor');
var promiseResolve = require('../internals/promise-resolve');
var redefine = require('../internals/redefine');
// Safari bug https://bugs.webkit.org/show_bug.cgi?id=200829
var NON_GENERIC = !!NativePromise && fails(function () {
NativePromise.prototype['finally'].call({ then: function () { /* empty */ } }, function () { /* empty */ });
});
// `Promise.prototype.finally` method
// https://tc39.github.io/ecma262/#sec-promise.prototype.finally
$({ target: 'Promise', proto: true, real: true, forced: NON_GENERIC }, {
'finally': function (onFinally) {
var C = speciesConstructor(this, getBuiltIn('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
);
}
});
// patch native Promise.prototype for native async functions
if (!IS_PURE && typeof NativePromise == 'function' && !NativePromise.prototype['finally']) {
redefine(NativePromise.prototype, 'finally', getBuiltIn('Promise').prototype['finally']);
}
core-js-3.6.1/packages/core-js/modules/es.promise.js 0000664 0000000 0000000 00000032426 13600575677 0022324 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var global = require('../internals/global');
var getBuiltIn = require('../internals/get-built-in');
var NativePromise = require('../internals/native-promise-constructor');
var redefine = require('../internals/redefine');
var redefineAll = require('../internals/redefine-all');
var setToStringTag = require('../internals/set-to-string-tag');
var setSpecies = require('../internals/set-species');
var isObject = require('../internals/is-object');
var aFunction = require('../internals/a-function');
var anInstance = require('../internals/an-instance');
var classof = require('../internals/classof-raw');
var inspectSource = require('../internals/inspect-source');
var iterate = require('../internals/iterate');
var checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');
var speciesConstructor = require('../internals/species-constructor');
var task = require('../internals/task').set;
var microtask = require('../internals/microtask');
var promiseResolve = require('../internals/promise-resolve');
var hostReportErrors = require('../internals/host-report-errors');
var newPromiseCapabilityModule = require('../internals/new-promise-capability');
var perform = require('../internals/perform');
var InternalStateModule = require('../internals/internal-state');
var isForced = require('../internals/is-forced');
var wellKnownSymbol = require('../internals/well-known-symbol');
var V8_VERSION = require('../internals/v8-version');
var SPECIES = wellKnownSymbol('species');
var PROMISE = 'Promise';
var getInternalState = InternalStateModule.get;
var setInternalState = InternalStateModule.set;
var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
var PromiseConstructor = NativePromise;
var TypeError = global.TypeError;
var document = global.document;
var process = global.process;
var $fetch = getBuiltIn('fetch');
var newPromiseCapability = newPromiseCapabilityModule.f;
var newGenericPromiseCapability = newPromiseCapability;
var IS_NODE = classof(process) == 'process';
var DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);
var UNHANDLED_REJECTION = 'unhandledrejection';
var REJECTION_HANDLED = 'rejectionhandled';
var PENDING = 0;
var FULFILLED = 1;
var REJECTED = 2;
var HANDLED = 1;
var UNHANDLED = 2;
var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
var FORCED = isForced(PROMISE, function () {
var GLOBAL_CORE_JS_PROMISE = inspectSource(PromiseConstructor) !== String(PromiseConstructor);
if (!GLOBAL_CORE_JS_PROMISE) {
// 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
if (V8_VERSION === 66) return true;
// Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
if (!IS_NODE && typeof PromiseRejectionEvent != 'function') return true;
}
// We need Promise#finally in the pure version for preventing prototype pollution
if (IS_PURE && !PromiseConstructor.prototype['finally']) return true;
// We can't use @@species feature detection in V8 since it causes
// deoptimization and performance degradation
// https://github.com/zloirock/core-js/issues/679
if (V8_VERSION >= 51 && /native code/.test(PromiseConstructor)) return false;
// Detect correctness of subclassing with @@species support
var promise = PromiseConstructor.resolve(1);
var FakePromise = function (exec) {
exec(function () { /* empty */ }, function () { /* empty */ });
};
var constructor = promise.constructor = {};
constructor[SPECIES] = FakePromise;
return !(promise.then(function () { /* empty */ }) instanceof FakePromise);
});
var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {
PromiseConstructor.all(iterable)['catch'](function () { /* empty */ });
});
// helpers
var isThenable = function (it) {
var then;
return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
};
var notify = function (promise, state, isReject) {
if (state.notified) return;
state.notified = true;
var chain = state.reactions;
microtask(function () {
var value = state.value;
var ok = state.state == FULFILLED;
var index = 0;
// variable length - can't use forEach
while (chain.length > index) {
var reaction = chain[index++];
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 (state.rejection === UNHANDLED) onHandleUnhandled(promise, state);
state.rejection = HANDLED;
}
if (handler === true) result = value;
else {
if (domain) domain.enter();
result = handler(value); // can throw
if (domain) {
domain.exit();
exited = true;
}
}
if (result === reaction.promise) {
reject(TypeError('Promise-chain cycle'));
} else if (then = isThenable(result)) {
then.call(result, resolve, reject);
} else resolve(result);
} else reject(value);
} catch (error) {
if (domain && !exited) domain.exit();
reject(error);
}
}
state.reactions = [];
state.notified = false;
if (isReject && !state.rejection) onUnhandled(promise, state);
});
};
var dispatchEvent = function (name, promise, reason) {
var event, handler;
if (DISPATCH_EVENT) {
event = document.createEvent('Event');
event.promise = promise;
event.reason = reason;
event.initEvent(name, false, true);
global.dispatchEvent(event);
} else event = { promise: promise, reason: reason };
if (handler = global['on' + name]) handler(event);
else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
};
var onUnhandled = function (promise, state) {
task.call(global, function () {
var value = state.value;
var IS_UNHANDLED = isUnhandled(state);
var result;
if (IS_UNHANDLED) {
result = perform(function () {
if (IS_NODE) {
process.emit('unhandledRejection', value, promise);
} else dispatchEvent(UNHANDLED_REJECTION, promise, value);
});
// Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;
if (result.error) throw result.value;
}
});
};
var isUnhandled = function (state) {
return state.rejection !== HANDLED && !state.parent;
};
var onHandleUnhandled = function (promise, state) {
task.call(global, function () {
if (IS_NODE) {
process.emit('rejectionHandled', promise);
} else dispatchEvent(REJECTION_HANDLED, promise, state.value);
});
};
var bind = function (fn, promise, state, unwrap) {
return function (value) {
fn(promise, state, value, unwrap);
};
};
var internalReject = function (promise, state, value, unwrap) {
if (state.done) return;
state.done = true;
if (unwrap) state = unwrap;
state.value = value;
state.state = REJECTED;
notify(promise, state, true);
};
var internalResolve = function (promise, state, value, unwrap) {
if (state.done) return;
state.done = true;
if (unwrap) state = unwrap;
try {
if (promise === value) throw TypeError("Promise can't be resolved itself");
var then = isThenable(value);
if (then) {
microtask(function () {
var wrapper = { done: false };
try {
then.call(value,
bind(internalResolve, promise, wrapper, state),
bind(internalReject, promise, wrapper, state)
);
} catch (error) {
internalReject(promise, wrapper, error, state);
}
});
} else {
state.value = value;
state.state = FULFILLED;
notify(promise, state, false);
}
} catch (error) {
internalReject(promise, { done: false }, error, state);
}
};
// constructor polyfill
if (FORCED) {
// 25.4.3.1 Promise(executor)
PromiseConstructor = function Promise(executor) {
anInstance(this, PromiseConstructor, PROMISE);
aFunction(executor);
Internal.call(this);
var state = getInternalState(this);
try {
executor(bind(internalResolve, this, state), bind(internalReject, this, state));
} catch (error) {
internalReject(this, state, error);
}
};
// eslint-disable-next-line no-unused-vars
Internal = function Promise(executor) {
setInternalState(this, {
type: PROMISE,
done: false,
notified: false,
parent: false,
reactions: [],
rejection: false,
state: PENDING,
value: undefined
});
};
Internal.prototype = redefineAll(PromiseConstructor.prototype, {
// `Promise.prototype.then` method
// https://tc39.github.io/ecma262/#sec-promise.prototype.then
then: function then(onFulfilled, onRejected) {
var state = getInternalPromiseState(this);
var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));
reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
reaction.fail = typeof onRejected == 'function' && onRejected;
reaction.domain = IS_NODE ? process.domain : undefined;
state.parent = true;
state.reactions.push(reaction);
if (state.state != PENDING) notify(this, state, false);
return reaction.promise;
},
// `Promise.prototype.catch` method
// https://tc39.github.io/ecma262/#sec-promise.prototype.catch
'catch': function (onRejected) {
return this.then(undefined, onRejected);
}
});
OwnPromiseCapability = function () {
var promise = new Internal();
var state = getInternalState(promise);
this.promise = promise;
this.resolve = bind(internalResolve, promise, state);
this.reject = bind(internalReject, promise, state);
};
newPromiseCapabilityModule.f = newPromiseCapability = function (C) {
return C === PromiseConstructor || C === PromiseWrapper
? new OwnPromiseCapability(C)
: newGenericPromiseCapability(C);
};
if (!IS_PURE && typeof NativePromise == 'function') {
nativeThen = NativePromise.prototype.then;
// wrap native Promise#then for native async functions
redefine(NativePromise.prototype, 'then', function then(onFulfilled, onRejected) {
var that = this;
return new PromiseConstructor(function (resolve, reject) {
nativeThen.call(that, resolve, reject);
}).then(onFulfilled, onRejected);
// https://github.com/zloirock/core-js/issues/640
}, { unsafe: true });
// wrap fetch result
if (typeof $fetch == 'function') $({ global: true, enumerable: true, forced: true }, {
// eslint-disable-next-line no-unused-vars
fetch: function fetch(input /* , init */) {
return promiseResolve(PromiseConstructor, $fetch.apply(global, arguments));
}
});
}
}
$({ global: true, wrap: true, forced: FORCED }, {
Promise: PromiseConstructor
});
setToStringTag(PromiseConstructor, PROMISE, false, true);
setSpecies(PROMISE);
PromiseWrapper = getBuiltIn(PROMISE);
// statics
$({ target: PROMISE, stat: true, forced: FORCED }, {
// `Promise.reject` method
// https://tc39.github.io/ecma262/#sec-promise.reject
reject: function reject(r) {
var capability = newPromiseCapability(this);
capability.reject.call(undefined, r);
return capability.promise;
}
});
$({ target: PROMISE, stat: true, forced: IS_PURE || FORCED }, {
// `Promise.resolve` method
// https://tc39.github.io/ecma262/#sec-promise.resolve
resolve: function resolve(x) {
return promiseResolve(IS_PURE && this === PromiseWrapper ? PromiseConstructor : this, x);
}
});
$({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
// `Promise.all` method
// https://tc39.github.io/ecma262/#sec-promise.all
all: function all(iterable) {
var C = this;
var capability = newPromiseCapability(C);
var resolve = capability.resolve;
var reject = capability.reject;
var result = perform(function () {
var $promiseResolve = aFunction(C.resolve);
var values = [];
var counter = 0;
var remaining = 1;
iterate(iterable, function (promise) {
var index = counter++;
var alreadyCalled = false;
values.push(undefined);
remaining++;
$promiseResolve.call(C, promise).then(function (value) {
if (alreadyCalled) return;
alreadyCalled = true;
values[index] = value;
--remaining || resolve(values);
}, reject);
});
--remaining || resolve(values);
});
if (result.error) reject(result.value);
return capability.promise;
},
// `Promise.race` method
// https://tc39.github.io/ecma262/#sec-promise.race
race: function race(iterable) {
var C = this;
var capability = newPromiseCapability(C);
var reject = capability.reject;
var result = perform(function () {
var $promiseResolve = aFunction(C.resolve);
iterate(iterable, function (promise) {
$promiseResolve.call(C, promise).then(capability.resolve, reject);
});
});
if (result.error) reject(result.value);
return capability.promise;
}
});
core-js-3.6.1/packages/core-js/modules/es.reflect.apply.js 0000664 0000000 0000000 00000001575 13600575677 0023417 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var getBuiltIn = require('../internals/get-built-in');
var aFunction = require('../internals/a-function');
var anObject = require('../internals/an-object');
var fails = require('../internals/fails');
var nativeApply = getBuiltIn('Reflect', 'apply');
var functionApply = Function.apply;
// MS Edge argumentsList argument is optional
var OPTIONAL_ARGUMENTS_LIST = !fails(function () {
nativeApply(function () { /* empty */ });
});
// `Reflect.apply` method
// https://tc39.github.io/ecma262/#sec-reflect.apply
$({ target: 'Reflect', stat: true, forced: OPTIONAL_ARGUMENTS_LIST }, {
apply: function apply(target, thisArgument, argumentsList) {
aFunction(target);
anObject(argumentsList);
return nativeApply
? nativeApply(target, thisArgument, argumentsList)
: functionApply.call(target, thisArgument, argumentsList);
}
});
core-js-3.6.1/packages/core-js/modules/es.reflect.construct.js 0000664 0000000 0000000 00000004213 13600575677 0024306 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var getBuiltIn = require('../internals/get-built-in');
var aFunction = require('../internals/a-function');
var anObject = require('../internals/an-object');
var isObject = require('../internals/is-object');
var create = require('../internals/object-create');
var bind = require('../internals/function-bind');
var fails = require('../internals/fails');
var nativeConstruct = getBuiltIn('Reflect', 'construct');
// `Reflect.construct` method
// https://tc39.github.io/ecma262/#sec-reflect.construct
// MS Edge supports only 2 arguments and argumentsList argument is optional
// FF Nightly sets third argument as `new.target`, but does not create `this` from it
var NEW_TARGET_BUG = fails(function () {
function F() { /* empty */ }
return !(nativeConstruct(function () { /* empty */ }, [], F) instanceof F);
});
var ARGS_BUG = !fails(function () {
nativeConstruct(function () { /* empty */ });
});
var FORCED = NEW_TARGET_BUG || ARGS_BUG;
$({ target: 'Reflect', stat: true, forced: FORCED, sham: FORCED }, {
construct: function construct(Target, args /* , newTarget */) {
aFunction(Target);
anObject(args);
var newTarget = arguments.length < 3 ? Target : aFunction(arguments[2]);
if (ARGS_BUG && !NEW_TARGET_BUG) return nativeConstruct(Target, args, newTarget);
if (Target == newTarget) {
// w/o altered newTarget, optimization for 0-4 arguments
switch (args.length) {
case 0: return new Target();
case 1: return new Target(args[0]);
case 2: return new Target(args[0], args[1]);
case 3: return new Target(args[0], args[1], args[2]);
case 4: return new Target(args[0], args[1], args[2], args[3]);
}
// w/o altered newTarget, lot of arguments case
var $args = [null];
$args.push.apply($args, args);
return new (bind.apply(Target, $args))();
}
// with altered newTarget, not support built-in constructors
var proto = newTarget.prototype;
var instance = create(isObject(proto) ? proto : Object.prototype);
var result = Function.apply.call(Target, instance, args);
return isObject(result) ? result : instance;
}
});
core-js-3.6.1/packages/core-js/modules/es.reflect.define-property.js 0000664 0000000 0000000 00000002073 13600575677 0025400 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var DESCRIPTORS = require('../internals/descriptors');
var anObject = require('../internals/an-object');
var toPrimitive = require('../internals/to-primitive');
var definePropertyModule = require('../internals/object-define-property');
var fails = require('../internals/fails');
// MS Edge has broken Reflect.defineProperty - throwing instead of returning false
var ERROR_INSTEAD_OF_FALSE = fails(function () {
// eslint-disable-next-line no-undef
Reflect.defineProperty(definePropertyModule.f({}, 1, { value: 1 }), 1, { value: 2 });
});
// `Reflect.defineProperty` method
// https://tc39.github.io/ecma262/#sec-reflect.defineproperty
$({ target: 'Reflect', stat: true, forced: ERROR_INSTEAD_OF_FALSE, sham: !DESCRIPTORS }, {
defineProperty: function defineProperty(target, propertyKey, attributes) {
anObject(target);
var key = toPrimitive(propertyKey, true);
anObject(attributes);
try {
definePropertyModule.f(target, key, attributes);
return true;
} catch (error) {
return false;
}
}
});
core-js-3.6.1/packages/core-js/modules/es.reflect.delete-property.js 0000664 0000000 0000000 00000001057 13600575677 0025411 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var anObject = require('../internals/an-object');
var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
// `Reflect.deleteProperty` method
// https://tc39.github.io/ecma262/#sec-reflect.deleteproperty
$({ target: 'Reflect', stat: true }, {
deleteProperty: function deleteProperty(target, propertyKey) {
var descriptor = getOwnPropertyDescriptor(anObject(target), propertyKey);
return descriptor && !descriptor.configurable ? false : delete target[propertyKey];
}
});
core-js-3.6.1/packages/core-js/modules/es.reflect.get-own-property-descriptor.js 0000664 0000000 0000000 00000001114 13600575677 0027675 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var DESCRIPTORS = require('../internals/descriptors');
var anObject = require('../internals/an-object');
var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
// `Reflect.getOwnPropertyDescriptor` method
// https://tc39.github.io/ecma262/#sec-reflect.getownpropertydescriptor
$({ target: 'Reflect', stat: true, sham: !DESCRIPTORS }, {
getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey) {
return getOwnPropertyDescriptorModule.f(anObject(target), propertyKey);
}
});
core-js-3.6.1/packages/core-js/modules/es.reflect.get-prototype-of.js 0000664 0000000 0000000 00000001020 13600575677 0025477 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var anObject = require('../internals/an-object');
var objectGetPrototypeOf = require('../internals/object-get-prototype-of');
var CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');
// `Reflect.getPrototypeOf` method
// https://tc39.github.io/ecma262/#sec-reflect.getprototypeof
$({ target: 'Reflect', stat: true, sham: !CORRECT_PROTOTYPE_GETTER }, {
getPrototypeOf: function getPrototypeOf(target) {
return objectGetPrototypeOf(anObject(target));
}
});
core-js-3.6.1/packages/core-js/modules/es.reflect.get.js 0000664 0000000 0000000 00000001760 13600575677 0023045 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var isObject = require('../internals/is-object');
var anObject = require('../internals/an-object');
var has = require('../internals/has');
var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
var getPrototypeOf = require('../internals/object-get-prototype-of');
// `Reflect.get` method
// https://tc39.github.io/ecma262/#sec-reflect.get
function get(target, propertyKey /* , receiver */) {
var receiver = arguments.length < 3 ? target : arguments[2];
var descriptor, prototype;
if (anObject(target) === receiver) return target[propertyKey];
if (descriptor = getOwnPropertyDescriptorModule.f(target, propertyKey)) return has(descriptor, 'value')
? descriptor.value
: descriptor.get === undefined
? undefined
: descriptor.get.call(receiver);
if (isObject(prototype = getPrototypeOf(target))) return get(prototype, propertyKey, receiver);
}
$({ target: 'Reflect', stat: true }, {
get: get
});
core-js-3.6.1/packages/core-js/modules/es.reflect.has.js 0000664 0000000 0000000 00000000360 13600575677 0023034 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
// `Reflect.has` method
// https://tc39.github.io/ecma262/#sec-reflect.has
$({ target: 'Reflect', stat: true }, {
has: function has(target, propertyKey) {
return propertyKey in target;
}
});
core-js-3.6.1/packages/core-js/modules/es.reflect.is-extensible.js 0000664 0000000 0000000 00000000637 13600575677 0025043 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var anObject = require('../internals/an-object');
var objectIsExtensible = Object.isExtensible;
// `Reflect.isExtensible` method
// https://tc39.github.io/ecma262/#sec-reflect.isextensible
$({ target: 'Reflect', stat: true }, {
isExtensible: function isExtensible(target) {
anObject(target);
return objectIsExtensible ? objectIsExtensible(target) : true;
}
});
core-js-3.6.1/packages/core-js/modules/es.reflect.own-keys.js 0000664 0000000 0000000 00000000352 13600575677 0024036 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var ownKeys = require('../internals/own-keys');
// `Reflect.ownKeys` method
// https://tc39.github.io/ecma262/#sec-reflect.ownkeys
$({ target: 'Reflect', stat: true }, {
ownKeys: ownKeys
});
core-js-3.6.1/packages/core-js/modules/es.reflect.prevent-extensions.js 0000664 0000000 0000000 00000001232 13600575677 0026140 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var getBuiltIn = require('../internals/get-built-in');
var anObject = require('../internals/an-object');
var FREEZING = require('../internals/freezing');
// `Reflect.preventExtensions` method
// https://tc39.github.io/ecma262/#sec-reflect.preventextensions
$({ target: 'Reflect', stat: true, sham: !FREEZING }, {
preventExtensions: function preventExtensions(target) {
anObject(target);
try {
var objectPreventExtensions = getBuiltIn('Object', 'preventExtensions');
if (objectPreventExtensions) objectPreventExtensions(target);
return true;
} catch (error) {
return false;
}
}
});
core-js-3.6.1/packages/core-js/modules/es.reflect.set-prototype-of.js 0000664 0000000 0000000 00000001200 13600575677 0025513 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var anObject = require('../internals/an-object');
var aPossiblePrototype = require('../internals/a-possible-prototype');
var objectSetPrototypeOf = require('../internals/object-set-prototype-of');
// `Reflect.setPrototypeOf` method
// https://tc39.github.io/ecma262/#sec-reflect.setprototypeof
if (objectSetPrototypeOf) $({ target: 'Reflect', stat: true }, {
setPrototypeOf: function setPrototypeOf(target, proto) {
anObject(target);
aPossiblePrototype(proto);
try {
objectSetPrototypeOf(target, proto);
return true;
} catch (error) {
return false;
}
}
});
core-js-3.6.1/packages/core-js/modules/es.reflect.set.js 0000664 0000000 0000000 00000004101 13600575677 0023051 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var anObject = require('../internals/an-object');
var isObject = require('../internals/is-object');
var has = require('../internals/has');
var fails = require('../internals/fails');
var definePropertyModule = require('../internals/object-define-property');
var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
var getPrototypeOf = require('../internals/object-get-prototype-of');
var createPropertyDescriptor = require('../internals/create-property-descriptor');
// `Reflect.set` method
// https://tc39.github.io/ecma262/#sec-reflect.set
function set(target, propertyKey, V /* , receiver */) {
var receiver = arguments.length < 4 ? target : arguments[3];
var ownDescriptor = getOwnPropertyDescriptorModule.f(anObject(target), propertyKey);
var existingDescriptor, prototype;
if (!ownDescriptor) {
if (isObject(prototype = getPrototypeOf(target))) {
return set(prototype, propertyKey, V, receiver);
}
ownDescriptor = createPropertyDescriptor(0);
}
if (has(ownDescriptor, 'value')) {
if (ownDescriptor.writable === false || !isObject(receiver)) return false;
if (existingDescriptor = getOwnPropertyDescriptorModule.f(receiver, propertyKey)) {
if (existingDescriptor.get || existingDescriptor.set || existingDescriptor.writable === false) return false;
existingDescriptor.value = V;
definePropertyModule.f(receiver, propertyKey, existingDescriptor);
} else definePropertyModule.f(receiver, propertyKey, createPropertyDescriptor(0, V));
return true;
}
return ownDescriptor.set === undefined ? false : (ownDescriptor.set.call(receiver, V), true);
}
// MS Edge 17-18 Reflect.set allows setting the property to object
// with non-writable property on the prototype
var MS_EDGE_BUG = fails(function () {
var object = definePropertyModule.f({}, 'a', { configurable: true });
// eslint-disable-next-line no-undef
return Reflect.set(getPrototypeOf(object), 'a', 1, object) !== false;
});
$({ target: 'Reflect', stat: true, forced: MS_EDGE_BUG }, {
set: set
});
core-js-3.6.1/packages/core-js/modules/es.regexp.constructor.js 0000664 0000000 0000000 00000006114 13600575677 0024517 0 ustar 00root root 0000000 0000000 var DESCRIPTORS = require('../internals/descriptors');
var global = require('../internals/global');
var isForced = require('../internals/is-forced');
var inheritIfRequired = require('../internals/inherit-if-required');
var defineProperty = require('../internals/object-define-property').f;
var getOwnPropertyNames = require('../internals/object-get-own-property-names').f;
var isRegExp = require('../internals/is-regexp');
var getFlags = require('../internals/regexp-flags');
var stickyHelpers = require('../internals/regexp-sticky-helpers');
var redefine = require('../internals/redefine');
var fails = require('../internals/fails');
var setInternalState = require('../internals/internal-state').set;
var setSpecies = require('../internals/set-species');
var wellKnownSymbol = require('../internals/well-known-symbol');
var MATCH = wellKnownSymbol('match');
var NativeRegExp = global.RegExp;
var RegExpPrototype = NativeRegExp.prototype;
var re1 = /a/g;
var re2 = /a/g;
// "new" should create a new object, old webkit bug
var CORRECT_NEW = new NativeRegExp(re1) !== re1;
var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;
var FORCED = DESCRIPTORS && isForced('RegExp', (!CORRECT_NEW || UNSUPPORTED_Y || fails(function () {
re2[MATCH] = false;
// RegExp constructor can alter flags and IsRegExp works correct with @@match
return NativeRegExp(re1) != re1 || NativeRegExp(re2) == re2 || NativeRegExp(re1, 'i') != '/a/i';
})));
// `RegExp` constructor
// https://tc39.github.io/ecma262/#sec-regexp-constructor
if (FORCED) {
var RegExpWrapper = function RegExp(pattern, flags) {
var thisIsRegExp = this instanceof RegExpWrapper;
var patternIsRegExp = isRegExp(pattern);
var flagsAreUndefined = flags === undefined;
var sticky;
if (!thisIsRegExp && patternIsRegExp && pattern.constructor === RegExpWrapper && flagsAreUndefined) {
return pattern;
}
if (CORRECT_NEW) {
if (patternIsRegExp && !flagsAreUndefined) pattern = pattern.source;
} else if (pattern instanceof RegExpWrapper) {
if (flagsAreUndefined) flags = getFlags.call(pattern);
pattern = pattern.source;
}
if (UNSUPPORTED_Y) {
sticky = !!flags && flags.indexOf('y') > -1;
if (sticky) flags = flags.replace(/y/g, '');
}
var result = inheritIfRequired(
CORRECT_NEW ? new NativeRegExp(pattern, flags) : NativeRegExp(pattern, flags),
thisIsRegExp ? this : RegExpPrototype,
RegExpWrapper
);
if (UNSUPPORTED_Y && sticky) setInternalState(result, { sticky: sticky });
return result;
};
var proxy = function (key) {
key in RegExpWrapper || defineProperty(RegExpWrapper, key, {
configurable: true,
get: function () { return NativeRegExp[key]; },
set: function (it) { NativeRegExp[key] = it; }
});
};
var keys = getOwnPropertyNames(NativeRegExp);
var index = 0;
while (keys.length > index) proxy(keys[index++]);
RegExpPrototype.constructor = RegExpWrapper;
RegExpWrapper.prototype = RegExpPrototype;
redefine(global, 'RegExp', RegExpWrapper);
}
// https://tc39.github.io/ecma262/#sec-get-regexp-@@species
setSpecies('RegExp');
core-js-3.6.1/packages/core-js/modules/es.regexp.exec.js 0000664 0000000 0000000 00000000272 13600575677 0023055 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var exec = require('../internals/regexp-exec');
$({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, {
exec: exec
});
core-js-3.6.1/packages/core-js/modules/es.regexp.flags.js 0000664 0000000 0000000 00000001043 13600575677 0023222 0 ustar 00root root 0000000 0000000 var DESCRIPTORS = require('../internals/descriptors');
var objectDefinePropertyModule = require('../internals/object-define-property');
var regExpFlags = require('../internals/regexp-flags');
var UNSUPPORTED_Y = require('../internals/regexp-sticky-helpers').UNSUPPORTED_Y;
// `RegExp.prototype.flags` getter
// https://tc39.github.io/ecma262/#sec-get-regexp.prototype.flags
if (DESCRIPTORS && (/./g.flags != 'g' || UNSUPPORTED_Y)) {
objectDefinePropertyModule.f(RegExp.prototype, 'flags', {
configurable: true,
get: regExpFlags
});
}
core-js-3.6.1/packages/core-js/modules/es.regexp.sticky.js 0000664 0000000 0000000 00000001477 13600575677 0023447 0 ustar 00root root 0000000 0000000 var DESCRIPTORS = require('../internals/descriptors');
var UNSUPPORTED_Y = require('../internals/regexp-sticky-helpers').UNSUPPORTED_Y;
var defineProperty = require('../internals/object-define-property').f;
var getInternalState = require('../internals/internal-state').get;
var RegExpPrototype = RegExp.prototype;
// `RegExp.prototype.sticky` getter
if (DESCRIPTORS && UNSUPPORTED_Y) {
defineProperty(RegExp.prototype, 'sticky', {
configurable: true,
get: function () {
if (this === RegExpPrototype) return undefined;
// We can't use InternalStateModule.getterFor because
// we don't add metadata for regexps created by a literal.
if (this instanceof RegExp) {
return !!getInternalState(this).sticky;
}
throw TypeError('Incompatible receiver, RegExp required');
}
});
}
core-js-3.6.1/packages/core-js/modules/es.regexp.test.js 0000664 0000000 0000000 00000001367 13600575677 0023116 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var isObject = require('../internals/is-object');
var DELEGATES_TO_EXEC = function () {
var execCalled = false;
var re = /[ac]/;
re.exec = function () {
execCalled = true;
return /./.exec.apply(this, arguments);
};
return re.test('abc') === true && execCalled;
}();
var nativeTest = /./.test;
$({ target: 'RegExp', proto: true, forced: !DELEGATES_TO_EXEC }, {
test: function (str) {
if (typeof this.exec !== 'function') {
return nativeTest.call(this, str);
}
var result = this.exec(str);
if (result !== null && !isObject(result)) {
throw new Error('RegExp exec method returned something other than an Object or null');
}
return !!result;
}
});
core-js-3.6.1/packages/core-js/modules/es.regexp.to-string.js 0000664 0000000 0000000 00000001731 13600575677 0024060 0 ustar 00root root 0000000 0000000 'use strict';
var redefine = require('../internals/redefine');
var anObject = require('../internals/an-object');
var fails = require('../internals/fails');
var flags = require('../internals/regexp-flags');
var TO_STRING = 'toString';
var RegExpPrototype = RegExp.prototype;
var nativeToString = RegExpPrototype[TO_STRING];
var NOT_GENERIC = fails(function () { return nativeToString.call({ source: 'a', flags: 'b' }) != '/a/b'; });
// FF44- RegExp#toString has a wrong name
var INCORRECT_NAME = nativeToString.name != TO_STRING;
// `RegExp.prototype.toString` method
// https://tc39.github.io/ecma262/#sec-regexp.prototype.tostring
if (NOT_GENERIC || INCORRECT_NAME) {
redefine(RegExp.prototype, TO_STRING, function toString() {
var R = anObject(this);
var p = String(R.source);
var rf = R.flags;
var f = String(rf === undefined && R instanceof RegExp && !('flags' in RegExpPrototype) ? flags.call(R) : rf);
return '/' + p + '/' + f;
}, { unsafe: true });
}
core-js-3.6.1/packages/core-js/modules/es.set.js 0000664 0000000 0000000 00000000566 13600575677 0021441 0 ustar 00root root 0000000 0000000 'use strict';
var collection = require('../internals/collection');
var collectionStrong = require('../internals/collection-strong');
// `Set` constructor
// https://tc39.github.io/ecma262/#sec-set-objects
module.exports = collection('Set', function (init) {
return function Set() { return init(this, arguments.length ? arguments[0] : undefined); };
}, collectionStrong);
core-js-3.6.1/packages/core-js/modules/es.string.anchor.js 0000664 0000000 0000000 00000000713 13600575677 0023417 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var createHTML = require('../internals/create-html');
var forcedStringHTMLMethod = require('../internals/forced-string-html-method');
// `String.prototype.anchor` method
// https://tc39.github.io/ecma262/#sec-string.prototype.anchor
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('anchor') }, {
anchor: function anchor(name) {
return createHTML(this, 'a', 'name', name);
}
});
core-js-3.6.1/packages/core-js/modules/es.string.big.js 0000664 0000000 0000000 00000000664 13600575677 0022713 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var createHTML = require('../internals/create-html');
var forcedStringHTMLMethod = require('../internals/forced-string-html-method');
// `String.prototype.big` method
// https://tc39.github.io/ecma262/#sec-string.prototype.big
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('big') }, {
big: function big() {
return createHTML(this, 'big', '', '');
}
});
core-js-3.6.1/packages/core-js/modules/es.string.blink.js 0000664 0000000 0000000 00000000700 13600575677 0023240 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var createHTML = require('../internals/create-html');
var forcedStringHTMLMethod = require('../internals/forced-string-html-method');
// `String.prototype.blink` method
// https://tc39.github.io/ecma262/#sec-string.prototype.blink
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('blink') }, {
blink: function blink() {
return createHTML(this, 'blink', '', '');
}
});
core-js-3.6.1/packages/core-js/modules/es.string.bold.js 0000664 0000000 0000000 00000000667 13600575677 0023075 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var createHTML = require('../internals/create-html');
var forcedStringHTMLMethod = require('../internals/forced-string-html-method');
// `String.prototype.bold` method
// https://tc39.github.io/ecma262/#sec-string.prototype.bold
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('bold') }, {
bold: function bold() {
return createHTML(this, 'b', '', '');
}
});
core-js-3.6.1/packages/core-js/modules/es.string.code-point-at.js 0000664 0000000 0000000 00000000532 13600575677 0024607 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var codeAt = require('../internals/string-multibyte').codeAt;
// `String.prototype.codePointAt` method
// https://tc39.github.io/ecma262/#sec-string.prototype.codepointat
$({ target: 'String', proto: true }, {
codePointAt: function codePointAt(pos) {
return codeAt(this, pos);
}
});
core-js-3.6.1/packages/core-js/modules/es.string.ends-with.js 0000664 0000000 0000000 00000003015 13600575677 0024045 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
var toLength = require('../internals/to-length');
var notARegExp = require('../internals/not-a-regexp');
var requireObjectCoercible = require('../internals/require-object-coercible');
var correctIsRegExpLogic = require('../internals/correct-is-regexp-logic');
var IS_PURE = require('../internals/is-pure');
var nativeEndsWith = ''.endsWith;
var min = Math.min;
var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('endsWith');
// https://github.com/zloirock/core-js/pull/702
var MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function () {
var descriptor = getOwnPropertyDescriptor(String.prototype, 'endsWith');
return descriptor && !descriptor.writable;
}();
// `String.prototype.endsWith` method
// https://tc39.github.io/ecma262/#sec-string.prototype.endswith
$({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {
endsWith: function endsWith(searchString /* , endPosition = @length */) {
var that = String(requireObjectCoercible(this));
notARegExp(searchString);
var endPosition = arguments.length > 1 ? arguments[1] : undefined;
var len = toLength(that.length);
var end = endPosition === undefined ? len : min(toLength(endPosition), len);
var search = String(searchString);
return nativeEndsWith
? nativeEndsWith.call(that, search, end)
: that.slice(end - search.length, end) === search;
}
});
core-js-3.6.1/packages/core-js/modules/es.string.fixed.js 0000664 0000000 0000000 00000000675 13600575677 0023253 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var createHTML = require('../internals/create-html');
var forcedStringHTMLMethod = require('../internals/forced-string-html-method');
// `String.prototype.fixed` method
// https://tc39.github.io/ecma262/#sec-string.prototype.fixed
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('fixed') }, {
fixed: function fixed() {
return createHTML(this, 'tt', '', '');
}
});
core-js-3.6.1/packages/core-js/modules/es.string.fontcolor.js 0000664 0000000 0000000 00000000740 13600575677 0024152 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var createHTML = require('../internals/create-html');
var forcedStringHTMLMethod = require('../internals/forced-string-html-method');
// `String.prototype.fontcolor` method
// https://tc39.github.io/ecma262/#sec-string.prototype.fontcolor
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('fontcolor') }, {
fontcolor: function fontcolor(color) {
return createHTML(this, 'font', 'color', color);
}
});
core-js-3.6.1/packages/core-js/modules/es.string.fontsize.js 0000664 0000000 0000000 00000000730 13600575677 0024005 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var createHTML = require('../internals/create-html');
var forcedStringHTMLMethod = require('../internals/forced-string-html-method');
// `String.prototype.fontsize` method
// https://tc39.github.io/ecma262/#sec-string.prototype.fontsize
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('fontsize') }, {
fontsize: function fontsize(size) {
return createHTML(this, 'font', 'size', size);
}
});
core-js-3.6.1/packages/core-js/modules/es.string.from-code-point.js 0000664 0000000 0000000 00000001747 13600575677 0025157 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var toAbsoluteIndex = require('../internals/to-absolute-index');
var fromCharCode = String.fromCharCode;
var nativeFromCodePoint = String.fromCodePoint;
// length should be 1, old FF problem
var INCORRECT_LENGTH = !!nativeFromCodePoint && nativeFromCodePoint.length != 1;
// `String.fromCodePoint` method
// https://tc39.github.io/ecma262/#sec-string.fromcodepoint
$({ target: 'String', stat: true, forced: INCORRECT_LENGTH }, {
fromCodePoint: function fromCodePoint(x) { // eslint-disable-line no-unused-vars
var elements = [];
var length = arguments.length;
var i = 0;
var code;
while (length > i) {
code = +arguments[i++];
if (toAbsoluteIndex(code, 0x10FFFF) !== code) throw RangeError(code + ' is not a valid code point');
elements.push(code < 0x10000
? fromCharCode(code)
: fromCharCode(((code -= 0x10000) >> 10) + 0xD800, code % 0x400 + 0xDC00)
);
} return elements.join('');
}
});
core-js-3.6.1/packages/core-js/modules/es.string.includes.js 0000664 0000000 0000000 00000001233 13600575677 0023751 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var notARegExp = require('../internals/not-a-regexp');
var requireObjectCoercible = require('../internals/require-object-coercible');
var correctIsRegExpLogic = require('../internals/correct-is-regexp-logic');
// `String.prototype.includes` method
// https://tc39.github.io/ecma262/#sec-string.prototype.includes
$({ target: 'String', proto: true, forced: !correctIsRegExpLogic('includes') }, {
includes: function includes(searchString /* , position = 0 */) {
return !!~String(requireObjectCoercible(this))
.indexOf(notARegExp(searchString), arguments.length > 1 ? arguments[1] : undefined);
}
});
core-js-3.6.1/packages/core-js/modules/es.string.italics.js 0000664 0000000 0000000 00000000706 13600575677 0023577 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var createHTML = require('../internals/create-html');
var forcedStringHTMLMethod = require('../internals/forced-string-html-method');
// `String.prototype.italics` method
// https://tc39.github.io/ecma262/#sec-string.prototype.italics
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('italics') }, {
italics: function italics() {
return createHTML(this, 'i', '', '');
}
});
core-js-3.6.1/packages/core-js/modules/es.string.iterator.js 0000664 0000000 0000000 00000002034 13600575677 0023774 0 ustar 00root root 0000000 0000000 'use strict';
var charAt = require('../internals/string-multibyte').charAt;
var InternalStateModule = require('../internals/internal-state');
var defineIterator = require('../internals/define-iterator');
var STRING_ITERATOR = 'String Iterator';
var setInternalState = InternalStateModule.set;
var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);
// `String.prototype[@@iterator]` method
// https://tc39.github.io/ecma262/#sec-string.prototype-@@iterator
defineIterator(String, 'String', function (iterated) {
setInternalState(this, {
type: STRING_ITERATOR,
string: String(iterated),
index: 0
});
// `%StringIteratorPrototype%.next` method
// https://tc39.github.io/ecma262/#sec-%stringiteratorprototype%.next
}, function next() {
var state = getInternalState(this);
var string = state.string;
var index = state.index;
var point;
if (index >= string.length) return { value: undefined, done: true };
point = charAt(string, index);
state.index += point.length;
return { value: point, done: false };
});
core-js-3.6.1/packages/core-js/modules/es.string.link.js 0000664 0000000 0000000 00000000677 13600575677 0023113 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var createHTML = require('../internals/create-html');
var forcedStringHTMLMethod = require('../internals/forced-string-html-method');
// `String.prototype.link` method
// https://tc39.github.io/ecma262/#sec-string.prototype.link
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('link') }, {
link: function link(url) {
return createHTML(this, 'a', 'href', url);
}
});
core-js-3.6.1/packages/core-js/modules/es.string.match-all.js 0000664 0000000 0000000 00000010546 13600575677 0024014 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var createIteratorConstructor = require('../internals/create-iterator-constructor');
var requireObjectCoercible = require('../internals/require-object-coercible');
var toLength = require('../internals/to-length');
var aFunction = require('../internals/a-function');
var anObject = require('../internals/an-object');
var classof = require('../internals/classof-raw');
var isRegExp = require('../internals/is-regexp');
var getRegExpFlags = require('../internals/regexp-flags');
var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
var fails = require('../internals/fails');
var wellKnownSymbol = require('../internals/well-known-symbol');
var speciesConstructor = require('../internals/species-constructor');
var advanceStringIndex = require('../internals/advance-string-index');
var InternalStateModule = require('../internals/internal-state');
var IS_PURE = require('../internals/is-pure');
var MATCH_ALL = wellKnownSymbol('matchAll');
var REGEXP_STRING = 'RegExp String';
var REGEXP_STRING_ITERATOR = REGEXP_STRING + ' Iterator';
var setInternalState = InternalStateModule.set;
var getInternalState = InternalStateModule.getterFor(REGEXP_STRING_ITERATOR);
var RegExpPrototype = RegExp.prototype;
var regExpBuiltinExec = RegExpPrototype.exec;
var nativeMatchAll = ''.matchAll;
var WORKS_WITH_NON_GLOBAL_REGEX = !!nativeMatchAll && !fails(function () {
'a'.matchAll(/./);
});
var regExpExec = function (R, S) {
var exec = R.exec;
var result;
if (typeof exec == 'function') {
result = exec.call(R, S);
if (typeof result != 'object') throw TypeError('Incorrect exec result');
return result;
} return regExpBuiltinExec.call(R, S);
};
// eslint-disable-next-line max-len
var $RegExpStringIterator = createIteratorConstructor(function RegExpStringIterator(regexp, string, global, fullUnicode) {
setInternalState(this, {
type: REGEXP_STRING_ITERATOR,
regexp: regexp,
string: string,
global: global,
unicode: fullUnicode,
done: false
});
}, REGEXP_STRING, function next() {
var state = getInternalState(this);
if (state.done) return { value: undefined, done: true };
var R = state.regexp;
var S = state.string;
var match = regExpExec(R, S);
if (match === null) return { value: undefined, done: state.done = true };
if (state.global) {
if (String(match[0]) == '') R.lastIndex = advanceStringIndex(S, toLength(R.lastIndex), state.unicode);
return { value: match, done: false };
}
state.done = true;
return { value: match, done: false };
});
var $matchAll = function (string) {
var R = anObject(this);
var S = String(string);
var C, flagsValue, flags, matcher, global, fullUnicode;
C = speciesConstructor(R, RegExp);
flagsValue = R.flags;
if (flagsValue === undefined && R instanceof RegExp && !('flags' in RegExpPrototype)) {
flagsValue = getRegExpFlags.call(R);
}
flags = flagsValue === undefined ? '' : String(flagsValue);
matcher = new C(C === RegExp ? R.source : R, flags);
global = !!~flags.indexOf('g');
fullUnicode = !!~flags.indexOf('u');
matcher.lastIndex = toLength(R.lastIndex);
return new $RegExpStringIterator(matcher, S, global, fullUnicode);
};
// `String.prototype.matchAll` method
// https://github.com/tc39/proposal-string-matchall
$({ target: 'String', proto: true, forced: WORKS_WITH_NON_GLOBAL_REGEX }, {
matchAll: function matchAll(regexp) {
var O = requireObjectCoercible(this);
var flags, S, matcher, rx;
if (regexp != null) {
if (isRegExp(regexp)) {
flags = String(requireObjectCoercible('flags' in RegExpPrototype
? regexp.flags
: getRegExpFlags.call(regexp)
));
if (!~flags.indexOf('g')) throw TypeError('`.matchAll` does not allow non-global regexes');
}
if (WORKS_WITH_NON_GLOBAL_REGEX) return nativeMatchAll.apply(O, arguments);
matcher = regexp[MATCH_ALL];
if (matcher === undefined && IS_PURE && classof(regexp) == 'RegExp') matcher = $matchAll;
if (matcher != null) return aFunction(matcher).call(regexp, O);
} else if (WORKS_WITH_NON_GLOBAL_REGEX) return nativeMatchAll.apply(O, arguments);
S = String(O);
rx = new RegExp(regexp, 'g');
return IS_PURE ? $matchAll.call(rx, S) : rx[MATCH_ALL](S);
}
});
IS_PURE || MATCH_ALL in RegExpPrototype || createNonEnumerableProperty(RegExpPrototype, MATCH_ALL, $matchAll);
core-js-3.6.1/packages/core-js/modules/es.string.match.js 0000664 0000000 0000000 00000003161 13600575677 0023241 0 ustar 00root root 0000000 0000000 'use strict';
var fixRegExpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic');
var anObject = require('../internals/an-object');
var toLength = require('../internals/to-length');
var requireObjectCoercible = require('../internals/require-object-coercible');
var advanceStringIndex = require('../internals/advance-string-index');
var regExpExec = require('../internals/regexp-exec-abstract');
// @@match logic
fixRegExpWellKnownSymbolLogic('match', 1, function (MATCH, nativeMatch, maybeCallNative) {
return [
// `String.prototype.match` method
// https://tc39.github.io/ecma262/#sec-string.prototype.match
function match(regexp) {
var O = requireObjectCoercible(this);
var matcher = regexp == undefined ? undefined : regexp[MATCH];
return matcher !== undefined ? matcher.call(regexp, O) : new RegExp(regexp)[MATCH](String(O));
},
// `RegExp.prototype[@@match]` method
// https://tc39.github.io/ecma262/#sec-regexp.prototype-@@match
function (regexp) {
var res = maybeCallNative(nativeMatch, regexp, this);
if (res.done) return res.value;
var rx = anObject(regexp);
var S = String(this);
if (!rx.global) return regExpExec(rx, S);
var fullUnicode = rx.unicode;
rx.lastIndex = 0;
var A = [];
var n = 0;
var result;
while ((result = regExpExec(rx, S)) !== null) {
var matchStr = String(result[0]);
A[n] = matchStr;
if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
n++;
}
return n === 0 ? null : A;
}
];
});
core-js-3.6.1/packages/core-js/modules/es.string.pad-end.js 0000664 0000000 0000000 00000000751 13600575677 0023457 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var $padEnd = require('../internals/string-pad').end;
var WEBKIT_BUG = require('../internals/webkit-string-pad-bug');
// `String.prototype.padEnd` method
// https://tc39.github.io/ecma262/#sec-string.prototype.padend
$({ target: 'String', proto: true, forced: WEBKIT_BUG }, {
padEnd: function padEnd(maxLength /* , fillString = ' ' */) {
return $padEnd(this, maxLength, arguments.length > 1 ? arguments[1] : undefined);
}
});
core-js-3.6.1/packages/core-js/modules/es.string.pad-start.js 0000664 0000000 0000000 00000000767 13600575677 0024055 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var $padStart = require('../internals/string-pad').start;
var WEBKIT_BUG = require('../internals/webkit-string-pad-bug');
// `String.prototype.padStart` method
// https://tc39.github.io/ecma262/#sec-string.prototype.padstart
$({ target: 'String', proto: true, forced: WEBKIT_BUG }, {
padStart: function padStart(maxLength /* , fillString = ' ' */) {
return $padStart(this, maxLength, arguments.length > 1 ? arguments[1] : undefined);
}
});
core-js-3.6.1/packages/core-js/modules/es.string.raw.js 0000664 0000000 0000000 00000001247 13600575677 0022741 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var toIndexedObject = require('../internals/to-indexed-object');
var toLength = require('../internals/to-length');
// `String.raw` method
// https://tc39.github.io/ecma262/#sec-string.raw
$({ target: 'String', stat: true }, {
raw: function raw(template) {
var rawTemplate = toIndexedObject(template.raw);
var literalSegments = toLength(rawTemplate.length);
var argumentsLength = arguments.length;
var elements = [];
var i = 0;
while (literalSegments > i) {
elements.push(String(rawTemplate[i++]));
if (i < argumentsLength) elements.push(String(arguments[i]));
} return elements.join('');
}
});
core-js-3.6.1/packages/core-js/modules/es.string.repeat.js 0000664 0000000 0000000 00000000374 13600575677 0023430 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var repeat = require('../internals/string-repeat');
// `String.prototype.repeat` method
// https://tc39.github.io/ecma262/#sec-string.prototype.repeat
$({ target: 'String', proto: true }, {
repeat: repeat
});
core-js-3.6.1/packages/core-js/modules/es.string.replace.js 0000664 0000000 0000000 00000011725 13600575677 0023565 0 ustar 00root root 0000000 0000000 'use strict';
var fixRegExpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic');
var anObject = require('../internals/an-object');
var toObject = require('../internals/to-object');
var toLength = require('../internals/to-length');
var toInteger = require('../internals/to-integer');
var requireObjectCoercible = require('../internals/require-object-coercible');
var advanceStringIndex = require('../internals/advance-string-index');
var regExpExec = require('../internals/regexp-exec-abstract');
var max = Math.max;
var min = Math.min;
var floor = Math.floor;
var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d\d?|<[^>]*>)/g;
var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d\d?)/g;
var maybeToString = function (it) {
return it === undefined ? it : String(it);
};
// @@replace logic
fixRegExpWellKnownSymbolLogic('replace', 2, function (REPLACE, nativeReplace, maybeCallNative, reason) {
return [
// `String.prototype.replace` method
// https://tc39.github.io/ecma262/#sec-string.prototype.replace
function replace(searchValue, replaceValue) {
var O = requireObjectCoercible(this);
var replacer = searchValue == undefined ? undefined : searchValue[REPLACE];
return replacer !== undefined
? replacer.call(searchValue, O, replaceValue)
: nativeReplace.call(String(O), searchValue, replaceValue);
},
// `RegExp.prototype[@@replace]` method
// https://tc39.github.io/ecma262/#sec-regexp.prototype-@@replace
function (regexp, replaceValue) {
if (reason.REPLACE_KEEPS_$0 || (typeof replaceValue === 'string' && replaceValue.indexOf('$0') === -1)) {
var res = maybeCallNative(nativeReplace, regexp, this, replaceValue);
if (res.done) return res.value;
}
var rx = anObject(regexp);
var S = String(this);
var functionalReplace = typeof replaceValue === 'function';
if (!functionalReplace) replaceValue = String(replaceValue);
var global = rx.global;
if (global) {
var fullUnicode = rx.unicode;
rx.lastIndex = 0;
}
var results = [];
while (true) {
var result = regExpExec(rx, S);
if (result === null) break;
results.push(result);
if (!global) break;
var matchStr = String(result[0]);
if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
}
var accumulatedResult = '';
var nextSourcePosition = 0;
for (var i = 0; i < results.length; i++) {
result = results[i];
var matched = String(result[0]);
var position = max(min(toInteger(result.index), S.length), 0);
var captures = [];
// NOTE: This is equivalent to
// captures = result.slice(1).map(maybeToString)
// but for some reason `nativeSlice.call(result, 1, result.length)` (called in
// the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
// causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.
for (var j = 1; j < result.length; j++) captures.push(maybeToString(result[j]));
var namedCaptures = result.groups;
if (functionalReplace) {
var replacerArgs = [matched].concat(captures, position, S);
if (namedCaptures !== undefined) replacerArgs.push(namedCaptures);
var replacement = String(replaceValue.apply(undefined, replacerArgs));
} else {
replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
}
if (position >= nextSourcePosition) {
accumulatedResult += S.slice(nextSourcePosition, position) + replacement;
nextSourcePosition = position + matched.length;
}
}
return accumulatedResult + S.slice(nextSourcePosition);
}
];
// https://tc39.github.io/ecma262/#sec-getsubstitution
function getSubstitution(matched, str, position, captures, namedCaptures, replacement) {
var tailPos = position + matched.length;
var m = captures.length;
var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;
if (namedCaptures !== undefined) {
namedCaptures = toObject(namedCaptures);
symbols = SUBSTITUTION_SYMBOLS;
}
return nativeReplace.call(replacement, symbols, function (match, ch) {
var capture;
switch (ch.charAt(0)) {
case '$': return '$';
case '&': return matched;
case '`': return str.slice(0, position);
case "'": return str.slice(tailPos);
case '<':
capture = namedCaptures[ch.slice(1, -1)];
break;
default: // \d\d?
var n = +ch;
if (n === 0) return match;
if (n > m) {
var f = floor(n / 10);
if (f === 0) return match;
if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1);
return match;
}
capture = captures[n - 1];
}
return capture === undefined ? '' : capture;
});
}
});
core-js-3.6.1/packages/core-js/modules/es.string.search.js 0000664 0000000 0000000 00000002635 13600575677 0023417 0 ustar 00root root 0000000 0000000 'use strict';
var fixRegExpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic');
var anObject = require('../internals/an-object');
var requireObjectCoercible = require('../internals/require-object-coercible');
var sameValue = require('../internals/same-value');
var regExpExec = require('../internals/regexp-exec-abstract');
// @@search logic
fixRegExpWellKnownSymbolLogic('search', 1, function (SEARCH, nativeSearch, maybeCallNative) {
return [
// `String.prototype.search` method
// https://tc39.github.io/ecma262/#sec-string.prototype.search
function search(regexp) {
var O = requireObjectCoercible(this);
var searcher = regexp == undefined ? undefined : regexp[SEARCH];
return searcher !== undefined ? searcher.call(regexp, O) : new RegExp(regexp)[SEARCH](String(O));
},
// `RegExp.prototype[@@search]` method
// https://tc39.github.io/ecma262/#sec-regexp.prototype-@@search
function (regexp) {
var res = maybeCallNative(nativeSearch, regexp, this);
if (res.done) return res.value;
var rx = anObject(regexp);
var S = String(this);
var previousLastIndex = rx.lastIndex;
if (!sameValue(previousLastIndex, 0)) rx.lastIndex = 0;
var result = regExpExec(rx, S);
if (!sameValue(rx.lastIndex, previousLastIndex)) rx.lastIndex = previousLastIndex;
return result === null ? -1 : result.index;
}
];
});
core-js-3.6.1/packages/core-js/modules/es.string.small.js 0000664 0000000 0000000 00000000700 13600575677 0023251 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var createHTML = require('../internals/create-html');
var forcedStringHTMLMethod = require('../internals/forced-string-html-method');
// `String.prototype.small` method
// https://tc39.github.io/ecma262/#sec-string.prototype.small
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('small') }, {
small: function small() {
return createHTML(this, 'small', '', '');
}
});
core-js-3.6.1/packages/core-js/modules/es.string.split.js 0000664 0000000 0000000 00000012527 13600575677 0023306 0 ustar 00root root 0000000 0000000 'use strict';
var fixRegExpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic');
var isRegExp = require('../internals/is-regexp');
var anObject = require('../internals/an-object');
var requireObjectCoercible = require('../internals/require-object-coercible');
var speciesConstructor = require('../internals/species-constructor');
var advanceStringIndex = require('../internals/advance-string-index');
var toLength = require('../internals/to-length');
var callRegExpExec = require('../internals/regexp-exec-abstract');
var regexpExec = require('../internals/regexp-exec');
var fails = require('../internals/fails');
var arrayPush = [].push;
var min = Math.min;
var MAX_UINT32 = 0xFFFFFFFF;
// babel-minify transpiles RegExp('x', 'y') -> /x/y and it causes SyntaxError
var SUPPORTS_Y = !fails(function () { return !RegExp(MAX_UINT32, 'y'); });
// @@split logic
fixRegExpWellKnownSymbolLogic('split', 2, function (SPLIT, nativeSplit, maybeCallNative) {
var internalSplit;
if (
'abbc'.split(/(b)*/)[1] == 'c' ||
'test'.split(/(?:)/, -1).length != 4 ||
'ab'.split(/(?:ab)*/).length != 2 ||
'.'.split(/(.?)(.?)/).length != 4 ||
'.'.split(/()()/).length > 1 ||
''.split(/.?/).length
) {
// based on es5-shim implementation, need to rework it
internalSplit = function (separator, limit) {
var string = String(requireObjectCoercible(this));
var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
if (lim === 0) return [];
if (separator === undefined) return [string];
// If `separator` is not a regex, use native split
if (!isRegExp(separator)) {
return nativeSplit.call(string, separator, lim);
}
var output = [];
var flags = (separator.ignoreCase ? 'i' : '') +
(separator.multiline ? 'm' : '') +
(separator.unicode ? 'u' : '') +
(separator.sticky ? 'y' : '');
var lastLastIndex = 0;
// Make `global` and avoid `lastIndex` issues by working with a copy
var separatorCopy = new RegExp(separator.source, flags + 'g');
var match, lastIndex, lastLength;
while (match = regexpExec.call(separatorCopy, string)) {
lastIndex = separatorCopy.lastIndex;
if (lastIndex > lastLastIndex) {
output.push(string.slice(lastLastIndex, match.index));
if (match.length > 1 && match.index < string.length) arrayPush.apply(output, match.slice(1));
lastLength = match[0].length;
lastLastIndex = lastIndex;
if (output.length >= lim) break;
}
if (separatorCopy.lastIndex === match.index) separatorCopy.lastIndex++; // Avoid an infinite loop
}
if (lastLastIndex === string.length) {
if (lastLength || !separatorCopy.test('')) output.push('');
} else output.push(string.slice(lastLastIndex));
return output.length > lim ? output.slice(0, lim) : output;
};
// Chakra, V8
} else if ('0'.split(undefined, 0).length) {
internalSplit = function (separator, limit) {
return separator === undefined && limit === 0 ? [] : nativeSplit.call(this, separator, limit);
};
} else internalSplit = nativeSplit;
return [
// `String.prototype.split` method
// https://tc39.github.io/ecma262/#sec-string.prototype.split
function split(separator, limit) {
var O = requireObjectCoercible(this);
var splitter = separator == undefined ? undefined : separator[SPLIT];
return splitter !== undefined
? splitter.call(separator, O, limit)
: internalSplit.call(String(O), separator, limit);
},
// `RegExp.prototype[@@split]` method
// https://tc39.github.io/ecma262/#sec-regexp.prototype-@@split
//
// NOTE: This cannot be properly polyfilled in engines that don't support
// the 'y' flag.
function (regexp, limit) {
var res = maybeCallNative(internalSplit, regexp, this, limit, internalSplit !== nativeSplit);
if (res.done) return res.value;
var rx = anObject(regexp);
var S = String(this);
var C = speciesConstructor(rx, RegExp);
var unicodeMatching = rx.unicode;
var flags = (rx.ignoreCase ? 'i' : '') +
(rx.multiline ? 'm' : '') +
(rx.unicode ? 'u' : '') +
(SUPPORTS_Y ? 'y' : 'g');
// ^(? + rx + ) is needed, in combination with some S slicing, to
// simulate the 'y' flag.
var splitter = new C(SUPPORTS_Y ? rx : '^(?:' + rx.source + ')', flags);
var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
if (lim === 0) return [];
if (S.length === 0) return callRegExpExec(splitter, S) === null ? [S] : [];
var p = 0;
var q = 0;
var A = [];
while (q < S.length) {
splitter.lastIndex = SUPPORTS_Y ? q : 0;
var z = callRegExpExec(splitter, SUPPORTS_Y ? S : S.slice(q));
var e;
if (
z === null ||
(e = min(toLength(splitter.lastIndex + (SUPPORTS_Y ? 0 : q)), S.length)) === p
) {
q = advanceStringIndex(S, q, unicodeMatching);
} else {
A.push(S.slice(p, q));
if (A.length === lim) return A;
for (var i = 1; i <= z.length - 1; i++) {
A.push(z[i]);
if (A.length === lim) return A;
}
q = p = e;
}
}
A.push(S.slice(p));
return A;
}
];
}, !SUPPORTS_Y);
core-js-3.6.1/packages/core-js/modules/es.string.starts-with.js 0000664 0000000 0000000 00000002676 13600575677 0024450 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
var toLength = require('../internals/to-length');
var notARegExp = require('../internals/not-a-regexp');
var requireObjectCoercible = require('../internals/require-object-coercible');
var correctIsRegExpLogic = require('../internals/correct-is-regexp-logic');
var IS_PURE = require('../internals/is-pure');
var nativeStartsWith = ''.startsWith;
var min = Math.min;
var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith');
// https://github.com/zloirock/core-js/pull/702
var MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function () {
var descriptor = getOwnPropertyDescriptor(String.prototype, 'startsWith');
return descriptor && !descriptor.writable;
}();
// `String.prototype.startsWith` method
// https://tc39.github.io/ecma262/#sec-string.prototype.startswith
$({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {
startsWith: function startsWith(searchString /* , position = 0 */) {
var that = String(requireObjectCoercible(this));
notARegExp(searchString);
var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length));
var search = String(searchString);
return nativeStartsWith
? nativeStartsWith.call(that, search, index)
: that.slice(index, index + search.length) === search;
}
});
core-js-3.6.1/packages/core-js/modules/es.string.strike.js 0000664 0000000 0000000 00000000706 13600575677 0023450 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var createHTML = require('../internals/create-html');
var forcedStringHTMLMethod = require('../internals/forced-string-html-method');
// `String.prototype.strike` method
// https://tc39.github.io/ecma262/#sec-string.prototype.strike
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('strike') }, {
strike: function strike() {
return createHTML(this, 'strike', '', '');
}
});
core-js-3.6.1/packages/core-js/modules/es.string.sub.js 0000664 0000000 0000000 00000000664 13600575677 0022743 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var createHTML = require('../internals/create-html');
var forcedStringHTMLMethod = require('../internals/forced-string-html-method');
// `String.prototype.sub` method
// https://tc39.github.io/ecma262/#sec-string.prototype.sub
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('sub') }, {
sub: function sub() {
return createHTML(this, 'sub', '', '');
}
});
core-js-3.6.1/packages/core-js/modules/es.string.sup.js 0000664 0000000 0000000 00000000664 13600575677 0022761 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var createHTML = require('../internals/create-html');
var forcedStringHTMLMethod = require('../internals/forced-string-html-method');
// `String.prototype.sup` method
// https://tc39.github.io/ecma262/#sec-string.prototype.sup
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('sup') }, {
sup: function sup() {
return createHTML(this, 'sup', '', '');
}
});
core-js-3.6.1/packages/core-js/modules/es.string.trim-end.js 0000664 0000000 0000000 00000001034 13600575677 0023661 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var $trimEnd = require('../internals/string-trim').end;
var forcedStringTrimMethod = require('../internals/forced-string-trim-method');
var FORCED = forcedStringTrimMethod('trimEnd');
var trimEnd = FORCED ? function trimEnd() {
return $trimEnd(this);
} : ''.trimEnd;
// `String.prototype.{ trimEnd, trimRight }` methods
// https://github.com/tc39/ecmascript-string-left-right-trim
$({ target: 'String', proto: true, forced: FORCED }, {
trimEnd: trimEnd,
trimRight: trimEnd
});
core-js-3.6.1/packages/core-js/modules/es.string.trim-start.js 0000664 0000000 0000000 00000001060 13600575677 0024247 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var $trimStart = require('../internals/string-trim').start;
var forcedStringTrimMethod = require('../internals/forced-string-trim-method');
var FORCED = forcedStringTrimMethod('trimStart');
var trimStart = FORCED ? function trimStart() {
return $trimStart(this);
} : ''.trimStart;
// `String.prototype.{ trimStart, trimLeft }` methods
// https://github.com/tc39/ecmascript-string-left-right-trim
$({ target: 'String', proto: true, forced: FORCED }, {
trimStart: trimStart,
trimLeft: trimStart
});
core-js-3.6.1/packages/core-js/modules/es.string.trim.js 0000664 0000000 0000000 00000000645 13600575677 0023124 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var $trim = require('../internals/string-trim').trim;
var forcedStringTrimMethod = require('../internals/forced-string-trim-method');
// `String.prototype.trim` method
// https://tc39.github.io/ecma262/#sec-string.prototype.trim
$({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, {
trim: function trim() {
return $trim(this);
}
});
core-js-3.6.1/packages/core-js/modules/es.symbol.async-iterator.js 0000664 0000000 0000000 00000000337 13600575677 0025112 0 ustar 00root root 0000000 0000000 var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
// `Symbol.asyncIterator` well-known symbol
// https://tc39.github.io/ecma262/#sec-symbol.asynciterator
defineWellKnownSymbol('asyncIterator');
core-js-3.6.1/packages/core-js/modules/es.symbol.description.js 0000664 0000000 0000000 00000004121 13600575677 0024464 0 ustar 00root root 0000000 0000000 // `Symbol.prototype.description` getter
// https://tc39.github.io/ecma262/#sec-symbol.prototype.description
'use strict';
var $ = require('../internals/export');
var DESCRIPTORS = require('../internals/descriptors');
var global = require('../internals/global');
var has = require('../internals/has');
var isObject = require('../internals/is-object');
var defineProperty = require('../internals/object-define-property').f;
var copyConstructorProperties = require('../internals/copy-constructor-properties');
var NativeSymbol = global.Symbol;
if (DESCRIPTORS && typeof NativeSymbol == 'function' && (!('description' in NativeSymbol.prototype) ||
// Safari 12 bug
NativeSymbol().description !== undefined
)) {
var EmptyStringDescriptionStore = {};
// wrap Symbol constructor for correct work with undefined description
var SymbolWrapper = function Symbol() {
var description = arguments.length < 1 || arguments[0] === undefined ? undefined : String(arguments[0]);
var result = this instanceof SymbolWrapper
? new NativeSymbol(description)
// in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)'
: description === undefined ? NativeSymbol() : NativeSymbol(description);
if (description === '') EmptyStringDescriptionStore[result] = true;
return result;
};
copyConstructorProperties(SymbolWrapper, NativeSymbol);
var symbolPrototype = SymbolWrapper.prototype = NativeSymbol.prototype;
symbolPrototype.constructor = SymbolWrapper;
var symbolToString = symbolPrototype.toString;
var native = String(NativeSymbol('test')) == 'Symbol(test)';
var regexp = /^Symbol\((.*)\)[^)]+$/;
defineProperty(symbolPrototype, 'description', {
configurable: true,
get: function description() {
var symbol = isObject(this) ? this.valueOf() : this;
var string = symbolToString.call(symbol);
if (has(EmptyStringDescriptionStore, symbol)) return '';
var desc = native ? string.slice(7, -1) : string.replace(regexp, '$1');
return desc === '' ? undefined : desc;
}
});
$({ global: true, forced: true }, {
Symbol: SymbolWrapper
});
}
core-js-3.6.1/packages/core-js/modules/es.symbol.has-instance.js 0000664 0000000 0000000 00000000331 13600575677 0024515 0 ustar 00root root 0000000 0000000 var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
// `Symbol.hasInstance` well-known symbol
// https://tc39.github.io/ecma262/#sec-symbol.hasinstance
defineWellKnownSymbol('hasInstance');
core-js-3.6.1/packages/core-js/modules/es.symbol.is-concat-spreadable.js 0000664 0000000 0000000 00000000356 13600575677 0026127 0 ustar 00root root 0000000 0000000 var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
// `Symbol.isConcatSpreadable` well-known symbol
// https://tc39.github.io/ecma262/#sec-symbol.isconcatspreadable
defineWellKnownSymbol('isConcatSpreadable');
core-js-3.6.1/packages/core-js/modules/es.symbol.iterator.js 0000664 0000000 0000000 00000000320 13600575677 0023767 0 ustar 00root root 0000000 0000000 var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
// `Symbol.iterator` well-known symbol
// https://tc39.github.io/ecma262/#sec-symbol.iterator
defineWellKnownSymbol('iterator');
core-js-3.6.1/packages/core-js/modules/es.symbol.js 0000664 0000000 0000000 00000031474 13600575677 0022155 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var global = require('../internals/global');
var getBuiltIn = require('../internals/get-built-in');
var IS_PURE = require('../internals/is-pure');
var DESCRIPTORS = require('../internals/descriptors');
var NATIVE_SYMBOL = require('../internals/native-symbol');
var USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');
var fails = require('../internals/fails');
var has = require('../internals/has');
var isArray = require('../internals/is-array');
var isObject = require('../internals/is-object');
var anObject = require('../internals/an-object');
var toObject = require('../internals/to-object');
var toIndexedObject = require('../internals/to-indexed-object');
var toPrimitive = require('../internals/to-primitive');
var createPropertyDescriptor = require('../internals/create-property-descriptor');
var nativeObjectCreate = require('../internals/object-create');
var objectKeys = require('../internals/object-keys');
var getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');
var getOwnPropertyNamesExternal = require('../internals/object-get-own-property-names-external');
var getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');
var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
var definePropertyModule = require('../internals/object-define-property');
var propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');
var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
var redefine = require('../internals/redefine');
var shared = require('../internals/shared');
var sharedKey = require('../internals/shared-key');
var hiddenKeys = require('../internals/hidden-keys');
var uid = require('../internals/uid');
var wellKnownSymbol = require('../internals/well-known-symbol');
var wrappedWellKnownSymbolModule = require('../internals/wrapped-well-known-symbol');
var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
var setToStringTag = require('../internals/set-to-string-tag');
var InternalStateModule = require('../internals/internal-state');
var $forEach = require('../internals/array-iteration').forEach;
var HIDDEN = sharedKey('hidden');
var SYMBOL = 'Symbol';
var PROTOTYPE = 'prototype';
var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
var setInternalState = InternalStateModule.set;
var getInternalState = InternalStateModule.getterFor(SYMBOL);
var ObjectPrototype = Object[PROTOTYPE];
var $Symbol = global.Symbol;
var $stringify = getBuiltIn('JSON', 'stringify');
var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
var nativeDefineProperty = definePropertyModule.f;
var nativeGetOwnPropertyNames = getOwnPropertyNamesExternal.f;
var nativePropertyIsEnumerable = propertyIsEnumerableModule.f;
var AllSymbols = shared('symbols');
var ObjectPrototypeSymbols = shared('op-symbols');
var StringToSymbolRegistry = shared('string-to-symbol-registry');
var SymbolToStringRegistry = shared('symbol-to-string-registry');
var WellKnownSymbolsStore = shared('wks');
var QObject = global.QObject;
// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
var USE_SETTER = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;
// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
var setSymbolDescriptor = DESCRIPTORS && fails(function () {
return nativeObjectCreate(nativeDefineProperty({}, 'a', {
get: function () { return nativeDefineProperty(this, 'a', { value: 7 }).a; }
})).a != 7;
}) ? function (O, P, Attributes) {
var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor(ObjectPrototype, P);
if (ObjectPrototypeDescriptor) delete ObjectPrototype[P];
nativeDefineProperty(O, P, Attributes);
if (ObjectPrototypeDescriptor && O !== ObjectPrototype) {
nativeDefineProperty(ObjectPrototype, P, ObjectPrototypeDescriptor);
}
} : nativeDefineProperty;
var wrap = function (tag, description) {
var symbol = AllSymbols[tag] = nativeObjectCreate($Symbol[PROTOTYPE]);
setInternalState(symbol, {
type: SYMBOL,
tag: tag,
description: description
});
if (!DESCRIPTORS) symbol.description = description;
return symbol;
};
var isSymbol = USE_SYMBOL_AS_UID ? function (it) {
return typeof it == 'symbol';
} : function (it) {
return Object(it) instanceof $Symbol;
};
var $defineProperty = function defineProperty(O, P, Attributes) {
if (O === ObjectPrototype) $defineProperty(ObjectPrototypeSymbols, P, Attributes);
anObject(O);
var key = toPrimitive(P, true);
anObject(Attributes);
if (has(AllSymbols, key)) {
if (!Attributes.enumerable) {
if (!has(O, HIDDEN)) nativeDefineProperty(O, HIDDEN, createPropertyDescriptor(1, {}));
O[HIDDEN][key] = true;
} else {
if (has(O, HIDDEN) && O[HIDDEN][key]) O[HIDDEN][key] = false;
Attributes = nativeObjectCreate(Attributes, { enumerable: createPropertyDescriptor(0, false) });
} return setSymbolDescriptor(O, key, Attributes);
} return nativeDefineProperty(O, key, Attributes);
};
var $defineProperties = function defineProperties(O, Properties) {
anObject(O);
var properties = toIndexedObject(Properties);
var keys = objectKeys(properties).concat($getOwnPropertySymbols(properties));
$forEach(keys, function (key) {
if (!DESCRIPTORS || $propertyIsEnumerable.call(properties, key)) $defineProperty(O, key, properties[key]);
});
return O;
};
var $create = function create(O, Properties) {
return Properties === undefined ? nativeObjectCreate(O) : $defineProperties(nativeObjectCreate(O), Properties);
};
var $propertyIsEnumerable = function propertyIsEnumerable(V) {
var P = toPrimitive(V, true);
var enumerable = nativePropertyIsEnumerable.call(this, P);
if (this === ObjectPrototype && has(AllSymbols, P) && !has(ObjectPrototypeSymbols, P)) return false;
return enumerable || !has(this, P) || !has(AllSymbols, P) || has(this, HIDDEN) && this[HIDDEN][P] ? enumerable : true;
};
var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(O, P) {
var it = toIndexedObject(O);
var key = toPrimitive(P, true);
if (it === ObjectPrototype && has(AllSymbols, key) && !has(ObjectPrototypeSymbols, key)) return;
var descriptor = nativeGetOwnPropertyDescriptor(it, key);
if (descriptor && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) {
descriptor.enumerable = true;
}
return descriptor;
};
var $getOwnPropertyNames = function getOwnPropertyNames(O) {
var names = nativeGetOwnPropertyNames(toIndexedObject(O));
var result = [];
$forEach(names, function (key) {
if (!has(AllSymbols, key) && !has(hiddenKeys, key)) result.push(key);
});
return result;
};
var $getOwnPropertySymbols = function getOwnPropertySymbols(O) {
var IS_OBJECT_PROTOTYPE = O === ObjectPrototype;
var names = nativeGetOwnPropertyNames(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject(O));
var result = [];
$forEach(names, function (key) {
if (has(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || has(ObjectPrototype, key))) {
result.push(AllSymbols[key]);
}
});
return result;
};
// `Symbol` constructor
// https://tc39.github.io/ecma262/#sec-symbol-constructor
if (!NATIVE_SYMBOL) {
$Symbol = function Symbol() {
if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor');
var description = !arguments.length || arguments[0] === undefined ? undefined : String(arguments[0]);
var tag = uid(description);
var setter = function (value) {
if (this === ObjectPrototype) setter.call(ObjectPrototypeSymbols, value);
if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false;
setSymbolDescriptor(this, tag, createPropertyDescriptor(1, value));
};
if (DESCRIPTORS && USE_SETTER) setSymbolDescriptor(ObjectPrototype, tag, { configurable: true, set: setter });
return wrap(tag, description);
};
redefine($Symbol[PROTOTYPE], 'toString', function toString() {
return getInternalState(this).tag;
});
redefine($Symbol, 'withoutSetter', function (description) {
return wrap(uid(description), description);
});
propertyIsEnumerableModule.f = $propertyIsEnumerable;
definePropertyModule.f = $defineProperty;
getOwnPropertyDescriptorModule.f = $getOwnPropertyDescriptor;
getOwnPropertyNamesModule.f = getOwnPropertyNamesExternal.f = $getOwnPropertyNames;
getOwnPropertySymbolsModule.f = $getOwnPropertySymbols;
wrappedWellKnownSymbolModule.f = function (name) {
return wrap(wellKnownSymbol(name), name);
};
if (DESCRIPTORS) {
// https://github.com/tc39/proposal-Symbol-description
nativeDefineProperty($Symbol[PROTOTYPE], 'description', {
configurable: true,
get: function description() {
return getInternalState(this).description;
}
});
if (!IS_PURE) {
redefine(ObjectPrototype, 'propertyIsEnumerable', $propertyIsEnumerable, { unsafe: true });
}
}
}
$({ global: true, wrap: true, forced: !NATIVE_SYMBOL, sham: !NATIVE_SYMBOL }, {
Symbol: $Symbol
});
$forEach(objectKeys(WellKnownSymbolsStore), function (name) {
defineWellKnownSymbol(name);
});
$({ target: SYMBOL, stat: true, forced: !NATIVE_SYMBOL }, {
// `Symbol.for` method
// https://tc39.github.io/ecma262/#sec-symbol.for
'for': function (key) {
var string = String(key);
if (has(StringToSymbolRegistry, string)) return StringToSymbolRegistry[string];
var symbol = $Symbol(string);
StringToSymbolRegistry[string] = symbol;
SymbolToStringRegistry[symbol] = string;
return symbol;
},
// `Symbol.keyFor` method
// https://tc39.github.io/ecma262/#sec-symbol.keyfor
keyFor: function keyFor(sym) {
if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol');
if (has(SymbolToStringRegistry, sym)) return SymbolToStringRegistry[sym];
},
useSetter: function () { USE_SETTER = true; },
useSimple: function () { USE_SETTER = false; }
});
$({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL, sham: !DESCRIPTORS }, {
// `Object.create` method
// https://tc39.github.io/ecma262/#sec-object.create
create: $create,
// `Object.defineProperty` method
// https://tc39.github.io/ecma262/#sec-object.defineproperty
defineProperty: $defineProperty,
// `Object.defineProperties` method
// https://tc39.github.io/ecma262/#sec-object.defineproperties
defineProperties: $defineProperties,
// `Object.getOwnPropertyDescriptor` method
// https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptors
getOwnPropertyDescriptor: $getOwnPropertyDescriptor
});
$({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL }, {
// `Object.getOwnPropertyNames` method
// https://tc39.github.io/ecma262/#sec-object.getownpropertynames
getOwnPropertyNames: $getOwnPropertyNames,
// `Object.getOwnPropertySymbols` method
// https://tc39.github.io/ecma262/#sec-object.getownpropertysymbols
getOwnPropertySymbols: $getOwnPropertySymbols
});
// Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives
// https://bugs.chromium.org/p/v8/issues/detail?id=3443
$({ target: 'Object', stat: true, forced: fails(function () { getOwnPropertySymbolsModule.f(1); }) }, {
getOwnPropertySymbols: function getOwnPropertySymbols(it) {
return getOwnPropertySymbolsModule.f(toObject(it));
}
});
// `JSON.stringify` method behavior with symbols
// https://tc39.github.io/ecma262/#sec-json.stringify
if ($stringify) {
var FORCED_JSON_STRINGIFY = !NATIVE_SYMBOL || fails(function () {
var symbol = $Symbol();
// MS Edge converts symbol values to JSON as {}
return $stringify([symbol]) != '[null]'
// WebKit converts symbol values to JSON as null
|| $stringify({ a: symbol }) != '{}'
// V8 throws on boxed symbols
|| $stringify(Object(symbol)) != '{}';
});
$({ target: 'JSON', stat: true, forced: FORCED_JSON_STRINGIFY }, {
// eslint-disable-next-line no-unused-vars
stringify: function stringify(it, replacer, space) {
var args = [it];
var index = 1;
var $replacer;
while (arguments.length > index) args.push(arguments[index++]);
$replacer = replacer;
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(null, args);
}
});
}
// `Symbol.prototype[@@toPrimitive]` method
// https://tc39.github.io/ecma262/#sec-symbol.prototype-@@toprimitive
if (!$Symbol[PROTOTYPE][TO_PRIMITIVE]) {
createNonEnumerableProperty($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);
}
// `Symbol.prototype[@@toStringTag]` property
// https://tc39.github.io/ecma262/#sec-symbol.prototype-@@tostringtag
setToStringTag($Symbol, SYMBOL);
hiddenKeys[HIDDEN] = true;
core-js-3.6.1/packages/core-js/modules/es.symbol.match-all.js 0000664 0000000 0000000 00000000231 13600575677 0024001 0 ustar 00root root 0000000 0000000 var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
// `Symbol.matchAll` well-known symbol
defineWellKnownSymbol('matchAll');
core-js-3.6.1/packages/core-js/modules/es.symbol.match.js 0000664 0000000 0000000 00000000307 13600575677 0023237 0 ustar 00root root 0000000 0000000 var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
// `Symbol.match` well-known symbol
// https://tc39.github.io/ecma262/#sec-symbol.match
defineWellKnownSymbol('match');
core-js-3.6.1/packages/core-js/modules/es.symbol.replace.js 0000664 0000000 0000000 00000000315 13600575677 0023555 0 ustar 00root root 0000000 0000000 var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
// `Symbol.replace` well-known symbol
// https://tc39.github.io/ecma262/#sec-symbol.replace
defineWellKnownSymbol('replace');
core-js-3.6.1/packages/core-js/modules/es.symbol.search.js 0000664 0000000 0000000 00000000312 13600575677 0023404 0 ustar 00root root 0000000 0000000 var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
// `Symbol.search` well-known symbol
// https://tc39.github.io/ecma262/#sec-symbol.search
defineWellKnownSymbol('search');
core-js-3.6.1/packages/core-js/modules/es.symbol.species.js 0000664 0000000 0000000 00000000315 13600575677 0023575 0 ustar 00root root 0000000 0000000 var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
// `Symbol.species` well-known symbol
// https://tc39.github.io/ecma262/#sec-symbol.species
defineWellKnownSymbol('species');
core-js-3.6.1/packages/core-js/modules/es.symbol.split.js 0000664 0000000 0000000 00000000307 13600575677 0023276 0 ustar 00root root 0000000 0000000 var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
// `Symbol.split` well-known symbol
// https://tc39.github.io/ecma262/#sec-symbol.split
defineWellKnownSymbol('split');
core-js-3.6.1/packages/core-js/modules/es.symbol.to-primitive.js 0000664 0000000 0000000 00000000331 13600575677 0024570 0 ustar 00root root 0000000 0000000 var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
// `Symbol.toPrimitive` well-known symbol
// https://tc39.github.io/ecma262/#sec-symbol.toprimitive
defineWellKnownSymbol('toPrimitive');
core-js-3.6.1/packages/core-js/modules/es.symbol.to-string-tag.js 0000664 0000000 0000000 00000000331 13600575677 0024637 0 ustar 00root root 0000000 0000000 var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
// `Symbol.toStringTag` well-known symbol
// https://tc39.github.io/ecma262/#sec-symbol.tostringtag
defineWellKnownSymbol('toStringTag');
core-js-3.6.1/packages/core-js/modules/es.symbol.unscopables.js 0000664 0000000 0000000 00000000331 13600575677 0024456 0 ustar 00root root 0000000 0000000 var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
// `Symbol.unscopables` well-known symbol
// https://tc39.github.io/ecma262/#sec-symbol.unscopables
defineWellKnownSymbol('unscopables');
core-js-3.6.1/packages/core-js/modules/es.typed-array.copy-within.js 0000664 0000000 0000000 00000001122 13600575677 0025345 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var $copyWithin = require('../internals/array-copy-within');
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.copyWithin` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.copywithin
exportTypedArrayMethod('copyWithin', function copyWithin(target, start /* , end */) {
return $copyWithin.call(aTypedArray(this), target, start, arguments.length > 2 ? arguments[2] : undefined);
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.every.js 0000664 0000000 0000000 00000001061 13600575677 0024227 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var $every = require('../internals/array-iteration').every;
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.every` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.every
exportTypedArrayMethod('every', function every(callbackfn /* , thisArg */) {
return $every(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.fill.js 0000664 0000000 0000000 00000001035 13600575677 0024024 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var $fill = require('../internals/array-fill');
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.fill` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.fill
// eslint-disable-next-line no-unused-vars
exportTypedArrayMethod('fill', function fill(value /* , start, end */) {
return $fill.apply(aTypedArray(this), arguments);
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.filter.js 0000664 0000000 0000000 00000001657 13600575677 0024375 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var $filter = require('../internals/array-iteration').filter;
var speciesConstructor = require('../internals/species-constructor');
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.filter` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.filter
exportTypedArrayMethod('filter', function filter(callbackfn /* , thisArg */) {
var list = $filter(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
var C = speciesConstructor(this, this.constructor);
var index = 0;
var length = list.length;
var result = new (aTypedArrayConstructor(C))(length);
while (length > index) result[index] = list[index++];
return result;
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.find-index.js 0000664 0000000 0000000 00000001113 13600575677 0025120 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var $findIndex = require('../internals/array-iteration').findIndex;
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.findIndex` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.findindex
exportTypedArrayMethod('findIndex', function findIndex(predicate /* , thisArg */) {
return $findIndex(aTypedArray(this), predicate, arguments.length > 1 ? arguments[1] : undefined);
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.find.js 0000664 0000000 0000000 00000001050 13600575677 0024013 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var $find = require('../internals/array-iteration').find;
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.find` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.find
exportTypedArrayMethod('find', function find(predicate /* , thisArg */) {
return $find(aTypedArray(this), predicate, arguments.length > 1 ? arguments[1] : undefined);
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.float32-array.js 0000664 0000000 0000000 00000000532 13600575677 0025465 0 ustar 00root root 0000000 0000000 var createTypedArrayConstructor = require('../internals/typed-array-constructor');
// `Float32Array` constructor
// https://tc39.github.io/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Float32', function (init) {
return function Float32Array(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.float64-array.js 0000664 0000000 0000000 00000000532 13600575677 0025472 0 ustar 00root root 0000000 0000000 var createTypedArrayConstructor = require('../internals/typed-array-constructor');
// `Float64Array` constructor
// https://tc39.github.io/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Float64', function (init) {
return function Float64Array(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.for-each.js 0000664 0000000 0000000 00000001070 13600575677 0024561 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var $forEach = require('../internals/array-iteration').forEach;
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.forEach` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.foreach
exportTypedArrayMethod('forEach', function forEach(callbackfn /* , thisArg */) {
$forEach(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.from.js 0000664 0000000 0000000 00000000757 13600575677 0024053 0 ustar 00root root 0000000 0000000 'use strict';
var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = require('../internals/typed-arrays-constructors-requires-wrappers');
var exportTypedArrayStaticMethod = require('../internals/array-buffer-view-core').exportTypedArrayStaticMethod;
var typedArrayFrom = require('../internals/typed-array-from');
// `%TypedArray%.from` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.from
exportTypedArrayStaticMethod('from', typedArrayFrom, TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS);
core-js-3.6.1/packages/core-js/modules/es.typed-array.includes.js 0000664 0000000 0000000 00000001115 13600575677 0024703 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var $includes = require('../internals/array-includes').includes;
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.includes` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.includes
exportTypedArrayMethod('includes', function includes(searchElement /* , fromIndex */) {
return $includes(aTypedArray(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.index-of.js 0000664 0000000 0000000 00000001106 13600575677 0024606 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var $indexOf = require('../internals/array-includes').indexOf;
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.indexOf` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.indexof
exportTypedArrayMethod('indexOf', function indexOf(searchElement /* , fromIndex */) {
return $indexOf(aTypedArray(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.int16-array.js 0000664 0000000 0000000 00000000524 13600575677 0025155 0 ustar 00root root 0000000 0000000 var createTypedArrayConstructor = require('../internals/typed-array-constructor');
// `Int16Array` constructor
// https://tc39.github.io/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Int16', function (init) {
return function Int16Array(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.int32-array.js 0000664 0000000 0000000 00000000524 13600575677 0025153 0 ustar 00root root 0000000 0000000 var createTypedArrayConstructor = require('../internals/typed-array-constructor');
// `Int32Array` constructor
// https://tc39.github.io/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Int32', function (init) {
return function Int32Array(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.int8-array.js 0000664 0000000 0000000 00000000521 13600575677 0025073 0 ustar 00root root 0000000 0000000 var createTypedArrayConstructor = require('../internals/typed-array-constructor');
// `Int8Array` constructor
// https://tc39.github.io/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Int8', function (init) {
return function Int8Array(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.iterator.js 0000664 0000000 0000000 00000003247 13600575677 0024736 0 ustar 00root root 0000000 0000000 'use strict';
var global = require('../internals/global');
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var ArrayIterators = require('../modules/es.array.iterator');
var wellKnownSymbol = require('../internals/well-known-symbol');
var ITERATOR = wellKnownSymbol('iterator');
var Uint8Array = global.Uint8Array;
var arrayValues = ArrayIterators.values;
var arrayKeys = ArrayIterators.keys;
var arrayEntries = ArrayIterators.entries;
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
var nativeTypedArrayIterator = Uint8Array && Uint8Array.prototype[ITERATOR];
var CORRECT_ITER_NAME = !!nativeTypedArrayIterator
&& (nativeTypedArrayIterator.name == 'values' || nativeTypedArrayIterator.name == undefined);
var typedArrayValues = function values() {
return arrayValues.call(aTypedArray(this));
};
// `%TypedArray%.prototype.entries` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.entries
exportTypedArrayMethod('entries', function entries() {
return arrayEntries.call(aTypedArray(this));
});
// `%TypedArray%.prototype.keys` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.keys
exportTypedArrayMethod('keys', function keys() {
return arrayKeys.call(aTypedArray(this));
});
// `%TypedArray%.prototype.values` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.values
exportTypedArrayMethod('values', typedArrayValues, !CORRECT_ITER_NAME);
// `%TypedArray%.prototype[@@iterator]` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype-@@iterator
exportTypedArrayMethod(ITERATOR, typedArrayValues, !CORRECT_ITER_NAME);
core-js-3.6.1/packages/core-js/modules/es.typed-array.join.js 0000664 0000000 0000000 00000000763 13600575677 0024044 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
var $join = [].join;
// `%TypedArray%.prototype.join` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.join
// eslint-disable-next-line no-unused-vars
exportTypedArrayMethod('join', function join(separator) {
return $join.apply(aTypedArray(this), arguments);
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.last-index-of.js 0000664 0000000 0000000 00000001127 13600575677 0025552 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var $lastIndexOf = require('../internals/array-last-index-of');
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.lastIndexOf` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.lastindexof
// eslint-disable-next-line no-unused-vars
exportTypedArrayMethod('lastIndexOf', function lastIndexOf(searchElement /* , fromIndex */) {
return $lastIndexOf.apply(aTypedArray(this), arguments);
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.map.js 0000664 0000000 0000000 00000001433 13600575677 0023655 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var $map = require('../internals/array-iteration').map;
var speciesConstructor = require('../internals/species-constructor');
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.map` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.map
exportTypedArrayMethod('map', function map(mapfn /* , thisArg */) {
return $map(aTypedArray(this), mapfn, arguments.length > 1 ? arguments[1] : undefined, function (O, length) {
return new (aTypedArrayConstructor(speciesConstructor(O, O.constructor)))(length);
});
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.of.js 0000664 0000000 0000000 00000001357 13600575677 0023511 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = require('../internals/typed-arrays-constructors-requires-wrappers');
var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor;
var exportTypedArrayStaticMethod = ArrayBufferViewCore.exportTypedArrayStaticMethod;
// `%TypedArray%.of` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.of
exportTypedArrayStaticMethod('of', function of(/* ...items */) {
var index = 0;
var length = arguments.length;
var result = new (aTypedArrayConstructor(this))(length);
while (length > index) result[index] = arguments[index++];
return result;
}, TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS);
core-js-3.6.1/packages/core-js/modules/es.typed-array.reduce-right.js 0000664 0000000 0000000 00000001151 13600575677 0025457 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var $reduceRight = require('../internals/array-reduce').right;
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.reduceRicht` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.reduceright
exportTypedArrayMethod('reduceRight', function reduceRight(callbackfn /* , initialValue */) {
return $reduceRight(aTypedArray(this), callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined);
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.reduce.js 0000664 0000000 0000000 00000001112 13600575677 0024341 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var $reduce = require('../internals/array-reduce').left;
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.reduce` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.reduce
exportTypedArrayMethod('reduce', function reduce(callbackfn /* , initialValue */) {
return $reduce(aTypedArray(this), callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined);
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.reverse.js 0000664 0000000 0000000 00000001231 13600575677 0024547 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
var floor = Math.floor;
// `%TypedArray%.prototype.reverse` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.reverse
exportTypedArrayMethod('reverse', function reverse() {
var that = this;
var length = aTypedArray(that).length;
var middle = floor(length / 2);
var index = 0;
var value;
while (index < middle) {
value = that[index];
that[index++] = that[--length];
that[length] = value;
} return that;
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.set.js 0000664 0000000 0000000 00000002010 13600575677 0023663 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var toLength = require('../internals/to-length');
var toOffset = require('../internals/to-offset');
var toObject = require('../internals/to-object');
var fails = require('../internals/fails');
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
var FORCED = fails(function () {
// eslint-disable-next-line no-undef
new Int8Array(1).set({});
});
// `%TypedArray%.prototype.set` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.set
exportTypedArrayMethod('set', function set(arrayLike /* , offset */) {
aTypedArray(this);
var offset = toOffset(arguments.length > 1 ? arguments[1] : undefined, 1);
var length = this.length;
var src = toObject(arrayLike);
var len = toLength(src.length);
var index = 0;
if (len + offset > length) throw RangeError('Wrong length');
while (index < len) this[offset + index] = src[index++];
}, FORCED);
core-js-3.6.1/packages/core-js/modules/es.typed-array.slice.js 0000664 0000000 0000000 00000001743 13600575677 0024203 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var speciesConstructor = require('../internals/species-constructor');
var fails = require('../internals/fails');
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
var $slice = [].slice;
var FORCED = fails(function () {
// eslint-disable-next-line no-undef
new Int8Array(1).slice();
});
// `%TypedArray%.prototype.slice` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.slice
exportTypedArrayMethod('slice', function slice(start, end) {
var list = $slice.call(aTypedArray(this), start, end);
var C = speciesConstructor(this, this.constructor);
var index = 0;
var length = list.length;
var result = new (aTypedArrayConstructor(C))(length);
while (length > index) result[index] = list[index++];
return result;
}, FORCED);
core-js-3.6.1/packages/core-js/modules/es.typed-array.some.js 0000664 0000000 0000000 00000001052 13600575677 0024040 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var $some = require('../internals/array-iteration').some;
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.some` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.some
exportTypedArrayMethod('some', function some(callbackfn /* , thisArg */) {
return $some(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.sort.js 0000664 0000000 0000000 00000000707 13600575677 0024072 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
var $sort = [].sort;
// `%TypedArray%.prototype.sort` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.sort
exportTypedArrayMethod('sort', function sort(comparefn) {
return $sort.call(aTypedArray(this), comparefn);
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.subarray.js 0000664 0000000 0000000 00000001606 13600575677 0024732 0 ustar 00root root 0000000 0000000 'use strict';
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var toLength = require('../internals/to-length');
var toAbsoluteIndex = require('../internals/to-absolute-index');
var speciesConstructor = require('../internals/species-constructor');
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.subarray` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.subarray
exportTypedArrayMethod('subarray', function subarray(begin, end) {
var O = aTypedArray(this);
var length = O.length;
var beginIndex = toAbsoluteIndex(begin, length);
return new (speciesConstructor(O, O.constructor))(
O.buffer,
O.byteOffset + beginIndex * O.BYTES_PER_ELEMENT,
toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - beginIndex)
);
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.to-locale-string.js 0000664 0000000 0000000 00000002040 13600575677 0026256 0 ustar 00root root 0000000 0000000 'use strict';
var global = require('../internals/global');
var ArrayBufferViewCore = require('../internals/array-buffer-view-core');
var fails = require('../internals/fails');
var Int8Array = global.Int8Array;
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
var $toLocaleString = [].toLocaleString;
var $slice = [].slice;
// iOS Safari 6.x fails here
var TO_LOCALE_STRING_BUG = !!Int8Array && fails(function () {
$toLocaleString.call(new Int8Array(1));
});
var FORCED = fails(function () {
return [1, 2].toLocaleString() != new Int8Array([1, 2]).toLocaleString();
}) || !fails(function () {
Int8Array.prototype.toLocaleString.call([1, 2]);
});
// `%TypedArray%.prototype.toLocaleString` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.tolocalestring
exportTypedArrayMethod('toLocaleString', function toLocaleString() {
return $toLocaleString.apply(TO_LOCALE_STRING_BUG ? $slice.call(aTypedArray(this)) : aTypedArray(this), arguments);
}, FORCED);
core-js-3.6.1/packages/core-js/modules/es.typed-array.to-string.js 0000664 0000000 0000000 00000001372 13600575677 0025030 0 ustar 00root root 0000000 0000000 'use strict';
var exportTypedArrayMethod = require('../internals/array-buffer-view-core').exportTypedArrayMethod;
var fails = require('../internals/fails');
var global = require('../internals/global');
var Uint8Array = global.Uint8Array;
var Uint8ArrayPrototype = Uint8Array && Uint8Array.prototype || {};
var arrayToString = [].toString;
var arrayJoin = [].join;
if (fails(function () { arrayToString.call({}); })) {
arrayToString = function toString() {
return arrayJoin.call(this);
};
}
var IS_NOT_ARRAY_METHOD = Uint8ArrayPrototype.toString != arrayToString;
// `%TypedArray%.prototype.toString` method
// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.tostring
exportTypedArrayMethod('toString', arrayToString, IS_NOT_ARRAY_METHOD);
core-js-3.6.1/packages/core-js/modules/es.typed-array.uint16-array.js 0000664 0000000 0000000 00000000527 13600575677 0025345 0 ustar 00root root 0000000 0000000 var createTypedArrayConstructor = require('../internals/typed-array-constructor');
// `Uint16Array` constructor
// https://tc39.github.io/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Uint16', function (init) {
return function Uint16Array(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.uint32-array.js 0000664 0000000 0000000 00000000527 13600575677 0025343 0 ustar 00root root 0000000 0000000 var createTypedArrayConstructor = require('../internals/typed-array-constructor');
// `Uint32Array` constructor
// https://tc39.github.io/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Uint32', function (init) {
return function Uint32Array(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.uint8-array.js 0000664 0000000 0000000 00000000524 13600575677 0025263 0 ustar 00root root 0000000 0000000 var createTypedArrayConstructor = require('../internals/typed-array-constructor');
// `Uint8Array` constructor
// https://tc39.github.io/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Uint8', function (init) {
return function Uint8Array(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
});
core-js-3.6.1/packages/core-js/modules/es.typed-array.uint8-clamped-array.js 0000664 0000000 0000000 00000000550 13600575677 0026665 0 ustar 00root root 0000000 0000000 var createTypedArrayConstructor = require('../internals/typed-array-constructor');
// `Uint8ClampedArray` constructor
// https://tc39.github.io/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Uint8', function (init) {
return function Uint8ClampedArray(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
}, true);
core-js-3.6.1/packages/core-js/modules/es.weak-map.js 0000664 0000000 0000000 00000005374 13600575677 0022352 0 ustar 00root root 0000000 0000000 'use strict';
var global = require('../internals/global');
var redefineAll = require('../internals/redefine-all');
var InternalMetadataModule = require('../internals/internal-metadata');
var collection = require('../internals/collection');
var collectionWeak = require('../internals/collection-weak');
var isObject = require('../internals/is-object');
var enforceIternalState = require('../internals/internal-state').enforce;
var NATIVE_WEAK_MAP = require('../internals/native-weak-map');
var IS_IE11 = !global.ActiveXObject && 'ActiveXObject' in global;
var isExtensible = Object.isExtensible;
var InternalWeakMap;
var wrapper = function (init) {
return function WeakMap() {
return init(this, arguments.length ? arguments[0] : undefined);
};
};
// `WeakMap` constructor
// https://tc39.github.io/ecma262/#sec-weakmap-constructor
var $WeakMap = module.exports = collection('WeakMap', wrapper, collectionWeak);
// IE11 WeakMap frozen keys fix
// We can't use feature detection because it crash some old IE builds
// https://github.com/zloirock/core-js/issues/485
if (NATIVE_WEAK_MAP && IS_IE11) {
InternalWeakMap = collectionWeak.getConstructor(wrapper, 'WeakMap', true);
InternalMetadataModule.REQUIRED = true;
var WeakMapPrototype = $WeakMap.prototype;
var nativeDelete = WeakMapPrototype['delete'];
var nativeHas = WeakMapPrototype.has;
var nativeGet = WeakMapPrototype.get;
var nativeSet = WeakMapPrototype.set;
redefineAll(WeakMapPrototype, {
'delete': function (key) {
if (isObject(key) && !isExtensible(key)) {
var state = enforceIternalState(this);
if (!state.frozen) state.frozen = new InternalWeakMap();
return nativeDelete.call(this, key) || state.frozen['delete'](key);
} return nativeDelete.call(this, key);
},
has: function has(key) {
if (isObject(key) && !isExtensible(key)) {
var state = enforceIternalState(this);
if (!state.frozen) state.frozen = new InternalWeakMap();
return nativeHas.call(this, key) || state.frozen.has(key);
} return nativeHas.call(this, key);
},
get: function get(key) {
if (isObject(key) && !isExtensible(key)) {
var state = enforceIternalState(this);
if (!state.frozen) state.frozen = new InternalWeakMap();
return nativeHas.call(this, key) ? nativeGet.call(this, key) : state.frozen.get(key);
} return nativeGet.call(this, key);
},
set: function set(key, value) {
if (isObject(key) && !isExtensible(key)) {
var state = enforceIternalState(this);
if (!state.frozen) state.frozen = new InternalWeakMap();
nativeHas.call(this, key) ? nativeSet.call(this, key, value) : state.frozen.set(key, value);
} else nativeSet.call(this, key, value);
return this;
}
});
}
core-js-3.6.1/packages/core-js/modules/es.weak-set.js 0000664 0000000 0000000 00000000563 13600575677 0022363 0 ustar 00root root 0000000 0000000 'use strict';
var collection = require('../internals/collection');
var collectionWeak = require('../internals/collection-weak');
// `WeakSet` constructor
// https://tc39.github.io/ecma262/#sec-weakset-constructor
collection('WeakSet', function (init) {
return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); };
}, collectionWeak);
core-js-3.6.1/packages/core-js/modules/esnext.aggregate-error.js 0000664 0000000 0000000 00000003446 13600575677 0024622 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var DESCRIPTORS = require('../internals/descriptors');
var getPrototypeOf = require('../internals/object-get-prototype-of');
var setPrototypeOf = require('../internals/object-set-prototype-of');
var create = require('../internals/object-create');
var defineProperty = require('../internals/object-define-property');
var createPropertyDescriptor = require('../internals/create-property-descriptor');
var iterate = require('../internals/iterate');
var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
var InternalStateModule = require('../internals/internal-state');
var setInternalState = InternalStateModule.set;
var getInternalAggregateErrorState = InternalStateModule.getterFor('AggregateError');
var $AggregateError = function AggregateError(errors, message) {
var that = this;
if (!(that instanceof $AggregateError)) return new $AggregateError(errors, message);
if (setPrototypeOf) {
that = setPrototypeOf(new Error(message), getPrototypeOf(that));
}
var errorsArray = [];
iterate(errors, errorsArray.push, errorsArray);
if (DESCRIPTORS) setInternalState(that, { errors: errorsArray, type: 'AggregateError' });
else that.errors = errorsArray;
if (message !== undefined) createNonEnumerableProperty(that, 'message', String(message));
return that;
};
$AggregateError.prototype = create(Error.prototype, {
constructor: createPropertyDescriptor(5, $AggregateError),
message: createPropertyDescriptor(5, ''),
name: createPropertyDescriptor(5, 'AggregateError')
});
if (DESCRIPTORS) defineProperty.f($AggregateError.prototype, 'errors', {
get: function () {
return getInternalAggregateErrorState(this).errors;
},
configurable: true
});
$({ global: true }, {
AggregateError: $AggregateError
});
core-js-3.6.1/packages/core-js/modules/esnext.array.is-template-object.js 0000664 0000000 0000000 00000001610 13600575677 0026341 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var isArray = require('../internals/is-array');
var isFrozen = Object.isFrozen;
var isFrozenStringArray = function (array, allowUndefined) {
if (!isFrozen || !isArray(array) || !isFrozen(array)) return false;
var index = 0;
var length = array.length;
var element;
while (index < length) {
element = array[index++];
if (!(typeof element === 'string' || (allowUndefined && typeof element === 'undefined'))) {
return false;
}
} return length !== 0;
};
// `Array.isTemplateObject` method
// https://github.com/tc39/proposal-array-is-template-object
$({ target: 'Array', stat: true }, {
isTemplateObject: function isTemplateObject(value) {
if (!isFrozenStringArray(value, true)) return false;
var raw = value.raw;
if (raw.length !== value.length || !isFrozenStringArray(raw, false)) return false;
return true;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.array.last-index.js 0000664 0000000 0000000 00000001271 13600575677 0024724 0 ustar 00root root 0000000 0000000 'use strict';
var DESCRIPTORS = require('../internals/descriptors');
var addToUnscopables = require('../internals/add-to-unscopables');
var toObject = require('../internals/to-object');
var toLength = require('../internals/to-length');
var defineProperty = require('../internals/object-define-property').f;
// `Array.prototype.lastIndex` getter
// https://github.com/keithamus/proposal-array-last
if (DESCRIPTORS && !('lastIndex' in [])) {
defineProperty(Array.prototype, 'lastIndex', {
configurable: true,
get: function lastIndex() {
var O = toObject(this);
var len = toLength(O.length);
return len == 0 ? 0 : len - 1;
}
});
addToUnscopables('lastIndex');
}
core-js-3.6.1/packages/core-js/modules/esnext.array.last-item.js 0000664 0000000 0000000 00000001537 13600575677 0024560 0 ustar 00root root 0000000 0000000 'use strict';
var DESCRIPTORS = require('../internals/descriptors');
var addToUnscopables = require('../internals/add-to-unscopables');
var toObject = require('../internals/to-object');
var toLength = require('../internals/to-length');
var defineProperty = require('../internals/object-define-property').f;
// `Array.prototype.lastIndex` accessor
// https://github.com/keithamus/proposal-array-last
if (DESCRIPTORS && !('lastItem' in [])) {
defineProperty(Array.prototype, 'lastItem', {
configurable: true,
get: function lastItem() {
var O = toObject(this);
var len = toLength(O.length);
return len == 0 ? undefined : O[len - 1];
},
set: function lastItem(value) {
var O = toObject(this);
var len = toLength(O.length);
return O[len == 0 ? 0 : len - 1] = value;
}
});
addToUnscopables('lastItem');
}
core-js-3.6.1/packages/core-js/modules/esnext.async-iterator.as-indexed-pairs.js 0000664 0000000 0000000 00000001521 13600575677 0027635 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var anObject = require('../internals/an-object');
var createAsyncIteratorProxy = require('../internals/create-async-iterator-proxy');
var AsyncIteratorProxy = createAsyncIteratorProxy(function (arg, Promise) {
var state = this;
var iterator = state.iterator;
return Promise.resolve(anObject(state.next.call(iterator, arg))).then(function (step) {
if (anObject(step).done) {
state.done = true;
return { done: true, value: undefined };
}
return { done: false, value: [state.index++, step.value] };
});
});
$({ target: 'AsyncIterator', proto: true, real: true }, {
asIndexedPairs: function asIndexedPairs() {
return new AsyncIteratorProxy({
iterator: anObject(this),
index: 0
});
}
});
core-js-3.6.1/packages/core-js/modules/esnext.async-iterator.constructor.js 0000664 0000000 0000000 00000002152 13600575677 0027066 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var anInstance = require('../internals/an-instance');
var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
var has = require('../internals/has');
var wellKnownSymbol = require('../internals/well-known-symbol');
var AsyncIteratorPrototype = require('../internals/async-iterator-prototype');
var IS_PURE = require('../internals/is-pure');
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
var AsyncIteratorConstructor = function AsyncIterator() {
anInstance(this, AsyncIteratorConstructor);
};
AsyncIteratorConstructor.prototype = AsyncIteratorPrototype;
if (!has(AsyncIteratorPrototype, TO_STRING_TAG)) {
createNonEnumerableProperty(AsyncIteratorPrototype, TO_STRING_TAG, 'AsyncIterator');
}
if (!has(AsyncIteratorPrototype, 'constructor') || AsyncIteratorPrototype.constructor === Object) {
createNonEnumerableProperty(AsyncIteratorPrototype, 'constructor', AsyncIteratorConstructor);
}
$({ global: true, forced: IS_PURE }, {
AsyncIterator: AsyncIteratorConstructor
});
core-js-3.6.1/packages/core-js/modules/esnext.async-iterator.drop.js 0000664 0000000 0000000 00000002422 13600575677 0025445 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var anObject = require('../internals/an-object');
var toPositiveInteger = require('../internals/to-positive-integer');
var createAsyncIteratorProxy = require('../internals/create-async-iterator-proxy');
var AsyncIteratorProxy = createAsyncIteratorProxy(function (arg, Promise) {
var state = this;
return new Promise(function (resolve, reject) {
var loop = function () {
try {
Promise.resolve(
anObject(state.next.call(state.iterator, state.remaining ? undefined : arg))
).then(function (step) {
try {
if (anObject(step).done) {
state.done = true;
resolve({ done: true, value: undefined });
} else if (state.remaining) {
state.remaining--;
loop();
} else resolve({ done: false, value: step.value });
} catch (err) { reject(err); }
}, reject);
} catch (error) { reject(error); }
};
loop();
});
});
$({ target: 'AsyncIterator', proto: true, real: true }, {
drop: function drop(limit) {
return new AsyncIteratorProxy({
iterator: anObject(this),
remaining: toPositiveInteger(limit)
});
}
});
core-js-3.6.1/packages/core-js/modules/esnext.async-iterator.every.js 0000664 0000000 0000000 00000000456 13600575677 0025640 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var $every = require('../internals/async-iterator-iteration').every;
$({ target: 'AsyncIterator', proto: true, real: true }, {
every: function every(fn) {
return $every(this, fn);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.async-iterator.filter.js 0000664 0000000 0000000 00000002511 13600575677 0025765 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var aFunction = require('../internals/a-function');
var anObject = require('../internals/an-object');
var createAsyncIteratorProxy = require('../internals/create-async-iterator-proxy');
var AsyncIteratorProxy = createAsyncIteratorProxy(function (arg, Promise) {
var state = this;
var filterer = state.filterer;
return new Promise(function (resolve, reject) {
var loop = function () {
try {
Promise.resolve(anObject(state.next.call(state.iterator, arg))).then(function (step) {
try {
if (anObject(step).done) {
state.done = true;
resolve({ done: true, value: undefined });
} else {
var value = step.value;
Promise.resolve(filterer(value)).then(function (selected) {
selected ? resolve({ done: false, value: value }) : loop();
}, reject);
}
} catch (err) { reject(err); }
}, reject);
} catch (error) { reject(error); }
};
loop();
});
});
$({ target: 'AsyncIterator', proto: true, real: true }, {
filter: function filter(filterer) {
return new AsyncIteratorProxy({
iterator: anObject(this),
filterer: aFunction(filterer)
});
}
});
core-js-3.6.1/packages/core-js/modules/esnext.async-iterator.find.js 0000664 0000000 0000000 00000000451 13600575677 0025421 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var $find = require('../internals/async-iterator-iteration').find;
$({ target: 'AsyncIterator', proto: true, real: true }, {
find: function find(fn) {
return $find(this, fn);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.async-iterator.flat-map.js 0000664 0000000 0000000 00000004651 13600575677 0026210 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var aFunction = require('../internals/a-function');
var anObject = require('../internals/an-object');
var createAsyncIteratorProxy = require('../internals/create-async-iterator-proxy');
var getAsyncIteratorMethod = require('../internals/get-async-iterator-method');
var AsyncIteratorProxy = createAsyncIteratorProxy(function (arg, Promise) {
var state = this;
var mapper = state.mapper;
var innerIterator, iteratorMethod;
return new Promise(function (resolve, reject) {
var outerLoop = function () {
try {
Promise.resolve(anObject(state.next.call(state.iterator, arg))).then(function (step) {
try {
if (anObject(step).done) {
state.done = true;
resolve({ done: true, value: undefined });
} else {
Promise.resolve(mapper(step.value)).then(function (mapped) {
try {
iteratorMethod = getAsyncIteratorMethod(mapped);
if (iteratorMethod !== undefined) {
state.innerIterator = innerIterator = anObject(iteratorMethod.call(mapped));
state.innerNext = aFunction(innerIterator.next);
return innerLoop();
} reject(TypeError('.flatMap callback should return an iterable object'));
} catch (error2) { reject(error2); }
}, reject);
}
} catch (error1) { reject(error1); }
}, reject);
} catch (error) { reject(error); }
};
var innerLoop = function () {
if (innerIterator = state.innerIterator) {
try {
Promise.resolve(anObject(state.innerNext.call(innerIterator))).then(function (result) {
try {
if (anObject(result).done) {
state.innerIterator = state.innerNext = null;
outerLoop();
} else resolve({ done: false, value: result.value });
} catch (error1) { reject(error1); }
}, reject);
} catch (error) { reject(error); }
} else outerLoop();
};
innerLoop();
});
});
$({ target: 'AsyncIterator', proto: true, real: true }, {
flatMap: function flatMap(mapper) {
return new AsyncIteratorProxy({
iterator: anObject(this),
mapper: aFunction(mapper),
innerIterator: null,
innerNext: null
});
}
});
core-js-3.6.1/packages/core-js/modules/esnext.async-iterator.for-each.js 0000664 0000000 0000000 00000000470 13600575677 0026166 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var $forEach = require('../internals/async-iterator-iteration').forEach;
$({ target: 'AsyncIterator', proto: true, real: true }, {
forEach: function forEach(fn) {
return $forEach(this, fn);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.async-iterator.from.js 0000664 0000000 0000000 00000002055 13600575677 0025446 0 ustar 00root root 0000000 0000000 // https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var path = require('../internals/path');
var aFunction = require('../internals/a-function');
var anObject = require('../internals/an-object');
var toObject = require('../internals/to-object');
var createAsyncIteratorProxy = require('../internals/create-async-iterator-proxy');
var getAsyncIteratorMethod = require('../internals/get-async-iterator-method');
var AsyncIterator = path.AsyncIterator;
var AsyncIteratorProxy = createAsyncIteratorProxy(function (arg) {
return anObject(this.next.call(this.iterator, arg));
}, true);
$({ target: 'AsyncIterator', stat: true }, {
from: function from(O) {
var object = toObject(O);
var usingIterator = getAsyncIteratorMethod(object);
var iterator;
if (usingIterator != null) {
iterator = aFunction(usingIterator).call(object);
if (iterator instanceof AsyncIterator) return iterator;
} else {
iterator = object;
} return new AsyncIteratorProxy({
iterator: iterator
});
}
});
core-js-3.6.1/packages/core-js/modules/esnext.async-iterator.map.js 0000664 0000000 0000000 00000001703 13600575677 0025257 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var aFunction = require('../internals/a-function');
var anObject = require('../internals/an-object');
var createAsyncIteratorProxy = require('../internals/create-async-iterator-proxy');
var AsyncIteratorProxy = createAsyncIteratorProxy(function (arg, Promise) {
var state = this;
var mapper = state.mapper;
return Promise.resolve(anObject(state.next.call(state.iterator, arg))).then(function (step) {
if (anObject(step).done) {
state.done = true;
return { done: true, value: undefined };
}
return Promise.resolve(mapper(step.value)).then(function (value) {
return { done: false, value: value };
});
});
});
$({ target: 'AsyncIterator', proto: true, real: true }, {
map: function map(mapper) {
return new AsyncIteratorProxy({
iterator: anObject(this),
mapper: aFunction(mapper)
});
}
});
core-js-3.6.1/packages/core-js/modules/esnext.async-iterator.reduce.js 0000664 0000000 0000000 00000003043 13600575677 0025750 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var aFunction = require('../internals/a-function');
var anObject = require('../internals/an-object');
var getBuiltIn = require('../internals/get-built-in');
var Promise = getBuiltIn('Promise');
$({ target: 'AsyncIterator', proto: true, real: true }, {
reduce: function reduce(reducer /* , initialValue */) {
var iterator = anObject(this);
var next = aFunction(iterator.next);
var noInitial = arguments.length < 2;
var accumulator = noInitial ? undefined : arguments[1];
aFunction(reducer);
return new Promise(function (resolve, reject) {
var loop = function () {
try {
Promise.resolve(anObject(next.call(iterator))).then(function (step) {
try {
if (anObject(step).done) {
noInitial ? reject(TypeError('Reduce of empty iterator with no initial value')) : resolve(accumulator);
} else {
var value = step.value;
if (noInitial) {
noInitial = false;
accumulator = value;
loop();
} else {
Promise.resolve(reducer(accumulator, value)).then(function (result) {
accumulator = result;
loop();
}, reject);
}
}
} catch (err) { reject(err); }
}, reject);
} catch (error) { reject(error); }
};
loop();
});
}
});
core-js-3.6.1/packages/core-js/modules/esnext.async-iterator.some.js 0000664 0000000 0000000 00000000451 13600575677 0025444 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var $some = require('../internals/async-iterator-iteration').some;
$({ target: 'AsyncIterator', proto: true, real: true }, {
some: function some(fn) {
return $some(this, fn);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.async-iterator.take.js 0000664 0000000 0000000 00000001343 13600575677 0025426 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var anObject = require('../internals/an-object');
var toPositiveInteger = require('../internals/to-positive-integer');
var createAsyncIteratorProxy = require('../internals/create-async-iterator-proxy');
var AsyncIteratorProxy = createAsyncIteratorProxy(function (arg) {
if (!this.remaining--) {
this.done = true;
return { done: true, value: undefined };
} return this.next.call(this.iterator, arg);
});
$({ target: 'AsyncIterator', proto: true, real: true }, {
take: function take(limit) {
return new AsyncIteratorProxy({
iterator: anObject(this),
remaining: toPositiveInteger(limit)
});
}
});
core-js-3.6.1/packages/core-js/modules/esnext.async-iterator.to-array.js 0000664 0000000 0000000 00000000462 13600575677 0026241 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var $toArray = require('../internals/async-iterator-iteration').toArray;
$({ target: 'AsyncIterator', proto: true, real: true }, {
toArray: function toArray() {
return $toArray(this);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.composite-key.js 0000664 0000000 0000000 00000001104 13600575677 0024322 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var getCompositeKeyNode = require('../internals/composite-key');
var getBuiltIn = require('../internals/get-built-in');
var create = require('../internals/object-create');
var initializer = function () {
var freeze = getBuiltIn('Object', 'freeze');
return freeze ? freeze(create(null)) : create(null);
};
// https://github.com/tc39/proposal-richer-keys/tree/master/compositeKey
$({ global: true }, {
compositeKey: function compositeKey() {
return getCompositeKeyNode.apply(Object, arguments).get('object', initializer);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.composite-symbol.js 0000664 0000000 0000000 00000001011 13600575677 0025034 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var getCompositeKeyNode = require('../internals/composite-key');
var getBuiltIn = require('../internals/get-built-in');
// https://github.com/tc39/proposal-richer-keys/tree/master/compositeKey
$({ global: true }, {
compositeSymbol: function compositeSymbol() {
if (arguments.length === 1 && typeof arguments[0] === 'string') return getBuiltIn('Symbol')['for'](arguments[0]);
return getCompositeKeyNode.apply(null, arguments).get('symbol', getBuiltIn('Symbol'));
}
});
core-js-3.6.1/packages/core-js/modules/esnext.global-this.js 0000664 0000000 0000000 00000000076 13600575677 0023746 0 ustar 00root root 0000000 0000000 // TODO: Remove from `core-js@4`
require('./es.global-this');
core-js-3.6.1/packages/core-js/modules/esnext.iterator.as-indexed-pairs.js 0000664 0000000 0000000 00000001175 13600575677 0026527 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var anObject = require('../internals/an-object');
var createIteratorProxy = require('../internals/create-iterator-proxy');
var IteratorProxy = createIteratorProxy(function (arg) {
var result = anObject(this.next.call(this.iterator, arg));
var done = this.done = !!result.done;
if (!done) return [this.index++, result.value];
});
$({ target: 'Iterator', proto: true, real: true }, {
asIndexedPairs: function asIndexedPairs() {
return new IteratorProxy({
iterator: anObject(this),
index: 0
});
}
});
core-js-3.6.1/packages/core-js/modules/esnext.iterator.constructor.js 0000664 0000000 0000000 00000003171 13600575677 0025755 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var global = require('../internals/global');
var anInstance = require('../internals/an-instance');
var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
var fails = require('../internals/fails');
var has = require('../internals/has');
var wellKnownSymbol = require('../internals/well-known-symbol');
var IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;
var IS_PURE = require('../internals/is-pure');
var ITERATOR = wellKnownSymbol('iterator');
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
var NativeIterator = global.Iterator;
// FF56- have non-standard global helper `Iterator`
var FORCED = IS_PURE
|| typeof NativeIterator != 'function'
|| NativeIterator.prototype !== IteratorPrototype
// FF44- non-standard `Iterator` passes previous tests
|| !fails(function () { NativeIterator({}); });
var IteratorConstructor = function Iterator() {
anInstance(this, IteratorConstructor);
};
if (IS_PURE) {
IteratorPrototype = {};
createNonEnumerableProperty(IteratorPrototype, ITERATOR, function () {
return this;
});
}
if (!has(IteratorPrototype, TO_STRING_TAG)) {
createNonEnumerableProperty(IteratorPrototype, TO_STRING_TAG, 'Iterator');
}
if (FORCED || !has(IteratorPrototype, 'constructor') || IteratorPrototype.constructor === Object) {
createNonEnumerableProperty(IteratorPrototype, 'constructor', IteratorConstructor);
}
IteratorConstructor.prototype = IteratorPrototype;
$({ global: true, forced: FORCED }, {
Iterator: IteratorConstructor
});
core-js-3.6.1/packages/core-js/modules/esnext.iterator.drop.js 0000664 0000000 0000000 00000001625 13600575677 0024336 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var anObject = require('../internals/an-object');
var toPositiveInteger = require('../internals/to-positive-integer');
var createIteratorProxy = require('../internals/create-iterator-proxy');
var IteratorProxy = createIteratorProxy(function (arg) {
var iterator = this.iterator;
var next = this.next;
var result, done;
while (this.remaining) {
this.remaining--;
result = anObject(next.call(iterator));
done = this.done = !!result.done;
if (done) return;
}
result = anObject(next.call(iterator, arg));
done = this.done = !!result.done;
if (!done) return result.value;
});
$({ target: 'Iterator', proto: true, real: true }, {
drop: function drop(limit) {
return new IteratorProxy({
iterator: anObject(this),
remaining: toPositiveInteger(limit)
});
}
});
core-js-3.6.1/packages/core-js/modules/esnext.iterator.every.js 0000664 0000000 0000000 00000001005 13600575677 0024514 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var iterate = require('../internals/iterate');
var aFunction = require('../internals/a-function');
var anObject = require('../internals/an-object');
$({ target: 'Iterator', proto: true, real: true }, {
every: function every(fn) {
anObject(this);
aFunction(fn);
return !iterate(this, function (value) {
if (!fn(value)) return iterate.stop();
}, undefined, false, true).stopped;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.iterator.filter.js 0000664 0000000 0000000 00000001742 13600575677 0024657 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var aFunction = require('../internals/a-function');
var anObject = require('../internals/an-object');
var createIteratorProxy = require('../internals/create-iterator-proxy');
var callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');
var IteratorProxy = createIteratorProxy(function (arg) {
var iterator = this.iterator;
var filterer = this.filterer;
var next = this.next;
var result, done, value;
while (true) {
result = anObject(next.call(iterator, arg));
done = this.done = !!result.done;
if (done) return;
value = result.value;
if (callWithSafeIterationClosing(iterator, filterer, value)) return value;
}
});
$({ target: 'Iterator', proto: true, real: true }, {
filter: function filter(filterer) {
return new IteratorProxy({
iterator: anObject(this),
filterer: aFunction(filterer)
});
}
});
core-js-3.6.1/packages/core-js/modules/esnext.iterator.find.js 0000664 0000000 0000000 00000001005 13600575677 0024302 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var iterate = require('../internals/iterate');
var aFunction = require('../internals/a-function');
var anObject = require('../internals/an-object');
$({ target: 'Iterator', proto: true, real: true }, {
find: function find(fn) {
anObject(this);
aFunction(fn);
return iterate(this, function (value) {
if (fn(value)) return iterate.stop(value);
}, undefined, false, true).result;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.iterator.flat-map.js 0000664 0000000 0000000 00000003027 13600575677 0025071 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var aFunction = require('../internals/a-function');
var anObject = require('../internals/an-object');
var getIteratorMethod = require('../internals/get-iterator-method');
var createIteratorProxy = require('../internals/create-iterator-proxy');
var callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');
var IteratorProxy = createIteratorProxy(function (arg) {
var iterator = this.iterator;
var result, mapped, iteratorMethod, innerIterator;
while (true) {
if (innerIterator = this.innerIterator) {
result = anObject(this.innerNext.call(innerIterator));
if (!result.done) return result.value;
this.innerIterator = this.innerNext = null;
}
result = anObject(this.next.call(iterator, arg));
if (this.done = !!result.done) return;
mapped = callWithSafeIterationClosing(iterator, this.mapper, result.value);
iteratorMethod = getIteratorMethod(mapped);
if (iteratorMethod === undefined) {
throw TypeError('.flatMap callback should return an iterable object');
}
this.innerIterator = innerIterator = anObject(iteratorMethod.call(mapped));
this.innerNext = aFunction(innerIterator.next);
}
});
$({ target: 'Iterator', proto: true, real: true }, {
flatMap: function flatMap(mapper) {
return new IteratorProxy({
iterator: anObject(this),
mapper: aFunction(mapper),
innerIterator: null,
innerNext: null
});
}
});
core-js-3.6.1/packages/core-js/modules/esnext.iterator.for-each.js 0000664 0000000 0000000 00000000545 13600575677 0025056 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var iterate = require('../internals/iterate');
var anObject = require('../internals/an-object');
$({ target: 'Iterator', proto: true, real: true }, {
forEach: function forEach(fn) {
iterate(anObject(this), fn, undefined, false, true);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.iterator.from.js 0000664 0000000 0000000 00000002077 13600575677 0024337 0 ustar 00root root 0000000 0000000 // https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var path = require('../internals/path');
var aFunction = require('../internals/a-function');
var anObject = require('../internals/an-object');
var toObject = require('../internals/to-object');
var createIteratorProxy = require('../internals/create-iterator-proxy');
var getIteratorMethod = require('../internals/get-iterator-method');
var Iterator = path.Iterator;
var IteratorProxy = createIteratorProxy(function (arg) {
var result = anObject(this.next.call(this.iterator, arg));
var done = this.done = !!result.done;
if (!done) return result.value;
}, true);
$({ target: 'Iterator', stat: true }, {
from: function from(O) {
var object = toObject(O);
var usingIterator = getIteratorMethod(object);
var iterator;
if (usingIterator != null) {
iterator = aFunction(usingIterator).call(object);
if (iterator instanceof Iterator) return iterator;
} else {
iterator = object;
} return new IteratorProxy({
iterator: iterator
});
}
});
core-js-3.6.1/packages/core-js/modules/esnext.iterator.map.js 0000664 0000000 0000000 00000001517 13600575677 0024147 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var aFunction = require('../internals/a-function');
var anObject = require('../internals/an-object');
var createIteratorProxy = require('../internals/create-iterator-proxy');
var callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');
var IteratorProxy = createIteratorProxy(function (arg) {
var iterator = this.iterator;
var result = anObject(this.next.call(iterator, arg));
var done = this.done = !!result.done;
if (!done) return callWithSafeIterationClosing(iterator, this.mapper, result.value);
});
$({ target: 'Iterator', proto: true, real: true }, {
map: function map(mapper) {
return new IteratorProxy({
iterator: anObject(this),
mapper: aFunction(mapper)
});
}
});
core-js-3.6.1/packages/core-js/modules/esnext.iterator.reduce.js 0000664 0000000 0000000 00000001526 13600575677 0024641 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var iterate = require('../internals/iterate');
var aFunction = require('../internals/a-function');
var anObject = require('../internals/an-object');
$({ target: 'Iterator', proto: true, real: true }, {
reduce: function reduce(reducer /* , initialValue */) {
anObject(this);
aFunction(reducer);
var noInitial = arguments.length < 2;
var accumulator = noInitial ? undefined : arguments[1];
iterate(this, function (value) {
if (noInitial) {
noInitial = false;
accumulator = value;
} else {
accumulator = reducer(accumulator, value);
}
}, undefined, false, true);
if (noInitial) throw TypeError('Reduce of empty iterator with no initial value');
return accumulator;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.iterator.some.js 0000664 0000000 0000000 00000001001 13600575677 0024321 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var iterate = require('../internals/iterate');
var aFunction = require('../internals/a-function');
var anObject = require('../internals/an-object');
$({ target: 'Iterator', proto: true, real: true }, {
some: function some(fn) {
anObject(this);
aFunction(fn);
return iterate(this, function (value) {
if (fn(value)) return iterate.stop();
}, undefined, false, true).stopped;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.iterator.take.js 0000664 0000000 0000000 00000001377 13600575677 0024322 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var anObject = require('../internals/an-object');
var toPositiveInteger = require('../internals/to-positive-integer');
var createIteratorProxy = require('../internals/create-iterator-proxy');
var IteratorProxy = createIteratorProxy(function (arg) {
if (!this.remaining--) {
this.done = true;
return;
}
var result = anObject(this.next.call(this.iterator, arg));
var done = this.done = !!result.done;
if (!done) return result.value;
});
$({ target: 'Iterator', proto: true, real: true }, {
take: function take(limit) {
return new IteratorProxy({
iterator: anObject(this),
remaining: toPositiveInteger(limit)
});
}
});
core-js-3.6.1/packages/core-js/modules/esnext.iterator.to-array.js 0000664 0000000 0000000 00000000637 13600575677 0025132 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-iterator-helpers
var $ = require('../internals/export');
var iterate = require('../internals/iterate');
var anObject = require('../internals/an-object');
var push = [].push;
$({ target: 'Iterator', proto: true, real: true }, {
toArray: function toArray() {
var result = [];
iterate(anObject(this), push, result, false, true);
return result;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.map.delete-all.js 0000664 0000000 0000000 00000000677 13600575677 0024334 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var collectionDeleteAll = require('../internals/collection-delete-all');
// `Map.prototype.deleteAll` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
deleteAll: function deleteAll(/* ...elements */) {
return collectionDeleteAll.apply(this, arguments);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.map.every.js 0000664 0000000 0000000 00000001520 13600575677 0023442 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var anObject = require('../internals/an-object');
var bind = require('../internals/bind-context');
var getMapIterator = require('../internals/get-map-iterator');
var iterate = require('../internals/iterate');
// `Map.prototype.every` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
every: function every(callbackfn /* , thisArg */) {
var map = anObject(this);
var iterator = getMapIterator(map);
var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
return !iterate(iterator, function (key, value) {
if (!boundFunction(value, key, map)) return iterate.stop();
}, undefined, true, true).stopped;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.map.filter.js 0000664 0000000 0000000 00000002175 13600575677 0023604 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var getBuiltIn = require('../internals/get-built-in');
var anObject = require('../internals/an-object');
var aFunction = require('../internals/a-function');
var bind = require('../internals/bind-context');
var speciesConstructor = require('../internals/species-constructor');
var getMapIterator = require('../internals/get-map-iterator');
var iterate = require('../internals/iterate');
// `Map.prototype.filter` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
filter: function filter(callbackfn /* , thisArg */) {
var map = anObject(this);
var iterator = getMapIterator(map);
var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
var newMap = new (speciesConstructor(map, getBuiltIn('Map')))();
var setter = aFunction(newMap.set);
iterate(iterator, function (key, value) {
if (boundFunction(value, key, map)) setter.call(newMap, key, value);
}, undefined, true, true);
return newMap;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.map.find-key.js 0000664 0000000 0000000 00000001526 13600575677 0024024 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var anObject = require('../internals/an-object');
var bind = require('../internals/bind-context');
var getMapIterator = require('../internals/get-map-iterator');
var iterate = require('../internals/iterate');
// `Map.prototype.findKey` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
findKey: function findKey(callbackfn /* , thisArg */) {
var map = anObject(this);
var iterator = getMapIterator(map);
var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
return iterate(iterator, function (key, value) {
if (boundFunction(value, key, map)) return iterate.stop(key);
}, undefined, true, true).result;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.map.find.js 0000664 0000000 0000000 00000001517 13600575677 0023236 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var anObject = require('../internals/an-object');
var bind = require('../internals/bind-context');
var getMapIterator = require('../internals/get-map-iterator');
var iterate = require('../internals/iterate');
// `Map.prototype.find` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
find: function find(callbackfn /* , thisArg */) {
var map = anObject(this);
var iterator = getMapIterator(map);
var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
return iterate(iterator, function (key, value) {
if (boundFunction(value, key, map)) return iterate.stop(value);
}, undefined, true, true).result;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.map.from.js 0000664 0000000 0000000 00000000345 13600575677 0023257 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var from = require('../internals/collection-from');
// `Map.from` method
// https://tc39.github.io/proposal-setmap-offrom/#sec-map.from
$({ target: 'Map', stat: true }, {
from: from
});
core-js-3.6.1/packages/core-js/modules/esnext.map.group-by.js 0000664 0000000 0000000 00000001363 13600575677 0024061 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var iterate = require('../internals/iterate');
var aFunction = require('../internals/a-function');
// `Map.groupBy` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Map', stat: true }, {
groupBy: function groupBy(iterable, keyDerivative) {
var newMap = new this();
aFunction(keyDerivative);
var has = aFunction(newMap.has);
var get = aFunction(newMap.get);
var set = aFunction(newMap.set);
iterate(iterable, function (element) {
var derivedKey = keyDerivative(element);
if (!has.call(newMap, derivedKey)) set.call(newMap, derivedKey, [element]);
else get.call(newMap, derivedKey).push(element);
});
return newMap;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.map.includes.js 0000664 0000000 0000000 00000001315 13600575677 0024120 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var anObject = require('../internals/an-object');
var getMapIterator = require('../internals/get-map-iterator');
var sameValueZero = require('../internals/same-value-zero');
var iterate = require('../internals/iterate');
// `Map.prototype.includes` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
includes: function includes(searchElement) {
return iterate(getMapIterator(anObject(this)), function (key, value) {
if (sameValueZero(value, searchElement)) return iterate.stop();
}, undefined, true, true).stopped;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.map.key-by.js 0000664 0000000 0000000 00000001052 13600575677 0023510 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var iterate = require('../internals/iterate');
var aFunction = require('../internals/a-function');
// `Map.keyBy` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Map', stat: true }, {
keyBy: function keyBy(iterable, keyDerivative) {
var newMap = new this();
aFunction(keyDerivative);
var setter = aFunction(newMap.set);
iterate(iterable, function (element) {
setter.call(newMap, keyDerivative(element), element);
});
return newMap;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.map.key-of.js 0000664 0000000 0000000 00000001200 13600575677 0023475 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var anObject = require('../internals/an-object');
var getMapIterator = require('../internals/get-map-iterator');
var iterate = require('../internals/iterate');
// `Map.prototype.includes` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
keyOf: function keyOf(searchElement) {
return iterate(getMapIterator(anObject(this)), function (key, value) {
if (value === searchElement) return iterate.stop(key);
}, undefined, true, true).result;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.map.map-keys.js 0000664 0000000 0000000 00000002167 13600575677 0024046 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var getBuiltIn = require('../internals/get-built-in');
var anObject = require('../internals/an-object');
var aFunction = require('../internals/a-function');
var bind = require('../internals/bind-context');
var speciesConstructor = require('../internals/species-constructor');
var getMapIterator = require('../internals/get-map-iterator');
var iterate = require('../internals/iterate');
// `Map.prototype.mapKeys` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
mapKeys: function mapKeys(callbackfn /* , thisArg */) {
var map = anObject(this);
var iterator = getMapIterator(map);
var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
var newMap = new (speciesConstructor(map, getBuiltIn('Map')))();
var setter = aFunction(newMap.set);
iterate(iterator, function (key, value) {
setter.call(newMap, boundFunction(value, key, map), value);
}, undefined, true, true);
return newMap;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.map.map-values.js 0000664 0000000 0000000 00000002173 13600575677 0024367 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var getBuiltIn = require('../internals/get-built-in');
var anObject = require('../internals/an-object');
var aFunction = require('../internals/a-function');
var bind = require('../internals/bind-context');
var speciesConstructor = require('../internals/species-constructor');
var getMapIterator = require('../internals/get-map-iterator');
var iterate = require('../internals/iterate');
// `Map.prototype.mapValues` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
mapValues: function mapValues(callbackfn /* , thisArg */) {
var map = anObject(this);
var iterator = getMapIterator(map);
var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
var newMap = new (speciesConstructor(map, getBuiltIn('Map')))();
var setter = aFunction(newMap.set);
iterate(iterator, function (key, value) {
setter.call(newMap, key, boundFunction(value, key, map));
}, undefined, true, true);
return newMap;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.map.merge.js 0000664 0000000 0000000 00000001273 13600575677 0023414 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var anObject = require('../internals/an-object');
var aFunction = require('../internals/a-function');
var iterate = require('../internals/iterate');
// `Map.prototype.merge` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
// eslint-disable-next-line no-unused-vars
merge: function merge(iterable /* ...iterbles */) {
var map = anObject(this);
var setter = aFunction(map.set);
var i = 0;
while (i < arguments.length) {
iterate(arguments[i++], setter, map, true);
}
return map;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.map.of.js 0000664 0000000 0000000 00000000331 13600575677 0022713 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var of = require('../internals/collection-of');
// `Map.of` method
// https://tc39.github.io/proposal-setmap-offrom/#sec-map.of
$({ target: 'Map', stat: true }, {
of: of
});
core-js-3.6.1/packages/core-js/modules/esnext.map.reduce.js 0000664 0000000 0000000 00000002073 13600575677 0023563 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var anObject = require('../internals/an-object');
var aFunction = require('../internals/a-function');
var getMapIterator = require('../internals/get-map-iterator');
var iterate = require('../internals/iterate');
// `Map.prototype.reduce` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
reduce: function reduce(callbackfn /* , initialValue */) {
var map = anObject(this);
var iterator = getMapIterator(map);
var noInitial = arguments.length < 2;
var accumulator = noInitial ? undefined : arguments[1];
aFunction(callbackfn);
iterate(iterator, function (key, value) {
if (noInitial) {
noInitial = false;
accumulator = value;
} else {
accumulator = callbackfn(accumulator, value, key, map);
}
}, undefined, true, true);
if (noInitial) throw TypeError('Reduce of empty map with no initial value');
return accumulator;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.map.some.js 0000664 0000000 0000000 00000001513 13600575677 0023255 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var anObject = require('../internals/an-object');
var bind = require('../internals/bind-context');
var getMapIterator = require('../internals/get-map-iterator');
var iterate = require('../internals/iterate');
// `Set.prototype.some` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
some: function some(callbackfn /* , thisArg */) {
var map = anObject(this);
var iterator = getMapIterator(map);
var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
return iterate(iterator, function (key, value) {
if (boundFunction(value, key, map)) return iterate.stop();
}, undefined, true, true).stopped;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.map.update-or-insert.js 0000664 0000000 0000000 00000000627 13600575677 0025521 0 ustar 00root root 0000000 0000000 'use strict';
// TODO: remove from `core-js@4`
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var $upsert = require('../internals/map-upsert');
// `Map.prototype.updateOrInsert` method (replaced by `Map.prototype.upsert`)
// https://github.com/thumbsupep/proposal-upsert
$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
updateOrInsert: $upsert
});
core-js-3.6.1/packages/core-js/modules/esnext.map.update.js 0000664 0000000 0000000 00000001457 13600575677 0023603 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var anObject = require('../internals/an-object');
var aFunction = require('../internals/a-function');
// `Set.prototype.update` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
update: function update(key, callback /* , thunk */) {
var map = anObject(this);
var length = arguments.length;
aFunction(callback);
var isPresentInMap = map.has(key);
if (!isPresentInMap && length < 3) {
throw TypeError('Updating absent value');
}
var value = isPresentInMap ? map.get(key) : aFunction(length > 2 ? arguments[2] : undefined)(key, map);
map.set(key, callback(value, key, map));
return map;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.map.upsert.js 0000664 0000000 0000000 00000000501 13600575677 0023630 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var $upsert = require('../internals/map-upsert');
// `Map.prototype.upsert` method
// https://github.com/thumbsupep/proposal-upsert
$({ target: 'Map', proto: true, real: true, forced: IS_PURE }, {
upsert: $upsert
});
core-js-3.6.1/packages/core-js/modules/esnext.math.clamp.js 0000664 0000000 0000000 00000000436 13600575677 0023565 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var min = Math.min;
var max = Math.max;
// `Math.clamp` method
// https://rwaldron.github.io/proposal-math-extensions/
$({ target: 'Math', stat: true }, {
clamp: function clamp(x, lower, upper) {
return min(upper, max(lower, x));
}
});
core-js-3.6.1/packages/core-js/modules/esnext.math.deg-per-rad.js 0000664 0000000 0000000 00000000305 13600575677 0024553 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
// `Math.DEG_PER_RAD` constant
// https://rwaldron.github.io/proposal-math-extensions/
$({ target: 'Math', stat: true }, {
DEG_PER_RAD: Math.PI / 180
});
core-js-3.6.1/packages/core-js/modules/esnext.math.degrees.js 0000664 0000000 0000000 00000000421 13600575677 0024101 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var RAD_PER_DEG = 180 / Math.PI;
// `Math.degrees` method
// https://rwaldron.github.io/proposal-math-extensions/
$({ target: 'Math', stat: true }, {
degrees: function degrees(radians) {
return radians * RAD_PER_DEG;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.math.fscale.js 0000664 0000000 0000000 00000000604 13600575677 0023723 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var scale = require('../internals/math-scale');
var fround = require('../internals/math-fround');
// `Math.fscale` method
// https://rwaldron.github.io/proposal-math-extensions/
$({ target: 'Math', stat: true }, {
fscale: function fscale(x, inLow, inHigh, outLow, outHigh) {
return fround(scale(x, inLow, inHigh, outLow, outHigh));
}
});
core-js-3.6.1/packages/core-js/modules/esnext.math.iaddh.js 0000664 0000000 0000000 00000000626 13600575677 0023543 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
// `Math.iaddh` method
// https://gist.github.com/BrendanEich/4294d5c212a6d2254703
// TODO: Remove from `core-js@4`
$({ target: 'Math', stat: true }, {
iaddh: function iaddh(x0, x1, y0, y1) {
var $x0 = x0 >>> 0;
var $x1 = x1 >>> 0;
var $y0 = y0 >>> 0;
return $x1 + (y1 >>> 0) + (($x0 & $y0 | ($x0 | $y0) & ~($x0 + $y0 >>> 0)) >>> 31) | 0;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.math.imulh.js 0000664 0000000 0000000 00000000777 13600575677 0023617 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
// `Math.imulh` method
// https://gist.github.com/BrendanEich/4294d5c212a6d2254703
// TODO: Remove from `core-js@4`
$({ target: 'Math', stat: true }, {
imulh: function imulh(u, v) {
var UINT16 = 0xFFFF;
var $u = +u;
var $v = +v;
var u0 = $u & UINT16;
var v0 = $v & UINT16;
var u1 = $u >> 16;
var v1 = $v >> 16;
var t = (u1 * v0 >>> 0) + (u0 * v0 >>> 16);
return u1 * v1 + (t >> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >> 16);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.math.isubh.js 0000664 0000000 0000000 00000000625 13600575677 0023603 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
// `Math.isubh` method
// https://gist.github.com/BrendanEich/4294d5c212a6d2254703
// TODO: Remove from `core-js@4`
$({ target: 'Math', stat: true }, {
isubh: function isubh(x0, x1, y0, y1) {
var $x0 = x0 >>> 0;
var $x1 = x1 >>> 0;
var $y0 = y0 >>> 0;
return $x1 - (y1 >>> 0) - ((~$x0 & $y0 | ~($x0 ^ $y0) & $x0 - $y0 >>> 0) >>> 31) | 0;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.math.rad-per-deg.js 0000664 0000000 0000000 00000000305 13600575677 0024553 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
// `Math.RAD_PER_DEG` constant
// https://rwaldron.github.io/proposal-math-extensions/
$({ target: 'Math', stat: true }, {
RAD_PER_DEG: 180 / Math.PI
});
core-js-3.6.1/packages/core-js/modules/esnext.math.radians.js 0000664 0000000 0000000 00000000421 13600575677 0024104 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var DEG_PER_RAD = Math.PI / 180;
// `Math.radians` method
// https://rwaldron.github.io/proposal-math-extensions/
$({ target: 'Math', stat: true }, {
radians: function radians(degrees) {
return degrees * DEG_PER_RAD;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.math.scale.js 0000664 0000000 0000000 00000000337 13600575677 0023560 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var scale = require('../internals/math-scale');
// `Math.scale` method
// https://rwaldron.github.io/proposal-math-extensions/
$({ target: 'Math', stat: true }, {
scale: scale
});
core-js-3.6.1/packages/core-js/modules/esnext.math.seeded-prng.js 0000664 0000000 0000000 00000002703 13600575677 0024665 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var anObject = require('../internals/an-object');
var numberIsFinite = require('../internals/number-is-finite');
var createIteratorConstructor = require('../internals/create-iterator-constructor');
var InternalStateModule = require('../internals/internal-state');
var SEEDED_RANDOM = 'Seeded Random';
var SEEDED_RANDOM_GENERATOR = SEEDED_RANDOM + ' Generator';
var setInternalState = InternalStateModule.set;
var getInternalState = InternalStateModule.getterFor(SEEDED_RANDOM_GENERATOR);
var SEED_TYPE_ERROR = 'Math.seededPRNG() argument should have a "seed" field with a finite value.';
var $SeededRandomGenerator = createIteratorConstructor(function SeededRandomGenerator(seed) {
setInternalState(this, {
type: SEEDED_RANDOM_GENERATOR,
seed: seed % 2147483647
});
}, SEEDED_RANDOM, function next() {
var state = getInternalState(this);
var seed = state.seed = (state.seed * 1103515245 + 12345) % 2147483647;
return { value: (seed & 1073741823) / 1073741823, done: false };
});
// `Math.seededPRNG` method
// https://github.com/tc39/proposal-seeded-random
// based on https://github.com/tc39/proposal-seeded-random/blob/78b8258835b57fc2100d076151ab506bc3202ae6/demo.html
$({ target: 'Math', stat: true, forced: true }, {
seededPRNG: function seededPRNG(it) {
var seed = anObject(it).seed;
if (!numberIsFinite(seed)) throw TypeError(SEED_TYPE_ERROR);
return new $SeededRandomGenerator(seed);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.math.signbit.js 0000664 0000000 0000000 00000000401 13600575677 0024120 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
// `Math.signbit` method
// https://github.com/tc39/proposal-Math.signbit
$({ target: 'Math', stat: true }, {
signbit: function signbit(x) {
return (x = +x) == x && x == 0 ? 1 / x == -Infinity : x < 0;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.math.umulh.js 0000664 0000000 0000000 00000001003 13600575677 0023612 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
// `Math.umulh` method
// https://gist.github.com/BrendanEich/4294d5c212a6d2254703
// TODO: Remove from `core-js@4`
$({ target: 'Math', stat: true }, {
umulh: function umulh(u, v) {
var UINT16 = 0xFFFF;
var $u = +u;
var $v = +v;
var u0 = $u & UINT16;
var v0 = $v & UINT16;
var u1 = $u >>> 16;
var v1 = $v >>> 16;
var t = (u1 * v0 >>> 0) + (u0 * v0 >>> 16);
return u1 * v1 + (t >>> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >>> 16);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.number.from-string.js 0000664 0000000 0000000 00000002141 13600575677 0025272 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var toInteger = require('../internals/to-integer');
var parseInt = require('../internals/parse-int');
var INVALID_NUMBER_REPRESENTATION = 'Invalid number representation';
var INVALID_RADIX = 'Invalid radix';
var valid = /^[\da-z]+$/;
// `Number.fromString` method
// https://github.com/tc39/proposal-number-fromstring
$({ target: 'Number', stat: true }, {
fromString: function fromString(string, radix) {
var sign = 1;
var R, mathNum;
if (typeof string != 'string') throw TypeError(INVALID_NUMBER_REPRESENTATION);
if (!string.length) throw SyntaxError(INVALID_NUMBER_REPRESENTATION);
if (string.charAt(0) == '-') {
sign = -1;
string = string.slice(1);
if (!string.length) throw SyntaxError(INVALID_NUMBER_REPRESENTATION);
}
R = radix === undefined ? 10 : toInteger(radix);
if (R < 2 || R > 36) throw RangeError(INVALID_RADIX);
if (!valid.test(string) || (mathNum = parseInt(string, R)).toString(R) !== string) {
throw SyntaxError(INVALID_NUMBER_REPRESENTATION);
}
return sign * mathNum;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.object.iterate-entries.js 0000664 0000000 0000000 00000000540 13600575677 0026106 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var ObjectIterator = require('../internals/object-iterator');
// `Object.iterateEntries` method
// https://github.com/tc39/proposal-object-iteration
$({ target: 'Object', stat: true }, {
iterateEntries: function iterateEntries(object) {
return new ObjectIterator(object, 'entries');
}
});
core-js-3.6.1/packages/core-js/modules/esnext.object.iterate-keys.js 0000664 0000000 0000000 00000000524 13600575677 0025412 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var ObjectIterator = require('../internals/object-iterator');
// `Object.iterateKeys` method
// https://github.com/tc39/proposal-object-iteration
$({ target: 'Object', stat: true }, {
iterateKeys: function iterateKeys(object) {
return new ObjectIterator(object, 'keys');
}
});
core-js-3.6.1/packages/core-js/modules/esnext.object.iterate-values.js 0000664 0000000 0000000 00000000534 13600575677 0025737 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var ObjectIterator = require('../internals/object-iterator');
// `Object.iterateValues` method
// https://github.com/tc39/proposal-object-iteration
$({ target: 'Object', stat: true }, {
iterateValues: function iterateValues(object) {
return new ObjectIterator(object, 'values');
}
});
core-js-3.6.1/packages/core-js/modules/esnext.observable.js 0000664 0000000 0000000 00000015624 13600575677 0023672 0 ustar 00root root 0000000 0000000 'use strict';
// https://github.com/tc39/proposal-observable
var $ = require('../internals/export');
var DESCRIPTORS = require('../internals/descriptors');
var setSpecies = require('../internals/set-species');
var aFunction = require('../internals/a-function');
var anObject = require('../internals/an-object');
var isObject = require('../internals/is-object');
var anInstance = require('../internals/an-instance');
var defineProperty = require('../internals/object-define-property').f;
var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
var redefineAll = require('../internals/redefine-all');
var getIterator = require('../internals/get-iterator');
var iterate = require('../internals/iterate');
var hostReportErrors = require('../internals/host-report-errors');
var wellKnownSymbol = require('../internals/well-known-symbol');
var InternalStateModule = require('../internals/internal-state');
var OBSERVABLE = wellKnownSymbol('observable');
var getInternalState = InternalStateModule.get;
var setInternalState = InternalStateModule.set;
var getMethod = function (fn) {
return fn == null ? undefined : aFunction(fn);
};
var cleanupSubscription = function (subscriptionState) {
var cleanup = subscriptionState.cleanup;
if (cleanup) {
subscriptionState.cleanup = undefined;
try {
cleanup();
} catch (error) {
hostReportErrors(error);
}
}
};
var subscriptionClosed = function (subscriptionState) {
return subscriptionState.observer === undefined;
};
var close = function (subscription, subscriptionState) {
if (!DESCRIPTORS) {
subscription.closed = true;
var subscriptionObserver = subscriptionState.subscriptionObserver;
if (subscriptionObserver) subscriptionObserver.closed = true;
} subscriptionState.observer = undefined;
};
var Subscription = function (observer, subscriber) {
var subscriptionState = setInternalState(this, {
cleanup: undefined,
observer: anObject(observer),
subscriptionObserver: undefined
});
var start;
if (!DESCRIPTORS) this.closed = false;
try {
if (start = getMethod(observer.start)) start.call(observer, this);
} catch (error) {
hostReportErrors(error);
}
if (subscriptionClosed(subscriptionState)) return;
var subscriptionObserver = subscriptionState.subscriptionObserver = new SubscriptionObserver(this);
try {
var cleanup = subscriber(subscriptionObserver);
var subscription = cleanup;
if (cleanup != null) subscriptionState.cleanup = typeof cleanup.unsubscribe === 'function'
? function () { subscription.unsubscribe(); }
: aFunction(cleanup);
} catch (error) {
subscriptionObserver.error(error);
return;
} if (subscriptionClosed(subscriptionState)) cleanupSubscription(subscriptionState);
};
Subscription.prototype = redefineAll({}, {
unsubscribe: function unsubscribe() {
var subscriptionState = getInternalState(this);
if (!subscriptionClosed(subscriptionState)) {
close(this, subscriptionState);
cleanupSubscription(subscriptionState);
}
}
});
if (DESCRIPTORS) defineProperty(Subscription.prototype, 'closed', {
configurable: true,
get: function () {
return subscriptionClosed(getInternalState(this));
}
});
var SubscriptionObserver = function (subscription) {
setInternalState(this, { subscription: subscription });
if (!DESCRIPTORS) this.closed = false;
};
SubscriptionObserver.prototype = redefineAll({}, {
next: function next(value) {
var subscriptionState = getInternalState(getInternalState(this).subscription);
if (!subscriptionClosed(subscriptionState)) {
var observer = subscriptionState.observer;
try {
var nextMethod = getMethod(observer.next);
if (nextMethod) nextMethod.call(observer, value);
} catch (error) {
hostReportErrors(error);
}
}
},
error: function error(value) {
var subscription = getInternalState(this).subscription;
var subscriptionState = getInternalState(subscription);
if (!subscriptionClosed(subscriptionState)) {
var observer = subscriptionState.observer;
close(subscription, subscriptionState);
try {
var errorMethod = getMethod(observer.error);
if (errorMethod) errorMethod.call(observer, value);
else hostReportErrors(value);
} catch (err) {
hostReportErrors(err);
} cleanupSubscription(subscriptionState);
}
},
complete: function complete() {
var subscription = getInternalState(this).subscription;
var subscriptionState = getInternalState(subscription);
if (!subscriptionClosed(subscriptionState)) {
var observer = subscriptionState.observer;
close(subscription, subscriptionState);
try {
var completeMethod = getMethod(observer.complete);
if (completeMethod) completeMethod.call(observer);
} catch (error) {
hostReportErrors(error);
} cleanupSubscription(subscriptionState);
}
}
});
if (DESCRIPTORS) defineProperty(SubscriptionObserver.prototype, 'closed', {
configurable: true,
get: function () {
return subscriptionClosed(getInternalState(getInternalState(this).subscription));
}
});
var $Observable = function Observable(subscriber) {
anInstance(this, $Observable, 'Observable');
setInternalState(this, { subscriber: aFunction(subscriber) });
};
redefineAll($Observable.prototype, {
subscribe: function subscribe(observer) {
var length = arguments.length;
return new Subscription(typeof observer === 'function' ? {
next: observer,
error: length > 1 ? arguments[1] : undefined,
complete: length > 2 ? arguments[2] : undefined
} : isObject(observer) ? observer : {}, getInternalState(this).subscriber);
}
});
redefineAll($Observable, {
from: function from(x) {
var C = typeof this === 'function' ? this : $Observable;
var observableMethod = getMethod(anObject(x)[OBSERVABLE]);
if (observableMethod) {
var observable = anObject(observableMethod.call(x));
return observable.constructor === C ? observable : new C(function (observer) {
return observable.subscribe(observer);
});
}
var iterator = getIterator(x);
return new C(function (observer) {
iterate(iterator, function (it) {
observer.next(it);
if (observer.closed) return iterate.stop();
}, undefined, false, true);
observer.complete();
});
},
of: function of() {
var C = typeof this === 'function' ? this : $Observable;
var length = arguments.length;
var items = new Array(length);
var index = 0;
while (index < length) items[index] = arguments[index++];
return new C(function (observer) {
for (var i = 0; i < length; i++) {
observer.next(items[i]);
if (observer.closed) return;
} observer.complete();
});
}
});
createNonEnumerableProperty($Observable.prototype, OBSERVABLE, function () { return this; });
$({ global: true }, {
Observable: $Observable
});
setSpecies('Observable');
core-js-3.6.1/packages/core-js/modules/esnext.promise.all-settled.js 0000664 0000000 0000000 00000000111 13600575677 0025416 0 ustar 00root root 0000000 0000000 // TODO: Remove from `core-js@4`
require('./es.promise.all-settled.js');
core-js-3.6.1/packages/core-js/modules/esnext.promise.any.js 0000664 0000000 0000000 00000003204 13600575677 0024001 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var aFunction = require('../internals/a-function');
var getBuiltIn = require('../internals/get-built-in');
var newPromiseCapabilityModule = require('../internals/new-promise-capability');
var perform = require('../internals/perform');
var iterate = require('../internals/iterate');
var PROMISE_ANY_ERROR = 'No one promise resolved';
// `Promise.any` method
// https://github.com/tc39/proposal-promise-any
$({ target: 'Promise', stat: true }, {
any: function any(iterable) {
var C = this;
var capability = newPromiseCapabilityModule.f(C);
var resolve = capability.resolve;
var reject = capability.reject;
var result = perform(function () {
var promiseResolve = aFunction(C.resolve);
var errors = [];
var counter = 0;
var remaining = 1;
var alreadyResolved = false;
iterate(iterable, function (promise) {
var index = counter++;
var alreadyRejected = false;
errors.push(undefined);
remaining++;
promiseResolve.call(C, promise).then(function (value) {
if (alreadyRejected || alreadyResolved) return;
alreadyResolved = true;
resolve(value);
}, function (e) {
if (alreadyRejected || alreadyResolved) return;
alreadyRejected = true;
errors[index] = e;
--remaining || reject(new (getBuiltIn('AggregateError'))(errors, PROMISE_ANY_ERROR));
});
});
--remaining || reject(new (getBuiltIn('AggregateError'))(errors, PROMISE_ANY_ERROR));
});
if (result.error) reject(result.value);
return capability.promise;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.promise.try.js 0000664 0000000 0000000 00000001064 13600575677 0024032 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var newPromiseCapabilityModule = require('../internals/new-promise-capability');
var perform = require('../internals/perform');
// `Promise.try` method
// https://github.com/tc39/proposal-promise-try
$({ target: 'Promise', stat: true }, {
'try': function (callbackfn) {
var promiseCapability = newPromiseCapabilityModule.f(this);
var result = perform(callbackfn);
(result.error ? promiseCapability.reject : promiseCapability.resolve)(result.value);
return promiseCapability.promise;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.reflect.define-metadata.js 0000664 0000000 0000000 00000001236 13600575677 0026173 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var ReflectMetadataModule = require('../internals/reflect-metadata');
var anObject = require('../internals/an-object');
var toMetadataKey = ReflectMetadataModule.toKey;
var ordinaryDefineOwnMetadata = ReflectMetadataModule.set;
// `Reflect.defineMetadata` method
// https://github.com/rbuckton/reflect-metadata
$({ target: 'Reflect', stat: true }, {
defineMetadata: function defineMetadata(metadataKey, metadataValue, target /* , targetKey */) {
var targetKey = arguments.length < 4 ? undefined : toMetadataKey(arguments[3]);
ordinaryDefineOwnMetadata(metadataKey, metadataValue, anObject(target), targetKey);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.reflect.delete-metadata.js 0000664 0000000 0000000 00000001703 13600575677 0026202 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var ReflectMetadataModule = require('../internals/reflect-metadata');
var anObject = require('../internals/an-object');
var toMetadataKey = ReflectMetadataModule.toKey;
var getOrCreateMetadataMap = ReflectMetadataModule.getMap;
var store = ReflectMetadataModule.store;
// `Reflect.deleteMetadata` method
// https://github.com/rbuckton/reflect-metadata
$({ target: 'Reflect', stat: true }, {
deleteMetadata: function deleteMetadata(metadataKey, target /* , targetKey */) {
var targetKey = arguments.length < 3 ? undefined : toMetadataKey(arguments[2]);
var metadataMap = getOrCreateMetadataMap(anObject(target), targetKey, false);
if (metadataMap === undefined || !metadataMap['delete'](metadataKey)) return false;
if (metadataMap.size) return true;
var targetMetadata = store.get(target);
targetMetadata['delete'](targetKey);
return !!targetMetadata.size || store['delete'](target);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.reflect.get-metadata-keys.js 0000664 0000000 0000000 00000002431 13600575677 0026467 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
var Set = require('../modules/es.set');
var ReflectMetadataModule = require('../internals/reflect-metadata');
var anObject = require('../internals/an-object');
var getPrototypeOf = require('../internals/object-get-prototype-of');
var iterate = require('../internals/iterate');
var ordinaryOwnMetadataKeys = ReflectMetadataModule.keys;
var toMetadataKey = ReflectMetadataModule.toKey;
var from = function (iter) {
var result = [];
iterate(iter, result.push, result);
return result;
};
var ordinaryMetadataKeys = function (O, P) {
var oKeys = ordinaryOwnMetadataKeys(O, P);
var parent = getPrototypeOf(O);
if (parent === null) return oKeys;
var pKeys = ordinaryMetadataKeys(parent, P);
return pKeys.length ? oKeys.length ? from(new Set(oKeys.concat(pKeys))) : pKeys : oKeys;
};
// `Reflect.getMetadataKeys` method
// https://github.com/rbuckton/reflect-metadata
$({ target: 'Reflect', stat: true }, {
getMetadataKeys: function getMetadataKeys(target /* , targetKey */) {
var targetKey = arguments.length < 2 ? undefined : toMetadataKey(arguments[1]);
return ordinaryMetadataKeys(anObject(target), targetKey);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.reflect.get-metadata.js 0000664 0000000 0000000 00000002040 13600575677 0025512 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var ReflectMetadataModule = require('../internals/reflect-metadata');
var anObject = require('../internals/an-object');
var getPrototypeOf = require('../internals/object-get-prototype-of');
var ordinaryHasOwnMetadata = ReflectMetadataModule.has;
var ordinaryGetOwnMetadata = ReflectMetadataModule.get;
var toMetadataKey = ReflectMetadataModule.toKey;
var ordinaryGetMetadata = function (MetadataKey, O, P) {
var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P);
if (hasOwn) return ordinaryGetOwnMetadata(MetadataKey, O, P);
var parent = getPrototypeOf(O);
return parent !== null ? ordinaryGetMetadata(MetadataKey, parent, P) : undefined;
};
// `Reflect.getMetadata` method
// https://github.com/rbuckton/reflect-metadata
$({ target: 'Reflect', stat: true }, {
getMetadata: function getMetadata(metadataKey, target /* , targetKey */) {
var targetKey = arguments.length < 3 ? undefined : toMetadataKey(arguments[2]);
return ordinaryGetMetadata(metadataKey, anObject(target), targetKey);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.reflect.get-own-metadata-keys.js 0000664 0000000 0000000 00000001166 13600575677 0027274 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var ReflectMetadataModule = require('../internals/reflect-metadata');
var anObject = require('../internals/an-object');
var ordinaryOwnMetadataKeys = ReflectMetadataModule.keys;
var toMetadataKey = ReflectMetadataModule.toKey;
// `Reflect.getOwnMetadataKeys` method
// https://github.com/rbuckton/reflect-metadata
$({ target: 'Reflect', stat: true }, {
getOwnMetadataKeys: function getOwnMetadataKeys(target /* , targetKey */) {
var targetKey = arguments.length < 2 ? undefined : toMetadataKey(arguments[1]);
return ordinaryOwnMetadataKeys(anObject(target), targetKey);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.reflect.get-own-metadata.js 0000664 0000000 0000000 00000001201 13600575677 0026311 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var ReflectMetadataModule = require('../internals/reflect-metadata');
var anObject = require('../internals/an-object');
var ordinaryGetOwnMetadata = ReflectMetadataModule.get;
var toMetadataKey = ReflectMetadataModule.toKey;
// `Reflect.getOwnMetadata` method
// https://github.com/rbuckton/reflect-metadata
$({ target: 'Reflect', stat: true }, {
getOwnMetadata: function getOwnMetadata(metadataKey, target /* , targetKey */) {
var targetKey = arguments.length < 3 ? undefined : toMetadataKey(arguments[2]);
return ordinaryGetOwnMetadata(metadataKey, anObject(target), targetKey);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.reflect.has-metadata.js 0000664 0000000 0000000 00000001677 13600575677 0025525 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var ReflectMetadataModule = require('../internals/reflect-metadata');
var anObject = require('../internals/an-object');
var getPrototypeOf = require('../internals/object-get-prototype-of');
var ordinaryHasOwnMetadata = ReflectMetadataModule.has;
var toMetadataKey = ReflectMetadataModule.toKey;
var ordinaryHasMetadata = function (MetadataKey, O, P) {
var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P);
if (hasOwn) return true;
var parent = getPrototypeOf(O);
return parent !== null ? ordinaryHasMetadata(MetadataKey, parent, P) : false;
};
// `Reflect.hasMetadata` method
// https://github.com/rbuckton/reflect-metadata
$({ target: 'Reflect', stat: true }, {
hasMetadata: function hasMetadata(metadataKey, target /* , targetKey */) {
var targetKey = arguments.length < 3 ? undefined : toMetadataKey(arguments[2]);
return ordinaryHasMetadata(metadataKey, anObject(target), targetKey);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.reflect.has-own-metadata.js 0000664 0000000 0000000 00000001201 13600575677 0026305 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var ReflectMetadataModule = require('../internals/reflect-metadata');
var anObject = require('../internals/an-object');
var ordinaryHasOwnMetadata = ReflectMetadataModule.has;
var toMetadataKey = ReflectMetadataModule.toKey;
// `Reflect.hasOwnMetadata` method
// https://github.com/rbuckton/reflect-metadata
$({ target: 'Reflect', stat: true }, {
hasOwnMetadata: function hasOwnMetadata(metadataKey, target /* , targetKey */) {
var targetKey = arguments.length < 3 ? undefined : toMetadataKey(arguments[2]);
return ordinaryHasOwnMetadata(metadataKey, anObject(target), targetKey);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.reflect.metadata.js 0000664 0000000 0000000 00000001135 13600575677 0024741 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var ReflectMetadataModule = require('../internals/reflect-metadata');
var anObject = require('../internals/an-object');
var toMetadataKey = ReflectMetadataModule.toKey;
var ordinaryDefineOwnMetadata = ReflectMetadataModule.set;
// `Reflect.metadata` method
// https://github.com/rbuckton/reflect-metadata
$({ target: 'Reflect', stat: true }, {
metadata: function metadata(metadataKey, metadataValue) {
return function decorator(target, key) {
ordinaryDefineOwnMetadata(metadataKey, metadataValue, anObject(target), toMetadataKey(key));
};
}
});
core-js-3.6.1/packages/core-js/modules/esnext.set.add-all.js 0000664 0000000 0000000 00000000655 13600575677 0023634 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var collectionAddAll = require('../internals/collection-add-all');
// `Set.prototype.addAll` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Set', proto: true, real: true, forced: IS_PURE }, {
addAll: function addAll(/* ...elements */) {
return collectionAddAll.apply(this, arguments);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.set.delete-all.js 0000664 0000000 0000000 00000000677 13600575677 0024352 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var collectionDeleteAll = require('../internals/collection-delete-all');
// `Set.prototype.deleteAll` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Set', proto: true, real: true, forced: IS_PURE }, {
deleteAll: function deleteAll(/* ...elements */) {
return collectionDeleteAll.apply(this, arguments);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.set.difference.js 0000664 0000000 0000000 00000001500 13600575677 0024416 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var getBuiltIn = require('../internals/get-built-in');
var anObject = require('../internals/an-object');
var aFunction = require('../internals/a-function');
var speciesConstructor = require('../internals/species-constructor');
var iterate = require('../internals/iterate');
// `Set.prototype.difference` method
// https://github.com/tc39/proposal-set-methods
$({ target: 'Set', proto: true, real: true, forced: IS_PURE }, {
difference: function difference(iterable) {
var set = anObject(this);
var newSet = new (speciesConstructor(set, getBuiltIn('Set')))(set);
var remover = aFunction(newSet['delete']);
iterate(iterable, function (value) {
remover.call(newSet, value);
});
return newSet;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.set.every.js 0000664 0000000 0000000 00000001516 13600575677 0023465 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var anObject = require('../internals/an-object');
var bind = require('../internals/bind-context');
var getSetIterator = require('../internals/get-set-iterator');
var iterate = require('../internals/iterate');
// `Set.prototype.every` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Set', proto: true, real: true, forced: IS_PURE }, {
every: function every(callbackfn /* , thisArg */) {
var set = anObject(this);
var iterator = getSetIterator(set);
var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
return !iterate(iterator, function (value) {
if (!boundFunction(value, value, set)) return iterate.stop();
}, undefined, false, true).stopped;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.set.filter.js 0000664 0000000 0000000 00000002164 13600575677 0023620 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var getBuiltIn = require('../internals/get-built-in');
var anObject = require('../internals/an-object');
var aFunction = require('../internals/a-function');
var bind = require('../internals/bind-context');
var speciesConstructor = require('../internals/species-constructor');
var getSetIterator = require('../internals/get-set-iterator');
var iterate = require('../internals/iterate');
// `Set.prototype.filter` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Set', proto: true, real: true, forced: IS_PURE }, {
filter: function filter(callbackfn /* , thisArg */) {
var set = anObject(this);
var iterator = getSetIterator(set);
var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
var newSet = new (speciesConstructor(set, getBuiltIn('Set')))();
var adder = aFunction(newSet.add);
iterate(iterator, function (value) {
if (boundFunction(value, value, set)) adder.call(newSet, value);
}, undefined, false, true);
return newSet;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.set.find.js 0000664 0000000 0000000 00000001515 13600575677 0023252 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var anObject = require('../internals/an-object');
var bind = require('../internals/bind-context');
var getSetIterator = require('../internals/get-set-iterator');
var iterate = require('../internals/iterate');
// `Set.prototype.find` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Set', proto: true, real: true, forced: IS_PURE }, {
find: function find(callbackfn /* , thisArg */) {
var set = anObject(this);
var iterator = getSetIterator(set);
var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
return iterate(iterator, function (value) {
if (boundFunction(value, value, set)) return iterate.stop(value);
}, undefined, false, true).result;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.set.from.js 0000664 0000000 0000000 00000000345 13600575677 0023275 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var from = require('../internals/collection-from');
// `Set.from` method
// https://tc39.github.io/proposal-setmap-offrom/#sec-set.from
$({ target: 'Set', stat: true }, {
from: from
});
core-js-3.6.1/packages/core-js/modules/esnext.set.intersection.js 0000664 0000000 0000000 00000001577 13600575677 0025050 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var getBuiltIn = require('../internals/get-built-in');
var anObject = require('../internals/an-object');
var aFunction = require('../internals/a-function');
var speciesConstructor = require('../internals/species-constructor');
var iterate = require('../internals/iterate');
// `Set.prototype.intersection` method
// https://github.com/tc39/proposal-set-methods
$({ target: 'Set', proto: true, real: true, forced: IS_PURE }, {
intersection: function intersection(iterable) {
var set = anObject(this);
var newSet = new (speciesConstructor(set, getBuiltIn('Set')))();
var hasCheck = aFunction(set.has);
var adder = aFunction(newSet.add);
iterate(iterable, function (value) {
if (hasCheck.call(set, value)) adder.call(newSet, value);
});
return newSet;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.set.is-disjoint-from.js 0000664 0000000 0000000 00000001273 13600575677 0025530 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var anObject = require('../internals/an-object');
var aFunction = require('../internals/a-function');
var iterate = require('../internals/iterate');
// `Set.prototype.isDisjointFrom` method
// https://tc39.github.io/proposal-set-methods/#Set.prototype.isDisjointFrom
$({ target: 'Set', proto: true, real: true, forced: IS_PURE }, {
isDisjointFrom: function isDisjointFrom(iterable) {
var set = anObject(this);
var hasCheck = aFunction(set.has);
return !iterate(iterable, function (value) {
if (hasCheck.call(set, value) === true) return iterate.stop();
}).stopped;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.set.is-subset-of.js 0000664 0000000 0000000 00000001756 13600575677 0024661 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var getBuiltIn = require('../internals/get-built-in');
var anObject = require('../internals/an-object');
var aFunction = require('../internals/a-function');
var getIterator = require('../internals/get-iterator');
var iterate = require('../internals/iterate');
// `Set.prototype.isSubsetOf` method
// https://tc39.github.io/proposal-set-methods/#Set.prototype.isSubsetOf
$({ target: 'Set', proto: true, real: true, forced: IS_PURE }, {
isSubsetOf: function isSubsetOf(iterable) {
var iterator = getIterator(this);
var otherSet = anObject(iterable);
var hasCheck = otherSet.has;
if (typeof hasCheck != 'function') {
otherSet = new (getBuiltIn('Set'))(iterable);
hasCheck = aFunction(otherSet.has);
}
return !iterate(iterator, function (value) {
if (hasCheck.call(otherSet, value) === false) return iterate.stop();
}, undefined, false, true).stopped;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.set.is-superset-of.js 0000664 0000000 0000000 00000001264 13600575677 0025220 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var anObject = require('../internals/an-object');
var aFunction = require('../internals/a-function');
var iterate = require('../internals/iterate');
// `Set.prototype.isSupersetOf` method
// https://tc39.github.io/proposal-set-methods/#Set.prototype.isSupersetOf
$({ target: 'Set', proto: true, real: true, forced: IS_PURE }, {
isSupersetOf: function isSupersetOf(iterable) {
var set = anObject(this);
var hasCheck = aFunction(set.has);
return !iterate(iterable, function (value) {
if (hasCheck.call(set, value) === false) return iterate.stop();
}).stopped;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.set.join.js 0000664 0000000 0000000 00000001272 13600575677 0023271 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var anObject = require('../internals/an-object');
var getSetIterator = require('../internals/get-set-iterator');
var iterate = require('../internals/iterate');
// `Set.prototype.join` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Set', proto: true, real: true, forced: IS_PURE }, {
join: function join(separator) {
var set = anObject(this);
var iterator = getSetIterator(set);
var sep = separator === undefined ? ',' : String(separator);
var result = [];
iterate(iterator, result.push, result, false, true);
return result.join(sep);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.set.map.js 0000664 0000000 0000000 00000002140 13600575677 0023102 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var getBuiltIn = require('../internals/get-built-in');
var anObject = require('../internals/an-object');
var aFunction = require('../internals/a-function');
var bind = require('../internals/bind-context');
var speciesConstructor = require('../internals/species-constructor');
var getSetIterator = require('../internals/get-set-iterator');
var iterate = require('../internals/iterate');
// `Set.prototype.map` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Set', proto: true, real: true, forced: IS_PURE }, {
map: function map(callbackfn /* , thisArg */) {
var set = anObject(this);
var iterator = getSetIterator(set);
var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
var newSet = new (speciesConstructor(set, getBuiltIn('Set')))();
var adder = aFunction(newSet.add);
iterate(iterator, function (value) {
adder.call(newSet, boundFunction(value, value, set));
}, undefined, false, true);
return newSet;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.set.of.js 0000664 0000000 0000000 00000000331 13600575677 0022731 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var of = require('../internals/collection-of');
// `Set.of` method
// https://tc39.github.io/proposal-setmap-offrom/#sec-set.of
$({ target: 'Set', stat: true }, {
of: of
});
core-js-3.6.1/packages/core-js/modules/esnext.set.reduce.js 0000664 0000000 0000000 00000002071 13600575677 0023577 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var anObject = require('../internals/an-object');
var aFunction = require('../internals/a-function');
var getSetIterator = require('../internals/get-set-iterator');
var iterate = require('../internals/iterate');
// `Set.prototype.reduce` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Set', proto: true, real: true, forced: IS_PURE }, {
reduce: function reduce(callbackfn /* , initialValue */) {
var set = anObject(this);
var iterator = getSetIterator(set);
var noInitial = arguments.length < 2;
var accumulator = noInitial ? undefined : arguments[1];
aFunction(callbackfn);
iterate(iterator, function (value) {
if (noInitial) {
noInitial = false;
accumulator = value;
} else {
accumulator = callbackfn(accumulator, value, value, set);
}
}, undefined, false, true);
if (noInitial) throw TypeError('Reduce of empty set with no initial value');
return accumulator;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.set.some.js 0000664 0000000 0000000 00000001511 13600575677 0023271 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var anObject = require('../internals/an-object');
var bind = require('../internals/bind-context');
var getSetIterator = require('../internals/get-set-iterator');
var iterate = require('../internals/iterate');
// `Set.prototype.some` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'Set', proto: true, real: true, forced: IS_PURE }, {
some: function some(callbackfn /* , thisArg */) {
var set = anObject(this);
var iterator = getSetIterator(set);
var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
return iterate(iterator, function (value) {
if (boundFunction(value, value, set)) return iterate.stop();
}, undefined, false, true).stopped;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.set.symmetric-difference.js 0000664 0000000 0000000 00000001637 13600575677 0026443 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var getBuiltIn = require('../internals/get-built-in');
var anObject = require('../internals/an-object');
var aFunction = require('../internals/a-function');
var speciesConstructor = require('../internals/species-constructor');
var iterate = require('../internals/iterate');
// `Set.prototype.symmetricDifference` method
// https://github.com/tc39/proposal-set-methods
$({ target: 'Set', proto: true, real: true, forced: IS_PURE }, {
symmetricDifference: function symmetricDifference(iterable) {
var set = anObject(this);
var newSet = new (speciesConstructor(set, getBuiltIn('Set')))(set);
var remover = aFunction(newSet['delete']);
var adder = aFunction(newSet.add);
iterate(iterable, function (value) {
remover.call(newSet, value) || adder.call(newSet, value);
});
return newSet;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.set.union.js 0000664 0000000 0000000 00000001344 13600575677 0023462 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var getBuiltIn = require('../internals/get-built-in');
var anObject = require('../internals/an-object');
var aFunction = require('../internals/a-function');
var speciesConstructor = require('../internals/species-constructor');
var iterate = require('../internals/iterate');
// `Set.prototype.union` method
// https://github.com/tc39/proposal-set-methods
$({ target: 'Set', proto: true, real: true, forced: IS_PURE }, {
union: function union(iterable) {
var set = anObject(this);
var newSet = new (speciesConstructor(set, getBuiltIn('Set')))(set);
iterate(iterable, aFunction(newSet.add), newSet);
return newSet;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.string.at.js 0000664 0000000 0000000 00000000463 13600575677 0023452 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var charAt = require('../internals/string-multibyte').charAt;
// `String.prototype.at` method
// https://github.com/mathiasbynens/String.prototype.at
$({ target: 'String', proto: true }, {
at: function at(pos) {
return charAt(this, pos);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.string.code-points.js 0000664 0000000 0000000 00000002633 13600575677 0025273 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var createIteratorConstructor = require('../internals/create-iterator-constructor');
var requireObjectCoercible = require('../internals/require-object-coercible');
var InternalStateModule = require('../internals/internal-state');
var StringMultibyteModule = require('../internals/string-multibyte');
var codeAt = StringMultibyteModule.codeAt;
var charAt = StringMultibyteModule.charAt;
var STRING_ITERATOR = 'String Iterator';
var setInternalState = InternalStateModule.set;
var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);
// TODO: unify with String#@@iterator
var $StringIterator = createIteratorConstructor(function StringIterator(string) {
setInternalState(this, {
type: STRING_ITERATOR,
string: string,
index: 0
});
}, 'String', function next() {
var state = getInternalState(this);
var string = state.string;
var index = state.index;
var point;
if (index >= string.length) return { value: undefined, done: true };
point = charAt(string, index);
state.index += point.length;
return { value: { codePoint: codeAt(point, 0), position: index }, done: false };
});
// `String.prototype.codePoints` method
// https://github.com/tc39/proposal-string-prototype-codepoints
$({ target: 'String', proto: true }, {
codePoints: function codePoints() {
return new $StringIterator(String(requireObjectCoercible(this)));
}
});
core-js-3.6.1/packages/core-js/modules/esnext.string.match-all.js 0000664 0000000 0000000 00000000103 13600575677 0024677 0 ustar 00root root 0000000 0000000 // TODO: Remove from `core-js@4`
require('./es.string.match-all');
core-js-3.6.1/packages/core-js/modules/esnext.string.replace-all.js 0000664 0000000 0000000 00000003713 13600575677 0025230 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var requireObjectCoercible = require('../internals/require-object-coercible');
var isRegExp = require('../internals/is-regexp');
var getRegExpFlags = require('../internals/regexp-flags');
var wellKnownSymbol = require('../internals/well-known-symbol');
var IS_PURE = require('../internals/is-pure');
var REPLACE = wellKnownSymbol('replace');
var RegExpPrototype = RegExp.prototype;
// `String.prototype.replaceAll` method
// https://github.com/tc39/proposal-string-replace-all
$({ target: 'String', proto: true }, {
replaceAll: function replaceAll(searchValue, replaceValue) {
var O = requireObjectCoercible(this);
var IS_REG_EXP, flags, replacer, string, searchString, template, result, position, index;
if (searchValue != null) {
IS_REG_EXP = isRegExp(searchValue);
if (IS_REG_EXP) {
flags = String(requireObjectCoercible('flags' in RegExpPrototype
? searchValue.flags
: getRegExpFlags.call(searchValue)
));
if (!~flags.indexOf('g')) throw TypeError('`.replaceAll` does not allow non-global regexes');
}
replacer = searchValue[REPLACE];
if (replacer !== undefined) {
return replacer.call(searchValue, O, replaceValue);
} else if (IS_PURE && IS_REG_EXP) {
return String(O).replace(searchValue, replaceValue);
}
}
string = String(O);
searchString = String(searchValue);
if (searchString === '') return replaceAll.call(string, /(?:)/g, replaceValue);
template = string.split(searchString);
if (typeof replaceValue !== 'function') {
return template.join(String(replaceValue));
}
result = template[0];
position = result.length;
for (index = 1; index < template.length; index++) {
result += String(replaceValue(searchString, position, string));
position += searchString.length + template[index].length;
result += template[index];
}
return result;
}
});
core-js-3.6.1/packages/core-js/modules/esnext.symbol.async-dispose.js 0000664 0000000 0000000 00000000325 13600575677 0025623 0 ustar 00root root 0000000 0000000 var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
// `Symbol.asyncDispose` well-known symbol
// https://github.com/tc39/proposal-using-statement
defineWellKnownSymbol('asyncDispose');
core-js-3.6.1/packages/core-js/modules/esnext.symbol.dispose.js 0000664 0000000 0000000 00000000313 13600575677 0024505 0 ustar 00root root 0000000 0000000 var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
// `Symbol.dispose` well-known symbol
// https://github.com/tc39/proposal-using-statement
defineWellKnownSymbol('dispose');
core-js-3.6.1/packages/core-js/modules/esnext.symbol.observable.js 0000664 0000000 0000000 00000000314 13600575677 0025164 0 ustar 00root root 0000000 0000000 var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
// `Symbol.observable` well-known symbol
// https://github.com/tc39/proposal-observable
defineWellKnownSymbol('observable');
core-js-3.6.1/packages/core-js/modules/esnext.symbol.pattern-match.js 0000664 0000000 0000000 00000000326 13600575677 0025612 0 ustar 00root root 0000000 0000000 var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
// `Symbol.patternMatch` well-known symbol
// https://github.com/tc39/proposal-pattern-matching
defineWellKnownSymbol('patternMatch');
core-js-3.6.1/packages/core-js/modules/esnext.symbol.replace-all.js 0000664 0000000 0000000 00000000225 13600575677 0025222 0 ustar 00root root 0000000 0000000 // TODO: remove from `core-js@4`
var defineWellKnownSymbol = require('../internals/define-well-known-symbol');
defineWellKnownSymbol('replaceAll');
core-js-3.6.1/packages/core-js/modules/esnext.weak-map.delete-all.js 0000664 0000000 0000000 00000000707 13600575677 0025253 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var collectionDeleteAll = require('../internals/collection-delete-all');
// `WeakMap.prototype.deleteAll` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'WeakMap', proto: true, real: true, forced: IS_PURE }, {
deleteAll: function deleteAll(/* ...elements */) {
return collectionDeleteAll.apply(this, arguments);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.weak-map.from.js 0000664 0000000 0000000 00000000361 13600575677 0024202 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var from = require('../internals/collection-from');
// `WeakMap.from` method
// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.from
$({ target: 'WeakMap', stat: true }, {
from: from
});
core-js-3.6.1/packages/core-js/modules/esnext.weak-map.of.js 0000664 0000000 0000000 00000000345 13600575677 0023645 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var of = require('../internals/collection-of');
// `WeakMap.of` method
// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.of
$({ target: 'WeakMap', stat: true }, {
of: of
});
core-js-3.6.1/packages/core-js/modules/esnext.weak-map.upsert.js 0000664 0000000 0000000 00000000511 13600575677 0024556 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var $upsert = require('../internals/map-upsert');
// `WeakMap.prototype.upsert` method
// https://github.com/thumbsupep/proposal-upsert
$({ target: 'WeakMap', proto: true, real: true, forced: IS_PURE }, {
upsert: $upsert
});
core-js-3.6.1/packages/core-js/modules/esnext.weak-set.add-all.js 0000664 0000000 0000000 00000000665 13600575677 0024562 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var collectionAddAll = require('../internals/collection-add-all');
// `WeakSet.prototype.addAll` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'WeakSet', proto: true, real: true, forced: IS_PURE }, {
addAll: function addAll(/* ...elements */) {
return collectionAddAll.apply(this, arguments);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.weak-set.delete-all.js 0000664 0000000 0000000 00000000707 13600575677 0025271 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
var IS_PURE = require('../internals/is-pure');
var collectionDeleteAll = require('../internals/collection-delete-all');
// `WeakSet.prototype.deleteAll` method
// https://github.com/tc39/proposal-collection-methods
$({ target: 'WeakSet', proto: true, real: true, forced: IS_PURE }, {
deleteAll: function deleteAll(/* ...elements */) {
return collectionDeleteAll.apply(this, arguments);
}
});
core-js-3.6.1/packages/core-js/modules/esnext.weak-set.from.js 0000664 0000000 0000000 00000000361 13600575677 0024220 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var from = require('../internals/collection-from');
// `WeakSet.from` method
// https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.from
$({ target: 'WeakSet', stat: true }, {
from: from
});
core-js-3.6.1/packages/core-js/modules/esnext.weak-set.of.js 0000664 0000000 0000000 00000000345 13600575677 0023663 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var of = require('../internals/collection-of');
// `WeakSet.of` method
// https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.of
$({ target: 'WeakSet', stat: true }, {
of: of
});
core-js-3.6.1/packages/core-js/modules/web.dom-collections.for-each.js 0000664 0000000 0000000 00000001263 13600575677 0025565 0 ustar 00root root 0000000 0000000 var global = require('../internals/global');
var DOMIterables = require('../internals/dom-iterables');
var forEach = require('../internals/array-for-each');
var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
for (var COLLECTION_NAME in DOMIterables) {
var Collection = global[COLLECTION_NAME];
var CollectionPrototype = Collection && Collection.prototype;
// some Chrome versions have non-configurable methods on DOMTokenList
if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try {
createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach);
} catch (error) {
CollectionPrototype.forEach = forEach;
}
}
core-js-3.6.1/packages/core-js/modules/web.dom-collections.iterator.js 0000664 0000000 0000000 00000003035 13600575677 0025731 0 ustar 00root root 0000000 0000000 var global = require('../internals/global');
var DOMIterables = require('../internals/dom-iterables');
var ArrayIteratorMethods = require('../modules/es.array.iterator');
var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
var wellKnownSymbol = require('../internals/well-known-symbol');
var ITERATOR = wellKnownSymbol('iterator');
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
var ArrayValues = ArrayIteratorMethods.values;
for (var COLLECTION_NAME in DOMIterables) {
var Collection = global[COLLECTION_NAME];
var CollectionPrototype = Collection && Collection.prototype;
if (CollectionPrototype) {
// some Chrome versions have non-configurable methods on DOMTokenList
if (CollectionPrototype[ITERATOR] !== ArrayValues) try {
createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);
} catch (error) {
CollectionPrototype[ITERATOR] = ArrayValues;
}
if (!CollectionPrototype[TO_STRING_TAG]) {
createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);
}
if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {
// some Chrome versions have non-configurable methods on DOMTokenList
if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {
createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
} catch (error) {
CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];
}
}
}
}
core-js-3.6.1/packages/core-js/modules/web.immediate.js 0000664 0000000 0000000 00000001014 13600575677 0022737 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var global = require('../internals/global');
var task = require('../internals/task');
var FORCED = !global.setImmediate || !global.clearImmediate;
// http://w3c.github.io/setImmediate/
$({ global: true, bind: true, enumerable: true, forced: FORCED }, {
// `setImmediate` method
// http://w3c.github.io/setImmediate/#si-setImmediate
setImmediate: task.set,
// `clearImmediate` method
// http://w3c.github.io/setImmediate/#si-clearImmediate
clearImmediate: task.clear
});
core-js-3.6.1/packages/core-js/modules/web.queue-microtask.js 0000664 0000000 0000000 00000001110 13600575677 0024114 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var global = require('../internals/global');
var microtask = require('../internals/microtask');
var classof = require('../internals/classof-raw');
var process = global.process;
var isNode = classof(process) == 'process';
// `queueMicrotask` method
// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-queuemicrotask
$({ global: true, enumerable: true, noTargetGet: true }, {
queueMicrotask: function queueMicrotask(fn) {
var domain = isNode && process.domain;
microtask(domain ? domain.bind(fn) : fn);
}
});
core-js-3.6.1/packages/core-js/modules/web.timers.js 0000664 0000000 0000000 00000002157 13600575677 0022315 0 ustar 00root root 0000000 0000000 var $ = require('../internals/export');
var global = require('../internals/global');
var userAgent = require('../internals/user-agent');
var slice = [].slice;
var MSIE = /MSIE .\./.test(userAgent); // <- dirty ie9- check
var wrap = function (scheduler) {
return function (handler, timeout /* , ...arguments */) {
var boundArgs = arguments.length > 2;
var args = boundArgs ? slice.call(arguments, 2) : undefined;
return scheduler(boundArgs ? function () {
// eslint-disable-next-line no-new-func
(typeof handler == 'function' ? handler : Function(handler)).apply(this, args);
} : handler, timeout);
};
};
// ie9- setTimeout & setInterval additional parameters fix
// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers
$({ global: true, bind: true, forced: MSIE }, {
// `setTimeout` method
// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-settimeout
setTimeout: wrap(global.setTimeout),
// `setInterval` method
// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-setinterval
setInterval: wrap(global.setInterval)
});
core-js-3.6.1/packages/core-js/modules/web.url-search-params.js 0000664 0000000 0000000 00000027134 13600575677 0024342 0 ustar 00root root 0000000 0000000 'use strict';
// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
require('../modules/es.array.iterator');
var $ = require('../internals/export');
var getBuiltIn = require('../internals/get-built-in');
var USE_NATIVE_URL = require('../internals/native-url');
var redefine = require('../internals/redefine');
var redefineAll = require('../internals/redefine-all');
var setToStringTag = require('../internals/set-to-string-tag');
var createIteratorConstructor = require('../internals/create-iterator-constructor');
var InternalStateModule = require('../internals/internal-state');
var anInstance = require('../internals/an-instance');
var hasOwn = require('../internals/has');
var bind = require('../internals/bind-context');
var classof = require('../internals/classof');
var anObject = require('../internals/an-object');
var isObject = require('../internals/is-object');
var create = require('../internals/object-create');
var createPropertyDescriptor = require('../internals/create-property-descriptor');
var getIterator = require('../internals/get-iterator');
var getIteratorMethod = require('../internals/get-iterator-method');
var wellKnownSymbol = require('../internals/well-known-symbol');
var $fetch = getBuiltIn('fetch');
var Headers = getBuiltIn('Headers');
var ITERATOR = wellKnownSymbol('iterator');
var URL_SEARCH_PARAMS = 'URLSearchParams';
var URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator';
var setInternalState = InternalStateModule.set;
var getInternalParamsState = InternalStateModule.getterFor(URL_SEARCH_PARAMS);
var getInternalIteratorState = InternalStateModule.getterFor(URL_SEARCH_PARAMS_ITERATOR);
var plus = /\+/g;
var sequences = Array(4);
var percentSequence = function (bytes) {
return sequences[bytes - 1] || (sequences[bytes - 1] = RegExp('((?:%[\\da-f]{2}){' + bytes + '})', 'gi'));
};
var percentDecode = function (sequence) {
try {
return decodeURIComponent(sequence);
} catch (error) {
return sequence;
}
};
var deserialize = function (it) {
var result = it.replace(plus, ' ');
var bytes = 4;
try {
return decodeURIComponent(result);
} catch (error) {
while (bytes) {
result = result.replace(percentSequence(bytes--), percentDecode);
}
return result;
}
};
var find = /[!'()~]|%20/g;
var replace = {
'!': '%21',
"'": '%27',
'(': '%28',
')': '%29',
'~': '%7E',
'%20': '+'
};
var replacer = function (match) {
return replace[match];
};
var serialize = function (it) {
return encodeURIComponent(it).replace(find, replacer);
};
var parseSearchParams = function (result, query) {
if (query) {
var attributes = query.split('&');
var index = 0;
var attribute, entry;
while (index < attributes.length) {
attribute = attributes[index++];
if (attribute.length) {
entry = attribute.split('=');
result.push({
key: deserialize(entry.shift()),
value: deserialize(entry.join('='))
});
}
}
}
};
var updateSearchParams = function (query) {
this.entries.length = 0;
parseSearchParams(this.entries, query);
};
var validateArgumentsLength = function (passed, required) {
if (passed < required) throw TypeError('Not enough arguments');
};
var URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) {
setInternalState(this, {
type: URL_SEARCH_PARAMS_ITERATOR,
iterator: getIterator(getInternalParamsState(params).entries),
kind: kind
});
}, 'Iterator', function next() {
var state = getInternalIteratorState(this);
var kind = state.kind;
var step = state.iterator.next();
var entry = step.value;
if (!step.done) {
step.value = kind === 'keys' ? entry.key : kind === 'values' ? entry.value : [entry.key, entry.value];
} return step;
});
// `URLSearchParams` constructor
// https://url.spec.whatwg.org/#interface-urlsearchparams
var URLSearchParamsConstructor = function URLSearchParams(/* init */) {
anInstance(this, URLSearchParamsConstructor, URL_SEARCH_PARAMS);
var init = arguments.length > 0 ? arguments[0] : undefined;
var that = this;
var entries = [];
var iteratorMethod, iterator, next, step, entryIterator, entryNext, first, second, key;
setInternalState(that, {
type: URL_SEARCH_PARAMS,
entries: entries,
updateURL: function () { /* empty */ },
updateSearchParams: updateSearchParams
});
if (init !== undefined) {
if (isObject(init)) {
iteratorMethod = getIteratorMethod(init);
if (typeof iteratorMethod === 'function') {
iterator = iteratorMethod.call(init);
next = iterator.next;
while (!(step = next.call(iterator)).done) {
entryIterator = getIterator(anObject(step.value));
entryNext = entryIterator.next;
if (
(first = entryNext.call(entryIterator)).done ||
(second = entryNext.call(entryIterator)).done ||
!entryNext.call(entryIterator).done
) throw TypeError('Expected sequence with length 2');
entries.push({ key: first.value + '', value: second.value + '' });
}
} else for (key in init) if (hasOwn(init, key)) entries.push({ key: key, value: init[key] + '' });
} else {
parseSearchParams(entries, typeof init === 'string' ? init.charAt(0) === '?' ? init.slice(1) : init : init + '');
}
}
};
var URLSearchParamsPrototype = URLSearchParamsConstructor.prototype;
redefineAll(URLSearchParamsPrototype, {
// `URLSearchParams.prototype.appent` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-append
append: function append(name, value) {
validateArgumentsLength(arguments.length, 2);
var state = getInternalParamsState(this);
state.entries.push({ key: name + '', value: value + '' });
state.updateURL();
},
// `URLSearchParams.prototype.delete` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-delete
'delete': function (name) {
validateArgumentsLength(arguments.length, 1);
var state = getInternalParamsState(this);
var entries = state.entries;
var key = name + '';
var index = 0;
while (index < entries.length) {
if (entries[index].key === key) entries.splice(index, 1);
else index++;
}
state.updateURL();
},
// `URLSearchParams.prototype.get` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-get
get: function get(name) {
validateArgumentsLength(arguments.length, 1);
var entries = getInternalParamsState(this).entries;
var key = name + '';
var index = 0;
for (; index < entries.length; index++) {
if (entries[index].key === key) return entries[index].value;
}
return null;
},
// `URLSearchParams.prototype.getAll` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-getall
getAll: function getAll(name) {
validateArgumentsLength(arguments.length, 1);
var entries = getInternalParamsState(this).entries;
var key = name + '';
var result = [];
var index = 0;
for (; index < entries.length; index++) {
if (entries[index].key === key) result.push(entries[index].value);
}
return result;
},
// `URLSearchParams.prototype.has` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-has
has: function has(name) {
validateArgumentsLength(arguments.length, 1);
var entries = getInternalParamsState(this).entries;
var key = name + '';
var index = 0;
while (index < entries.length) {
if (entries[index++].key === key) return true;
}
return false;
},
// `URLSearchParams.prototype.set` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-set
set: function set(name, value) {
validateArgumentsLength(arguments.length, 1);
var state = getInternalParamsState(this);
var entries = state.entries;
var found = false;
var key = name + '';
var val = value + '';
var index = 0;
var entry;
for (; index < entries.length; index++) {
entry = entries[index];
if (entry.key === key) {
if (found) entries.splice(index--, 1);
else {
found = true;
entry.value = val;
}
}
}
if (!found) entries.push({ key: key, value: val });
state.updateURL();
},
// `URLSearchParams.prototype.sort` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-sort
sort: function sort() {
var state = getInternalParamsState(this);
var entries = state.entries;
// Array#sort is not stable in some engines
var slice = entries.slice();
var entry, entriesIndex, sliceIndex;
entries.length = 0;
for (sliceIndex = 0; sliceIndex < slice.length; sliceIndex++) {
entry = slice[sliceIndex];
for (entriesIndex = 0; entriesIndex < sliceIndex; entriesIndex++) {
if (entries[entriesIndex].key > entry.key) {
entries.splice(entriesIndex, 0, entry);
break;
}
}
if (entriesIndex === sliceIndex) entries.push(entry);
}
state.updateURL();
},
// `URLSearchParams.prototype.forEach` method
forEach: function forEach(callback /* , thisArg */) {
var entries = getInternalParamsState(this).entries;
var boundFunction = bind(callback, arguments.length > 1 ? arguments[1] : undefined, 3);
var index = 0;
var entry;
while (index < entries.length) {
entry = entries[index++];
boundFunction(entry.value, entry.key, this);
}
},
// `URLSearchParams.prototype.keys` method
keys: function keys() {
return new URLSearchParamsIterator(this, 'keys');
},
// `URLSearchParams.prototype.values` method
values: function values() {
return new URLSearchParamsIterator(this, 'values');
},
// `URLSearchParams.prototype.entries` method
entries: function entries() {
return new URLSearchParamsIterator(this, 'entries');
}
}, { enumerable: true });
// `URLSearchParams.prototype[@@iterator]` method
redefine(URLSearchParamsPrototype, ITERATOR, URLSearchParamsPrototype.entries);
// `URLSearchParams.prototype.toString` method
// https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior
redefine(URLSearchParamsPrototype, 'toString', function toString() {
var entries = getInternalParamsState(this).entries;
var result = [];
var index = 0;
var entry;
while (index < entries.length) {
entry = entries[index++];
result.push(serialize(entry.key) + '=' + serialize(entry.value));
} return result.join('&');
}, { enumerable: true });
setToStringTag(URLSearchParamsConstructor, URL_SEARCH_PARAMS);
$({ global: true, forced: !USE_NATIVE_URL }, {
URLSearchParams: URLSearchParamsConstructor
});
// Wrap `fetch` for correct work with polyfilled `URLSearchParams`
// https://github.com/zloirock/core-js/issues/674
if (!USE_NATIVE_URL && typeof $fetch == 'function' && typeof Headers == 'function') {
$({ global: true, enumerable: true, forced: true }, {
fetch: function fetch(input /* , init */) {
var args = [input];
var init, body, headers;
if (arguments.length > 1) {
init = arguments[1];
if (isObject(init)) {
body = init.body;
if (classof(body) === URL_SEARCH_PARAMS) {
headers = init.headers ? new Headers(init.headers) : new Headers();
if (!headers.has('content-type')) {
headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
}
init = create(init, {
body: createPropertyDescriptor(0, String(body)),
headers: createPropertyDescriptor(0, headers)
});
}
}
args.push(init);
} return $fetch.apply(this, args);
}
});
}
module.exports = {
URLSearchParams: URLSearchParamsConstructor,
getState: getInternalParamsState
};
core-js-3.6.1/packages/core-js/modules/web.url.js 0000664 0000000 0000000 00000077623 13600575677 0021626 0 ustar 00root root 0000000 0000000 'use strict';
// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
require('../modules/es.string.iterator');
var $ = require('../internals/export');
var DESCRIPTORS = require('../internals/descriptors');
var USE_NATIVE_URL = require('../internals/native-url');
var global = require('../internals/global');
var defineProperties = require('../internals/object-define-properties');
var redefine = require('../internals/redefine');
var anInstance = require('../internals/an-instance');
var has = require('../internals/has');
var assign = require('../internals/object-assign');
var arrayFrom = require('../internals/array-from');
var codeAt = require('../internals/string-multibyte').codeAt;
var toASCII = require('../internals/punycode-to-ascii');
var setToStringTag = require('../internals/set-to-string-tag');
var URLSearchParamsModule = require('../modules/web.url-search-params');
var InternalStateModule = require('../internals/internal-state');
var NativeURL = global.URL;
var URLSearchParams = URLSearchParamsModule.URLSearchParams;
var getInternalSearchParamsState = URLSearchParamsModule.getState;
var setInternalState = InternalStateModule.set;
var getInternalURLState = InternalStateModule.getterFor('URL');
var floor = Math.floor;
var pow = Math.pow;
var INVALID_AUTHORITY = 'Invalid authority';
var INVALID_SCHEME = 'Invalid scheme';
var INVALID_HOST = 'Invalid host';
var INVALID_PORT = 'Invalid port';
var ALPHA = /[A-Za-z]/;
var ALPHANUMERIC = /[\d+\-.A-Za-z]/;
var DIGIT = /\d/;
var HEX_START = /^(0x|0X)/;
var OCT = /^[0-7]+$/;
var DEC = /^\d+$/;
var HEX = /^[\dA-Fa-f]+$/;
// eslint-disable-next-line no-control-regex
var FORBIDDEN_HOST_CODE_POINT = /[\u0000\u0009\u000A\u000D #%/:?@[\\]]/;
// eslint-disable-next-line no-control-regex
var FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT = /[\u0000\u0009\u000A\u000D #/:?@[\\]]/;
// eslint-disable-next-line no-control-regex
var LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE = /^[\u0000-\u001F ]+|[\u0000-\u001F ]+$/g;
// eslint-disable-next-line no-control-regex
var TAB_AND_NEW_LINE = /[\u0009\u000A\u000D]/g;
var EOF;
var parseHost = function (url, input) {
var result, codePoints, index;
if (input.charAt(0) == '[') {
if (input.charAt(input.length - 1) != ']') return INVALID_HOST;
result = parseIPv6(input.slice(1, -1));
if (!result) return INVALID_HOST;
url.host = result;
// opaque host
} else if (!isSpecial(url)) {
if (FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT.test(input)) return INVALID_HOST;
result = '';
codePoints = arrayFrom(input);
for (index = 0; index < codePoints.length; index++) {
result += percentEncode(codePoints[index], C0ControlPercentEncodeSet);
}
url.host = result;
} else {
input = toASCII(input);
if (FORBIDDEN_HOST_CODE_POINT.test(input)) return INVALID_HOST;
result = parseIPv4(input);
if (result === null) return INVALID_HOST;
url.host = result;
}
};
var parseIPv4 = function (input) {
var parts = input.split('.');
var partsLength, numbers, index, part, radix, number, ipv4;
if (parts.length && parts[parts.length - 1] == '') {
parts.pop();
}
partsLength = parts.length;
if (partsLength > 4) return input;
numbers = [];
for (index = 0; index < partsLength; index++) {
part = parts[index];
if (part == '') return input;
radix = 10;
if (part.length > 1 && part.charAt(0) == '0') {
radix = HEX_START.test(part) ? 16 : 8;
part = part.slice(radix == 8 ? 1 : 2);
}
if (part === '') {
number = 0;
} else {
if (!(radix == 10 ? DEC : radix == 8 ? OCT : HEX).test(part)) return input;
number = parseInt(part, radix);
}
numbers.push(number);
}
for (index = 0; index < partsLength; index++) {
number = numbers[index];
if (index == partsLength - 1) {
if (number >= pow(256, 5 - partsLength)) return null;
} else if (number > 255) return null;
}
ipv4 = numbers.pop();
for (index = 0; index < numbers.length; index++) {
ipv4 += numbers[index] * pow(256, 3 - index);
}
return ipv4;
};
// eslint-disable-next-line max-statements
var parseIPv6 = function (input) {
var address = [0, 0, 0, 0, 0, 0, 0, 0];
var pieceIndex = 0;
var compress = null;
var pointer = 0;
var value, length, numbersSeen, ipv4Piece, number, swaps, swap;
var char = function () {
return input.charAt(pointer);
};
if (char() == ':') {
if (input.charAt(1) != ':') return;
pointer += 2;
pieceIndex++;
compress = pieceIndex;
}
while (char()) {
if (pieceIndex == 8) return;
if (char() == ':') {
if (compress !== null) return;
pointer++;
pieceIndex++;
compress = pieceIndex;
continue;
}
value = length = 0;
while (length < 4 && HEX.test(char())) {
value = value * 16 + parseInt(char(), 16);
pointer++;
length++;
}
if (char() == '.') {
if (length == 0) return;
pointer -= length;
if (pieceIndex > 6) return;
numbersSeen = 0;
while (char()) {
ipv4Piece = null;
if (numbersSeen > 0) {
if (char() == '.' && numbersSeen < 4) pointer++;
else return;
}
if (!DIGIT.test(char())) return;
while (DIGIT.test(char())) {
number = parseInt(char(), 10);
if (ipv4Piece === null) ipv4Piece = number;
else if (ipv4Piece == 0) return;
else ipv4Piece = ipv4Piece * 10 + number;
if (ipv4Piece > 255) return;
pointer++;
}
address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece;
numbersSeen++;
if (numbersSeen == 2 || numbersSeen == 4) pieceIndex++;
}
if (numbersSeen != 4) return;
break;
} else if (char() == ':') {
pointer++;
if (!char()) return;
} else if (char()) return;
address[pieceIndex++] = value;
}
if (compress !== null) {
swaps = pieceIndex - compress;
pieceIndex = 7;
while (pieceIndex != 0 && swaps > 0) {
swap = address[pieceIndex];
address[pieceIndex--] = address[compress + swaps - 1];
address[compress + --swaps] = swap;
}
} else if (pieceIndex != 8) return;
return address;
};
var findLongestZeroSequence = function (ipv6) {
var maxIndex = null;
var maxLength = 1;
var currStart = null;
var currLength = 0;
var index = 0;
for (; index < 8; index++) {
if (ipv6[index] !== 0) {
if (currLength > maxLength) {
maxIndex = currStart;
maxLength = currLength;
}
currStart = null;
currLength = 0;
} else {
if (currStart === null) currStart = index;
++currLength;
}
}
if (currLength > maxLength) {
maxIndex = currStart;
maxLength = currLength;
}
return maxIndex;
};
var serializeHost = function (host) {
var result, index, compress, ignore0;
// ipv4
if (typeof host == 'number') {
result = [];
for (index = 0; index < 4; index++) {
result.unshift(host % 256);
host = floor(host / 256);
} return result.join('.');
// ipv6
} else if (typeof host == 'object') {
result = '';
compress = findLongestZeroSequence(host);
for (index = 0; index < 8; index++) {
if (ignore0 && host[index] === 0) continue;
if (ignore0) ignore0 = false;
if (compress === index) {
result += index ? ':' : '::';
ignore0 = true;
} else {
result += host[index].toString(16);
if (index < 7) result += ':';
}
}
return '[' + result + ']';
} return host;
};
var C0ControlPercentEncodeSet = {};
var fragmentPercentEncodeSet = assign({}, C0ControlPercentEncodeSet, {
' ': 1, '"': 1, '<': 1, '>': 1, '`': 1
});
var pathPercentEncodeSet = assign({}, fragmentPercentEncodeSet, {
'#': 1, '?': 1, '{': 1, '}': 1
});
var userinfoPercentEncodeSet = assign({}, pathPercentEncodeSet, {
'/': 1, ':': 1, ';': 1, '=': 1, '@': 1, '[': 1, '\\': 1, ']': 1, '^': 1, '|': 1
});
var percentEncode = function (char, set) {
var code = codeAt(char, 0);
return code > 0x20 && code < 0x7F && !has(set, char) ? char : encodeURIComponent(char);
};
var specialSchemes = {
ftp: 21,
file: null,
http: 80,
https: 443,
ws: 80,
wss: 443
};
var isSpecial = function (url) {
return has(specialSchemes, url.scheme);
};
var includesCredentials = function (url) {
return url.username != '' || url.password != '';
};
var cannotHaveUsernamePasswordPort = function (url) {
return !url.host || url.cannotBeABaseURL || url.scheme == 'file';
};
var isWindowsDriveLetter = function (string, normalized) {
var second;
return string.length == 2 && ALPHA.test(string.charAt(0))
&& ((second = string.charAt(1)) == ':' || (!normalized && second == '|'));
};
var startsWithWindowsDriveLetter = function (string) {
var third;
return string.length > 1 && isWindowsDriveLetter(string.slice(0, 2)) && (
string.length == 2 ||
((third = string.charAt(2)) === '/' || third === '\\' || third === '?' || third === '#')
);
};
var shortenURLsPath = function (url) {
var path = url.path;
var pathSize = path.length;
if (pathSize && (url.scheme != 'file' || pathSize != 1 || !isWindowsDriveLetter(path[0], true))) {
path.pop();
}
};
var isSingleDot = function (segment) {
return segment === '.' || segment.toLowerCase() === '%2e';
};
var isDoubleDot = function (segment) {
segment = segment.toLowerCase();
return segment === '..' || segment === '%2e.' || segment === '.%2e' || segment === '%2e%2e';
};
// States:
var SCHEME_START = {};
var SCHEME = {};
var NO_SCHEME = {};
var SPECIAL_RELATIVE_OR_AUTHORITY = {};
var PATH_OR_AUTHORITY = {};
var RELATIVE = {};
var RELATIVE_SLASH = {};
var SPECIAL_AUTHORITY_SLASHES = {};
var SPECIAL_AUTHORITY_IGNORE_SLASHES = {};
var AUTHORITY = {};
var HOST = {};
var HOSTNAME = {};
var PORT = {};
var FILE = {};
var FILE_SLASH = {};
var FILE_HOST = {};
var PATH_START = {};
var PATH = {};
var CANNOT_BE_A_BASE_URL_PATH = {};
var QUERY = {};
var FRAGMENT = {};
// eslint-disable-next-line max-statements
var parseURL = function (url, input, stateOverride, base) {
var state = stateOverride || SCHEME_START;
var pointer = 0;
var buffer = '';
var seenAt = false;
var seenBracket = false;
var seenPasswordToken = false;
var codePoints, char, bufferCodePoints, failure;
if (!stateOverride) {
url.scheme = '';
url.username = '';
url.password = '';
url.host = null;
url.port = null;
url.path = [];
url.query = null;
url.fragment = null;
url.cannotBeABaseURL = false;
input = input.replace(LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE, '');
}
input = input.replace(TAB_AND_NEW_LINE, '');
codePoints = arrayFrom(input);
while (pointer <= codePoints.length) {
char = codePoints[pointer];
switch (state) {
case SCHEME_START:
if (char && ALPHA.test(char)) {
buffer += char.toLowerCase();
state = SCHEME;
} else if (!stateOverride) {
state = NO_SCHEME;
continue;
} else return INVALID_SCHEME;
break;
case SCHEME:
if (char && (ALPHANUMERIC.test(char) || char == '+' || char == '-' || char == '.')) {
buffer += char.toLowerCase();
} else if (char == ':') {
if (stateOverride && (
(isSpecial(url) != has(specialSchemes, buffer)) ||
(buffer == 'file' && (includesCredentials(url) || url.port !== null)) ||
(url.scheme == 'file' && !url.host)
)) return;
url.scheme = buffer;
if (stateOverride) {
if (isSpecial(url) && specialSchemes[url.scheme] == url.port) url.port = null;
return;
}
buffer = '';
if (url.scheme == 'file') {
state = FILE;
} else if (isSpecial(url) && base && base.scheme == url.scheme) {
state = SPECIAL_RELATIVE_OR_AUTHORITY;
} else if (isSpecial(url)) {
state = SPECIAL_AUTHORITY_SLASHES;
} else if (codePoints[pointer + 1] == '/') {
state = PATH_OR_AUTHORITY;
pointer++;
} else {
url.cannotBeABaseURL = true;
url.path.push('');
state = CANNOT_BE_A_BASE_URL_PATH;
}
} else if (!stateOverride) {
buffer = '';
state = NO_SCHEME;
pointer = 0;
continue;
} else return INVALID_SCHEME;
break;
case NO_SCHEME:
if (!base || (base.cannotBeABaseURL && char != '#')) return INVALID_SCHEME;
if (base.cannotBeABaseURL && char == '#') {
url.scheme = base.scheme;
url.path = base.path.slice();
url.query = base.query;
url.fragment = '';
url.cannotBeABaseURL = true;
state = FRAGMENT;
break;
}
state = base.scheme == 'file' ? FILE : RELATIVE;
continue;
case SPECIAL_RELATIVE_OR_AUTHORITY:
if (char == '/' && codePoints[pointer + 1] == '/') {
state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
pointer++;
} else {
state = RELATIVE;
continue;
} break;
case PATH_OR_AUTHORITY:
if (char == '/') {
state = AUTHORITY;
break;
} else {
state = PATH;
continue;
}
case RELATIVE:
url.scheme = base.scheme;
if (char == EOF) {
url.username = base.username;
url.password = base.password;
url.host = base.host;
url.port = base.port;
url.path = base.path.slice();
url.query = base.query;
} else if (char == '/' || (char == '\\' && isSpecial(url))) {
state = RELATIVE_SLASH;
} else if (char == '?') {
url.username = base.username;
url.password = base.password;
url.host = base.host;
url.port = base.port;
url.path = base.path.slice();
url.query = '';
state = QUERY;
} else if (char == '#') {
url.username = base.username;
url.password = base.password;
url.host = base.host;
url.port = base.port;
url.path = base.path.slice();
url.query = base.query;
url.fragment = '';
state = FRAGMENT;
} else {
url.username = base.username;
url.password = base.password;
url.host = base.host;
url.port = base.port;
url.path = base.path.slice();
url.path.pop();
state = PATH;
continue;
} break;
case RELATIVE_SLASH:
if (isSpecial(url) && (char == '/' || char == '\\')) {
state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
} else if (char == '/') {
state = AUTHORITY;
} else {
url.username = base.username;
url.password = base.password;
url.host = base.host;
url.port = base.port;
state = PATH;
continue;
} break;
case SPECIAL_AUTHORITY_SLASHES:
state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
if (char != '/' || buffer.charAt(pointer + 1) != '/') continue;
pointer++;
break;
case SPECIAL_AUTHORITY_IGNORE_SLASHES:
if (char != '/' && char != '\\') {
state = AUTHORITY;
continue;
} break;
case AUTHORITY:
if (char == '@') {
if (seenAt) buffer = '%40' + buffer;
seenAt = true;
bufferCodePoints = arrayFrom(buffer);
for (var i = 0; i < bufferCodePoints.length; i++) {
var codePoint = bufferCodePoints[i];
if (codePoint == ':' && !seenPasswordToken) {
seenPasswordToken = true;
continue;
}
var encodedCodePoints = percentEncode(codePoint, userinfoPercentEncodeSet);
if (seenPasswordToken) url.password += encodedCodePoints;
else url.username += encodedCodePoints;
}
buffer = '';
} else if (
char == EOF || char == '/' || char == '?' || char == '#' ||
(char == '\\' && isSpecial(url))
) {
if (seenAt && buffer == '') return INVALID_AUTHORITY;
pointer -= arrayFrom(buffer).length + 1;
buffer = '';
state = HOST;
} else buffer += char;
break;
case HOST:
case HOSTNAME:
if (stateOverride && url.scheme == 'file') {
state = FILE_HOST;
continue;
} else if (char == ':' && !seenBracket) {
if (buffer == '') return INVALID_HOST;
failure = parseHost(url, buffer);
if (failure) return failure;
buffer = '';
state = PORT;
if (stateOverride == HOSTNAME) return;
} else if (
char == EOF || char == '/' || char == '?' || char == '#' ||
(char == '\\' && isSpecial(url))
) {
if (isSpecial(url) && buffer == '') return INVALID_HOST;
if (stateOverride && buffer == '' && (includesCredentials(url) || url.port !== null)) return;
failure = parseHost(url, buffer);
if (failure) return failure;
buffer = '';
state = PATH_START;
if (stateOverride) return;
continue;
} else {
if (char == '[') seenBracket = true;
else if (char == ']') seenBracket = false;
buffer += char;
} break;
case PORT:
if (DIGIT.test(char)) {
buffer += char;
} else if (
char == EOF || char == '/' || char == '?' || char == '#' ||
(char == '\\' && isSpecial(url)) ||
stateOverride
) {
if (buffer != '') {
var port = parseInt(buffer, 10);
if (port > 0xFFFF) return INVALID_PORT;
url.port = (isSpecial(url) && port === specialSchemes[url.scheme]) ? null : port;
buffer = '';
}
if (stateOverride) return;
state = PATH_START;
continue;
} else return INVALID_PORT;
break;
case FILE:
url.scheme = 'file';
if (char == '/' || char == '\\') state = FILE_SLASH;
else if (base && base.scheme == 'file') {
if (char == EOF) {
url.host = base.host;
url.path = base.path.slice();
url.query = base.query;
} else if (char == '?') {
url.host = base.host;
url.path = base.path.slice();
url.query = '';
state = QUERY;
} else if (char == '#') {
url.host = base.host;
url.path = base.path.slice();
url.query = base.query;
url.fragment = '';
state = FRAGMENT;
} else {
if (!startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) {
url.host = base.host;
url.path = base.path.slice();
shortenURLsPath(url);
}
state = PATH;
continue;
}
} else {
state = PATH;
continue;
} break;
case FILE_SLASH:
if (char == '/' || char == '\\') {
state = FILE_HOST;
break;
}
if (base && base.scheme == 'file' && !startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) {
if (isWindowsDriveLetter(base.path[0], true)) url.path.push(base.path[0]);
else url.host = base.host;
}
state = PATH;
continue;
case FILE_HOST:
if (char == EOF || char == '/' || char == '\\' || char == '?' || char == '#') {
if (!stateOverride && isWindowsDriveLetter(buffer)) {
state = PATH;
} else if (buffer == '') {
url.host = '';
if (stateOverride) return;
state = PATH_START;
} else {
failure = parseHost(url, buffer);
if (failure) return failure;
if (url.host == 'localhost') url.host = '';
if (stateOverride) return;
buffer = '';
state = PATH_START;
} continue;
} else buffer += char;
break;
case PATH_START:
if (isSpecial(url)) {
state = PATH;
if (char != '/' && char != '\\') continue;
} else if (!stateOverride && char == '?') {
url.query = '';
state = QUERY;
} else if (!stateOverride && char == '#') {
url.fragment = '';
state = FRAGMENT;
} else if (char != EOF) {
state = PATH;
if (char != '/') continue;
} break;
case PATH:
if (
char == EOF || char == '/' ||
(char == '\\' && isSpecial(url)) ||
(!stateOverride && (char == '?' || char == '#'))
) {
if (isDoubleDot(buffer)) {
shortenURLsPath(url);
if (char != '/' && !(char == '\\' && isSpecial(url))) {
url.path.push('');
}
} else if (isSingleDot(buffer)) {
if (char != '/' && !(char == '\\' && isSpecial(url))) {
url.path.push('');
}
} else {
if (url.scheme == 'file' && !url.path.length && isWindowsDriveLetter(buffer)) {
if (url.host) url.host = '';
buffer = buffer.charAt(0) + ':'; // normalize windows drive letter
}
url.path.push(buffer);
}
buffer = '';
if (url.scheme == 'file' && (char == EOF || char == '?' || char == '#')) {
while (url.path.length > 1 && url.path[0] === '') {
url.path.shift();
}
}
if (char == '?') {
url.query = '';
state = QUERY;
} else if (char == '#') {
url.fragment = '';
state = FRAGMENT;
}
} else {
buffer += percentEncode(char, pathPercentEncodeSet);
} break;
case CANNOT_BE_A_BASE_URL_PATH:
if (char == '?') {
url.query = '';
state = QUERY;
} else if (char == '#') {
url.fragment = '';
state = FRAGMENT;
} else if (char != EOF) {
url.path[0] += percentEncode(char, C0ControlPercentEncodeSet);
} break;
case QUERY:
if (!stateOverride && char == '#') {
url.fragment = '';
state = FRAGMENT;
} else if (char != EOF) {
if (char == "'" && isSpecial(url)) url.query += '%27';
else if (char == '#') url.query += '%23';
else url.query += percentEncode(char, C0ControlPercentEncodeSet);
} break;
case FRAGMENT:
if (char != EOF) url.fragment += percentEncode(char, fragmentPercentEncodeSet);
break;
}
pointer++;
}
};
// `URL` constructor
// https://url.spec.whatwg.org/#url-class
var URLConstructor = function URL(url /* , base */) {
var that = anInstance(this, URLConstructor, 'URL');
var base = arguments.length > 1 ? arguments[1] : undefined;
var urlString = String(url);
var state = setInternalState(that, { type: 'URL' });
var baseState, failure;
if (base !== undefined) {
if (base instanceof URLConstructor) baseState = getInternalURLState(base);
else {
failure = parseURL(baseState = {}, String(base));
if (failure) throw TypeError(failure);
}
}
failure = parseURL(state, urlString, null, baseState);
if (failure) throw TypeError(failure);
var searchParams = state.searchParams = new URLSearchParams();
var searchParamsState = getInternalSearchParamsState(searchParams);
searchParamsState.updateSearchParams(state.query);
searchParamsState.updateURL = function () {
state.query = String(searchParams) || null;
};
if (!DESCRIPTORS) {
that.href = serializeURL.call(that);
that.origin = getOrigin.call(that);
that.protocol = getProtocol.call(that);
that.username = getUsername.call(that);
that.password = getPassword.call(that);
that.host = getHost.call(that);
that.hostname = getHostname.call(that);
that.port = getPort.call(that);
that.pathname = getPathname.call(that);
that.search = getSearch.call(that);
that.searchParams = getSearchParams.call(that);
that.hash = getHash.call(that);
}
};
var URLPrototype = URLConstructor.prototype;
var serializeURL = function () {
var url = getInternalURLState(this);
var scheme = url.scheme;
var username = url.username;
var password = url.password;
var host = url.host;
var port = url.port;
var path = url.path;
var query = url.query;
var fragment = url.fragment;
var output = scheme + ':';
if (host !== null) {
output += '//';
if (includesCredentials(url)) {
output += username + (password ? ':' + password : '') + '@';
}
output += serializeHost(host);
if (port !== null) output += ':' + port;
} else if (scheme == 'file') output += '//';
output += url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : '';
if (query !== null) output += '?' + query;
if (fragment !== null) output += '#' + fragment;
return output;
};
var getOrigin = function () {
var url = getInternalURLState(this);
var scheme = url.scheme;
var port = url.port;
if (scheme == 'blob') try {
return new URL(scheme.path[0]).origin;
} catch (error) {
return 'null';
}
if (scheme == 'file' || !isSpecial(url)) return 'null';
return scheme + '://' + serializeHost(url.host) + (port !== null ? ':' + port : '');
};
var getProtocol = function () {
return getInternalURLState(this).scheme + ':';
};
var getUsername = function () {
return getInternalURLState(this).username;
};
var getPassword = function () {
return getInternalURLState(this).password;
};
var getHost = function () {
var url = getInternalURLState(this);
var host = url.host;
var port = url.port;
return host === null ? ''
: port === null ? serializeHost(host)
: serializeHost(host) + ':' + port;
};
var getHostname = function () {
var host = getInternalURLState(this).host;
return host === null ? '' : serializeHost(host);
};
var getPort = function () {
var port = getInternalURLState(this).port;
return port === null ? '' : String(port);
};
var getPathname = function () {
var url = getInternalURLState(this);
var path = url.path;
return url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : '';
};
var getSearch = function () {
var query = getInternalURLState(this).query;
return query ? '?' + query : '';
};
var getSearchParams = function () {
return getInternalURLState(this).searchParams;
};
var getHash = function () {
var fragment = getInternalURLState(this).fragment;
return fragment ? '#' + fragment : '';
};
var accessorDescriptor = function (getter, setter) {
return { get: getter, set: setter, configurable: true, enumerable: true };
};
if (DESCRIPTORS) {
defineProperties(URLPrototype, {
// `URL.prototype.href` accessors pair
// https://url.spec.whatwg.org/#dom-url-href
href: accessorDescriptor(serializeURL, function (href) {
var url = getInternalURLState(this);
var urlString = String(href);
var failure = parseURL(url, urlString);
if (failure) throw TypeError(failure);
getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query);
}),
// `URL.prototype.origin` getter
// https://url.spec.whatwg.org/#dom-url-origin
origin: accessorDescriptor(getOrigin),
// `URL.prototype.protocol` accessors pair
// https://url.spec.whatwg.org/#dom-url-protocol
protocol: accessorDescriptor(getProtocol, function (protocol) {
var url = getInternalURLState(this);
parseURL(url, String(protocol) + ':', SCHEME_START);
}),
// `URL.prototype.username` accessors pair
// https://url.spec.whatwg.org/#dom-url-username
username: accessorDescriptor(getUsername, function (username) {
var url = getInternalURLState(this);
var codePoints = arrayFrom(String(username));
if (cannotHaveUsernamePasswordPort(url)) return;
url.username = '';
for (var i = 0; i < codePoints.length; i++) {
url.username += percentEncode(codePoints[i], userinfoPercentEncodeSet);
}
}),
// `URL.prototype.password` accessors pair
// https://url.spec.whatwg.org/#dom-url-password
password: accessorDescriptor(getPassword, function (password) {
var url = getInternalURLState(this);
var codePoints = arrayFrom(String(password));
if (cannotHaveUsernamePasswordPort(url)) return;
url.password = '';
for (var i = 0; i < codePoints.length; i++) {
url.password += percentEncode(codePoints[i], userinfoPercentEncodeSet);
}
}),
// `URL.prototype.host` accessors pair
// https://url.spec.whatwg.org/#dom-url-host
host: accessorDescriptor(getHost, function (host) {
var url = getInternalURLState(this);
if (url.cannotBeABaseURL) return;
parseURL(url, String(host), HOST);
}),
// `URL.prototype.hostname` accessors pair
// https://url.spec.whatwg.org/#dom-url-hostname
hostname: accessorDescriptor(getHostname, function (hostname) {
var url = getInternalURLState(this);
if (url.cannotBeABaseURL) return;
parseURL(url, String(hostname), HOSTNAME);
}),
// `URL.prototype.port` accessors pair
// https://url.spec.whatwg.org/#dom-url-port
port: accessorDescriptor(getPort, function (port) {
var url = getInternalURLState(this);
if (cannotHaveUsernamePasswordPort(url)) return;
port = String(port);
if (port == '') url.port = null;
else parseURL(url, port, PORT);
}),
// `URL.prototype.pathname` accessors pair
// https://url.spec.whatwg.org/#dom-url-pathname
pathname: accessorDescriptor(getPathname, function (pathname) {
var url = getInternalURLState(this);
if (url.cannotBeABaseURL) return;
url.path = [];
parseURL(url, pathname + '', PATH_START);
}),
// `URL.prototype.search` accessors pair
// https://url.spec.whatwg.org/#dom-url-search
search: accessorDescriptor(getSearch, function (search) {
var url = getInternalURLState(this);
search = String(search);
if (search == '') {
url.query = null;
} else {
if ('?' == search.charAt(0)) search = search.slice(1);
url.query = '';
parseURL(url, search, QUERY);
}
getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query);
}),
// `URL.prototype.searchParams` getter
// https://url.spec.whatwg.org/#dom-url-searchparams
searchParams: accessorDescriptor(getSearchParams),
// `URL.prototype.hash` accessors pair
// https://url.spec.whatwg.org/#dom-url-hash
hash: accessorDescriptor(getHash, function (hash) {
var url = getInternalURLState(this);
hash = String(hash);
if (hash == '') {
url.fragment = null;
return;
}
if ('#' == hash.charAt(0)) hash = hash.slice(1);
url.fragment = '';
parseURL(url, hash, FRAGMENT);
})
});
}
// `URL.prototype.toJSON` method
// https://url.spec.whatwg.org/#dom-url-tojson
redefine(URLPrototype, 'toJSON', function toJSON() {
return serializeURL.call(this);
}, { enumerable: true });
// `URL.prototype.toString` method
// https://url.spec.whatwg.org/#URL-stringification-behavior
redefine(URLPrototype, 'toString', function toString() {
return serializeURL.call(this);
}, { enumerable: true });
if (NativeURL) {
var nativeCreateObjectURL = NativeURL.createObjectURL;
var nativeRevokeObjectURL = NativeURL.revokeObjectURL;
// `URL.createObjectURL` method
// https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL
// eslint-disable-next-line no-unused-vars
if (nativeCreateObjectURL) redefine(URLConstructor, 'createObjectURL', function createObjectURL(blob) {
return nativeCreateObjectURL.apply(NativeURL, arguments);
});
// `URL.revokeObjectURL` method
// https://developer.mozilla.org/en-US/docs/Web/API/URL/revokeObjectURL
// eslint-disable-next-line no-unused-vars
if (nativeRevokeObjectURL) redefine(URLConstructor, 'revokeObjectURL', function revokeObjectURL(url) {
return nativeRevokeObjectURL.apply(NativeURL, arguments);
});
}
setToStringTag(URLConstructor, 'URL');
$({ global: true, forced: !USE_NATIVE_URL, sham: !DESCRIPTORS }, {
URL: URLConstructor
});
core-js-3.6.1/packages/core-js/modules/web.url.to-json.js 0000664 0000000 0000000 00000000421 13600575677 0023174 0 ustar 00root root 0000000 0000000 'use strict';
var $ = require('../internals/export');
// `URL.prototype.toJSON` method
// https://url.spec.whatwg.org/#dom-url-tojson
$({ target: 'URL', proto: true, enumerable: true }, {
toJSON: function toJSON() {
return URL.prototype.toString.call(this);
}
});
core-js-3.6.1/packages/core-js/package.json 0000664 0000000 0000000 00000002025 13600575677 0020510 0 ustar 00root root 0000000 0000000 {
"name": "core-js",
"description": "Standard library",
"version": "3.6.1",
"repository": {
"type": "git",
"url": "https://github.com/zloirock/core-js.git"
},
"main": "index.js",
"funding": {
"type": "opencollective",
"url": "https://opencollective.com/core-js"
},
"license": "MIT",
"keywords": [
"ES3",
"ES5",
"ES6",
"ES7",
"ES2015",
"ES2016",
"ES2017",
"ES2018",
"ES2019",
"ES2020",
"ECMAScript 3",
"ECMAScript 5",
"ECMAScript 6",
"ECMAScript 7",
"ECMAScript 2015",
"ECMAScript 2016",
"ECMAScript 2017",
"ECMAScript 2018",
"ECMAScript 2019",
"ECMAScript 2020",
"Harmony",
"Strawman",
"Map",
"Set",
"WeakMap",
"WeakSet",
"Promise",
"Observable",
"Symbol",
"TypedArray",
"URL",
"URLSearchParams",
"queueMicrotask",
"setImmediate",
"polyfill",
"ponyfill",
"shim"
],
"scripts": {
"postinstall": "node -e \"try{require('./postinstall')}catch(e){}\""
}
}
core-js-3.6.1/packages/core-js/postinstall.js 0000664 0000000 0000000 00000003765 13600575677 0021150 0 ustar 00root root 0000000 0000000 /* eslint-disable max-len */
var fs = require('fs');
var os = require('os');
var path = require('path');
var env = process.env;
var ADBLOCK = is(env.ADBLOCK);
var COLOR = is(env.npm_config_color);
var DISABLE_OPENCOLLECTIVE = is(env.DISABLE_OPENCOLLECTIVE);
var SILENT = ['silent', 'error', 'warn'].indexOf(env.npm_config_loglevel) !== -1;
var MINUTE = 60 * 1000;
// you could add a PR with an env variable for your CI detection
var CI = [
'BUILD_NUMBER',
'CI',
'CONTINUOUS_INTEGRATION',
'RUN_ID'
].some(function (it) { return is(env[it]); });
var BANNER = '\u001B[96mThank you for using core-js (\u001B[94m https://github.com/zloirock/core-js \u001B[96m) for polyfilling JavaScript standard library!\u001B[0m\n\n' +
'\u001B[96mThe project needs your help! Please consider supporting of core-js on Open Collective or Patreon: \u001B[0m\n' +
'\u001B[96m>\u001B[94m https://opencollective.com/core-js \u001B[0m\n' +
'\u001B[96m>\u001B[94m https://www.patreon.com/zloirock \u001B[0m\n\n' +
'\u001B[96mAlso, the author of core-js (\u001B[94m https://github.com/zloirock \u001B[96m) is looking for a good job -)\u001B[0m\n';
function is(it) {
return !!it && it !== '0' && it !== 'false';
}
function isBannerRequired() {
if (ADBLOCK || CI || DISABLE_OPENCOLLECTIVE || SILENT) return false;
var file = path.join(os.tmpdir(), 'core-js-banners');
var banners = [];
try {
var DELTA = Date.now() - fs.statSync(file).mtime;
if (DELTA >= 0 && DELTA < MINUTE * 3) {
banners = JSON.parse(fs.readFileSync(file, 'utf8'));
if (banners.indexOf(BANNER) !== -1) return false;
}
} catch (error) {
banners = [];
}
try {
banners.push(BANNER);
fs.writeFileSync(file, JSON.stringify(banners), 'utf8');
} catch (error) { /* empty */ }
return true;
}
function showBanner() {
// eslint-disable-next-line no-console,no-control-regex
console.log(COLOR ? BANNER : BANNER.replace(/\u001B\[\d+m/g, ''));
}
if (isBannerRequired()) showBanner();
core-js-3.6.1/packages/core-js/proposals/ 0000775 0000000 0000000 00000000000 13600575677 0020245 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/proposals/array-is-template-object.js 0000664 0000000 0000000 00000000067 13600575677 0025412 0 ustar 00root root 0000000 0000000 require('../modules/esnext.array.is-template-object');
core-js-3.6.1/packages/core-js/proposals/array-last.js 0000664 0000000 0000000 00000000135 13600575677 0022661 0 ustar 00root root 0000000 0000000 require('../modules/esnext.array.last-index');
require('../modules/esnext.array.last-item');
core-js-3.6.1/packages/core-js/proposals/collection-methods.js 0000664 0000000 0000000 00000002160 13600575677 0024376 0 ustar 00root root 0000000 0000000 require('../modules/esnext.map.group-by');
require('../modules/esnext.map.key-by');
require('../modules/esnext.map.delete-all');
require('../modules/esnext.map.every');
require('../modules/esnext.map.filter');
require('../modules/esnext.map.find');
require('../modules/esnext.map.find-key');
require('../modules/esnext.map.includes');
require('../modules/esnext.map.key-of');
require('../modules/esnext.map.map-keys');
require('../modules/esnext.map.map-values');
require('../modules/esnext.map.merge');
require('../modules/esnext.map.reduce');
require('../modules/esnext.map.some');
require('../modules/esnext.map.update');
require('../modules/esnext.set.add-all');
require('../modules/esnext.set.delete-all');
require('../modules/esnext.set.every');
require('../modules/esnext.set.filter');
require('../modules/esnext.set.find');
require('../modules/esnext.set.join');
require('../modules/esnext.set.map');
require('../modules/esnext.set.reduce');
require('../modules/esnext.set.some');
require('../modules/esnext.weak-map.delete-all');
require('../modules/esnext.weak-set.add-all');
require('../modules/esnext.weak-set.delete-all');
core-js-3.6.1/packages/core-js/proposals/collection-of-from.js 0000664 0000000 0000000 00000000504 13600575677 0024300 0 ustar 00root root 0000000 0000000 require('../modules/esnext.map.from');
require('../modules/esnext.map.of');
require('../modules/esnext.set.from');
require('../modules/esnext.set.of');
require('../modules/esnext.weak-map.from');
require('../modules/esnext.weak-map.of');
require('../modules/esnext.weak-set.from');
require('../modules/esnext.weak-set.of');
core-js-3.6.1/packages/core-js/proposals/efficient-64-bit-arithmetic.js 0000664 0000000 0000000 00000000244 13600575677 0025671 0 ustar 00root root 0000000 0000000 require('../modules/esnext.math.iaddh');
require('../modules/esnext.math.isubh');
require('../modules/esnext.math.imulh');
require('../modules/esnext.math.umulh');
core-js-3.6.1/packages/core-js/proposals/global-this.js 0000664 0000000 0000000 00000000161 13600575677 0023006 0 ustar 00root root 0000000 0000000 require('../modules/esnext.global-this');
var global = require('../internals/global');
module.exports = global;
core-js-3.6.1/packages/core-js/proposals/index.js 0000664 0000000 0000000 00000000025 13600575677 0021707 0 ustar 00root root 0000000 0000000 require('../stage');
core-js-3.6.1/packages/core-js/proposals/iterator-helpers.js 0000664 0000000 0000000 00000002552 13600575677 0024100 0 ustar 00root root 0000000 0000000 require('../modules/esnext.async-iterator.constructor');
require('../modules/esnext.async-iterator.as-indexed-pairs');
require('../modules/esnext.async-iterator.drop');
require('../modules/esnext.async-iterator.every');
require('../modules/esnext.async-iterator.filter');
require('../modules/esnext.async-iterator.find');
require('../modules/esnext.async-iterator.flat-map');
require('../modules/esnext.async-iterator.for-each');
require('../modules/esnext.async-iterator.from');
require('../modules/esnext.async-iterator.map');
require('../modules/esnext.async-iterator.reduce');
require('../modules/esnext.async-iterator.some');
require('../modules/esnext.async-iterator.take');
require('../modules/esnext.async-iterator.to-array');
require('../modules/esnext.iterator.constructor');
require('../modules/esnext.iterator.as-indexed-pairs');
require('../modules/esnext.iterator.drop');
require('../modules/esnext.iterator.every');
require('../modules/esnext.iterator.filter');
require('../modules/esnext.iterator.find');
require('../modules/esnext.iterator.flat-map');
require('../modules/esnext.iterator.for-each');
require('../modules/esnext.iterator.from');
require('../modules/esnext.iterator.map');
require('../modules/esnext.iterator.reduce');
require('../modules/esnext.iterator.some');
require('../modules/esnext.iterator.take');
require('../modules/esnext.iterator.to-array');
core-js-3.6.1/packages/core-js/proposals/keys-composition.js 0000664 0000000 0000000 00000000133 13600575677 0024114 0 ustar 00root root 0000000 0000000 require('../modules/esnext.composite-key');
require('../modules/esnext.composite-symbol');
core-js-3.6.1/packages/core-js/proposals/map-update-or-insert.js 0000664 0000000 0000000 00000000072 13600575677 0024557 0 ustar 00root root 0000000 0000000 // TODO: remove from `core-js@4`
require('./map-upsert');
core-js-3.6.1/packages/core-js/proposals/map-upsert.js 0000664 0000000 0000000 00000000334 13600575677 0022700 0 ustar 00root root 0000000 0000000 // https://github.com/thumbsupep/proposal-upsert
// TODO: remove from `core-js@4`
require('../modules/esnext.map.update-or-insert');
require('../modules/esnext.map.upsert');
require('../modules/esnext.weak-map.upsert');
core-js-3.6.1/packages/core-js/proposals/math-extensions.js 0000664 0000000 0000000 00000000460 13600575677 0023731 0 ustar 00root root 0000000 0000000 require('../modules/esnext.math.clamp');
require('../modules/esnext.math.deg-per-rad');
require('../modules/esnext.math.degrees');
require('../modules/esnext.math.fscale');
require('../modules/esnext.math.rad-per-deg');
require('../modules/esnext.math.radians');
require('../modules/esnext.math.scale');
core-js-3.6.1/packages/core-js/proposals/math-signbit.js 0000664 0000000 0000000 00000000053 13600575677 0023167 0 ustar 00root root 0000000 0000000 require('../modules/esnext.math.signbit');
core-js-3.6.1/packages/core-js/proposals/number-from-string.js 0000664 0000000 0000000 00000000061 13600575677 0024335 0 ustar 00root root 0000000 0000000 require('../modules/esnext.number.from-string');
core-js-3.6.1/packages/core-js/proposals/object-iteration.js 0000664 0000000 0000000 00000000233 13600575677 0024043 0 ustar 00root root 0000000 0000000 require('../modules/esnext.object.iterate-entries');
require('../modules/esnext.object.iterate-keys');
require('../modules/esnext.object.iterate-values');
core-js-3.6.1/packages/core-js/proposals/observable.js 0000664 0000000 0000000 00000000131 13600575677 0022722 0 ustar 00root root 0000000 0000000 require('../modules/esnext.observable');
require('../modules/esnext.symbol.observable');
core-js-3.6.1/packages/core-js/proposals/pattern-matching.js 0000664 0000000 0000000 00000000063 13600575677 0024047 0 ustar 00root root 0000000 0000000 require('../modules/esnext.symbol.pattern-match');
core-js-3.6.1/packages/core-js/proposals/promise-all-settled.js 0000664 0000000 0000000 00000000123 13600575677 0024465 0 ustar 00root root 0000000 0000000 // TODO: Remove from `core-js@4`
require('../modules/esnext.promise.all-settled');
core-js-3.6.1/packages/core-js/proposals/promise-any.js 0000664 0000000 0000000 00000000130 13600575677 0023040 0 ustar 00root root 0000000 0000000 require('../modules/esnext.aggregate-error');
require('../modules/esnext.promise.any');
core-js-3.6.1/packages/core-js/proposals/promise-try.js 0000664 0000000 0000000 00000000052 13600575677 0023072 0 ustar 00root root 0000000 0000000 require('../modules/esnext.promise.try');
core-js-3.6.1/packages/core-js/proposals/reflect-metadata.js 0000664 0000000 0000000 00000000743 13600575677 0024011 0 ustar 00root root 0000000 0000000 require('../modules/esnext.reflect.define-metadata');
require('../modules/esnext.reflect.delete-metadata');
require('../modules/esnext.reflect.get-metadata');
require('../modules/esnext.reflect.get-metadata-keys');
require('../modules/esnext.reflect.get-own-metadata');
require('../modules/esnext.reflect.get-own-metadata-keys');
require('../modules/esnext.reflect.has-metadata');
require('../modules/esnext.reflect.has-own-metadata');
require('../modules/esnext.reflect.metadata');
core-js-3.6.1/packages/core-js/proposals/seeded-random.js 0000664 0000000 0000000 00000000057 13600575677 0023314 0 ustar 00root root 0000000 0000000 require('../modules/esnext.math.seeded-prng');
core-js-3.6.1/packages/core-js/proposals/set-methods.js 0000664 0000000 0000000 00000000516 13600575677 0023041 0 ustar 00root root 0000000 0000000 require('../modules/esnext.set.difference');
require('../modules/esnext.set.intersection');
require('../modules/esnext.set.is-disjoint-from');
require('../modules/esnext.set.is-subset-of');
require('../modules/esnext.set.is-superset-of');
require('../modules/esnext.set.union');
require('../modules/esnext.set.symmetric-difference');
core-js-3.6.1/packages/core-js/proposals/string-at.js 0000664 0000000 0000000 00000000050 13600575677 0022506 0 ustar 00root root 0000000 0000000 require('../modules/esnext.string.at');
core-js-3.6.1/packages/core-js/proposals/string-code-points.js 0000664 0000000 0000000 00000000061 13600575677 0024330 0 ustar 00root root 0000000 0000000 require('../modules/esnext.string.code-points');
core-js-3.6.1/packages/core-js/proposals/string-match-all.js 0000664 0000000 0000000 00000000120 13600575677 0023742 0 ustar 00root root 0000000 0000000 // TODO: Remove from `core-js@4`
require('../modules/esnext.string.match-all');
core-js-3.6.1/packages/core-js/proposals/string-replace-all.js 0000664 0000000 0000000 00000000142 13600575677 0024265 0 ustar 00root root 0000000 0000000 require('../modules/esnext.string.replace-all');
require('../modules/esnext.symbol.replace-all');
core-js-3.6.1/packages/core-js/proposals/url.js 0000664 0000000 0000000 00000000163 13600575677 0021405 0 ustar 00root root 0000000 0000000 require('../modules/web.url');
require('../modules/web.url.to-json');
require('../modules/web.url-search-params');
core-js-3.6.1/packages/core-js/proposals/using-statement.js 0000664 0000000 0000000 00000000224 13600575677 0023730 0 ustar 00root root 0000000 0000000 // https://github.com/tc39/proposal-using-statement
require('../modules/esnext.symbol.async-dispose');
require('../modules/esnext.symbol.dispose');
core-js-3.6.1/packages/core-js/stable/ 0000775 0000000 0000000 00000000000 13600575677 0017475 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/README.md 0000664 0000000 0000000 00000000222 13600575677 0020750 0 ustar 00root root 0000000 0000000 This folder contains entry points for all stable `core-js` features with dependencies. It's the recommended way for usage only required features.
core-js-3.6.1/packages/core-js/stable/array-buffer/ 0000775 0000000 0000000 00000000000 13600575677 0022062 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/array-buffer/constructor.js 0000664 0000000 0000000 00000000125 13600575677 0025003 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array-buffer/constructor');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array-buffer/index.js 0000664 0000000 0000000 00000000111 13600575677 0023520 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array-buffer');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array-buffer/is-view.js 0000664 0000000 0000000 00000000121 13600575677 0023775 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array-buffer/is-view');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array-buffer/slice.js 0000664 0000000 0000000 00000000117 13600575677 0023516 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array-buffer/slice');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/ 0000775 0000000 0000000 00000000000 13600575677 0020613 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/array/concat.js 0000664 0000000 0000000 00000000111 13600575677 0022411 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/concat');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/copy-within.js 0000664 0000000 0000000 00000000116 13600575677 0023421 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/copy-within');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/entries.js 0000664 0000000 0000000 00000000112 13600575677 0022614 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/entries');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/every.js 0000664 0000000 0000000 00000000110 13600575677 0022273 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/every');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/fill.js 0000664 0000000 0000000 00000000107 13600575677 0022075 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/fill');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/filter.js 0000664 0000000 0000000 00000000111 13600575677 0022427 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/filter');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/find-index.js 0000664 0000000 0000000 00000000115 13600575677 0023173 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/find-index');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/find.js 0000664 0000000 0000000 00000000107 13600575677 0022067 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/find');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/flat-map.js 0000664 0000000 0000000 00000000113 13600575677 0022645 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/flat-map');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/flat.js 0000664 0000000 0000000 00000000107 13600575677 0022075 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/flat');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/for-each.js 0000664 0000000 0000000 00000000113 13600575677 0022630 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/for-each');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/from.js 0000664 0000000 0000000 00000000107 13600575677 0022112 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/from');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/includes.js 0000664 0000000 0000000 00000000113 13600575677 0022752 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/includes');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/index-of.js 0000664 0000000 0000000 00000000113 13600575677 0022655 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/index-of');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/index.js 0000664 0000000 0000000 00000000102 13600575677 0022251 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/is-array.js 0000664 0000000 0000000 00000000113 13600575677 0022673 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/is-array');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/iterator.js 0000664 0000000 0000000 00000000113 13600575677 0022775 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/iterator');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/join.js 0000664 0000000 0000000 00000000107 13600575677 0022106 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/join');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/keys.js 0000664 0000000 0000000 00000000107 13600575677 0022122 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/keys');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/last-index-of.js 0000664 0000000 0000000 00000000120 13600575677 0023614 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/last-index-of');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/map.js 0000664 0000000 0000000 00000000106 13600575677 0021723 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/map');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/of.js 0000664 0000000 0000000 00000000105 13600575677 0021551 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/of');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/reduce-right.js 0000664 0000000 0000000 00000000117 13600575677 0023532 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/reduce-right');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/reduce.js 0000664 0000000 0000000 00000000111 13600575677 0022411 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/reduce');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/reverse.js 0000664 0000000 0000000 00000000112 13600575677 0022616 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/reverse');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/slice.js 0000664 0000000 0000000 00000000110 13600575677 0022240 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/slice');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/some.js 0000664 0000000 0000000 00000000107 13600575677 0022112 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/some');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/sort.js 0000664 0000000 0000000 00000000107 13600575677 0022136 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/sort');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/splice.js 0000664 0000000 0000000 00000000111 13600575677 0022421 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/splice');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/values.js 0000664 0000000 0000000 00000000111 13600575677 0022441 0 ustar 00root root 0000000 0000000 var parent = require('../../es/array/values');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/ 0000775 0000000 0000000 00000000000 13600575677 0022301 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/array/virtual/concat.js 0000664 0000000 0000000 00000000124 13600575677 0024103 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/concat');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/copy-within.js 0000664 0000000 0000000 00000000131 13600575677 0025104 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/copy-within');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/entries.js 0000664 0000000 0000000 00000000125 13600575677 0024306 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/entries');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/every.js 0000664 0000000 0000000 00000000123 13600575677 0023765 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/every');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/fill.js 0000664 0000000 0000000 00000000122 13600575677 0023560 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/fill');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/filter.js 0000664 0000000 0000000 00000000124 13600575677 0024121 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/filter');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/find-index.js 0000664 0000000 0000000 00000000130 13600575677 0024656 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/find-index');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/find.js 0000664 0000000 0000000 00000000122 13600575677 0023552 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/find');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/flat-map.js 0000664 0000000 0000000 00000000126 13600575677 0024337 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/flat-map');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/flat.js 0000664 0000000 0000000 00000000122 13600575677 0023560 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/flat');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/for-each.js 0000664 0000000 0000000 00000000126 13600575677 0024322 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/for-each');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/includes.js 0000664 0000000 0000000 00000000126 13600575677 0024444 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/includes');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/index-of.js 0000664 0000000 0000000 00000000126 13600575677 0024347 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/index-of');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/index.js 0000664 0000000 0000000 00000000115 13600575677 0023743 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/iterator.js 0000664 0000000 0000000 00000000126 13600575677 0024467 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/iterator');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/join.js 0000664 0000000 0000000 00000000122 13600575677 0023571 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/join');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/keys.js 0000664 0000000 0000000 00000000122 13600575677 0023605 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/keys');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/last-index-of.js 0000664 0000000 0000000 00000000133 13600575677 0025306 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/last-index-of');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/map.js 0000664 0000000 0000000 00000000121 13600575677 0023406 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/map');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/reduce-right.js 0000664 0000000 0000000 00000000132 13600575677 0025215 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/reduce-right');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/reduce.js 0000664 0000000 0000000 00000000124 13600575677 0024103 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/reduce');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/reverse.js 0000664 0000000 0000000 00000000125 13600575677 0024310 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/reverse');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/slice.js 0000664 0000000 0000000 00000000123 13600575677 0023732 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/slice');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/some.js 0000664 0000000 0000000 00000000122 13600575677 0023575 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/some');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/sort.js 0000664 0000000 0000000 00000000122 13600575677 0023621 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/sort');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/splice.js 0000664 0000000 0000000 00000000124 13600575677 0024113 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/splice');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/array/virtual/values.js 0000664 0000000 0000000 00000000124 13600575677 0024133 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/array/virtual/values');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/clear-immediate.js 0000664 0000000 0000000 00000000165 13600575677 0023057 0 ustar 00root root 0000000 0000000 require('../modules/web.immediate');
var path = require('../internals/path');
module.exports = path.clearImmediate;
core-js-3.6.1/packages/core-js/stable/data-view/ 0000775 0000000 0000000 00000000000 13600575677 0021356 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/data-view/index.js 0000664 0000000 0000000 00000000106 13600575677 0023020 0 ustar 00root root 0000000 0000000 var parent = require('../../es/data-view');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/date/ 0000775 0000000 0000000 00000000000 13600575677 0020412 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/date/index.js 0000664 0000000 0000000 00000000101 13600575677 0022047 0 ustar 00root root 0000000 0000000 var parent = require('../../es/date');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/date/now.js 0000664 0000000 0000000 00000000105 13600575677 0021547 0 ustar 00root root 0000000 0000000 var parent = require('../../es/date/now');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/date/to-iso-string.js 0000664 0000000 0000000 00000000117 13600575677 0023465 0 ustar 00root root 0000000 0000000 var parent = require('../../es/date/to-iso-string');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/date/to-json.js 0000664 0000000 0000000 00000000111 13600575677 0022332 0 ustar 00root root 0000000 0000000 var parent = require('../../es/date/to-json');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/date/to-primitive.js 0000664 0000000 0000000 00000000116 13600575677 0023376 0 ustar 00root root 0000000 0000000 var parent = require('../../es/date/to-primitive');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/date/to-string.js 0000664 0000000 0000000 00000000113 13600575677 0022671 0 ustar 00root root 0000000 0000000 var parent = require('../../es/date/to-string');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/dom-collections/ 0000775 0000000 0000000 00000000000 13600575677 0022570 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/dom-collections/for-each.js 0000664 0000000 0000000 00000000212 13600575677 0024605 0 ustar 00root root 0000000 0000000 require('../../modules/web.dom-collections.for-each');
var parent = require('../../internals/array-for-each');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/dom-collections/index.js 0000664 0000000 0000000 00000000626 13600575677 0024241 0 ustar 00root root 0000000 0000000 require('../../modules/web.dom-collections.for-each');
require('../../modules/web.dom-collections.iterator');
var ArrayIterators = require('../../modules/es.array.iterator');
var forEach = require('../../internals/array-for-each');
module.exports = {
keys: ArrayIterators.keys,
values: ArrayIterators.values,
entries: ArrayIterators.entries,
iterator: ArrayIterators.values,
forEach: forEach
};
core-js-3.6.1/packages/core-js/stable/dom-collections/iterator.js 0000664 0000000 0000000 00000000244 13600575677 0024757 0 ustar 00root root 0000000 0000000 require('../../modules/web.dom-collections.iterator');
var entryUnbind = require('../../internals/entry-unbind');
module.exports = entryUnbind('Array', 'values');
core-js-3.6.1/packages/core-js/stable/function/ 0000775 0000000 0000000 00000000000 13600575677 0021322 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/function/bind.js 0000664 0000000 0000000 00000000112 13600575677 0022566 0 ustar 00root root 0000000 0000000 var parent = require('../../es/function/bind');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/function/has-instance.js 0000664 0000000 0000000 00000000122 13600575677 0024230 0 ustar 00root root 0000000 0000000 var parent = require('../../es/function/has-instance');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/function/index.js 0000664 0000000 0000000 00000000105 13600575677 0022763 0 ustar 00root root 0000000 0000000 var parent = require('../../es/function');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/function/name.js 0000664 0000000 0000000 00000000112 13600575677 0022572 0 ustar 00root root 0000000 0000000 var parent = require('../../es/function/name');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/function/virtual/ 0000775 0000000 0000000 00000000000 13600575677 0023010 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/function/virtual/bind.js 0000664 0000000 0000000 00000000125 13600575677 0024260 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/function/virtual/bind');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/function/virtual/index.js 0000664 0000000 0000000 00000000120 13600575677 0024446 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/function/virtual');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/global-this.js 0000664 0000000 0000000 00000000105 13600575677 0022234 0 ustar 00root root 0000000 0000000 var parent = require('../es/global-this');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/index.js 0000664 0000000 0000000 00000000146 13600575677 0021143 0 ustar 00root root 0000000 0000000 require('../es');
require('../web');
var path = require('../internals/path');
module.exports = path;
core-js-3.6.1/packages/core-js/stable/instance/ 0000775 0000000 0000000 00000000000 13600575677 0021301 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/instance/bind.js 0000664 0000000 0000000 00000000112 13600575677 0022545 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/bind');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/code-point-at.js 0000664 0000000 0000000 00000000123 13600575677 0024276 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/code-point-at');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/concat.js 0000664 0000000 0000000 00000000114 13600575677 0023102 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/concat');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/copy-within.js 0000664 0000000 0000000 00000000121 13600575677 0024103 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/copy-within');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/ends-with.js 0000664 0000000 0000000 00000000117 13600575677 0023540 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/ends-with');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/entries.js 0000664 0000000 0000000 00000001020 13600575677 0023301 0 ustar 00root root 0000000 0000000 require('../../modules/web.dom-collections.iterator');
var entries = require('../array/virtual/entries');
var classof = require('../../internals/classof');
var ArrayPrototype = Array.prototype;
var DOMIterables = {
DOMTokenList: true,
NodeList: true
};
module.exports = function (it) {
var own = it.entries;
return it === ArrayPrototype || (it instanceof Array && own === ArrayPrototype.entries)
// eslint-disable-next-line no-prototype-builtins
|| DOMIterables.hasOwnProperty(classof(it)) ? entries : own;
};
core-js-3.6.1/packages/core-js/stable/instance/every.js 0000664 0000000 0000000 00000000113 13600575677 0022764 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/every');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/fill.js 0000664 0000000 0000000 00000000112 13600575677 0022557 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/fill');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/filter.js 0000664 0000000 0000000 00000000114 13600575677 0023120 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/filter');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/find-index.js 0000664 0000000 0000000 00000000120 13600575677 0023655 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/find-index');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/find.js 0000664 0000000 0000000 00000000112 13600575677 0022551 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/find');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/flags.js 0000664 0000000 0000000 00000000113 13600575677 0022726 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/flags');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/flat-map.js 0000664 0000000 0000000 00000000116 13600575677 0023336 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/flat-map');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/flat.js 0000664 0000000 0000000 00000000112 13600575677 0022557 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/flat');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/for-each.js 0000664 0000000 0000000 00000001021 13600575677 0023315 0 ustar 00root root 0000000 0000000 require('../../modules/web.dom-collections.iterator');
var forEach = require('../array/virtual/for-each');
var classof = require('../../internals/classof');
var ArrayPrototype = Array.prototype;
var DOMIterables = {
DOMTokenList: true,
NodeList: true
};
module.exports = function (it) {
var own = it.forEach;
return it === ArrayPrototype || (it instanceof Array && own === ArrayPrototype.forEach)
// eslint-disable-next-line no-prototype-builtins
|| DOMIterables.hasOwnProperty(classof(it)) ? forEach : own;
};
core-js-3.6.1/packages/core-js/stable/instance/includes.js 0000664 0000000 0000000 00000000116 13600575677 0023443 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/includes');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/index-of.js 0000664 0000000 0000000 00000000116 13600575677 0023346 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/index-of');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/keys.js 0000664 0000000 0000000 00000001001 13600575677 0022602 0 ustar 00root root 0000000 0000000 require('../../modules/web.dom-collections.iterator');
var keys = require('../array/virtual/keys');
var classof = require('../../internals/classof');
var ArrayPrototype = Array.prototype;
var DOMIterables = {
DOMTokenList: true,
NodeList: true
};
module.exports = function (it) {
var own = it.keys;
return it === ArrayPrototype || (it instanceof Array && own === ArrayPrototype.keys)
// eslint-disable-next-line no-prototype-builtins
|| DOMIterables.hasOwnProperty(classof(it)) ? keys : own;
};
core-js-3.6.1/packages/core-js/stable/instance/last-index-of.js 0000664 0000000 0000000 00000000123 13600575677 0024305 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/last-index-of');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/map.js 0000664 0000000 0000000 00000000111 13600575677 0022405 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/map');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/match-all.js 0000664 0000000 0000000 00000000117 13600575677 0023500 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/match-all');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/pad-end.js 0000664 0000000 0000000 00000000115 13600575677 0023144 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/pad-end');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/pad-start.js 0000664 0000000 0000000 00000000117 13600575677 0023535 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/pad-start');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/reduce-right.js 0000664 0000000 0000000 00000000122 13600575677 0024214 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/reduce-right');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/reduce.js 0000664 0000000 0000000 00000000114 13600575677 0023102 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/reduce');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/repeat.js 0000664 0000000 0000000 00000000114 13600575677 0023113 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/repeat');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/reverse.js 0000664 0000000 0000000 00000000115 13600575677 0023307 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/reverse');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/slice.js 0000664 0000000 0000000 00000000113 13600575677 0022731 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/slice');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/some.js 0000664 0000000 0000000 00000000112 13600575677 0022574 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/some');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/sort.js 0000664 0000000 0000000 00000000112 13600575677 0022620 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/sort');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/splice.js 0000664 0000000 0000000 00000000114 13600575677 0023112 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/splice');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/starts-with.js 0000664 0000000 0000000 00000000121 13600575677 0024122 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/starts-with');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/trim-end.js 0000664 0000000 0000000 00000000116 13600575677 0023354 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/trim-end');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/trim-left.js 0000664 0000000 0000000 00000000117 13600575677 0023541 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/trim-left');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/trim-right.js 0000664 0000000 0000000 00000000120 13600575677 0023716 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/trim-right');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/trim-start.js 0000664 0000000 0000000 00000000120 13600575677 0023736 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/trim-start');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/trim.js 0000664 0000000 0000000 00000000112 13600575677 0022604 0 ustar 00root root 0000000 0000000 var parent = require('../../es/instance/trim');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/instance/values.js 0000664 0000000 0000000 00000001013 13600575677 0023131 0 ustar 00root root 0000000 0000000 require('../../modules/web.dom-collections.iterator');
var values = require('../array/virtual/values');
var classof = require('../../internals/classof');
var ArrayPrototype = Array.prototype;
var DOMIterables = {
DOMTokenList: true,
NodeList: true
};
module.exports = function (it) {
var own = it.values;
return it === ArrayPrototype || (it instanceof Array && own === ArrayPrototype.values)
// eslint-disable-next-line no-prototype-builtins
|| DOMIterables.hasOwnProperty(classof(it)) ? values : own;
};
core-js-3.6.1/packages/core-js/stable/json/ 0000775 0000000 0000000 00000000000 13600575677 0020446 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/json/index.js 0000664 0000000 0000000 00000000101 13600575677 0022103 0 ustar 00root root 0000000 0000000 var parent = require('../../es/json');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/json/stringify.js 0000664 0000000 0000000 00000000113 13600575677 0023015 0 ustar 00root root 0000000 0000000 var parent = require('../../es/json/stringify');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/json/to-string-tag.js 0000664 0000000 0000000 00000000117 13600575677 0023502 0 ustar 00root root 0000000 0000000 var parent = require('../../es/json/to-string-tag');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/map/ 0000775 0000000 0000000 00000000000 13600575677 0020252 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/map/index.js 0000664 0000000 0000000 00000000100 13600575677 0021706 0 ustar 00root root 0000000 0000000 var parent = require('../../es/map');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/ 0000775 0000000 0000000 00000000000 13600575677 0020426 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/math/acosh.js 0000664 0000000 0000000 00000000107 13600575677 0022057 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/acosh');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/asinh.js 0000664 0000000 0000000 00000000107 13600575677 0022064 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/asinh');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/atanh.js 0000664 0000000 0000000 00000000107 13600575677 0022055 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/atanh');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/cbrt.js 0000664 0000000 0000000 00000000106 13600575677 0021713 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/cbrt');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/clz32.js 0000664 0000000 0000000 00000000107 13600575677 0021717 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/clz32');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/cosh.js 0000664 0000000 0000000 00000000106 13600575677 0021715 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/cosh');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/expm1.js 0000664 0000000 0000000 00000000107 13600575677 0022014 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/expm1');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/fround.js 0000664 0000000 0000000 00000000110 13600575677 0022251 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/fround');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/hypot.js 0000664 0000000 0000000 00000000107 13600575677 0022125 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/hypot');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/imul.js 0000664 0000000 0000000 00000000106 13600575677 0021727 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/imul');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/index.js 0000664 0000000 0000000 00000000101 13600575677 0022063 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/log10.js 0000664 0000000 0000000 00000000107 13600575677 0021704 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/log10');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/log1p.js 0000664 0000000 0000000 00000000107 13600575677 0022004 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/log1p');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/log2.js 0000664 0000000 0000000 00000000106 13600575677 0021624 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/log2');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/sign.js 0000664 0000000 0000000 00000000106 13600575677 0021721 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/sign');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/sinh.js 0000664 0000000 0000000 00000000106 13600575677 0021722 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/sinh');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/tanh.js 0000664 0000000 0000000 00000000106 13600575677 0021713 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/tanh');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/to-string-tag.js 0000664 0000000 0000000 00000000117 13600575677 0023462 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/to-string-tag');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/math/trunc.js 0000664 0000000 0000000 00000000107 13600575677 0022115 0 ustar 00root root 0000000 0000000 var parent = require('../../es/math/trunc');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/number/ 0000775 0000000 0000000 00000000000 13600575677 0020765 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/number/constructor.js 0000664 0000000 0000000 00000000117 13600575677 0023707 0 ustar 00root root 0000000 0000000 var parent = require('../../es/number/constructor');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/number/epsilon.js 0000664 0000000 0000000 00000000113 13600575677 0022767 0 ustar 00root root 0000000 0000000 var parent = require('../../es/number/epsilon');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/number/index.js 0000664 0000000 0000000 00000000103 13600575677 0022424 0 ustar 00root root 0000000 0000000 var parent = require('../../es/number');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/number/is-finite.js 0000664 0000000 0000000 00000000115 13600575677 0023207 0 ustar 00root root 0000000 0000000 var parent = require('../../es/number/is-finite');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/number/is-integer.js 0000664 0000000 0000000 00000000116 13600575677 0023367 0 ustar 00root root 0000000 0000000 var parent = require('../../es/number/is-integer');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/number/is-nan.js 0000664 0000000 0000000 00000000112 13600575677 0022502 0 ustar 00root root 0000000 0000000 var parent = require('../../es/number/is-nan');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/number/is-safe-integer.js 0000664 0000000 0000000 00000000123 13600575677 0024301 0 ustar 00root root 0000000 0000000 var parent = require('../../es/number/is-safe-integer');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/number/max-safe-integer.js 0000664 0000000 0000000 00000000124 13600575677 0024454 0 ustar 00root root 0000000 0000000 var parent = require('../../es/number/max-safe-integer');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/number/min-safe-integer.js 0000664 0000000 0000000 00000000124 13600575677 0024452 0 ustar 00root root 0000000 0000000 var parent = require('../../es/number/min-safe-integer');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/number/parse-float.js 0000664 0000000 0000000 00000000117 13600575677 0023537 0 ustar 00root root 0000000 0000000 var parent = require('../../es/number/parse-float');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/number/parse-int.js 0000664 0000000 0000000 00000000115 13600575677 0023222 0 ustar 00root root 0000000 0000000 var parent = require('../../es/number/parse-int');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/number/to-fixed.js 0000664 0000000 0000000 00000000114 13600575677 0023036 0 ustar 00root root 0000000 0000000 var parent = require('../../es/number/to-fixed');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/number/to-precision.js 0000664 0000000 0000000 00000000120 13600575677 0023727 0 ustar 00root root 0000000 0000000 var parent = require('../../es/number/to-precision');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/number/virtual/ 0000775 0000000 0000000 00000000000 13600575677 0022453 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/number/virtual/index.js 0000664 0000000 0000000 00000000116 13600575677 0024116 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/number/virtual');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/number/virtual/to-fixed.js 0000664 0000000 0000000 00000000127 13600575677 0024530 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/number/virtual/to-fixed');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/number/virtual/to-precision.js 0000664 0000000 0000000 00000000133 13600575677 0025421 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/number/virtual/to-precision');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/ 0000775 0000000 0000000 00000000000 13600575677 0020743 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/object/assign.js 0000664 0000000 0000000 00000000112 13600575677 0022557 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/assign');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/create.js 0000664 0000000 0000000 00000000112 13600575677 0022536 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/create');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/define-getter.js 0000664 0000000 0000000 00000000121 13600575677 0024015 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/define-getter');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/define-properties.js 0000664 0000000 0000000 00000000125 13600575677 0024723 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/define-properties');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/define-property.js 0000664 0000000 0000000 00000000123 13600575677 0024411 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/define-property');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/define-setter.js 0000664 0000000 0000000 00000000121 13600575677 0024031 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/define-setter');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/entries.js 0000664 0000000 0000000 00000000113 13600575677 0022745 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/entries');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/freeze.js 0000664 0000000 0000000 00000000112 13600575677 0022553 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/freeze');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/from-entries.js 0000664 0000000 0000000 00000000120 13600575677 0023704 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/from-entries');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/get-own-property-descriptor.js 0000664 0000000 0000000 00000000137 13600575677 0026720 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/get-own-property-descriptor');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/get-own-property-descriptors.js 0000664 0000000 0000000 00000000140 13600575677 0027075 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/get-own-property-descriptors');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/get-own-property-names.js 0000664 0000000 0000000 00000000132 13600575677 0025640 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/get-own-property-names');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/get-own-property-symbols.js 0000664 0000000 0000000 00000000134 13600575677 0026227 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/get-own-property-symbols');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/get-prototype-of.js 0000664 0000000 0000000 00000000124 13600575677 0024522 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/get-prototype-of');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/index.js 0000664 0000000 0000000 00000000103 13600575677 0022402 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/is-extensible.js 0000664 0000000 0000000 00000000121 13600575677 0024046 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/is-extensible');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/is-frozen.js 0000664 0000000 0000000 00000000115 13600575677 0023212 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/is-frozen');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/is-sealed.js 0000664 0000000 0000000 00000000115 13600575677 0023144 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/is-sealed');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/is.js 0000664 0000000 0000000 00000000106 13600575677 0021711 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/is');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/keys.js 0000664 0000000 0000000 00000000110 13600575677 0022244 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/keys');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/lookup-getter.js 0000664 0000000 0000000 00000000121 13600575677 0024074 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/lookup-getter');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/lookup-setter.js 0000664 0000000 0000000 00000000121 13600575677 0024110 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/lookup-setter');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/prevent-extensions.js 0000664 0000000 0000000 00000000126 13600575677 0025160 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/prevent-extensions');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/seal.js 0000664 0000000 0000000 00000000110 13600575677 0022215 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/seal');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/set-prototype-of.js 0000664 0000000 0000000 00000000124 13600575677 0024536 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/set-prototype-of');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/to-string.js 0000664 0000000 0000000 00000000115 13600575677 0023224 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/to-string');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/object/values.js 0000664 0000000 0000000 00000000112 13600575677 0022572 0 ustar 00root root 0000000 0000000 var parent = require('../../es/object/values');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/parse-float.js 0000664 0000000 0000000 00000000105 13600575677 0022244 0 ustar 00root root 0000000 0000000 var parent = require('../es/parse-float');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/parse-int.js 0000664 0000000 0000000 00000000103 13600575677 0021727 0 ustar 00root root 0000000 0000000 var parent = require('../es/parse-int');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/promise/ 0000775 0000000 0000000 00000000000 13600575677 0021153 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/promise/all-settled.js 0000664 0000000 0000000 00000000120 13600575677 0023714 0 ustar 00root root 0000000 0000000 var parent = require('../../es/promise/all-settled');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/promise/finally.js 0000664 0000000 0000000 00000000114 13600575677 0023143 0 ustar 00root root 0000000 0000000 var parent = require('../../es/promise/finally');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/promise/index.js 0000664 0000000 0000000 00000000104 13600575677 0022613 0 ustar 00root root 0000000 0000000 var parent = require('../../es/promise');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/queue-microtask.js 0000664 0000000 0000000 00000000112 13600575677 0023143 0 ustar 00root root 0000000 0000000 var parent = require('../web/queue-microtask');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/reflect/ 0000775 0000000 0000000 00000000000 13600575677 0021121 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/reflect/apply.js 0000664 0000000 0000000 00000000112 13600575677 0022576 0 ustar 00root root 0000000 0000000 var parent = require('../../es/reflect/apply');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/reflect/construct.js 0000664 0000000 0000000 00000000116 13600575677 0023501 0 ustar 00root root 0000000 0000000 var parent = require('../../es/reflect/construct');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/reflect/define-property.js 0000664 0000000 0000000 00000000124 13600575677 0024570 0 ustar 00root root 0000000 0000000 var parent = require('../../es/reflect/define-property');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/reflect/delete-property.js 0000664 0000000 0000000 00000000124 13600575677 0024600 0 ustar 00root root 0000000 0000000 var parent = require('../../es/reflect/delete-property');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/reflect/get-own-property-descriptor.js 0000664 0000000 0000000 00000000140 13600575677 0027070 0 ustar 00root root 0000000 0000000 var parent = require('../../es/reflect/get-own-property-descriptor');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/reflect/get-prototype-of.js 0000664 0000000 0000000 00000000125 13600575677 0024701 0 ustar 00root root 0000000 0000000 var parent = require('../../es/reflect/get-prototype-of');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/reflect/get.js 0000664 0000000 0000000 00000000110 13600575677 0022226 0 ustar 00root root 0000000 0000000 var parent = require('../../es/reflect/get');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/reflect/has.js 0000664 0000000 0000000 00000000110 13600575677 0022222 0 ustar 00root root 0000000 0000000 var parent = require('../../es/reflect/has');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/reflect/index.js 0000664 0000000 0000000 00000000104 13600575677 0022561 0 ustar 00root root 0000000 0000000 var parent = require('../../es/reflect');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/reflect/is-extensible.js 0000664 0000000 0000000 00000000122 13600575677 0024225 0 ustar 00root root 0000000 0000000 var parent = require('../../es/reflect/is-extensible');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/reflect/own-keys.js 0000664 0000000 0000000 00000000115 13600575677 0023230 0 ustar 00root root 0000000 0000000 var parent = require('../../es/reflect/own-keys');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/reflect/prevent-extensions.js 0000664 0000000 0000000 00000000127 13600575677 0025337 0 ustar 00root root 0000000 0000000 var parent = require('../../es/reflect/prevent-extensions');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/reflect/set-prototype-of.js 0000664 0000000 0000000 00000000125 13600575677 0024715 0 ustar 00root root 0000000 0000000 var parent = require('../../es/reflect/set-prototype-of');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/reflect/set.js 0000664 0000000 0000000 00000000110 13600575677 0022242 0 ustar 00root root 0000000 0000000 var parent = require('../../es/reflect/set');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/regexp/ 0000775 0000000 0000000 00000000000 13600575677 0020767 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/regexp/constructor.js 0000664 0000000 0000000 00000000117 13600575677 0023711 0 ustar 00root root 0000000 0000000 var parent = require('../../es/regexp/constructor');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/regexp/flags.js 0000664 0000000 0000000 00000000111 13600575677 0022412 0 ustar 00root root 0000000 0000000 var parent = require('../../es/regexp/flags');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/regexp/index.js 0000664 0000000 0000000 00000000103 13600575677 0022426 0 ustar 00root root 0000000 0000000 var parent = require('../../es/regexp');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/regexp/match.js 0000664 0000000 0000000 00000000111 13600575677 0022412 0 ustar 00root root 0000000 0000000 var parent = require('../../es/regexp/match');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/regexp/replace.js 0000664 0000000 0000000 00000000113 13600575677 0022733 0 ustar 00root root 0000000 0000000 var parent = require('../../es/regexp/replace');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/regexp/search.js 0000664 0000000 0000000 00000000112 13600575677 0022564 0 ustar 00root root 0000000 0000000 var parent = require('../../es/regexp/search');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/regexp/split.js 0000664 0000000 0000000 00000000111 13600575677 0022451 0 ustar 00root root 0000000 0000000 var parent = require('../../es/regexp/split');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/regexp/sticky.js 0000664 0000000 0000000 00000000112 13600575677 0022625 0 ustar 00root root 0000000 0000000 var parent = require('../../es/regexp/sticky');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/regexp/test.js 0000664 0000000 0000000 00000000110 13600575677 0022274 0 ustar 00root root 0000000 0000000 var parent = require('../../es/regexp/test');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/regexp/to-string.js 0000664 0000000 0000000 00000000115 13600575677 0023250 0 ustar 00root root 0000000 0000000 var parent = require('../../es/regexp/to-string');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/set-immediate.js 0000664 0000000 0000000 00000000163 13600575677 0022562 0 ustar 00root root 0000000 0000000 require('../modules/web.immediate');
var path = require('../internals/path');
module.exports = path.setImmediate;
core-js-3.6.1/packages/core-js/stable/set-interval.js 0000664 0000000 0000000 00000000157 13600575677 0022453 0 ustar 00root root 0000000 0000000 require('../modules/web.timers');
var path = require('../internals/path');
module.exports = path.setInterval;
core-js-3.6.1/packages/core-js/stable/set-timeout.js 0000664 0000000 0000000 00000000156 13600575677 0022314 0 ustar 00root root 0000000 0000000 require('../modules/web.timers');
var path = require('../internals/path');
module.exports = path.setTimeout;
core-js-3.6.1/packages/core-js/stable/set/ 0000775 0000000 0000000 00000000000 13600575677 0020270 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/set/index.js 0000664 0000000 0000000 00000000100 13600575677 0021724 0 ustar 00root root 0000000 0000000 var parent = require('../../es/set');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/ 0000775 0000000 0000000 00000000000 13600575677 0021003 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/string/anchor.js 0000664 0000000 0000000 00000000112 13600575677 0022605 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/anchor');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/big.js 0000664 0000000 0000000 00000000107 13600575677 0022100 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/big');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/blink.js 0000664 0000000 0000000 00000000111 13600575677 0022431 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/blink');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/bold.js 0000664 0000000 0000000 00000000110 13600575677 0022251 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/bold');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/code-point-at.js 0000664 0000000 0000000 00000000121 13600575677 0023776 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/code-point-at');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/ends-with.js 0000664 0000000 0000000 00000000115 13600575677 0023240 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/ends-with');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/fixed.js 0000664 0000000 0000000 00000000111 13600575677 0022431 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/fixed');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/fontcolor.js 0000664 0000000 0000000 00000000115 13600575677 0023343 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/fontcolor');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/fontsize.js 0000664 0000000 0000000 00000000114 13600575677 0023176 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/fontsize');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/from-code-point.js 0000664 0000000 0000000 00000000123 13600575677 0024337 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/from-code-point');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/includes.js 0000664 0000000 0000000 00000000114 13600575677 0023143 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/includes');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/index.js 0000664 0000000 0000000 00000000103 13600575677 0022442 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/italics.js 0000664 0000000 0000000 00000000113 13600575677 0022764 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/italics');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/iterator.js 0000664 0000000 0000000 00000000114 13600575677 0023166 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/iterator');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/link.js 0000664 0000000 0000000 00000000110 13600575677 0022266 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/link');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/match-all.js 0000664 0000000 0000000 00000000115 13600575677 0023200 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/match-all');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/match.js 0000664 0000000 0000000 00000000111 13600575677 0022426 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/match');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/pad-end.js 0000664 0000000 0000000 00000000113 13600575677 0022644 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/pad-end');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/pad-start.js 0000664 0000000 0000000 00000000115 13600575677 0023235 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/pad-start');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/raw.js 0000664 0000000 0000000 00000000107 13600575677 0022130 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/raw');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/repeat.js 0000664 0000000 0000000 00000000112 13600575677 0022613 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/repeat');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/replace.js 0000664 0000000 0000000 00000000113 13600575677 0022747 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/replace');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/search.js 0000664 0000000 0000000 00000000112 13600575677 0022600 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/search');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/small.js 0000664 0000000 0000000 00000000111 13600575677 0022442 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/small');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/split.js 0000664 0000000 0000000 00000000111 13600575677 0022465 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/split');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/starts-with.js 0000664 0000000 0000000 00000000117 13600575677 0023631 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/starts-with');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/strike.js 0000664 0000000 0000000 00000000112 13600575677 0022634 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/strike');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/sub.js 0000664 0000000 0000000 00000000107 13600575677 0022130 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/sub');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/sup.js 0000664 0000000 0000000 00000000107 13600575677 0022146 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/sup');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/trim-end.js 0000664 0000000 0000000 00000000114 13600575677 0023054 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/trim-end');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/trim-left.js 0000664 0000000 0000000 00000000115 13600575677 0023241 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/trim-left');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/trim-right.js 0000664 0000000 0000000 00000000116 13600575677 0023425 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/trim-right');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/trim-start.js 0000664 0000000 0000000 00000000116 13600575677 0023445 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/trim-start');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/trim.js 0000664 0000000 0000000 00000000110 13600575677 0022304 0 ustar 00root root 0000000 0000000 var parent = require('../../es/string/trim');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/ 0000775 0000000 0000000 00000000000 13600575677 0022471 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/string/virtual/anchor.js 0000664 0000000 0000000 00000000125 13600575677 0024277 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/anchor');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/big.js 0000664 0000000 0000000 00000000122 13600575677 0023563 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/big');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/blink.js 0000664 0000000 0000000 00000000124 13600575677 0024123 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/blink');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/bold.js 0000664 0000000 0000000 00000000123 13600575677 0023743 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/bold');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/code-point-at.js 0000664 0000000 0000000 00000000134 13600575677 0025470 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/code-point-at');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/ends-with.js 0000664 0000000 0000000 00000000130 13600575677 0024723 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/ends-with');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/fixed.js 0000664 0000000 0000000 00000000124 13600575677 0024123 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/fixed');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/fontcolor.js 0000664 0000000 0000000 00000000130 13600575677 0025026 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/fontcolor');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/fontsize.js 0000664 0000000 0000000 00000000127 13600575677 0024670 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/fontsize');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/includes.js 0000664 0000000 0000000 00000000127 13600575677 0024635 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/includes');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/index.js 0000664 0000000 0000000 00000000116 13600575677 0024134 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/italics.js 0000664 0000000 0000000 00000000126 13600575677 0024456 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/italics');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/iterator.js 0000664 0000000 0000000 00000000127 13600575677 0024660 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/iterator');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/link.js 0000664 0000000 0000000 00000000123 13600575677 0023760 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/link');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/match-all.js 0000664 0000000 0000000 00000000130 13600575677 0024663 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/match-all');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/pad-end.js 0000664 0000000 0000000 00000000126 13600575677 0024336 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/pad-end');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/pad-start.js 0000664 0000000 0000000 00000000130 13600575677 0024720 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/pad-start');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/repeat.js 0000664 0000000 0000000 00000000125 13600575677 0024305 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/repeat');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/small.js 0000664 0000000 0000000 00000000124 13600575677 0024134 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/small');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/starts-with.js 0000664 0000000 0000000 00000000132 13600575677 0025314 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/starts-with');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/strike.js 0000664 0000000 0000000 00000000125 13600575677 0024326 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/strike');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/sub.js 0000664 0000000 0000000 00000000122 13600575677 0023613 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/sub');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/sup.js 0000664 0000000 0000000 00000000122 13600575677 0023631 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/sup');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/trim-end.js 0000664 0000000 0000000 00000000127 13600575677 0024546 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/trim-end');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/trim-left.js 0000664 0000000 0000000 00000000130 13600575677 0024724 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/trim-left');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/trim-right.js 0000664 0000000 0000000 00000000131 13600575677 0025110 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/trim-right');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/trim-start.js 0000664 0000000 0000000 00000000131 13600575677 0025130 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/trim-start');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/string/virtual/trim.js 0000664 0000000 0000000 00000000123 13600575677 0023776 0 ustar 00root root 0000000 0000000 var parent = require('../../../es/string/virtual/trim');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/symbol/ 0000775 0000000 0000000 00000000000 13600575677 0021002 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/symbol/async-iterator.js 0000664 0000000 0000000 00000000122 13600575677 0024277 0 ustar 00root root 0000000 0000000 var parent = require('../../es/symbol/async-iterator');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/symbol/description.js 0000664 0000000 0000000 00000000060 13600575677 0023657 0 ustar 00root root 0000000 0000000 require('../../modules/es.symbol.description');
core-js-3.6.1/packages/core-js/stable/symbol/for.js 0000664 0000000 0000000 00000000107 13600575677 0022124 0 ustar 00root root 0000000 0000000 var parent = require('../../es/symbol/for');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/symbol/has-instance.js 0000664 0000000 0000000 00000000120 13600575677 0023706 0 ustar 00root root 0000000 0000000 var parent = require('../../es/symbol/has-instance');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/symbol/index.js 0000664 0000000 0000000 00000000103 13600575677 0022441 0 ustar 00root root 0000000 0000000 var parent = require('../../es/symbol');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/symbol/is-concat-spreadable.js 0000664 0000000 0000000 00000000130 13600575677 0025312 0 ustar 00root root 0000000 0000000 var parent = require('../../es/symbol/is-concat-spreadable');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/symbol/iterator.js 0000664 0000000 0000000 00000000114 13600575677 0023165 0 ustar 00root root 0000000 0000000 var parent = require('../../es/symbol/iterator');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/symbol/key-for.js 0000664 0000000 0000000 00000000113 13600575677 0022707 0 ustar 00root root 0000000 0000000 var parent = require('../../es/symbol/key-for');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/symbol/match-all.js 0000664 0000000 0000000 00000000115 13600575677 0023177 0 ustar 00root root 0000000 0000000 var parent = require('../../es/symbol/match-all');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/symbol/match.js 0000664 0000000 0000000 00000000111 13600575677 0022425 0 ustar 00root root 0000000 0000000 var parent = require('../../es/symbol/match');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/symbol/replace.js 0000664 0000000 0000000 00000000113 13600575677 0022746 0 ustar 00root root 0000000 0000000 var parent = require('../../es/symbol/replace');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/symbol/search.js 0000664 0000000 0000000 00000000112 13600575677 0022577 0 ustar 00root root 0000000 0000000 var parent = require('../../es/symbol/search');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/symbol/species.js 0000664 0000000 0000000 00000000113 13600575677 0022766 0 ustar 00root root 0000000 0000000 var parent = require('../../es/symbol/species');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/symbol/split.js 0000664 0000000 0000000 00000000111 13600575677 0022464 0 ustar 00root root 0000000 0000000 var parent = require('../../es/symbol/split');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/symbol/to-primitive.js 0000664 0000000 0000000 00000000120 13600575677 0023761 0 ustar 00root root 0000000 0000000 var parent = require('../../es/symbol/to-primitive');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/symbol/to-string-tag.js 0000664 0000000 0000000 00000000121 13600575677 0024031 0 ustar 00root root 0000000 0000000 var parent = require('../../es/symbol/to-string-tag');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/symbol/unscopables.js 0000664 0000000 0000000 00000000117 13600575677 0023655 0 ustar 00root root 0000000 0000000 var parent = require('../../es/symbol/unscopables');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/typed-array/ 0000775 0000000 0000000 00000000000 13600575677 0021736 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/typed-array/copy-within.js 0000664 0000000 0000000 00000000065 13600575677 0024547 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.copy-within');
core-js-3.6.1/packages/core-js/stable/typed-array/entries.js 0000664 0000000 0000000 00000000062 13600575677 0023743 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.iterator');
core-js-3.6.1/packages/core-js/stable/typed-array/every.js 0000664 0000000 0000000 00000000057 13600575677 0023430 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.every');
core-js-3.6.1/packages/core-js/stable/typed-array/fill.js 0000664 0000000 0000000 00000000056 13600575677 0023223 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.fill');
core-js-3.6.1/packages/core-js/stable/typed-array/filter.js 0000664 0000000 0000000 00000000060 13600575677 0023555 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.filter');
core-js-3.6.1/packages/core-js/stable/typed-array/find-index.js 0000664 0000000 0000000 00000000064 13600575677 0024321 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.find-index');
core-js-3.6.1/packages/core-js/stable/typed-array/find.js 0000664 0000000 0000000 00000000056 13600575677 0023215 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.find');
core-js-3.6.1/packages/core-js/stable/typed-array/float32-array.js 0000664 0000000 0000000 00000000126 13600575677 0024661 0 ustar 00root root 0000000 0000000 var parent = require('../../es/typed-array/float32-array');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/typed-array/float64-array.js 0000664 0000000 0000000 00000000126 13600575677 0024666 0 ustar 00root root 0000000 0000000 var parent = require('../../es/typed-array/float64-array');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/typed-array/for-each.js 0000664 0000000 0000000 00000000062 13600575677 0023756 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.for-each');
core-js-3.6.1/packages/core-js/stable/typed-array/from.js 0000664 0000000 0000000 00000000056 13600575677 0023240 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.from');
core-js-3.6.1/packages/core-js/stable/typed-array/includes.js 0000664 0000000 0000000 00000000062 13600575677 0024100 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.includes');
core-js-3.6.1/packages/core-js/stable/typed-array/index-of.js 0000664 0000000 0000000 00000000062 13600575677 0024003 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.index-of');
core-js-3.6.1/packages/core-js/stable/typed-array/index.js 0000664 0000000 0000000 00000000110 13600575677 0023373 0 ustar 00root root 0000000 0000000 var parent = require('../../es/typed-array');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/typed-array/int16-array.js 0000664 0000000 0000000 00000000124 13600575677 0024346 0 ustar 00root root 0000000 0000000 var parent = require('../../es/typed-array/int16-array');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/typed-array/int32-array.js 0000664 0000000 0000000 00000000124 13600575677 0024344 0 ustar 00root root 0000000 0000000 var parent = require('../../es/typed-array/int32-array');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/typed-array/int8-array.js 0000664 0000000 0000000 00000000123 13600575677 0024266 0 ustar 00root root 0000000 0000000 var parent = require('../../es/typed-array/int8-array');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/typed-array/iterator.js 0000664 0000000 0000000 00000000062 13600575677 0024123 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.iterator');
core-js-3.6.1/packages/core-js/stable/typed-array/join.js 0000664 0000000 0000000 00000000056 13600575677 0023234 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.join');
core-js-3.6.1/packages/core-js/stable/typed-array/keys.js 0000664 0000000 0000000 00000000062 13600575677 0023245 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.iterator');
core-js-3.6.1/packages/core-js/stable/typed-array/last-index-of.js 0000664 0000000 0000000 00000000067 13600575677 0024751 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.last-index-of');
core-js-3.6.1/packages/core-js/stable/typed-array/map.js 0000664 0000000 0000000 00000000055 13600575677 0023051 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.map');
core-js-3.6.1/packages/core-js/stable/typed-array/of.js 0000664 0000000 0000000 00000000054 13600575677 0022677 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.of');
core-js-3.6.1/packages/core-js/stable/typed-array/reduce-right.js 0000664 0000000 0000000 00000000066 13600575677 0024660 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.reduce-right');
core-js-3.6.1/packages/core-js/stable/typed-array/reduce.js 0000664 0000000 0000000 00000000060 13600575677 0023537 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.reduce');
core-js-3.6.1/packages/core-js/stable/typed-array/reverse.js 0000664 0000000 0000000 00000000061 13600575677 0023744 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.reverse');
core-js-3.6.1/packages/core-js/stable/typed-array/set.js 0000664 0000000 0000000 00000000055 13600575677 0023067 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.set');
core-js-3.6.1/packages/core-js/stable/typed-array/slice.js 0000664 0000000 0000000 00000000057 13600575677 0023375 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.slice');
core-js-3.6.1/packages/core-js/stable/typed-array/some.js 0000664 0000000 0000000 00000000056 13600575677 0023240 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.some');
core-js-3.6.1/packages/core-js/stable/typed-array/sort.js 0000664 0000000 0000000 00000000056 13600575677 0023264 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.sort');
core-js-3.6.1/packages/core-js/stable/typed-array/subarray.js 0000664 0000000 0000000 00000000062 13600575677 0024122 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.subarray');
core-js-3.6.1/packages/core-js/stable/typed-array/to-locale-string.js 0000664 0000000 0000000 00000000072 13600575677 0025456 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.to-locale-string');
core-js-3.6.1/packages/core-js/stable/typed-array/to-string.js 0000664 0000000 0000000 00000000063 13600575677 0024221 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.to-string');
core-js-3.6.1/packages/core-js/stable/typed-array/uint16-array.js 0000664 0000000 0000000 00000000125 13600575677 0024534 0 ustar 00root root 0000000 0000000 var parent = require('../../es/typed-array/uint16-array');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/typed-array/uint32-array.js 0000664 0000000 0000000 00000000125 13600575677 0024532 0 ustar 00root root 0000000 0000000 var parent = require('../../es/typed-array/uint32-array');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/typed-array/uint8-array.js 0000664 0000000 0000000 00000000124 13600575677 0024454 0 ustar 00root root 0000000 0000000 var parent = require('../../es/typed-array/uint8-array');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/typed-array/uint8-clamped-array.js 0000664 0000000 0000000 00000000134 13600575677 0026060 0 ustar 00root root 0000000 0000000 var parent = require('../../es/typed-array/uint8-clamped-array');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/typed-array/values.js 0000664 0000000 0000000 00000000062 13600575677 0023571 0 ustar 00root root 0000000 0000000 require('../../modules/es.typed-array.iterator');
core-js-3.6.1/packages/core-js/stable/url-search-params/ 0000775 0000000 0000000 00000000000 13600575677 0023023 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/url-search-params/index.js 0000664 0000000 0000000 00000000117 13600575677 0024467 0 ustar 00root root 0000000 0000000 var parent = require('../../web/url-search-params');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/url/ 0000775 0000000 0000000 00000000000 13600575677 0020277 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/url/index.js 0000664 0000000 0000000 00000000101 13600575677 0021734 0 ustar 00root root 0000000 0000000 var parent = require('../../web/url');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/url/to-json.js 0000664 0000000 0000000 00000000052 13600575677 0022223 0 ustar 00root root 0000000 0000000 require('../../modules/web.url.to-json');
core-js-3.6.1/packages/core-js/stable/weak-map/ 0000775 0000000 0000000 00000000000 13600575677 0021177 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/weak-map/index.js 0000664 0000000 0000000 00000000105 13600575677 0022640 0 ustar 00root root 0000000 0000000 var parent = require('../../es/weak-map');
module.exports = parent;
core-js-3.6.1/packages/core-js/stable/weak-set/ 0000775 0000000 0000000 00000000000 13600575677 0021215 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stable/weak-set/index.js 0000664 0000000 0000000 00000000105 13600575677 0022656 0 ustar 00root root 0000000 0000000 var parent = require('../../es/weak-set');
module.exports = parent;
core-js-3.6.1/packages/core-js/stage/ 0000775 0000000 0000000 00000000000 13600575677 0017326 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/stage/0.js 0000664 0000000 0000000 00000000254 13600575677 0020024 0 ustar 00root root 0000000 0000000 require('../proposals/efficient-64-bit-arithmetic');
require('../proposals/string-at');
require('../proposals/url');
var parent = require('./1');
module.exports = parent;
core-js-3.6.1/packages/core-js/stage/1.js 0000664 0000000 0000000 00000001110 13600575677 0020015 0 ustar 00root root 0000000 0000000 require('../proposals/array-last');
require('../proposals/collection-methods');
require('../proposals/collection-of-from');
require('../proposals/keys-composition');
require('../proposals/math-extensions');
require('../proposals/math-signbit');
require('../proposals/number-from-string');
require('../proposals/object-iteration');
require('../proposals/observable');
require('../proposals/pattern-matching');
require('../proposals/promise-try');
require('../proposals/seeded-random');
require('../proposals/string-code-points');
var parent = require('./2');
module.exports = parent;
core-js-3.6.1/packages/core-js/stage/2.js 0000664 0000000 0000000 00000000405 13600575677 0020024 0 ustar 00root root 0000000 0000000 require('../proposals/array-is-template-object');
require('../proposals/iterator-helpers');
require('../proposals/map-upsert');
require('../proposals/set-methods');
require('../proposals/using-statement');
var parent = require('./3');
module.exports = parent;
core-js-3.6.1/packages/core-js/stage/3.js 0000664 0000000 0000000 00000000210 13600575677 0020017 0 ustar 00root root 0000000 0000000 require('../proposals/promise-any');
require('../proposals/string-replace-all');
var parent = require('./4');
module.exports = parent;
core-js-3.6.1/packages/core-js/stage/4.js 0000664 0000000 0000000 00000000275 13600575677 0020033 0 ustar 00root root 0000000 0000000 require('../proposals/global-this');
require('../proposals/promise-all-settled');
require('../proposals/string-match-all');
var path = require('../internals/path');
module.exports = path;
core-js-3.6.1/packages/core-js/stage/README.md 0000664 0000000 0000000 00000000222 13600575677 0020601 0 ustar 00root root 0000000 0000000 This folder contains entry points for [ECMAScript proposals](https://github.com/zloirock/core-js/tree/v3#ecmascript-proposals) with dependencies.
core-js-3.6.1/packages/core-js/stage/index.js 0000664 0000000 0000000 00000000077 13600575677 0020777 0 ustar 00root root 0000000 0000000 var proposals = require('./pre');
module.exports = proposals;
core-js-3.6.1/packages/core-js/stage/pre.js 0000664 0000000 0000000 00000000141 13600575677 0020446 0 ustar 00root root 0000000 0000000 require('../proposals/reflect-metadata');
var parent = require('./0');
module.exports = parent;
core-js-3.6.1/packages/core-js/web/ 0000775 0000000 0000000 00000000000 13600575677 0017000 5 ustar 00root root 0000000 0000000 core-js-3.6.1/packages/core-js/web/README.md 0000664 0000000 0000000 00000000221 13600575677 0020252 0 ustar 00root root 0000000 0000000 This folder contains entry points for features from [WHATWG / W3C](https://github.com/zloirock/core-js/tree/v3#web-standards) with dependencies.
core-js-3.6.1/packages/core-js/web/dom-collections.js 0000664 0000000 0000000 00000000251 13600575677 0022427 0 ustar 00root root 0000000 0000000 require('../modules/web.dom-collections.for-each');
require('../modules/web.dom-collections.iterator');
var path = require('../internals/path');
module.exports = path;
core-js-3.6.1/packages/core-js/web/immediate.js 0000664 0000000 0000000 00000000146 13600575677 0021275 0 ustar 00root root 0000000 0000000 require('../modules/web.immediate');
var path = require('../internals/path');
module.exports = path;
core-js-3.6.1/packages/core-js/web/index.js 0000664 0000000 0000000 00000000616 13600575677 0020450 0 ustar 00root root 0000000 0000000 require('../modules/web.dom-collections.for-each');
require('../modules/web.dom-collections.iterator');
require('../modules/web.immediate');
require('../modules/web.queue-microtask');
require('../modules/web.timers');
require('../modules/web.url');
require('../modules/web.url.to-json');
require('../modules/web.url-search-params');
var path = require('../internals/path');
module.exports = path;
core-js-3.6.1/packages/core-js/web/queue-microtask.js 0000664 0000000 0000000 00000000173 13600575677 0022455 0 ustar 00root root 0000000 0000000 require('../modules/web.queue-microtask');
var path = require('../internals/path');
module.exports = path.queueMicrotask;
core-js-3.6.1/packages/core-js/web/timers.js 0000664 0000000 0000000 00000000143 13600575677 0020637 0 ustar 00root root 0000000 0000000 require('../modules/web.timers');
var path = require('../internals/path');
module.exports = path;
core-js-3.6.1/packages/core-js/web/url-search-params.js 0000664 0000000 0000000 00000000176 13600575677 0022670 0 ustar 00root root 0000000 0000000 require('../modules/web.url-search-params');
var path = require('../internals/path');
module.exports = path.URLSearchParams;
core-js-3.6.1/packages/core-js/web/url.js 0000664 0000000 0000000 00000000270 13600575677 0020137 0 ustar 00root root 0000000 0000000 require('../modules/web.url');
require('../modules/web.url.to-json');
require('../modules/web.url-search-params');
var path = require('../internals/path');
module.exports = path.URL;
core-js-3.6.1/tests/ 0000775 0000000 0000000 00000000000 13600575677 0014245 5 ustar 00root root 0000000 0000000 core-js-3.6.1/tests/commonjs-entries-content.js 0000664 0000000 0000000 00000012171 13600575677 0021551 0 ustar 00root root 0000000 0000000 'use strict';
const { deepStrictEqual, ok } = require('assert');
const allModules = require('../packages/core-js-compat/modules');
const entries = require('../packages/core-js-compat/entries');
function filter(regexp) {
return allModules.filter(it => regexp.test(it));
}
function equal(name, required) {
const contains = new Set(entries[name]);
const shouldContain = new Set(Array.isArray(required) ? required : filter(required));
deepStrictEqual(contains, shouldContain);
}
function superset(name, required) {
const contains = new Set(entries[name]);
const shouldContain = Array.isArray(required) ? required : filter(required);
for (const module of shouldContain) {
ok(contains.has(module), module);
}
}
function subset(name, required) {
const contains = entries[name];
const shouldContain = new Set(Array.isArray(required) ? required : filter(required));
for (const module of contains) {
ok(shouldContain.has(module), module);
}
}
equal('core-js', allModules);
equal('core-js/es', /^es\./);
superset('core-js/es/array', /^es\.array\./);
superset('core-js/es/array-buffer', /^es\.array-buffer\./);
superset('core-js/es/data-view', /^es\.data-view\./);
superset('core-js/es/date', /^es\.date\./);
superset('core-js/es/function', /^es\.function\./);
superset('core-js/es/json', /^es\.json\./);
superset('core-js/es/map', /^es\.map/);
superset('core-js/es/math', /^es\.math\./);
superset('core-js/es/number', /^es\.number\./);
superset('core-js/es/object', /^es\.object\./);
superset('core-js/es/promise', /^es\.promise/);
superset('core-js/es/reflect', /^es\.reflect\./);
superset('core-js/es/regexp', /^es\.regexp\./);
superset('core-js/es/set', /^es\.set/);
superset('core-js/es/string', /^es\.string\./);
superset('core-js/es/symbol', /^es\.symbol/);
superset('core-js/es/typed-array', /^es\.typed-array\./);
superset('core-js/es/weak-map', /^es\.weak-map/);
superset('core-js/es/weak-set', /^es\.weak-set/);
equal('core-js/web', /^web\./);
equal('core-js/stable', /^(es|web)\./);
superset('core-js/stable/array', /^es\.array\./);
superset('core-js/stable/array-buffer', /^es\.array-buffer\./);
superset('core-js/stable/data-view', /^es\.data-view\./);
superset('core-js/stable/date', /^es\.date\./);
superset('core-js/stable/dom-collections', /^web\.dom-collections\./);
superset('core-js/stable/function', /^es\.function\./);
superset('core-js/stable/json', /^es\.json\./);
superset('core-js/stable/map', /^es\.map/);
superset('core-js/stable/math', /^es\.math\./);
superset('core-js/stable/number', /^es\.number\./);
superset('core-js/stable/object', /^es\.object\./);
superset('core-js/stable/promise', /^es\.promise/);
superset('core-js/stable/reflect', /^es\.reflect\./);
superset('core-js/stable/regexp', /^es\.regexp\./);
superset('core-js/stable/set', /^es\.set/);
superset('core-js/stable/string', /^es\.string\./);
superset('core-js/stable/symbol', /^es\.symbol/);
superset('core-js/stable/typed-array', /^es\.typed-array\./);
superset('core-js/stable/url', /^web\.url(\.|$)/);
superset('core-js/stable/url-search-params', /^web\.url-search-params/);
superset('core-js/stable/weak-map', /^es\.weak-map/);
superset('core-js/stable/weak-set', /^es\.weak-set/);
equal('core-js/features', allModules);
superset('core-js/features/array', /^(es|esnext)\.array\./);
superset('core-js/features/array-buffer', /^(es|esnext)\.array-buffer\./);
superset('core-js/features/async-iterator', /^(es|esnext)\.async-iterator\./);
superset('core-js/features/data-view', /^(es|esnext)\.data-view\./);
superset('core-js/features/date', /^(es|esnext)\.date\./);
superset('core-js/features/dom-collections', /^web\.dom-collections\./);
superset('core-js/features/function', /^(es|esnext)\.function\./);
superset('core-js/features/iterator', /^(es|esnext)\.iterator\./);
superset('core-js/features/json', /^(es|esnext)\.json\./);
superset('core-js/features/map', /^(es|esnext)\.map/);
superset('core-js/features/math', /^(es|esnext)\.math\./);
superset('core-js/features/number', /^(es|esnext)\.number\./);
superset('core-js/features/object', /^(es|esnext)\.object\./);
superset('core-js/features/observable', /^(es|esnext)\.observable/);
superset('core-js/features/promise', /^(es|esnext)\.promise/);
superset('core-js/features/reflect', /^(es|esnext)\.reflect\./);
superset('core-js/features/regexp', /^(es|esnext)\.regexp\./);
superset('core-js/features/set', /^(es|esnext)\.set/);
superset('core-js/features/string', /^(es|esnext)\.string\./);
superset('core-js/features/symbol', /^(es|esnext)\.symbol/);
superset('core-js/features/typed-array', /^(es|esnext)\.typed-array\./);
superset('core-js/features/url', /^web\.url(\.|$)/);
superset('core-js/features/url-search-params', /^web\.url-search-params/);
superset('core-js/features/weak-map', /^(es|esnext)\.weak-map/);
superset('core-js/features/weak-set', /^(es|esnext)\.weak-set/);
equal('core-js/proposals', /^(esnext\.|web\.url)/);
equal('core-js/stage', /^(esnext\.|web\.url)/);
equal('core-js/stage/pre', /^(esnext\.|web\.url)/);
subset('core-js/stage/0', /^(esnext\.|web\.url)/);
subset('core-js/stage/1', /^(esnext\.|web\.url)/);
subset('core-js/stage/2', /^esnext\./);
subset('core-js/stage/3', /^esnext\./);
subset('core-js/stage/4', /^esnext\./);
core-js-3.6.1/tests/commonjs.js 0000664 0000000 0000000 00000250324 13600575677 0016436 0 ustar 00root root 0000000 0000000 /* eslint-disable import/no-dynamic-require */
'use strict';
const { ok } = require('assert');
const compat = require('../packages/core-js-compat/data');
let tested = 0;
let PATH;
function load(module) {
tested++;
// eslint-disable-next-line global-require
return require(`${ PATH }/${ module }`);
}
for (const _PATH of ['../packages/core-js-pure', '../packages/core-js']) {
PATH = _PATH;
ok(load('features/object/assign')({ q: 1 }, { w: 2 }).w === 2);
ok(load('features/object/create')(Array.prototype) instanceof Array);
ok(load('features/object/define-property')({}, 'a', { value: 42 }).a === 42);
ok(load('features/object/define-properties')({}, { a: { value: 42 } }).a === 42);
ok(load('features/object/freeze')({}));
ok(load('features/object/get-own-property-descriptor')({ q: 1 }, 'q').enumerable);
ok(load('features/object/get-own-property-names')({ q: 42 })[0] === 'q');
ok(load('features/object/get-own-property-symbols')({ [Symbol()]: 42 }).length === 1);
ok(load('features/object/get-prototype-of')([]) === Array.prototype);
ok(load('features/object/is')(NaN, NaN));
ok(load('features/object/is-extensible')({}));
ok(!load('features/object/is-frozen')({}));
ok(!load('features/object/is-sealed')({}));
ok(typeof load('features/object/iterate-entries')({}).next === 'function');
ok(typeof load('features/object/iterate-keys')({}).next === 'function');
ok(typeof load('features/object/iterate-values')({}).next === 'function');
ok(load('features/object/keys')({ q: 0 })[0] === 'q');
ok(load('features/object/prevent-extensions')({}));
ok(load('features/object/seal')({}));
ok(load('features/object/set-prototype-of')({}, []) instanceof Array);
ok(load('features/object/to-string')([]) === '[object Array]');
ok(load('features/object/entries')({ q: 2 })[0][0] === 'q');
ok(load('features/object/from-entries')([['a', 42]]).a === 42);
ok(load('features/object/values')({ q: 2 })[0] === 2);
ok(load('features/object/get-own-property-descriptors')({ q: 1 }).q.enumerable);
ok(typeof load('features/object/define-getter') === 'function');
ok(typeof load('features/object/define-setter') === 'function');
ok(typeof load('features/object/lookup-getter') === 'function');
ok(typeof load('features/object/lookup-setter') === 'function');
ok('values' in load('features/object'));
ok(load('features/function/bind')(function (a, b) {
return this + a + b;
}, 1, 2)(3) === 6);
ok(load('features/function/virtual/bind').call(function (a, b) {
return this + a + b;
}, 1, 2)(3) === 6);
ok(load('features/function/virtual').bind.call(function (a, b) {
return this + a + b;
}, 1, 2)(3) === 6);
load('features/function/name');
load('features/function/has-instance');
// eslint-disable-next-line prefer-arrow-callback
ok(Function[load('features/symbol/has-instance')](function () { /* empty */ }));
ok('bind' in load('features/function'));
ok(load('features/array/is-array')([]));
ok(typeof load('features/array/is-template-object') === 'function');
ok(Array.isArray(load('features/array/from')('qwe')));
ok(Array.isArray(load('features/array/of')('q', 'w', 'e')));
ok(load('features/array/join')('qwe', 1) === 'q1w1e');
ok(load('features/array/slice')('qwe', 1)[1] === 'e');
ok(load('features/array/sort')([1, 3, 2])[1] === 2);
ok(typeof load('features/array/for-each') === 'function');
ok(typeof load('features/array/map') === 'function');
ok(typeof load('features/array/filter') === 'function');
ok(typeof load('features/array/flat') === 'function');
ok(typeof load('features/array/flat-map') === 'function');
ok(typeof load('features/array/some') === 'function');
ok(typeof load('features/array/every') === 'function');
ok(typeof load('features/array/reduce') === 'function');
ok(typeof load('features/array/reduce-right') === 'function');
ok(typeof load('features/array/reverse') === 'function');
ok(typeof load('features/array/index-of') === 'function');
ok(typeof load('features/array/last-index-of') === 'function');
ok(load('features/array/concat')([1, 2, 3], [4, 5, 6]).length === 6);
ok(load('features/array/copy-within')([1, 2, 3, 4, 5], 0, 3)[0] === 4);
ok('next' in load('features/array/entries')([]));
load('features/array/last-item');
load('features/array/last-index');
ok(load('features/array/fill')(Array(5), 2)[0] === 2);
ok(load('features/array/find')([2, 3, 4], it => it % 2) === 3);
ok(load('features/array/find-index')([2, 3, 4], it => it % 2) === 1);
ok('next' in load('features/array/keys')([]));
ok('next' in load('features/array/values')([]));
ok(load('features/array/includes')([1, 2, 3], 2));
ok('next' in load('features/array/iterator')([]));
ok(load('features/array/virtual/join').call('qwe', 1) === 'q1w1e');
ok(load('features/array/virtual/slice').call('qwe', 1)[1] === 'e');
ok(load('features/array/virtual/splice').call([1, 2, 3], 1, 2)[0] === 2);
ok(load('features/array/virtual/sort').call([1, 3, 2])[1] === 2);
ok(typeof load('features/array/virtual/for-each') === 'function');
ok(typeof load('features/array/virtual/map') === 'function');
ok(typeof load('features/array/virtual/filter') === 'function');
ok(typeof load('features/array/virtual/flat') === 'function');
ok(typeof load('features/array/virtual/flat-map') === 'function');
ok(typeof load('features/array/virtual/some') === 'function');
ok(typeof load('features/array/virtual/every') === 'function');
ok(typeof load('features/array/virtual/reduce') === 'function');
ok(typeof load('features/array/virtual/reduce-right') === 'function');
ok(typeof load('features/array/virtual/reverse') === 'function');
ok(typeof load('features/array/virtual/index-of') === 'function');
ok(typeof load('features/array/virtual/last-index-of') === 'function');
ok(load('features/array/virtual/concat').call([1, 2, 3], [4, 5, 6]).length === 6);
ok(load('features/array/virtual/copy-within').call([1, 2, 3, 4, 5], 0, 3)[0] === 4);
ok('next' in load('features/array/virtual/entries').call([]));
ok(load('features/array/virtual/fill').call(Array(5), 2)[0] === 2);
ok(load('features/array/virtual/find').call([2, 3, 4], it => it % 2) === 3);
ok(load('features/array/virtual/find-index').call([2, 3, 4], it => it % 2) === 1);
ok('next' in load('features/array/virtual/keys').call([]));
ok('next' in load('features/array/virtual/values').call([]));
ok(load('features/array/virtual/includes').call([1, 2, 3], 2));
ok('next' in load('features/array/virtual/iterator').call([]));
ok(load('features/array/virtual').includes.call([1, 2, 3], 2));
ok('from' in load('features/array'));
ok(load('features/array/splice')([1, 2, 3], 1, 2)[0] === 2);
ok(load('features/math/acosh')(1) === 0);
ok(Object.is(load('features/math/asinh')(-0), -0));
ok(load('features/math/atanh')(1) === Infinity);
ok(load('features/math/cbrt')(-8) === -2);
ok(load('features/math/clz32')(0) === 32);
ok(load('features/math/cosh')(0) === 1);
ok(load('features/math/expm1')(-Infinity) === -1);
ok(load('features/math/fround')(0) === 0);
ok(load('features/math/hypot')(3, 4) === 5);
ok(load('features/math/imul')(2, 2) === 4);
ok(load('features/math/log10')(-0) === -Infinity);
ok(load('features/math/log1p')(-1) === -Infinity);
ok(load('features/math/log2')(1) === 0);
ok(load('features/math/sign')(-2) === -1);
ok(Object.is(load('features/math/sinh')(-0), -0));
ok(load('features/math/tanh')(Infinity) === 1);
ok(load('features/math/to-string-tag') === 'Math');
ok(load('features/math/trunc')(1.5) === 1);
ok(load('features/math/clamp')(6, 2, 4) === 4);
ok(load('features/math/deg-per-rad') === Math.PI / 180);
ok(load('features/math/degrees')(Math.PI) === 180);
ok(load('features/math/fscale')(3, 1, 2, 1, 2) === 3);
ok(load('features/math/iaddh')(3, 2, 0xFFFFFFFF, 4) === 7);
ok(load('features/math/isubh')(3, 4, 0xFFFFFFFF, 2) === 1);
ok(load('features/math/imulh')(0xFFFFFFFF, 7) === -1);
ok(load('features/math/rad-per-deg') === 180 / Math.PI);
ok(load('features/math/radians')(180) === Math.PI);
ok(load('features/math/scale')(3, 1, 2, 1, 2) === 3);
ok(load('features/math/umulh')(0xFFFFFFFF, 7) === 6);
ok(load('features/math/signbit')(-2) === true);
ok(typeof load('features/math/seeded-prng')({ seed: 42 }).next().value === 'number');
ok(load('features/number/constructor')('5') === 5);
ok(load('features/number/epsilon') === 2 ** -52);
ok(load('features/number/is-finite')(42.5));
ok(load('features/number/is-integer')(42.5) === false);
ok(load('features/number/is-nan')(NaN));
ok(load('features/number/is-safe-integer')(42));
ok(load('features/number/max-safe-integer') === 0x1FFFFFFFFFFFFF);
ok(load('features/number/min-safe-integer') === -0x1FFFFFFFFFFFFF);
ok(load('features/number/parse-float')('1.5') === 1.5);
ok(load('features/number/parse-int')('2.1') === 2);
ok(load('features/number/to-fixed')(1, 1) === '1.0');
ok(load('features/number/to-precision')(1) === '1');
ok(load('features/number/from-string')('12', 3) === 5);
ok(load('features/parse-float')('1.5') === 1.5);
ok(load('features/parse-int')('2.1') === 2);
ok(load('features/number/virtual/to-fixed').call(1, 1) === '1.0');
ok(load('features/number/virtual/to-precision').call(1) === '1');
ok(load('features/number/virtual').toFixed.call(42, 2) === '42.00');
ok('isNaN' in load('features/number'));
ok(load('features/reflect/apply')((a, b) => a + b, null, [1, 2]) === 3);
ok(load('features/reflect/construct')(function () {
return this.a = 2;
}, []).a === 2);
let O;
load('features/reflect/define-property')(O = {}, 'a', { value: 42 });
ok(O.a === 42);
ok(load('features/reflect/delete-property')({ q: 1 }, 'q'));
ok(load('features/reflect/get')({ q: 1 }, 'q') === 1);
ok(load('features/reflect/get-own-property-descriptor')({ q: 1 }, 'q').enumerable);
ok(load('features/reflect/get-prototype-of')([]) === Array.prototype);
ok(load('features/reflect/has')({ q: 1 }, 'q'));
ok(load('features/reflect/is-extensible')({}));
ok(load('features/reflect/own-keys')({ q: 1 })[0] === 'q');
ok(load('features/reflect/prevent-extensions')({}));
ok(load('features/reflect/set')({}, 'a', 42));
load('features/reflect/set-prototype-of')(O = {}, []);
ok(O instanceof Array);
ok(typeof load('features/reflect/define-metadata') === 'function');
ok(typeof load('features/reflect/delete-metadata') === 'function');
ok(typeof load('features/reflect/get-metadata') === 'function');
ok(typeof load('features/reflect/get-metadata-keys') === 'function');
ok(typeof load('features/reflect/get-own-metadata') === 'function');
ok(typeof load('features/reflect/get-own-metadata-keys') === 'function');
ok(typeof load('features/reflect/has-metadata') === 'function');
ok(typeof load('features/reflect/has-own-metadata') === 'function');
ok(typeof load('features/reflect/metadata') === 'function');
ok('has' in load('features/reflect'));
ok(load('features/string/from-code-point')(97) === 'a');
ok(load('features/string/raw')({ raw: 'test' }, 0, 1, 2) === 't0e1s2t');
ok(load('features/string/trim')(' ab ') === 'ab');
ok(load('features/string/code-point-at')('a', 0) === 97);
ok(load('features/string/ends-with')('qwe', 'we'));
ok(load('features/string/includes')('qwe', 'w'));
ok(load('features/string/repeat')('q', 3) === 'qqq');
ok(load('features/string/starts-with')('qwe', 'qw'));
ok(typeof load('features/string/anchor') === 'function');
ok(typeof load('features/string/big') === 'function');
ok(typeof load('features/string/blink') === 'function');
ok(typeof load('features/string/bold') === 'function');
ok(typeof load('features/string/fixed') === 'function');
ok(typeof load('features/string/fontcolor') === 'function');
ok(typeof load('features/string/fontsize') === 'function');
ok(typeof load('features/string/italics') === 'function');
ok(typeof load('features/string/link') === 'function');
ok(typeof load('features/string/small') === 'function');
ok(typeof load('features/string/strike') === 'function');
ok(typeof load('features/string/sub') === 'function');
ok(typeof load('features/string/sup') === 'function');
ok(load('features/string/at')('a', 0) === 'a');
ok('next' in load('features/string/code-points')('a'));
ok(load('features/string/pad-start')('a', 3) === ' a');
ok(load('features/string/pad-end')('a', 3) === 'a ');
ok(load('features/string/trim-start')(' a ') === 'a ');
ok(load('features/string/trim-end')(' a ') === ' a');
ok(load('features/string/trim-left')(' a ') === 'a ');
ok(load('features/string/trim-right')(' a ') === ' a');
ok('next' in load('features/string/match-all')('a', /./g));
ok(typeof load('features/string/replace-all') === 'function');
ok('next' in load('features/string/iterator')('qwe'));
ok(load('features/string/virtual/code-point-at').call('a', 0) === 97);
ok(load('features/string/virtual/ends-with').call('qwe', 'we'));
ok(load('features/string/virtual/includes').call('qwe', 'w'));
ok(load('features/string/virtual/repeat').call('q', 3) === 'qqq');
ok(load('features/string/virtual/starts-with').call('qwe', 'qw'));
ok(typeof load('features/string/virtual/anchor') === 'function');
ok(typeof load('features/string/virtual/big') === 'function');
ok(typeof load('features/string/virtual/blink') === 'function');
ok(typeof load('features/string/virtual/bold') === 'function');
ok(typeof load('features/string/virtual/fixed') === 'function');
ok(typeof load('features/string/virtual/fontcolor') === 'function');
ok(typeof load('features/string/virtual/fontsize') === 'function');
ok(typeof load('features/string/virtual/italics') === 'function');
ok(typeof load('features/string/virtual/link') === 'function');
ok(typeof load('features/string/virtual/small') === 'function');
ok(typeof load('features/string/virtual/strike') === 'function');
ok(typeof load('features/string/virtual/sub') === 'function');
ok(typeof load('features/string/virtual/sup') === 'function');
ok(load('features/string/virtual/at').call('a', 0) === 'a');
ok('next' in load('features/string/virtual/code-points').call('a'));
ok(load('features/string/virtual/pad-start').call('a', 3) === ' a');
ok(load('features/string/virtual/pad-end').call('a', 3) === 'a ');
ok(load('features/string/virtual/trim-start').call(' a ') === 'a ');
ok(load('features/string/virtual/trim-end').call(' a ') === ' a');
ok(load('features/string/virtual/trim-left').call(' a ') === 'a ');
ok(load('features/string/virtual/trim-right').call(' a ') === ' a');
ok('next' in load('features/string/virtual/match-all').call('a', /./g));
ok(typeof load('features/string/virtual/replace-all') === 'function');
ok(load('features/string/virtual').at.call('a', 0) === 'a');
ok('next' in load('features/string/virtual/iterator').call('qwe'));
ok('raw' in load('features/string'));
ok(String(load('features/regexp/constructor')('a', 'g')) === '/a/g');
ok(load('features/regexp/to-string')(/./g) === '/./g');
ok(load('features/regexp/flags')(/./g) === 'g');
ok(typeof load('features/regexp/match') === 'function');
ok(typeof load('features/regexp/replace') === 'function');
ok(typeof load('features/regexp/search') === 'function');
ok(typeof load('features/regexp/split') === 'function');
ok(typeof load('features/regexp/sticky') === 'function');
ok(typeof load('features/regexp/test') === 'function');
load('features/regexp');
ok(load('features/json').stringify([1]) === '[1]');
ok(load('features/json/stringify')([1]) === '[1]');
ok(load('features/json/to-string-tag') === 'JSON');
ok(typeof load('features/date/now')(new Date()) === 'number');
ok(typeof load('features/date/to-string')(new Date()) === 'string');
ok(typeof load('features/date/to-primitive')(new Date(), 'number') === 'number');
ok(typeof load('features/date/to-iso-string')(new Date()) === 'string');
ok(load('features/date/to-json')(Infinity) === null);
ok(load('features/date'));
load('features/symbol/description');
ok(load('features/symbol/has-instance'));
ok(load('features/symbol/is-concat-spreadable'));
ok(load('features/symbol/iterator'));
ok(load('features/symbol/match'));
ok(load('features/symbol/match-all'));
ok(load('features/symbol/replace'));
ok(load('features/symbol/search'));
ok(load('features/symbol/species'));
ok(load('features/symbol/split'));
ok(load('features/symbol/to-primitive'));
ok(load('features/symbol/to-string-tag'));
ok(load('features/symbol/unscopables'));
ok(load('features/symbol/async-iterator'));
ok(load('features/symbol/observable'));
ok(load('features/symbol/pattern-match'));
ok(load('features/symbol/replace-all'));
ok(load('features/symbol/async-dispose'));
ok(load('features/symbol/dispose'));
ok(typeof load('features/symbol/for') === 'function');
ok(typeof load('features/symbol/key-for') === 'function');
ok('iterator' in load('features/symbol'));
let Map = load('features/map');
let Set = load('features/set');
let WeakMap = load('features/weak-map');
let WeakSet = load('features/weak-set');
ok(new Map([[1, 2], [3, 4]]).size === 2);
ok(new Set([1, 2, 3, 2, 1]).size === 3);
ok(new WeakMap([[O = {}, 42]]).get(O) === 42);
ok(new WeakSet([O = {}]).has(O));
ok(load('features/map/of')([1, 2], [3, 4]) instanceof Map);
ok(load('features/set/of')(1, 2, 3, 2, 1) instanceof Set);
ok(load('features/weak-map/of')([{}, 1], [[], 2]) instanceof WeakMap);
ok(load('features/weak-set/of')({}, []) instanceof WeakSet);
ok(load('features/map/from')([[1, 2], [3, 4]]) instanceof Map);
ok(load('features/set/from')([1, 2, 3, 2, 1]) instanceof Set);
ok(load('features/weak-map/from')([[{}, 1], [[], 2]]) instanceof WeakMap);
ok(load('features/weak-set/from')([{}, []]) instanceof WeakSet);
ok(load('features/map/delete-all')(new Map(), 1, 2) === false);
ok(load('features/map/every')(new Map([[1, 2], [2, 3], [3, 4]]), it => it % 2) === false);
ok(load('features/map/filter')(new Map([[1, 2], [2, 3], [3, 4]]), it => it % 2).size === 1);
ok(load('features/map/find')(new Map([[1, 2], [2, 3], [3, 4]]), it => it % 2) === 3);
ok(load('features/map/find-key')(new Map([[1, 2], [2, 3], [3, 4]]), it => it % 2) === 2);
ok(load('features/map/group-by')([], it => it) instanceof Map);
ok(load('features/map/includes')(new Map([[1, 2]]), 2), true);
ok(load('features/map/key-by')([], it => it) instanceof Map);
ok(load('features/map/key-of')(new Map([[1, 2]]), 2), 1);
ok(load('features/map/map-keys')(new Map([[1, 2], [2, 3], [3, 4]]), it => it).size === 3);
ok(load('features/map/map-values')(new Map([[1, 2], [2, 3], [3, 4]]), it => it).size === 3);
ok(load('features/map/merge')(new Map([[1, 2], [2, 3]]), [[2, 4], [4, 5]]).size === 3);
ok(load('features/map/reduce')(new Map([[1, 2], [2, 3], [3, 4]]), (a, b) => a + b) === 9);
ok(load('features/map/some')(new Map([[1, 2], [2, 3], [3, 4]]), it => it % 2) === true);
ok(load('features/map/update')(new Map([[1, 2]]), 1, it => it * 2).get(1) === 4);
ok(load('features/map/update-or-insert')(new Map([[1, 2]]), 1, it => it ** 2, () => 42) === 4);
ok(load('features/map/upsert')(new Map([[1, 2]]), 1, it => it ** 2, () => 42) === 4);
ok(load('features/set/add-all')(new Set([1, 2, 3]), 4, 5).size === 5);
ok(load('features/set/delete-all')(new Set([1, 2, 3]), 4, 5) === false);
ok(load('features/set/difference')(new Set([1, 2, 3]), [3, 4, 5]).size === 2);
ok(load('features/set/every')(new Set([1, 2, 3]), it => typeof it == 'number'));
ok(load('features/set/filter')(new Set([1, 2, 3]), it => it % 2).size === 2);
ok(load('features/set/find')(new Set([2, 3, 4]), it => it % 2) === 3);
ok(load('features/set/intersection')(new Set([1, 2, 3]), [1, 3, 4]).size === 2);
ok(load('features/set/is-disjoint-from')(new Set([1, 2, 3]), [4, 5, 6]));
ok(load('features/set/is-subset-of')(new Set([1, 2, 3]), [1, 2, 3, 4]));
ok(load('features/set/is-superset-of')(new Set([1, 2, 3, 4]), [1, 2, 3]));
ok(load('features/set/join')(new Set([1, 2, 3])) === '1,2,3');
ok(load('features/set/map')(new Set([1, 2, 3]), it => it % 2).size === 2);
ok(load('features/set/reduce')(new Set([1, 2, 3]), (it, v) => it + v) === 6);
ok(load('features/set/some')(new Set([1, 2, 3]), it => typeof it == 'number'));
ok(load('features/set/symmetric-difference')(new Set([1, 2, 3]), [3, 4, 5]).size === 4);
ok(load('features/set/union')(new Set([1, 2, 3]), [3, 4, 5]).size === 5);
ok(load('features/weak-map/delete-all')(new WeakMap(), [], {}) === false);
ok(load('features/weak-map/upsert')(new WeakMap(), {}, null, () => 42) === 42);
ok(load('features/weak-set/add-all')(new WeakSet(), [], {}) instanceof WeakSet);
ok(load('features/weak-set/delete-all')(new WeakSet(), [], {}) === false);
let Promise = load('features/promise');
ok('all' in Promise);
ok(load('features/promise/all-settled')([1, 2, 3]) instanceof Promise);
ok(load('features/promise/any')([1, 2, 3]) instanceof Promise);
ok(load('features/promise/try')(() => 42) instanceof load('features/promise'));
ok(new (load('features/aggregate-error'))([42]).errors[0] === 42);
ok('from' in load('features/observable'));
ok(load('es/global-this').Math === Math);
ok(load('stable/global-this').Math === Math);
ok(load('features/global-this').Math === Math);
ok(typeof load('features/dom-collections').iterator === 'function');
ok(typeof load('features/dom-collections/iterator') === 'function');
ok(typeof load('features/set-timeout') === 'function');
ok(typeof load('features/set-interval') === 'function');
ok(typeof load('features/set-immediate') === 'function');
ok(typeof load('features/clear-immediate') === 'function');
ok(typeof load('features/queue-microtask') === 'function');
ok(typeof load('features/composite-key')({}, 1, {}) === 'object');
ok(typeof load('features/composite-symbol')({}, 1, {}) === 'symbol');
ok(typeof load('features/async-iterator') === 'function');
ok(typeof load('features/async-iterator/as-indexed-pairs') === 'function');
ok(typeof load('features/async-iterator/drop') === 'function');
ok(typeof load('features/async-iterator/every') === 'function');
ok(typeof load('features/async-iterator/filter') === 'function');
ok(typeof load('features/async-iterator/find') === 'function');
ok(typeof load('features/async-iterator/flat-map') === 'function');
ok(typeof load('features/async-iterator/for-each') === 'function');
ok(typeof load('features/async-iterator/from') === 'function');
ok(typeof load('features/async-iterator/map') === 'function');
ok(typeof load('features/async-iterator/reduce') === 'function');
ok(typeof load('features/async-iterator/some') === 'function');
ok(typeof load('features/async-iterator/take') === 'function');
ok(typeof load('features/async-iterator/to-array') === 'function');
ok(typeof load('features/iterator') === 'function');
ok(typeof load('features/iterator/as-indexed-pairs') === 'function');
ok(typeof load('features/iterator/drop') === 'function');
ok(typeof load('features/iterator/every') === 'function');
ok(typeof load('features/iterator/filter') === 'function');
ok(typeof load('features/iterator/find') === 'function');
ok(typeof load('features/iterator/flat-map') === 'function');
ok(typeof load('features/iterator/for-each') === 'function');
ok(typeof load('features/iterator/from') === 'function');
ok(typeof load('features/iterator/map') === 'function');
ok(typeof load('features/iterator/reduce') === 'function');
ok(typeof load('features/iterator/some') === 'function');
ok(typeof load('features/iterator/take') === 'function');
ok(typeof load('features/iterator/to-array') === 'function');
ok(typeof load('features/url') === 'function');
load('features/url/to-json');
ok(typeof load('features/url-search-params') === 'function');
ok(load('features/is-iterable')([]));
ok(typeof load('features/get-iterator-method')([]) === 'function');
ok('next' in load('features/get-iterator')([]));
ok(load('features'));
ok(load('stable/object/assign')({ q: 1 }, { w: 2 }).w === 2);
ok(load('stable/object/create')(Array.prototype) instanceof Array);
ok(load('stable/object/define-property')({}, 'a', { value: 42 }).a === 42);
ok(load('stable/object/define-properties')({}, { a: { value: 42 } }).a === 42);
ok(load('stable/object/freeze')({}));
ok(load('stable/object/get-own-property-descriptor')({ q: 1 }, 'q').enumerable);
ok(load('stable/object/get-own-property-names')({ q: 42 })[0] === 'q');
ok(load('stable/object/get-own-property-symbols')({ [Symbol()]: 42 }).length === 1);
ok(load('stable/object/get-prototype-of')([]) === Array.prototype);
ok(load('stable/object/is')(NaN, NaN));
ok(load('stable/object/is-extensible')({}));
ok(!load('stable/object/is-frozen')({}));
ok(!load('stable/object/is-sealed')({}));
ok(load('stable/object/keys')({ q: 0 })[0] === 'q');
ok(load('stable/object/prevent-extensions')({}));
ok(load('stable/object/seal')({}));
ok(load('stable/object/set-prototype-of')({}, []) instanceof Array);
ok(load('stable/object/to-string')([]) === '[object Array]');
ok(load('stable/object/entries')({ q: 2 })[0][0] === 'q');
ok(load('stable/object/from-entries')([['a', 42]]).a === 42);
ok(load('stable/object/values')({ q: 2 })[0] === 2);
ok(load('stable/object/get-own-property-descriptors')({ q: 1 }).q.enumerable);
ok(typeof load('stable/object/define-getter') === 'function');
ok(typeof load('stable/object/define-setter') === 'function');
ok(typeof load('stable/object/lookup-getter') === 'function');
ok(typeof load('stable/object/lookup-setter') === 'function');
ok('values' in load('stable/object'));
ok(load('stable/function/bind')(function (a, b) {
return this + a + b;
}, 1, 2)(3) === 6);
ok(load('stable/function/virtual/bind').call(function (a, b) {
return this + a + b;
}, 1, 2)(3) === 6);
ok(load('stable/function/virtual').bind.call(function (a, b) {
return this + a + b;
}, 1, 2)(3) === 6);
load('stable/function/name');
load('stable/function/has-instance');
// eslint-disable-next-line prefer-arrow-callback
ok(Function[load('stable/symbol/has-instance')](function () { /* empty */ }));
ok('bind' in load('stable/function'));
ok(load('stable/array/is-array')([]));
ok(Array.isArray(load('stable/array/from')('qwe')));
ok(Array.isArray(load('stable/array/of')('q', 'w', 'e')));
ok(load('stable/array/join')('qwe', 1) === 'q1w1e');
ok(load('stable/array/slice')('qwe', 1)[1] === 'e');
ok(load('stable/array/sort')([1, 3, 2])[1] === 2);
ok(typeof load('stable/array/for-each') === 'function');
ok(typeof load('stable/array/map') === 'function');
ok(typeof load('stable/array/filter') === 'function');
ok(typeof load('stable/array/flat') === 'function');
ok(typeof load('stable/array/flat-map') === 'function');
ok(typeof load('stable/array/some') === 'function');
ok(typeof load('stable/array/every') === 'function');
ok(typeof load('stable/array/reduce') === 'function');
ok(typeof load('stable/array/reduce-right') === 'function');
ok(typeof load('stable/array/reverse') === 'function');
ok(typeof load('stable/array/index-of') === 'function');
ok(typeof load('stable/array/last-index-of') === 'function');
ok(load('stable/array/concat')([1, 2, 3], [4, 5, 6]).length === 6);
ok(load('stable/array/copy-within')([1, 2, 3, 4, 5], 0, 3)[0] === 4);
ok('next' in load('stable/array/entries')([]));
ok(load('stable/array/fill')(Array(5), 2)[0] === 2);
ok(load('stable/array/find')([2, 3, 4], it => it % 2) === 3);
ok(load('stable/array/find-index')([2, 3, 4], it => it % 2) === 1);
ok('next' in load('stable/array/keys')([]));
ok('next' in load('stable/array/values')([]));
ok(load('stable/array/includes')([1, 2, 3], 2));
ok('next' in load('stable/array/iterator')([]));
ok(load('stable/array/virtual/join').call('qwe', 1) === 'q1w1e');
ok(load('stable/array/virtual/slice').call('qwe', 1)[1] === 'e');
ok(load('stable/array/virtual/splice').call([1, 2, 3], 1, 2)[0] === 2);
ok(load('stable/array/virtual/sort').call([1, 3, 2])[1] === 2);
ok(typeof load('stable/array/virtual/for-each') === 'function');
ok(typeof load('stable/array/virtual/map') === 'function');
ok(typeof load('stable/array/virtual/filter') === 'function');
ok(typeof load('stable/array/virtual/flat') === 'function');
ok(typeof load('stable/array/virtual/flat-map') === 'function');
ok(typeof load('stable/array/virtual/some') === 'function');
ok(typeof load('stable/array/virtual/every') === 'function');
ok(typeof load('stable/array/virtual/reduce') === 'function');
ok(typeof load('stable/array/virtual/reduce-right') === 'function');
ok(typeof load('stable/array/virtual/reverse') === 'function');
ok(typeof load('stable/array/virtual/index-of') === 'function');
ok(typeof load('stable/array/virtual/last-index-of') === 'function');
ok(load('stable/array/virtual/concat').call([1, 2, 3], [4, 5, 6]).length === 6);
ok(load('stable/array/virtual/copy-within').call([1, 2, 3, 4, 5], 0, 3)[0] === 4);
ok('next' in load('stable/array/virtual/entries').call([]));
ok(load('stable/array/virtual/fill').call(Array(5), 2)[0] === 2);
ok(load('stable/array/virtual/find').call([2, 3, 4], it => it % 2) === 3);
ok(load('stable/array/virtual/find-index').call([2, 3, 4], it => it % 2) === 1);
ok('next' in load('stable/array/virtual/keys').call([]));
ok('next' in load('stable/array/virtual/values').call([]));
ok(load('stable/array/virtual/includes').call([1, 2, 3], 2));
ok('next' in load('stable/array/virtual/iterator').call([]));
ok(load('stable/array/virtual').includes.call([1, 2, 3], 2));
ok('from' in load('stable/array'));
ok(load('stable/array/splice')([1, 2, 3], 1, 2)[0] === 2);
ok(load('stable/math/acosh')(1) === 0);
ok(Object.is(load('stable/math/asinh')(-0), -0));
ok(load('stable/math/atanh')(1) === Infinity);
ok(load('stable/math/cbrt')(-8) === -2);
ok(load('stable/math/clz32')(0) === 32);
ok(load('stable/math/cosh')(0) === 1);
ok(load('stable/math/expm1')(-Infinity) === -1);
ok(load('stable/math/fround')(0) === 0);
ok(load('stable/math/hypot')(3, 4) === 5);
ok(load('stable/math/imul')(2, 2) === 4);
ok(load('stable/math/log10')(-0) === -Infinity);
ok(load('stable/math/log1p')(-1) === -Infinity);
ok(load('stable/math/log2')(1) === 0);
ok(load('stable/math/sign')(-2) === -1);
ok(Object.is(load('stable/math/sinh')(-0), -0));
ok(load('stable/math/tanh')(Infinity) === 1);
ok(load('stable/math/to-string-tag') === 'Math');
ok(load('stable/math/trunc')(1.5) === 1);
ok(load('stable/number/constructor')('5') === 5);
ok(load('stable/number/epsilon') === 2 ** -52);
ok(load('stable/number/is-finite')(42.5));
ok(load('stable/number/is-integer')(42.5) === false);
ok(load('stable/number/is-nan')(NaN));
ok(load('stable/number/is-safe-integer')(42));
ok(load('stable/number/max-safe-integer') === 0x1FFFFFFFFFFFFF);
ok(load('stable/number/min-safe-integer') === -0x1FFFFFFFFFFFFF);
ok(load('stable/number/parse-float')('1.5') === 1.5);
ok(load('stable/number/parse-int')('2.1') === 2);
ok(load('stable/number/to-fixed')(1, 1) === '1.0');
ok(load('stable/number/to-precision')(1) === '1');
ok(load('stable/parse-float')('1.5') === 1.5);
ok(load('stable/parse-int')('2.1') === 2);
ok(load('stable/number/virtual/to-fixed').call(1, 1) === '1.0');
ok(load('stable/number/virtual/to-precision').call(1) === '1');
ok(load('stable/number/virtual').toFixed.call(42, 2) === '42.00');
ok('isNaN' in load('stable/number'));
ok(load('stable/reflect/apply')((a, b) => a + b, null, [1, 2]) === 3);
ok(load('stable/reflect/construct')(function () {
return this.a = 2;
}, []).a === 2);
load('stable/reflect/define-property')(O = {}, 'a', { value: 42 });
ok(O.a === 42);
ok(load('stable/reflect/delete-property')({ q: 1 }, 'q'));
ok(load('stable/reflect/get')({ q: 1 }, 'q') === 1);
ok(load('stable/reflect/get-own-property-descriptor')({ q: 1 }, 'q').enumerable);
ok(load('stable/reflect/get-prototype-of')([]) === Array.prototype);
ok(load('stable/reflect/has')({ q: 1 }, 'q'));
ok(load('stable/reflect/is-extensible')({}));
ok(load('stable/reflect/own-keys')({ q: 1 })[0] === 'q');
ok(load('stable/reflect/prevent-extensions')({}));
ok(load('stable/reflect/set')({}, 'a', 42));
load('stable/reflect/set-prototype-of')(O = {}, []);
ok(O instanceof Array);
ok('has' in load('stable/reflect'));
ok(load('stable/string/from-code-point')(97) === 'a');
ok(load('stable/string/raw')({ raw: 'test' }, 0, 1, 2) === 't0e1s2t');
ok(load('stable/string/trim')(' ab ') === 'ab');
ok(load('stable/string/code-point-at')('a', 0) === 97);
ok(load('stable/string/ends-with')('qwe', 'we'));
ok(load('stable/string/includes')('qwe', 'w'));
ok(load('stable/string/repeat')('q', 3) === 'qqq');
ok('next' in load('stable/string/match-all')('a', /./g));
ok(load('stable/string/starts-with')('qwe', 'qw'));
ok(typeof load('stable/string/anchor') === 'function');
ok(typeof load('stable/string/big') === 'function');
ok(typeof load('stable/string/blink') === 'function');
ok(typeof load('stable/string/bold') === 'function');
ok(typeof load('stable/string/fixed') === 'function');
ok(typeof load('stable/string/fontcolor') === 'function');
ok(typeof load('stable/string/fontsize') === 'function');
ok(typeof load('stable/string/italics') === 'function');
ok(typeof load('stable/string/link') === 'function');
ok(typeof load('stable/string/small') === 'function');
ok(typeof load('stable/string/strike') === 'function');
ok(typeof load('stable/string/sub') === 'function');
ok(typeof load('stable/string/sup') === 'function');
ok(load('stable/string/pad-start')('a', 3) === ' a');
ok(load('stable/string/pad-end')('a', 3) === 'a ');
ok(load('stable/string/trim-start')(' a ') === 'a ');
ok(load('stable/string/trim-end')(' a ') === ' a');
ok(load('stable/string/trim-left')(' a ') === 'a ');
ok(load('stable/string/trim-right')(' a ') === ' a');
ok('next' in load('stable/string/iterator')('qwe'));
ok(load('stable/string/virtual/code-point-at').call('a', 0) === 97);
ok(load('stable/string/virtual/ends-with').call('qwe', 'we'));
ok(load('stable/string/virtual/includes').call('qwe', 'w'));
ok(load('stable/string/virtual/repeat').call('q', 3) === 'qqq');
ok(load('stable/string/virtual/starts-with').call('qwe', 'qw'));
ok(typeof load('stable/string/virtual/anchor') === 'function');
ok(typeof load('stable/string/virtual/big') === 'function');
ok(typeof load('stable/string/virtual/blink') === 'function');
ok(typeof load('stable/string/virtual/bold') === 'function');
ok(typeof load('stable/string/virtual/fixed') === 'function');
ok(typeof load('stable/string/virtual/fontcolor') === 'function');
ok(typeof load('stable/string/virtual/fontsize') === 'function');
ok(typeof load('stable/string/virtual/italics') === 'function');
ok(typeof load('stable/string/virtual/link') === 'function');
ok(typeof load('stable/string/virtual/small') === 'function');
ok(typeof load('stable/string/virtual/strike') === 'function');
ok(typeof load('stable/string/virtual/sub') === 'function');
ok(typeof load('stable/string/virtual/sup') === 'function');
ok(load('stable/string/virtual/pad-start').call('a', 3) === ' a');
ok(load('stable/string/virtual/pad-end').call('a', 3) === 'a ');
ok(load('stable/string/virtual/trim-start').call(' a ') === 'a ');
ok(load('stable/string/virtual/trim-end').call(' a ') === ' a');
ok(load('stable/string/virtual/trim-left').call(' a ') === 'a ');
ok(load('stable/string/virtual/trim-right').call(' a ') === ' a');
ok(load('stable/string/virtual').at.call('a', 0) === 'a');
ok('next' in load('stable/string/virtual/iterator').call('qwe'));
ok('raw' in load('stable/string'));
ok(String(load('stable/regexp/constructor')('a', 'g')) === '/a/g');
ok(load('stable/regexp/to-string')(/./g) === '/./g');
ok(load('stable/regexp/flags')(/./g) === 'g');
ok(typeof load('stable/regexp/match') === 'function');
ok(typeof load('stable/regexp/replace') === 'function');
ok(typeof load('stable/regexp/search') === 'function');
ok(typeof load('stable/regexp/split') === 'function');
ok(typeof load('stable/regexp/sticky') === 'function');
ok(typeof load('stable/regexp/test') === 'function');
load('stable/regexp');
ok(load('stable/json').stringify([1]) === '[1]');
ok(load('stable/json/stringify')([1]) === '[1]');
ok(load('stable/json/to-string-tag') === 'JSON');
ok(typeof load('stable/date/now')(new Date()) === 'number');
ok(typeof load('stable/date/to-string')(new Date()) === 'string');
ok(typeof load('stable/date/to-primitive')(new Date(), 'number') === 'number');
ok(typeof load('stable/date/to-iso-string')(new Date()) === 'string');
ok(load('stable/date/to-json')(Infinity) === null);
ok(load('stable/date'));
load('stable/symbol/description');
ok(load('stable/symbol/has-instance'));
ok(load('stable/symbol/is-concat-spreadable'));
ok(load('stable/symbol/iterator'));
ok(load('stable/symbol/match'));
ok(load('stable/symbol/match-all'));
ok(load('stable/symbol/replace'));
ok(load('stable/symbol/search'));
ok(load('stable/symbol/species'));
ok(load('stable/symbol/split'));
ok(load('stable/symbol/to-primitive'));
ok(load('stable/symbol/to-string-tag'));
ok(load('stable/symbol/unscopables'));
ok(load('stable/symbol/async-iterator'));
ok(typeof load('stable/symbol/for') === 'function');
ok(typeof load('stable/symbol/key-for') === 'function');
ok('iterator' in load('stable/symbol'));
Map = load('stable/map');
Set = load('stable/set');
WeakMap = load('stable/weak-map');
WeakSet = load('stable/weak-set');
ok(new Map([[1, 2], [3, 4]]).size === 2);
ok(new Set([1, 2, 3, 2, 1]).size === 3);
ok(new WeakMap([[O = {}, 42]]).get(O) === 42);
ok(new WeakSet([O = {}]).has(O));
Promise = load('stable/promise');
ok('all' in Promise);
ok(load('stable/promise/all-settled')([1, 2, 3]) instanceof Promise);
ok(typeof load('stable/dom-collections').iterator === 'function');
ok(typeof load('stable/dom-collections/iterator') === 'function');
ok(typeof load('stable/set-timeout') === 'function');
ok(typeof load('stable/set-interval') === 'function');
ok(typeof load('stable/set-immediate') === 'function');
ok(typeof load('stable/clear-immediate') === 'function');
ok(typeof load('stable/queue-microtask') === 'function');
ok(typeof load('stable/url') === 'function');
load('stable/url/to-json');
ok(typeof load('stable/url-search-params') === 'function');
ok(load('stable'));
ok(load('es/object/assign')({ q: 1 }, { w: 2 }).w === 2);
ok(load('es/object/create')(Array.prototype) instanceof Array);
ok(load('es/object/define-property')({}, 'a', { value: 42 }).a === 42);
ok(load('es/object/define-properties')({}, { a: { value: 42 } }).a === 42);
ok(load('es/object/freeze')({}));
ok(load('es/object/get-own-property-descriptor')({ q: 1 }, 'q').enumerable);
ok(load('es/object/get-own-property-names')({ q: 42 })[0] === 'q');
ok(load('es/object/get-own-property-symbols')({ [Symbol()]: 42 }).length === 1);
ok(load('es/object/get-prototype-of')([]) === Array.prototype);
ok(load('es/object/is')(NaN, NaN));
ok(load('es/object/is-extensible')({}));
ok(!load('es/object/is-frozen')({}));
ok(!load('es/object/is-sealed')({}));
ok(load('es/object/keys')({ q: 0 })[0] === 'q');
ok(load('es/object/prevent-extensions')({}));
ok(load('es/object/seal')({}));
ok(load('es/object/set-prototype-of')({}, []) instanceof Array);
ok(load('es/object/to-string')([]) === '[object Array]');
ok(load('es/object/entries')({ q: 2 })[0][0] === 'q');
ok(load('es/object/from-entries')([['a', 42]]).a === 42);
ok(load('es/object/values')({ q: 2 })[0] === 2);
ok(load('es/object/get-own-property-descriptors')({ q: 1 }).q.enumerable);
ok(typeof load('es/object/define-getter') === 'function');
ok(typeof load('es/object/define-setter') === 'function');
ok(typeof load('es/object/lookup-getter') === 'function');
ok(typeof load('es/object/lookup-setter') === 'function');
ok('values' in load('es/object'));
ok(load('es/function/bind')(function (a, b) {
return this + a + b;
}, 1, 2)(3) === 6);
ok(load('es/function/virtual/bind').call(function (a, b) {
return this + a + b;
}, 1, 2)(3) === 6);
ok(load('es/function/virtual').bind.call(function (a, b) {
return this + a + b;
}, 1, 2)(3) === 6);
load('es/function/name');
load('es/function/has-instance');
// eslint-disable-next-line prefer-arrow-callback
ok(Function[load('es/symbol/has-instance')](function () { /* empty */ }));
ok('bind' in load('es/function'));
ok(load('es/array/is-array')([]));
ok(Array.isArray(load('es/array/from')('qwe')));
ok(Array.isArray(load('es/array/of')('q', 'w', 'e')));
ok(load('es/array/join')('qwe', 1) === 'q1w1e');
ok(load('es/array/slice')('qwe', 1)[1] === 'e');
ok(load('es/array/sort')([1, 3, 2])[1] === 2);
ok(typeof load('es/array/for-each') === 'function');
ok(typeof load('es/array/map') === 'function');
ok(typeof load('es/array/filter') === 'function');
ok(typeof load('es/array/flat') === 'function');
ok(typeof load('es/array/flat-map') === 'function');
ok(typeof load('es/array/some') === 'function');
ok(typeof load('es/array/every') === 'function');
ok(typeof load('es/array/reduce') === 'function');
ok(typeof load('es/array/reduce-right') === 'function');
ok(typeof load('es/array/reverse') === 'function');
ok(typeof load('es/array/index-of') === 'function');
ok(typeof load('es/array/last-index-of') === 'function');
ok(load('es/array/concat')([1, 2, 3], [4, 5, 6]).length === 6);
ok(load('es/array/copy-within')([1, 2, 3, 4, 5], 0, 3)[0] === 4);
ok('next' in load('es/array/entries')([]));
ok(load('es/array/fill')(Array(5), 2)[0] === 2);
ok(load('es/array/find')([2, 3, 4], it => it % 2) === 3);
ok(load('es/array/find-index')([2, 3, 4], it => it % 2) === 1);
ok('next' in load('es/array/keys')([]));
ok('next' in load('es/array/values')([]));
ok(load('es/array/includes')([1, 2, 3], 2));
ok('next' in load('es/array/iterator')([]));
ok(load('es/array/virtual/join').call('qwe', 1) === 'q1w1e');
ok(load('es/array/virtual/slice').call('qwe', 1)[1] === 'e');
ok(load('es/array/virtual/splice').call([1, 2, 3], 1, 2)[0] === 2);
ok(load('es/array/virtual/sort').call([1, 3, 2])[1] === 2);
ok(typeof load('es/array/virtual/for-each') === 'function');
ok(typeof load('es/array/virtual/map') === 'function');
ok(typeof load('es/array/virtual/filter') === 'function');
ok(typeof load('es/array/virtual/flat') === 'function');
ok(typeof load('es/array/virtual/flat-map') === 'function');
ok(typeof load('es/array/virtual/some') === 'function');
ok(typeof load('es/array/virtual/every') === 'function');
ok(typeof load('es/array/virtual/reduce') === 'function');
ok(typeof load('es/array/virtual/reduce-right') === 'function');
ok(typeof load('es/array/virtual/reverse') === 'function');
ok(typeof load('es/array/virtual/index-of') === 'function');
ok(typeof load('es/array/virtual/last-index-of') === 'function');
ok(load('es/array/virtual/concat').call([1, 2, 3], [4, 5, 6]).length === 6);
ok(load('es/array/virtual/copy-within').call([1, 2, 3, 4, 5], 0, 3)[0] === 4);
ok('next' in load('es/array/virtual/entries').call([]));
ok(load('es/array/virtual/fill').call(Array(5), 2)[0] === 2);
ok(load('es/array/virtual/find').call([2, 3, 4], it => it % 2) === 3);
ok(load('es/array/virtual/find-index').call([2, 3, 4], it => it % 2) === 1);
ok('next' in load('es/array/virtual/keys').call([]));
ok('next' in load('es/array/virtual/values').call([]));
ok(load('es/array/virtual/includes').call([1, 2, 3], 2));
ok('next' in load('es/array/virtual/iterator').call([]));
ok(load('es/array/virtual').includes.call([1, 2, 3], 2));
ok('from' in load('es/array'));
ok(load('es/array/splice')([1, 2, 3], 1, 2)[0] === 2);
ok(load('es/math/acosh')(1) === 0);
ok(Object.is(load('es/math/asinh')(-0), -0));
ok(load('es/math/atanh')(1) === Infinity);
ok(load('es/math/cbrt')(-8) === -2);
ok(load('es/math/clz32')(0) === 32);
ok(load('es/math/cosh')(0) === 1);
ok(load('es/math/expm1')(-Infinity) === -1);
ok(load('es/math/fround')(0) === 0);
ok(load('es/math/hypot')(3, 4) === 5);
ok(load('es/math/imul')(2, 2) === 4);
ok(load('es/math/log10')(-0) === -Infinity);
ok(load('es/math/log1p')(-1) === -Infinity);
ok(load('es/math/log2')(1) === 0);
ok(load('es/math/sign')(-2) === -1);
ok(Object.is(load('es/math/sinh')(-0), -0));
ok(load('es/math/tanh')(Infinity) === 1);
ok(load('es/math/to-string-tag') === 'Math');
ok(load('es/math/trunc')(1.5) === 1);
ok(load('es/number/constructor')('5') === 5);
ok(load('es/number/epsilon') === 2 ** -52);
ok(load('es/number/is-finite')(42.5));
ok(load('es/number/is-integer')(42.5) === false);
ok(load('es/number/is-nan')(NaN));
ok(load('es/number/is-safe-integer')(42));
ok(load('es/number/max-safe-integer') === 0x1FFFFFFFFFFFFF);
ok(load('es/number/min-safe-integer') === -0x1FFFFFFFFFFFFF);
ok(load('es/number/parse-float')('1.5') === 1.5);
ok(load('es/number/parse-int')('2.1') === 2);
ok(load('es/number/to-fixed')(1, 1) === '1.0');
ok(load('es/number/to-precision')(1) === '1');
ok(load('es/parse-float')('1.5') === 1.5);
ok(load('es/parse-int')('2.1') === 2);
ok(load('es/number/virtual/to-fixed').call(1, 1) === '1.0');
ok(load('es/number/virtual/to-precision').call(1) === '1');
ok(load('es/number/virtual').toFixed.call(42, 2) === '42.00');
ok('isNaN' in load('es/number'));
ok(load('es/reflect/apply')((a, b) => a + b, null, [1, 2]) === 3);
ok(load('es/reflect/construct')(function () {
return this.a = 2;
}, []).a === 2);
load('es/reflect/define-property')(O = {}, 'a', { value: 42 });
ok(O.a === 42);
ok(load('es/reflect/delete-property')({ q: 1 }, 'q'));
ok(load('es/reflect/get')({ q: 1 }, 'q') === 1);
ok(load('es/reflect/get-own-property-descriptor')({ q: 1 }, 'q').enumerable);
ok(load('es/reflect/get-prototype-of')([]) === Array.prototype);
ok(load('es/reflect/has')({ q: 1 }, 'q'));
ok(load('es/reflect/is-extensible')({}));
ok(load('es/reflect/own-keys')({ q: 1 })[0] === 'q');
ok(load('es/reflect/prevent-extensions')({}));
ok(load('es/reflect/set')({}, 'a', 42));
load('es/reflect/set-prototype-of')(O = {}, []);
ok(O instanceof Array);
ok('has' in load('es/reflect'));
ok(load('es/string/from-code-point')(97) === 'a');
ok(load('es/string/raw')({ raw: 'test' }, 0, 1, 2) === 't0e1s2t');
ok(load('es/string/trim')(' ab ') === 'ab');
ok(load('es/string/trim-start')(' a ') === 'a ');
ok(load('es/string/trim-end')(' a ') === ' a');
ok(load('es/string/trim-left')(' a ') === 'a ');
ok(load('es/string/trim-right')(' a ') === ' a');
ok(load('es/string/code-point-at')('a', 0) === 97);
ok(load('es/string/ends-with')('qwe', 'we'));
ok(load('es/string/includes')('qwe', 'w'));
ok(load('es/string/repeat')('q', 3) === 'qqq');
ok(load('es/string/starts-with')('qwe', 'qw'));
ok(typeof load('es/string/anchor') === 'function');
ok(typeof load('es/string/big') === 'function');
ok(typeof load('es/string/blink') === 'function');
ok(typeof load('es/string/bold') === 'function');
ok(typeof load('es/string/fixed') === 'function');
ok(typeof load('es/string/fontcolor') === 'function');
ok(typeof load('es/string/fontsize') === 'function');
ok(typeof load('es/string/italics') === 'function');
ok(typeof load('es/string/link') === 'function');
ok(typeof load('es/string/small') === 'function');
ok(typeof load('es/string/strike') === 'function');
ok(typeof load('es/string/sub') === 'function');
ok(typeof load('es/string/sup') === 'function');
ok(load('es/string/pad-start')('a', 3) === ' a');
ok(load('es/string/pad-end')('a', 3) === 'a ');
ok('next' in load('es/string/iterator')('qwe'));
ok(load('es/string/virtual/code-point-at').call('a', 0) === 97);
ok(load('es/string/virtual/ends-with').call('qwe', 'we'));
ok(load('es/string/virtual/includes').call('qwe', 'w'));
ok(load('es/string/virtual/repeat').call('q', 3) === 'qqq');
ok(load('es/string/virtual/starts-with').call('qwe', 'qw'));
ok(load('es/string/virtual/trim').call(' ab ') === 'ab');
ok(load('es/string/virtual/trim-start').call(' a ') === 'a ');
ok(load('es/string/virtual/trim-end').call(' a ') === ' a');
ok(load('es/string/virtual/trim-left').call(' a ') === 'a ');
ok(load('es/string/virtual/trim-right').call(' a ') === ' a');
ok(typeof load('es/string/virtual/anchor') === 'function');
ok(typeof load('es/string/virtual/big') === 'function');
ok(typeof load('es/string/virtual/blink') === 'function');
ok(typeof load('es/string/virtual/bold') === 'function');
ok(typeof load('es/string/virtual/fixed') === 'function');
ok(typeof load('es/string/virtual/fontcolor') === 'function');
ok(typeof load('es/string/virtual/fontsize') === 'function');
ok(typeof load('es/string/virtual/italics') === 'function');
ok(typeof load('es/string/virtual/link') === 'function');
ok(typeof load('es/string/virtual/small') === 'function');
ok(typeof load('es/string/virtual/strike') === 'function');
ok(typeof load('es/string/virtual/sub') === 'function');
ok(typeof load('es/string/virtual/sup') === 'function');
ok(load('es/string/virtual/pad-start').call('a', 3) === ' a');
ok(load('es/string/virtual/pad-end').call('a', 3) === 'a ');
ok(load('es/string/virtual').trim.call(' a') === 'a');
ok('next' in load('es/string/virtual/iterator').call('qwe'));
ok('raw' in load('es/string'));
ok(String(load('es/regexp/constructor')('a', 'g')) === '/a/g');
ok(load('es/regexp/to-string')(/./g) === '/./g');
ok(load('es/regexp/flags')(/./g) === 'g');
ok(typeof load('es/regexp/match') === 'function');
ok(typeof load('es/regexp/replace') === 'function');
ok(typeof load('es/regexp/search') === 'function');
ok(typeof load('es/regexp/split') === 'function');
ok(typeof load('es/regexp/sticky') === 'function');
ok(typeof load('es/regexp/test') === 'function');
load('es/regexp');
ok(load('es/json').stringify([1]) === '[1]');
ok(load('es/json/stringify')([1]) === '[1]');
ok(load('es/json/to-string-tag') === 'JSON');
ok(typeof load('es/date/now')(new Date()) === 'number');
ok(typeof load('es/date/to-string')(new Date()) === 'string');
ok(typeof load('es/date/to-primitive')(new Date(), 'number') === 'number');
ok(typeof load('es/date/to-iso-string')(new Date()) === 'string');
ok(load('es/date/to-json')(Infinity) === null);
ok(load('es/date'));
ok(load('es/symbol/has-instance'));
ok(load('es/symbol/is-concat-spreadable'));
ok(load('es/symbol/iterator'));
ok(load('es/symbol/match'));
ok(load('es/symbol/match-all'));
ok(load('es/symbol/replace'));
ok(load('es/symbol/search'));
ok(load('es/symbol/species'));
ok(load('es/symbol/split'));
ok(load('es/symbol/to-primitive'));
ok(load('es/symbol/to-string-tag'));
ok(load('es/symbol/unscopables'));
ok(load('es/symbol/async-iterator'));
load('es/symbol/description');
ok(typeof load('es/symbol/for') === 'function');
ok(typeof load('es/symbol/key-for') === 'function');
ok('iterator' in load('es/symbol'));
Map = load('es/map');
Set = load('es/set');
WeakMap = load('es/weak-map');
WeakSet = load('es/weak-set');
ok(new Map([[1, 2], [3, 4]]).size === 2);
ok(new Set([1, 2, 3, 2, 1]).size === 3);
ok(new WeakMap([[O = {}, 42]]).get(O) === 42);
ok(new WeakSet([O = {}]).has(O));
Promise = load('es/promise');
ok('all' in Promise);
ok(load('es/promise/all-settled')([1, 2, 3]) instanceof Promise);
ok('Map' in load('es'));
ok('setTimeout' in load('web/timers'));
ok('setImmediate' in load('web/immediate'));
ok(typeof load('web/queue-microtask') === 'function');
load('web/dom-collections');
ok(typeof load('web/url') === 'function');
ok(typeof load('web/url-search-params') === 'function');
ok('setImmediate' in load('web'));
load('proposals/array-is-template-object');
load('proposals/array-last');
load('proposals/collection-methods');
load('proposals/collection-of-from');
load('proposals/efficient-64-bit-arithmetic');
load('proposals/global-this');
load('proposals/iterator-helpers');
load('proposals/math-extensions');
load('proposals/math-signbit');
load('proposals/number-from-string');
load('proposals/object-iteration');
load('proposals/observable');
load('proposals/pattern-matching');
load('proposals/promise-all-settled');
load('proposals/promise-any');
load('proposals/promise-try');
load('proposals/reflect-metadata');
load('proposals/keys-composition');
load('proposals/seeded-random');
load('proposals/set-methods');
load('proposals/string-at');
load('proposals/string-code-points');
load('proposals/string-match-all');
load('proposals/string-replace-all');
load('proposals/using-statement');
load('proposals/url');
load('proposals');
ok(load('stage/4'));
ok(load('stage/3'));
ok(load('stage/2'));
ok(load('stage/1'));
ok(load('stage/0'));
ok(load('stage/pre'));
ok(load('stage'));
ok(load('index'));
const instanceAt = load('features/instance/at');
ok(typeof instanceAt === 'function');
ok(instanceAt({}) === undefined);
ok(typeof instanceAt('') === 'function');
ok(instanceAt('').call('abc', 1) === 'b');
let instanceBind = load('features/instance/bind');
ok(typeof instanceBind === 'function');
ok(instanceBind({}) === undefined);
ok(typeof instanceBind(it => it) === 'function');
ok(instanceBind(it => it).call(it => it, 1, 2)() === 2);
instanceBind = load('stable/instance/bind');
ok(typeof instanceBind === 'function');
ok(instanceBind({}) === undefined);
ok(typeof instanceBind(it => it) === 'function');
ok(instanceBind(it => it).call(it => it, 1, 2)() === 2);
instanceBind = load('es/instance/bind');
ok(typeof instanceBind === 'function');
ok(instanceBind({}) === undefined);
ok(typeof instanceBind(it => it) === 'function');
ok(instanceBind(it => it).call(it => it, 1, 2)() === 2);
let instanceCodePointAt = load('features/instance/code-point-at');
ok(typeof instanceCodePointAt === 'function');
ok(instanceCodePointAt({}) === undefined);
ok(typeof instanceCodePointAt('') === 'function');
ok(instanceCodePointAt('').call('a', 0) === 97);
instanceCodePointAt = load('stable/instance/code-point-at');
ok(typeof instanceCodePointAt === 'function');
ok(instanceCodePointAt({}) === undefined);
ok(typeof instanceCodePointAt('') === 'function');
ok(instanceCodePointAt('').call('a', 0) === 97);
instanceCodePointAt = load('es/instance/code-point-at');
ok(typeof instanceCodePointAt === 'function');
ok(instanceCodePointAt({}) === undefined);
ok(typeof instanceCodePointAt('') === 'function');
ok(instanceCodePointAt('').call('a', 0) === 97);
const instanceCodePoints = load('features/instance/code-points');
ok(typeof instanceCodePoints === 'function');
ok(instanceCodePoints({}) === undefined);
ok(typeof instanceCodePoints('') === 'function');
ok(instanceCodePoints('').call('abc').next().value.codePoint === 97);
let instanceConcat = load('features/instance/concat');
ok(typeof instanceConcat === 'function');
ok(instanceConcat({}) === undefined);
ok(typeof instanceConcat([]) === 'function');
ok(instanceConcat([]).call([1, 2, 3], [4, 5, 6]).length === 6);
instanceConcat = load('stable/instance/concat');
ok(typeof instanceConcat === 'function');
ok(instanceConcat({}) === undefined);
ok(typeof instanceConcat([]) === 'function');
ok(instanceConcat([]).call([1, 2, 3], [4, 5, 6]).length === 6);
instanceConcat = load('es/instance/concat');
ok(typeof instanceConcat === 'function');
ok(instanceConcat({}) === undefined);
ok(typeof instanceConcat([]) === 'function');
ok(instanceConcat([]).call([1, 2, 3], [4, 5, 6]).length === 6);
let instanceCopyWithin = load('features/instance/copy-within');
ok(typeof instanceCopyWithin === 'function');
ok(instanceCopyWithin({}) === undefined);
ok(typeof instanceCopyWithin([]) === 'function');
ok(instanceCopyWithin([]).call([1, 2, 3, 4, 5], 0, 3)[0] === 4);
instanceCopyWithin = load('stable/instance/copy-within');
ok(typeof instanceCopyWithin === 'function');
ok(instanceCopyWithin({}) === undefined);
ok(typeof instanceCopyWithin([]) === 'function');
ok(instanceCopyWithin([]).call([1, 2, 3, 4, 5], 0, 3)[0] === 4);
instanceCopyWithin = load('es/instance/copy-within');
ok(typeof instanceCopyWithin === 'function');
ok(instanceCopyWithin({}) === undefined);
ok(typeof instanceCopyWithin([]) === 'function');
ok(instanceCopyWithin([]).call([1, 2, 3, 4, 5], 0, 3)[0] === 4);
let instanceEndsWith = load('features/instance/ends-with');
ok(typeof instanceEndsWith === 'function');
ok(instanceEndsWith({}) === undefined);
ok(typeof instanceEndsWith('') === 'function');
ok(instanceEndsWith('').call('qwe', 'we'));
instanceEndsWith = load('stable/instance/ends-with');
ok(typeof instanceEndsWith === 'function');
ok(instanceEndsWith({}) === undefined);
ok(typeof instanceEndsWith('') === 'function');
ok(instanceEndsWith('').call('qwe', 'we'));
instanceEndsWith = load('es/instance/ends-with');
ok(typeof instanceEndsWith === 'function');
ok(instanceEndsWith({}) === undefined);
ok(typeof instanceEndsWith('') === 'function');
ok(instanceEndsWith('').call('qwe', 'we'));
let instanceEntries = load('features/instance/entries');
ok(typeof instanceEntries === 'function');
ok(instanceEntries({}) === undefined);
ok(typeof instanceEntries([]) === 'function');
ok(instanceEntries([]).call([1, 2, 3]).next().value[1] === 1);
instanceEntries = load('stable/instance/entries');
ok(typeof instanceEntries === 'function');
ok(instanceEntries({}) === undefined);
ok(typeof instanceEntries([]) === 'function');
ok(instanceEntries([]).call([1, 2, 3]).next().value[1] === 1);
instanceEntries = load('es/instance/entries');
ok(typeof instanceEntries === 'function');
ok(instanceEntries({}) === undefined);
ok(typeof instanceEntries([]) === 'function');
ok(instanceEntries([]).call([1, 2, 3]).next().value[1] === 1);
let instanceEvery = load('features/instance/every');
ok(typeof instanceEvery === 'function');
ok(instanceEvery({}) === undefined);
ok(typeof instanceEvery([]) === 'function');
ok(instanceEvery([]).call([1, 2, 3], it => typeof it === 'number'));
instanceEvery = load('stable/instance/every');
ok(typeof instanceEvery === 'function');
ok(instanceEvery({}) === undefined);
ok(typeof instanceEvery([]) === 'function');
ok(instanceEvery([]).call([1, 2, 3], it => typeof it === 'number'));
instanceEvery = load('es/instance/every');
ok(typeof instanceEvery === 'function');
ok(instanceEvery({}) === undefined);
ok(typeof instanceEvery([]) === 'function');
ok(instanceEvery([]).call([1, 2, 3], it => typeof it === 'number'));
let instanceFill = load('features/instance/fill');
ok(typeof instanceFill === 'function');
ok(instanceFill({}) === undefined);
ok(typeof instanceFill([]) === 'function');
ok(instanceFill([]).call(Array(5), 42)[3] === 42);
instanceFill = load('stable/instance/fill');
ok(typeof instanceFill === 'function');
ok(instanceFill({}) === undefined);
ok(typeof instanceFill([]) === 'function');
ok(instanceFill([]).call(Array(5), 42)[3] === 42);
instanceFill = load('es/instance/fill');
ok(typeof instanceFill === 'function');
ok(instanceFill({}) === undefined);
ok(typeof instanceFill([]) === 'function');
ok(instanceFill([]).call(Array(5), 42)[3] === 42);
let instanceFilter = load('features/instance/filter');
ok(typeof instanceFilter === 'function');
ok(instanceFilter({}) === undefined);
ok(typeof instanceFilter([]) === 'function');
ok(instanceFilter([]).call([1, 2, 3], it => it % 2).length === 2);
instanceFilter = load('stable/instance/filter');
ok(typeof instanceFilter === 'function');
ok(instanceFilter({}) === undefined);
ok(typeof instanceFilter([]) === 'function');
ok(instanceFilter([]).call([1, 2, 3], it => it % 2).length === 2);
instanceFilter = load('es/instance/filter');
ok(typeof instanceFilter === 'function');
ok(instanceFilter({}) === undefined);
ok(typeof instanceFilter([]) === 'function');
ok(instanceFilter([]).call([1, 2, 3], it => it % 2).length === 2);
let instanceFindIndex = load('features/instance/find-index');
ok(typeof instanceFindIndex === 'function');
ok(instanceFindIndex({}) === undefined);
ok(typeof instanceFindIndex([]) === 'function');
ok(instanceFindIndex([]).call([1, 2, 3], it => it % 2) === 0);
instanceFindIndex = load('stable/instance/find-index');
ok(typeof instanceFindIndex === 'function');
ok(instanceFindIndex({}) === undefined);
ok(typeof instanceFindIndex([]) === 'function');
ok(instanceFindIndex([]).call([1, 2, 3], it => it % 2) === 0);
instanceFindIndex = load('es/instance/find-index');
ok(typeof instanceFindIndex === 'function');
ok(instanceFindIndex({}) === undefined);
ok(typeof instanceFindIndex([]) === 'function');
ok(instanceFindIndex([]).call([1, 2, 3], it => it % 2) === 0);
let instanceFind = load('features/instance/find');
ok(typeof instanceFind === 'function');
ok(instanceFind({}) === undefined);
ok(typeof instanceFind([]) === 'function');
ok(instanceFind([]).call([1, 2, 3], it => it % 2) === 1);
instanceFind = load('stable/instance/find');
ok(typeof instanceFind === 'function');
ok(instanceFind({}) === undefined);
ok(typeof instanceFind([]) === 'function');
ok(instanceFind([]).call([1, 2, 3], it => it % 2) === 1);
instanceFind = load('es/instance/find');
ok(typeof instanceFind === 'function');
ok(instanceFind({}) === undefined);
ok(typeof instanceFind([]) === 'function');
ok(instanceFind([]).call([1, 2, 3], it => it % 2) === 1);
let instanceFlags = load('features/instance/flags');
ok(typeof instanceFlags === 'function');
ok(instanceFlags({}) === undefined);
ok(instanceFlags(/./g) === 'g');
instanceFlags = load('stable/instance/flags');
ok(typeof instanceFlags === 'function');
ok(instanceFlags({}) === undefined);
ok(instanceFlags(/./g) === 'g');
instanceFlags = load('es/instance/flags');
ok(typeof instanceFlags === 'function');
ok(instanceFlags({}) === undefined);
ok(instanceFlags(/./g) === 'g');
let instanceFlatMap = load('features/instance/flat-map');
ok(typeof instanceFlatMap === 'function');
ok(instanceFlatMap({}) === undefined);
ok(typeof instanceFlatMap([]) === 'function');
ok(instanceFlatMap([]).call([1, 2, 3], (v, i) => [v, i]).length === 6);
instanceFlatMap = load('stable/instance/flat-map');
ok(typeof instanceFlatMap === 'function');
ok(instanceFlatMap({}) === undefined);
ok(typeof instanceFlatMap([]) === 'function');
ok(instanceFlatMap([]).call([1, 2, 3], (v, i) => [v, i]).length === 6);
instanceFlatMap = load('es/instance/flat-map');
ok(typeof instanceFlatMap === 'function');
ok(instanceFlatMap({}) === undefined);
ok(typeof instanceFlatMap([]) === 'function');
ok(instanceFlatMap([]).call([1, 2, 3], (v, i) => [v, i]).length === 6);
let instanceFlat = load('features/instance/flat');
ok(typeof instanceFlat === 'function');
ok(instanceFlat({}) === undefined);
ok(typeof instanceFlat([]) === 'function');
ok(instanceFlat([]).call([1, [2, 3], [4, [5, [6]]]]).length === 5);
instanceFlat = load('stable/instance/flat');
ok(typeof instanceFlat === 'function');
ok(instanceFlat({}) === undefined);
ok(typeof instanceFlat([]) === 'function');
ok(instanceFlat([]).call([1, [2, 3], [4, [5, [6]]]]).length === 5);
instanceFlat = load('es/instance/flat');
ok(typeof instanceFlat === 'function');
ok(instanceFlat({}) === undefined);
ok(typeof instanceFlat([]) === 'function');
ok(instanceFlat([]).call([1, [2, 3], [4, [5, [6]]]]).length === 5);
let instanceForEach = load('features/instance/for-each');
ok(typeof instanceForEach === 'function');
ok(instanceForEach({}) === undefined);
ok(typeof instanceForEach([]) === 'function');
instanceForEach = load('stable/instance/for-each');
ok(typeof instanceForEach === 'function');
ok(instanceForEach({}) === undefined);
ok(typeof instanceForEach([]) === 'function');
instanceForEach = load('es/instance/for-each');
ok(typeof instanceForEach === 'function');
ok(instanceForEach({}) === undefined);
ok(typeof instanceForEach([]) === 'function');
let instanceIncludes = load('features/instance/includes');
ok(typeof instanceIncludes === 'function');
ok(instanceIncludes({}) === undefined);
ok(typeof instanceIncludes([]) === 'function');
ok(typeof instanceIncludes('') === 'function');
ok(instanceIncludes([]).call([1, 2, 3], 2));
ok(instanceIncludes('').call('123', '2'));
instanceIncludes = load('stable/instance/includes');
ok(typeof instanceIncludes === 'function');
ok(instanceIncludes({}) === undefined);
ok(typeof instanceIncludes([]) === 'function');
ok(typeof instanceIncludes('') === 'function');
ok(instanceIncludes([]).call([1, 2, 3], 2));
ok(instanceIncludes('').call('123', '2'));
instanceIncludes = load('es/instance/includes');
ok(typeof instanceIncludes === 'function');
ok(instanceIncludes({}) === undefined);
ok(typeof instanceIncludes([]) === 'function');
ok(typeof instanceIncludes('') === 'function');
ok(instanceIncludes([]).call([1, 2, 3], 2));
ok(instanceIncludes('').call('123', '2'));
let instanceIndexOf = load('features/instance/index-of');
ok(typeof instanceIndexOf === 'function');
ok(instanceIndexOf({}) === undefined);
ok(typeof instanceIndexOf([]) === 'function');
ok(instanceIndexOf([]).call([1, 2, 3], 2) === 1);
instanceIndexOf = load('stable/instance/index-of');
ok(typeof instanceIndexOf === 'function');
ok(instanceIndexOf({}) === undefined);
ok(typeof instanceIndexOf([]) === 'function');
ok(instanceIndexOf([]).call([1, 2, 3], 2) === 1);
instanceIndexOf = load('es/instance/index-of');
ok(typeof instanceIndexOf === 'function');
ok(instanceIndexOf({}) === undefined);
ok(typeof instanceIndexOf([]) === 'function');
ok(instanceIndexOf([]).call([1, 2, 3], 2) === 1);
let instanceKeys = load('features/instance/keys');
ok(typeof instanceKeys === 'function');
ok(instanceKeys({}) === undefined);
ok(typeof instanceKeys([]) === 'function');
ok(instanceKeys([]).call([1, 2, 3]).next().value === 0);
instanceKeys = load('stable/instance/keys');
ok(typeof instanceKeys === 'function');
ok(instanceKeys({}) === undefined);
ok(typeof instanceKeys([]) === 'function');
ok(instanceKeys([]).call([1, 2, 3]).next().value === 0);
instanceKeys = load('es/instance/keys');
ok(typeof instanceKeys === 'function');
ok(instanceKeys({}) === undefined);
ok(typeof instanceKeys([]) === 'function');
ok(instanceKeys([]).call([1, 2, 3]).next().value === 0);
let instanceLastIndexOf = load('features/instance/last-index-of');
ok(typeof instanceLastIndexOf === 'function');
ok(instanceLastIndexOf({}) === undefined);
ok(typeof instanceLastIndexOf([]) === 'function');
ok(instanceLastIndexOf([]).call([1, 2, 3], 2) === 1);
instanceLastIndexOf = load('stable/instance/last-index-of');
ok(typeof instanceLastIndexOf === 'function');
ok(instanceLastIndexOf({}) === undefined);
ok(typeof instanceLastIndexOf([]) === 'function');
ok(instanceLastIndexOf([]).call([1, 2, 3], 2) === 1);
instanceLastIndexOf = load('es/instance/last-index-of');
ok(typeof instanceLastIndexOf === 'function');
ok(instanceLastIndexOf({}) === undefined);
ok(typeof instanceLastIndexOf([]) === 'function');
ok(instanceLastIndexOf([]).call([1, 2, 3], 2) === 1);
let instanceMap = load('features/instance/map');
ok(typeof instanceMap === 'function');
ok(instanceMap({}) === undefined);
ok(typeof instanceMap([]) === 'function');
ok(instanceMap([]).call([1, 2, 3], it => it % 2)[1] === 0);
instanceMap = load('stable/instance/map');
ok(typeof instanceMap === 'function');
ok(instanceMap({}) === undefined);
ok(typeof instanceMap([]) === 'function');
ok(instanceMap([]).call([1, 2, 3], it => it % 2)[1] === 0);
instanceMap = load('es/instance/map');
ok(typeof instanceMap === 'function');
ok(instanceMap({}) === undefined);
ok(typeof instanceMap([]) === 'function');
ok(instanceMap([]).call([1, 2, 3], it => it % 2)[1] === 0);
let instanceMatchAll = load('features/instance/match-all');
ok(typeof instanceMatchAll === 'function');
ok(instanceMatchAll({}) === undefined);
ok(typeof instanceMatchAll('') === 'function');
ok(instanceMatchAll('').call('test1test2', /t(e)(st(\d?))/g).next().value[0] === 'test1');
instanceMatchAll = load('stable/instance/match-all');
ok(typeof instanceMatchAll === 'function');
ok(instanceMatchAll({}) === undefined);
ok(typeof instanceMatchAll('') === 'function');
ok(instanceMatchAll('').call('test1test2', /t(e)(st(\d?))/g).next().value[0] === 'test1');
instanceMatchAll = load('es/instance/match-all');
ok(typeof instanceMatchAll === 'function');
ok(instanceMatchAll({}) === undefined);
ok(typeof instanceMatchAll('') === 'function');
ok(instanceMatchAll('').call('test1test2', /t(e)(st(\d?))/g).next().value[0] === 'test1');
let instancePadEnd = load('features/instance/pad-end');
ok(typeof instancePadEnd === 'function');
ok(instancePadEnd({}) === undefined);
ok(typeof instancePadEnd('') === 'function');
ok(instancePadEnd('').call('a', 3, 'b') === 'abb');
instancePadEnd = load('stable/instance/pad-end');
ok(typeof instancePadEnd === 'function');
ok(instancePadEnd({}) === undefined);
ok(typeof instancePadEnd('') === 'function');
ok(instancePadEnd('').call('a', 3, 'b') === 'abb');
instancePadEnd = load('es/instance/pad-end');
ok(typeof instancePadEnd === 'function');
ok(instancePadEnd({}) === undefined);
ok(typeof instancePadEnd('') === 'function');
ok(instancePadEnd('').call('a', 3, 'b') === 'abb');
let instancePadStart = load('features/instance/pad-start');
ok(typeof instancePadStart === 'function');
ok(instancePadStart({}) === undefined);
ok(typeof instancePadStart('') === 'function');
ok(instancePadStart('').call('a', 3, 'b') === 'bba');
instancePadStart = load('stable/instance/pad-start');
ok(typeof instancePadStart === 'function');
ok(instancePadStart({}) === undefined);
ok(typeof instancePadStart('') === 'function');
ok(instancePadStart('').call('a', 3, 'b') === 'bba');
instancePadStart = load('es/instance/pad-start');
ok(typeof instancePadStart === 'function');
ok(instancePadStart({}) === undefined);
ok(typeof instancePadStart('') === 'function');
ok(instancePadStart('').call('a', 3, 'b') === 'bba');
let instanceReduceRight = load('features/instance/reduce-right');
ok(typeof instanceReduceRight === 'function');
ok(instanceReduceRight({}) === undefined);
ok(typeof instanceReduceRight([]) === 'function');
ok(instanceReduceRight([]).call([1, 2, 3], (memo, it) => it + memo, '') === '123');
instanceReduceRight = load('stable/instance/reduce-right');
ok(typeof instanceReduceRight === 'function');
ok(instanceReduceRight({}) === undefined);
ok(typeof instanceReduceRight([]) === 'function');
ok(instanceReduceRight([]).call([1, 2, 3], (memo, it) => it + memo, '') === '123');
instanceReduceRight = load('es/instance/reduce-right');
ok(typeof instanceReduceRight === 'function');
ok(instanceReduceRight({}) === undefined);
ok(typeof instanceReduceRight([]) === 'function');
ok(instanceReduceRight([]).call([1, 2, 3], (memo, it) => it + memo, '') === '123');
let instanceReduce = load('features/instance/reduce');
ok(typeof instanceReduce === 'function');
ok(instanceReduce({}) === undefined);
ok(typeof instanceReduce([]) === 'function');
ok(instanceReduce([]).call([1, 2, 3], (memo, it) => it + memo, '') === '321');
instanceReduce = load('stable/instance/reduce');
ok(typeof instanceReduce === 'function');
ok(instanceReduce({}) === undefined);
ok(typeof instanceReduce([]) === 'function');
ok(instanceReduce([]).call([1, 2, 3], (memo, it) => it + memo, '') === '321');
instanceReduce = load('es/instance/reduce');
ok(typeof instanceReduce === 'function');
ok(instanceReduce({}) === undefined);
ok(typeof instanceReduce([]) === 'function');
ok(instanceReduce([]).call([1, 2, 3], (memo, it) => it + memo, '') === '321');
let instanceRepeat = load('features/instance/repeat');
ok(typeof instanceRepeat === 'function');
ok(instanceRepeat({}) === undefined);
ok(typeof instanceRepeat('') === 'function');
ok(instanceRepeat('').call('a', 3) === 'aaa');
instanceRepeat = load('stable/instance/repeat');
ok(typeof instanceRepeat === 'function');
ok(instanceRepeat({}) === undefined);
ok(typeof instanceRepeat('') === 'function');
ok(instanceRepeat('').call('a', 3) === 'aaa');
instanceRepeat = load('es/instance/repeat');
ok(typeof instanceRepeat === 'function');
ok(instanceRepeat({}) === undefined);
ok(typeof instanceRepeat('') === 'function');
ok(instanceRepeat('').call('a', 3) === 'aaa');
const instanceReplaceAll = load('features/instance/replace-all');
ok(typeof instanceReplaceAll === 'function');
ok(instanceReplaceAll({}) === undefined);
ok(typeof instanceReplaceAll('') === 'function');
ok(instanceReplaceAll('').call('aba', 'a', 'c') === 'cbc');
let instanceReverse = load('features/instance/reverse');
ok(typeof instanceReverse === 'function');
ok(instanceReverse({}) === undefined);
ok(typeof instanceReverse([]) === 'function');
instanceReverse = load('stable/instance/reverse');
ok(typeof instanceReverse === 'function');
ok(instanceReverse({}) === undefined);
ok(typeof instanceReverse([]) === 'function');
instanceReverse = load('es/instance/reverse');
ok(typeof instanceReverse === 'function');
ok(instanceReverse({}) === undefined);
ok(typeof instanceReverse([]) === 'function');
let instanceSlice = load('features/instance/slice');
ok(typeof instanceSlice === 'function');
ok(instanceSlice({}) === undefined);
ok(typeof instanceSlice([]) === 'function');
instanceSlice = load('stable/instance/slice');
ok(typeof instanceSlice === 'function');
ok(instanceSlice({}) === undefined);
ok(typeof instanceSlice([]) === 'function');
instanceSlice = load('es/instance/slice');
ok(typeof instanceSlice === 'function');
ok(instanceSlice({}) === undefined);
ok(typeof instanceSlice([]) === 'function');
let instanceSome = load('features/instance/some');
ok(typeof instanceSome === 'function');
ok(instanceSome({}) === undefined);
ok(typeof instanceSome([]) === 'function');
ok(instanceSome([]).call([1, 2, 3], it => typeof it === 'number'));
instanceSome = load('stable/instance/some');
ok(typeof instanceSome === 'function');
ok(instanceSome({}) === undefined);
ok(typeof instanceSome([]) === 'function');
ok(instanceSome([]).call([1, 2, 3], it => typeof it === 'number'));
instanceSome = load('es/instance/some');
ok(typeof instanceSome === 'function');
ok(instanceSome({}) === undefined);
ok(typeof instanceSome([]) === 'function');
ok(instanceSome([]).call([1, 2, 3], it => typeof it === 'number'));
let instanceSort = load('features/instance/sort');
ok(typeof instanceSort === 'function');
ok(instanceSort({}) === undefined);
ok(typeof instanceSort([]) === 'function');
instanceSort = load('stable/instance/sort');
ok(typeof instanceSort === 'function');
ok(instanceSort({}) === undefined);
ok(typeof instanceSort([]) === 'function');
instanceSort = load('es/instance/sort');
ok(typeof instanceSort === 'function');
ok(instanceSort({}) === undefined);
ok(typeof instanceSort([]) === 'function');
let instanceSplice = load('features/instance/splice');
ok(typeof instanceSplice === 'function');
ok(instanceSplice({}) === undefined);
ok(typeof instanceSplice([]) === 'function');
instanceSplice = load('stable/instance/splice');
ok(typeof instanceSplice === 'function');
ok(instanceSplice({}) === undefined);
ok(typeof instanceSplice([]) === 'function');
instanceSplice = load('es/instance/splice');
ok(typeof instanceSplice === 'function');
ok(instanceSplice({}) === undefined);
ok(typeof instanceSplice([]) === 'function');
let instanceStartsWith = load('features/instance/starts-with');
ok(typeof instanceStartsWith === 'function');
ok(instanceStartsWith({}) === undefined);
ok(typeof instanceStartsWith('') === 'function');
ok(instanceStartsWith('').call('qwe', 'qw'));
instanceStartsWith = load('stable/instance/starts-with');
ok(typeof instanceStartsWith === 'function');
ok(instanceStartsWith({}) === undefined);
ok(typeof instanceStartsWith('') === 'function');
ok(instanceStartsWith('').call('qwe', 'qw'));
instanceStartsWith = load('es/instance/starts-with');
ok(typeof instanceStartsWith === 'function');
ok(instanceStartsWith({}) === undefined);
ok(typeof instanceStartsWith('') === 'function');
ok(instanceStartsWith('').call('qwe', 'qw'));
let instanceTrimEnd = load('features/instance/trim-end');
ok(typeof instanceTrimEnd === 'function');
ok(instanceTrimEnd({}) === undefined);
ok(typeof instanceTrimEnd('') === 'function');
ok(instanceTrimEnd('').call(' 1 ') === ' 1');
instanceTrimEnd = load('stable/instance/trim-end');
ok(typeof instanceTrimEnd === 'function');
ok(instanceTrimEnd({}) === undefined);
ok(typeof instanceTrimEnd('') === 'function');
ok(instanceTrimEnd('').call(' 1 ') === ' 1');
instanceTrimEnd = load('es/instance/trim-end');
ok(typeof instanceTrimEnd === 'function');
ok(instanceTrimEnd({}) === undefined);
ok(typeof instanceTrimEnd('') === 'function');
ok(instanceTrimEnd('').call(' 1 ') === ' 1');
let instanceTrimLeft = load('features/instance/trim-left');
ok(typeof instanceTrimLeft === 'function');
ok(instanceTrimLeft({}) === undefined);
ok(typeof instanceTrimLeft('') === 'function');
ok(instanceTrimLeft('').call(' 1 ') === '1 ');
instanceTrimLeft = load('stable/instance/trim-left');
ok(typeof instanceTrimLeft === 'function');
ok(instanceTrimLeft({}) === undefined);
ok(typeof instanceTrimLeft('') === 'function');
ok(instanceTrimLeft('').call(' 1 ') === '1 ');
instanceTrimLeft = load('es/instance/trim-left');
ok(typeof instanceTrimLeft === 'function');
ok(instanceTrimLeft({}) === undefined);
ok(typeof instanceTrimLeft('') === 'function');
ok(instanceTrimLeft('').call(' 1 ') === '1 ');
let instanceTrimRight = load('features/instance/trim-right');
ok(typeof instanceTrimRight === 'function');
ok(instanceTrimRight({}) === undefined);
ok(typeof instanceTrimRight('') === 'function');
ok(instanceTrimRight('').call(' 1 ') === ' 1');
instanceTrimRight = load('stable/instance/trim-right');
ok(typeof instanceTrimRight === 'function');
ok(instanceTrimRight({}) === undefined);
ok(typeof instanceTrimRight('') === 'function');
ok(instanceTrimRight('').call(' 1 ') === ' 1');
instanceTrimRight = load('es/instance/trim-right');
ok(typeof instanceTrimRight === 'function');
ok(instanceTrimRight({}) === undefined);
ok(typeof instanceTrimRight('') === 'function');
ok(instanceTrimRight('').call(' 1 ') === ' 1');
let instanceTrimStart = load('features/instance/trim-start');
ok(typeof instanceTrimStart === 'function');
ok(instanceTrimStart({}) === undefined);
ok(typeof instanceTrimStart('') === 'function');
ok(instanceTrimStart('').call(' 1 ') === '1 ');
instanceTrimStart = load('stable/instance/trim-start');
ok(typeof instanceTrimStart === 'function');
ok(instanceTrimStart({}) === undefined);
ok(typeof instanceTrimStart('') === 'function');
ok(instanceTrimStart('').call(' 1 ') === '1 ');
instanceTrimStart = load('es/instance/trim-start');
ok(typeof instanceTrimStart === 'function');
ok(instanceTrimStart({}) === undefined);
ok(typeof instanceTrimStart('') === 'function');
ok(instanceTrimStart('').call(' 1 ') === '1 ');
let instanceTrim = load('features/instance/trim');
ok(typeof instanceTrim === 'function');
ok(instanceTrim({}) === undefined);
ok(typeof instanceTrim('') === 'function');
ok(instanceTrim('').call(' 1 ') === '1');
instanceTrim = load('stable/instance/trim');
ok(typeof instanceTrim === 'function');
ok(instanceTrim({}) === undefined);
ok(typeof instanceTrim('') === 'function');
ok(instanceTrim('').call(' 1 ') === '1');
instanceTrim = load('es/instance/trim');
ok(typeof instanceTrim === 'function');
ok(instanceTrim({}) === undefined);
ok(typeof instanceTrim('') === 'function');
ok(instanceTrim('').call(' 1 ') === '1');
let instanceValues = load('features/instance/values');
ok(typeof instanceValues === 'function');
ok(instanceValues({}) === undefined);
ok(typeof instanceValues([]) === 'function');
ok(instanceValues([]).call([1, 2, 3]).next().value === 1);
instanceValues = load('stable/instance/values');
ok(typeof instanceValues === 'function');
ok(instanceValues({}) === undefined);
ok(typeof instanceValues([]) === 'function');
ok(instanceValues([]).call([1, 2, 3]).next().value === 1);
instanceValues = load('es/instance/values');
ok(typeof instanceValues === 'function');
ok(instanceValues({}) === undefined);
ok(typeof instanceValues([]) === 'function');
ok(instanceValues([]).call([1, 2, 3]).next().value === 1);
for (const key in compat) load(`modules/${ key }`);
}
ok(typeof load('features/string/match') === 'function');
ok(typeof load('features/string/replace') === 'function');
ok(typeof load('features/string/search') === 'function');
ok(load('features/string/split')('a s d', ' ').length === 3);
ok(typeof load('features/array-buffer') === 'function');
ok(typeof load('features/array-buffer/constructor') === 'function');
ok(typeof load('features/array-buffer/is-view') === 'function');
load('features/array-buffer/slice');
ok(typeof load('features/data-view') === 'function');
ok(typeof load('features/typed-array/int8-array') === 'function');
ok(typeof load('features/typed-array/uint8-array') === 'function');
ok(typeof load('features/typed-array/uint8-clamped-array') === 'function');
ok(typeof load('features/typed-array/int16-array') === 'function');
ok(typeof load('features/typed-array/uint16-array') === 'function');
ok(typeof load('features/typed-array/int32-array') === 'function');
ok(typeof load('features/typed-array/uint32-array') === 'function');
ok(typeof load('features/typed-array/float32-array') === 'function');
ok(typeof load('features/typed-array/float64-array') === 'function');
load('features/typed-array/copy-within');
load('features/typed-array/entries');
load('features/typed-array/every');
load('features/typed-array/fill');
load('features/typed-array/filter');
load('features/typed-array/find');
load('features/typed-array/find-index');
load('features/typed-array/for-each');
load('features/typed-array/from');
load('features/typed-array/includes');
load('features/typed-array/index-of');
load('features/typed-array/iterator');
load('features/typed-array/join');
load('features/typed-array/keys');
load('features/typed-array/last-index-of');
load('features/typed-array/map');
load('features/typed-array/of');
load('features/typed-array/reduce');
load('features/typed-array/reduce-right');
load('features/typed-array/reverse');
load('features/typed-array/set');
load('features/typed-array/slice');
load('features/typed-array/some');
load('features/typed-array/sort');
load('features/typed-array/subarray');
load('features/typed-array/to-locale-string');
load('features/typed-array/to-string');
load('features/typed-array/values');
ok(typeof load('features/typed-array').Uint32Array === 'function');
ok(typeof load('es/string/match') === 'function');
ok('next' in load('es/string/match-all')('a', /./g));
ok(typeof load('es/string/replace') === 'function');
ok(typeof load('es/string/search') === 'function');
ok(load('es/string/split')('a s d', ' ').length === 3);
ok(typeof load('es/array-buffer') === 'function');
ok(typeof load('es/array-buffer/constructor') === 'function');
ok(typeof load('es/array-buffer/is-view') === 'function');
load('es/array-buffer/slice');
ok(typeof load('es/data-view') === 'function');
ok(typeof load('es/typed-array/int8-array') === 'function');
ok(typeof load('es/typed-array/uint8-array') === 'function');
ok(typeof load('es/typed-array/uint8-clamped-array') === 'function');
ok(typeof load('es/typed-array/int16-array') === 'function');
ok(typeof load('es/typed-array/uint16-array') === 'function');
ok(typeof load('es/typed-array/int32-array') === 'function');
ok(typeof load('es/typed-array/uint32-array') === 'function');
ok(typeof load('es/typed-array/float32-array') === 'function');
ok(typeof load('es/typed-array/float64-array') === 'function');
load('es/typed-array/copy-within');
load('es/typed-array/entries');
load('es/typed-array/every');
load('es/typed-array/fill');
load('es/typed-array/filter');
load('es/typed-array/find');
load('es/typed-array/find-index');
load('es/typed-array/for-each');
load('es/typed-array/from');
load('es/typed-array/includes');
load('es/typed-array/index-of');
load('es/typed-array/iterator');
load('es/typed-array/join');
load('es/typed-array/keys');
load('es/typed-array/last-index-of');
load('es/typed-array/map');
load('es/typed-array/of');
load('es/typed-array/reduce');
load('es/typed-array/reduce-right');
load('es/typed-array/reverse');
load('es/typed-array/set');
load('es/typed-array/slice');
load('es/typed-array/some');
load('es/typed-array/sort');
load('es/typed-array/subarray');
load('es/typed-array/to-locale-string');
load('es/typed-array/to-string');
load('es/typed-array/values');
ok(typeof load('es/typed-array').Uint32Array === 'function');
// eslint-disable-next-line no-console
console.log(`Tested ${ tested } CommonJS entry points`);
core-js-3.6.1/tests/compat/ 0000775 0000000 0000000 00000000000 13600575677 0015530 5 ustar 00root root 0000000 0000000 core-js-3.6.1/tests/compat/browsers-runner.js 0000664 0000000 0000000 00000001222 13600575677 0021240 0 ustar 00root root 0000000 0000000 var table = document.getElementById('table');
for (var key in window.tests) {
var test = window.tests[key];
var result = true;
try {
if (typeof test == 'function') {
result = !!test();
} else {
for (var i = 0; i < test.length; i++) result = result && !!test[i].call(undefined);
}
} catch (error) {
result = false;
}
var tr = document.createElement('tr');
tr.className = result;
var td1 = document.createElement('td');
td1.innerHTML = key;
tr.appendChild(td1);
var td2 = document.createElement('td');
td2.innerHTML = result ? 'not required' : 'required';
tr.appendChild(td2);
table.appendChild(tr);
}
core-js-3.6.1/tests/compat/index.html 0000664 0000000 0000000 00000000433 13600575677 0017525 0 ustar 00root root 0000000 0000000
core-js-compat
core-js-3.6.1/tests/compat/node-runner.js 0000664 0000000 0000000 00000000703 13600575677 0020322 0 ustar 00root root 0000000 0000000 require('./tests');
var tests = global.tests;
var result = {};
for (var key in tests) {
var test = tests[key];
try {
if (typeof test == 'function') {
result[key] = !!test();
} else result[key] = test.reduce(function (accumulator, $test) {
return accumulator && !!$test();
}, true);
} catch (error) {
result[key] = false;
}
}
// eslint-disable-next-line no-console
console.log(JSON.stringify(result, null, ' '));
core-js-3.6.1/tests/compat/tests.js 0000664 0000000 0000000 00000127007 13600575677 0017237 0 ustar 00root root 0000000 0000000 /* eslint-disable no-new, radix */
// eslint-disable-next-line no-new-func
var GLOBAL = Function('return this')();
// eslint-disable-next-line max-len
var WHITESPACES = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
var NOT_WHITESPACES = '\u200B\u0085\u180E';
var USERAGENT = GLOBAL.navigator && GLOBAL.navigator.userAgent || '';
// eslint-disable-next-line unicorn/no-unsafe-regex
var WEBKIT_STRING_PAD_BUG = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(USERAGENT);
var DESCRIPTORS_SUPPORT = function () {
return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a == 7;
};
var PROMISES_SUPPORT = function () {
var process = GLOBAL.process;
var IS_NODE = Object.prototype.toString.call(process) == '[object process]';
var v8 = process && process.versions && process.versions.v8 || '';
var promise = Promise.resolve(1);
var empty = function () { /* empty */ };
var FakePromise = (promise.constructor = {})[Symbol.species] = function (exec) {
exec(empty, empty);
};
return (IS_NODE || typeof PromiseRejectionEvent == 'function')
&& promise.then(empty) instanceof FakePromise
&& v8.indexOf('6.6') !== 0
&& USERAGENT.indexOf('Chrome/66') === -1;
};
var SYMBOLS_SUPPORT = function () {
return String(Symbol());
};
var URL_AND_URL_SEARCH_PARAMS_SUPPORT = function () {
var url = new URL('b?a=1&b=2&c=3', 'http://a');
var searchParams = url.searchParams;
var result = '';
url.pathname = 'c%20d';
searchParams.forEach(function (value, key) {
searchParams['delete']('b');
result += key + value;
});
return searchParams.sort
&& url.href === 'http://a/c%20d?a=1&c=3'
&& searchParams.get('c') === '3'
&& String(new URLSearchParams('?a=1')) === 'a=1'
&& searchParams[Symbol.iterator]
&& new URL('https://a@b').username === 'a'
&& new URLSearchParams(new URLSearchParams('a=b')).get('a') === 'b'
&& new URL('http://тест').host === 'xn--e1aybc'
&& new URL('http://a#б').hash === '#%D0%B1'
&& result === 'a1c3'
&& new URL('http://x', undefined).host === 'x';
};
var OBJECT_PROTOTYPE_ACCESSORS_SUPPORT = function () {
try {
Object.prototype.__defineSetter__.call(null, Math.random(), function () { /* empty */ });
} catch (error) {
return Object.prototype.__defineSetter__;
}
};
var SAFE_ITERATION_CLOSING_SUPPORT = function () {
var SAFE_CLOSING = false;
try {
var called = 0;
var iteratorWithReturn = {
next: function () {
return { done: !!called++ };
},
'return': function () {
SAFE_CLOSING = true;
}
};
iteratorWithReturn[Symbol.iterator] = function () {
return this;
};
Array.from(iteratorWithReturn, function () { throw Error('close'); });
} catch (error) {
return SAFE_CLOSING;
}
};
var ARRAY_BUFFER_SUPPORT = function () {
return ArrayBuffer && DataView;
};
var TYPED_ARRAY_CONSTRUCTORS_LIST = {
Int8Array: 1,
Uint8Array: 1,
Uint8ClampedArray: 1,
Int16Array: 2,
Uint16Array: 2,
Int32Array: 4,
Uint32Array: 4,
Float32Array: 4,
Float64Array: 8
};
var ARRAY_BUFFER_VIEWS_SUPPORT = function () {
for (var constructor in TYPED_ARRAY_CONSTRUCTORS_LIST) if (!GLOBAL[constructor]) return false;
return ARRAY_BUFFER_SUPPORT();
};
var TYPED_ARRAY_CONSTRUCTORS_NOT_REQUIRES_WRAPPERS = function () {
try {
return !Int8Array(1);
} catch (error) { /* empty */ }
try {
return !new Int8Array(-1);
} catch (error) { /* empty */ }
new Int8Array();
new Int8Array(null);
new Int8Array(1.5);
var called = 0;
var iterable = {
next: function () {
return { done: !!called++, value: 1 };
}
};
iterable[Symbol.iterator] = function () {
return this;
};
return new Int8Array(iterable)[0] == 1
&& new Int8Array(new ArrayBuffer(2), 1, undefined).length == 1;
};
function createIsRegExpLogicTest(name) {
return function () {
var regexp = /./;
try {
'/./'[name](regexp);
} catch (e) {
try {
regexp[Symbol.match] = false;
return '/./'[name](regexp);
} catch (f) { /* empty */ }
} return false;
};
}
function createStringHTMLMethodTest(METHOD_NAME) {
return function () {
var test = ''[METHOD_NAME]('"');
return test == test.toLowerCase() && test.split('"').length <= 3;
};
}
function createStringTrimMethodTest(METHOD_NAME) {
return function () {
return !WHITESPACES[METHOD_NAME]()
&& NOT_WHITESPACES[METHOD_NAME]() === NOT_WHITESPACES
&& WHITESPACES[METHOD_NAME].name === METHOD_NAME;
};
}
GLOBAL.tests = {
'es.symbol': [SYMBOLS_SUPPORT, function () {
return Object.getOwnPropertySymbols
&& Object.getOwnPropertySymbols('qwe')
&& Symbol['for']
&& Symbol.keyFor
&& JSON.stringify([Symbol()]) == '[null]'
&& JSON.stringify({ a: Symbol() }) == '{}'
&& JSON.stringify(Object(Symbol())) == '{}'
&& Symbol.prototype[Symbol.toPrimitive]
&& Symbol.prototype[Symbol.toStringTag];
}],
'es.symbol.description': function () {
return Symbol('foo').description == 'foo' && Symbol().description === undefined;
},
'es.symbol.async-iterator': function () {
return Symbol.asyncIterator;
},
'es.symbol.has-instance': [SYMBOLS_SUPPORT, function () {
return Symbol.hasInstance;
}],
'es.symbol.is-concat-spreadable': [SYMBOLS_SUPPORT, function () {
return Symbol.isConcatSpreadable;
}],
'es.symbol.iterator': [SYMBOLS_SUPPORT, function () {
return Symbol.iterator;
}],
'es.symbol.match': [SYMBOLS_SUPPORT, function () {
return Symbol.match;
}],
'es.symbol.match-all': [SYMBOLS_SUPPORT, function () {
return Symbol.matchAll;
}],
'es.symbol.replace': [SYMBOLS_SUPPORT, function () {
return Symbol.replace;
}],
'es.symbol.search': [SYMBOLS_SUPPORT, function () {
return Symbol.search;
}],
'es.symbol.species': [SYMBOLS_SUPPORT, function () {
return Symbol.species;
}],
'es.symbol.split': [SYMBOLS_SUPPORT, function () {
return Symbol.split;
}],
'es.symbol.to-primitive': [SYMBOLS_SUPPORT, function () {
return Symbol.toPrimitive;
}],
'es.symbol.to-string-tag': [SYMBOLS_SUPPORT, function () {
return Symbol.toStringTag;
}],
'es.symbol.unscopables': [SYMBOLS_SUPPORT, function () {
return Symbol.unscopables;
}],
'es.array.concat': function () {
var array1 = [];
array1[Symbol.isConcatSpreadable] = false;
var array2 = [];
var constructor = array2.constructor = {};
constructor[Symbol.species] = function () {
return { foo: 1 };
};
return array1.concat()[0] === array1 && array2.concat().foo === 1;
},
'es.array.copy-within': function () {
return Array.prototype.copyWithin && Array.prototype[Symbol.unscopables].copyWithin;
},
'es.array.every': function () {
try {
Array.prototype.every.call(null, function () { /* empty */ });
return false;
} catch (error) { /* empty */ }
return Array.prototype.every;
},
'es.array.fill': function () {
return Array.prototype.fill && Array.prototype[Symbol.unscopables].fill;
},
'es.array.filter': function () {
[].filter.call({ length: -1, 0: 1 }, function (it) { throw it; });
var array = [];
var constructor = array.constructor = {};
constructor[Symbol.species] = function () {
return { foo: 1 };
};
return array.filter(Boolean).foo === 1;
},
'es.array.find': function () {
var SKIPS_HOLES = true;
Array(1).find(function () { return SKIPS_HOLES = false; });
return !SKIPS_HOLES && Array.prototype[Symbol.unscopables].find;
},
'es.array.find-index': function () {
var SKIPS_HOLES = true;
Array(1).findIndex(function () { return SKIPS_HOLES = false; });
return !SKIPS_HOLES && Array.prototype[Symbol.unscopables].findIndex;
},
'es.array.flat': function () {
return Array.prototype.flat;
},
'es.array.flat-map': function () {
return Array.prototype.flatMap;
},
'es.array.for-each': function () {
try {
Array.prototype.forEach.call(null, function () { /* empty */ });
return false;
} catch (error) { /* empty */ }
return Array.prototype.forEach;
},
'es.array.from': SAFE_ITERATION_CLOSING_SUPPORT,
'es.array.includes': function () {
return Array.prototype.includes && Array.prototype[Symbol.unscopables].includes;
},
'es.array.index-of': function () {
try {
Array.prototype.indexOf.call(null);
} catch (error) {
return 1 / [1].indexOf(1, -0) > 0;
}
},
'es.array.is-array': function () {
return Array.isArray;
},
'es.array.iterator': [SYMBOLS_SUPPORT, function () {
return [][Symbol.iterator] === [].values
&& [][Symbol.iterator].name === 'values'
&& [].entries()[Symbol.toStringTag] === 'Array Iterator'
&& [].keys().next()
&& [][Symbol.unscopables].keys
&& [][Symbol.unscopables].values
&& [][Symbol.unscopables].entries;
}],
'es.array.join': function () {
try {
if (!Object.prototype.propertyIsEnumerable.call(Object('z'), 0)) return false;
} catch (error) {
return false;
}
try {
Array.prototype.join.call(null);
return false;
} catch (error) { /* empty */ }
return true;
},
'es.array.last-index-of': function () {
try {
Array.prototype.lastIndexOf.call(null);
} catch (error) {
return 1 / [1].lastIndexOf(1, -0) > 0;
}
},
'es.array.map': function () {
[].map.call({ length: -1, 0: 1 }, function (it) { throw it; });
var array = [];
var constructor = array.constructor = {};
constructor[Symbol.species] = function () {
return { foo: 1 };
};
return array.map(function () { return true; }).foo === 1;
},
'es.array.of': function () {
function F() { /* empty */ }
return Array.of.call(F) instanceof F;
},
'es.array.reduce': function () {
try {
Array.prototype.reduce.call(null, function () { /* empty */ }, 1);
} catch (error) {
return Array.prototype.reduce;
}
},
'es.array.reduce-right': function () {
try {
Array.prototype.reduceRight.call(null, function () { /* empty */ }, 1);
} catch (error) {
return Array.prototype.reduceRight;
}
},
'es.array.reverse': function () {
var test = [1, 2];
return String(test) !== String(test.reverse());
},
'es.array.slice': function () {
var array = [];
var constructor = array.constructor = {};
constructor[Symbol.species] = function () {
return { foo: 1 };
};
return array.slice().foo === 1;
},
'es.array.some': function () {
try {
Array.prototype.some.call(null, function () { /* empty */ });
} catch (error) {
return Array.prototype.some;
}
},
'es.array.sort': function () {
try {
Array.prototype.sort.call(null);
} catch (e) {
try {
[1, 2, 3].sort(null);
} catch (f) {
[1, 2, 3].sort(undefined);
return true;
}
}
},
'es.array.species': [SYMBOLS_SUPPORT, function () {
return Array[Symbol.species];
}],
'es.array.splice': function () {
var array = [];
var constructor = array.constructor = {};
constructor[Symbol.species] = function () {
return { foo: 1 };
};
return array.splice().foo === 1;
},
'es.array.unscopables.flat': function () {
return Array.prototype[Symbol.unscopables].flat;
},
'es.array.unscopables.flat-map': function () {
return Array.prototype[Symbol.unscopables].flatMap;
},
'es.array-buffer.constructor': [ARRAY_BUFFER_SUPPORT, function () {
try {
return !ArrayBuffer(1);
} catch (error) { /* empty */ }
try {
return !new ArrayBuffer(-1);
} catch (error) { /* empty */ }
new ArrayBuffer();
new ArrayBuffer(1.5);
new ArrayBuffer(NaN);
return ArrayBuffer.name == 'ArrayBuffer';
}],
'es.array-buffer.is-view': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return ArrayBuffer.isView;
}],
'es.array-buffer.slice': [ARRAY_BUFFER_SUPPORT, function () {
return new ArrayBuffer(2).slice(1, undefined).byteLength;
}],
'es.data-view': ARRAY_BUFFER_SUPPORT,
'es.date.now': function () {
return Date.now;
},
'es.date.to-iso-string': function () {
try {
new Date(NaN).toISOString();
} catch (error) {
return new Date(-5e13 - 1).toISOString() == '0385-07-25T07:06:39.999Z';
}
},
'es.date.to-json': function () {
return new Date(NaN).toJSON() === null
&& Date.prototype.toJSON.call({ toISOString: function () { return 1; } }) === 1;
},
'es.date.to-primitive': [SYMBOLS_SUPPORT, function () {
return Date.prototype[Symbol.toPrimitive];
}],
'es.date.to-string': function () {
return new Date(NaN).toString() == 'Invalid Date';
},
'es.function.bind': function () {
return Function.prototype.bind;
},
'es.function.has-instance': [SYMBOLS_SUPPORT, function () {
return Symbol.hasInstance in Function.prototype;
}],
'es.function.name': function () {
return 'name' in Function.prototype;
},
'es.global-this': function () {
return globalThis;
},
'es.json.stringify': function () {
return JSON.stringify('\uDF06\uD834') === '"\\udf06\\ud834"'
&& JSON.stringify('\uDEAD') === '"\\udead"';
},
'es.json.to-string-tag': [SYMBOLS_SUPPORT, function () {
return JSON[Symbol.toStringTag];
}],
'es.map': [SAFE_ITERATION_CLOSING_SUPPORT, function () {
var called = 0;
var iterable = {
next: function () {
return { done: !!called++, value: [1, 2] };
}
};
iterable[Symbol.iterator] = function () {
return this;
};
var map = new Map(iterable);
return map.forEach
&& map[Symbol.iterator]().next()
&& map.get(1) == 2
&& map.set(-0, 3) == map
&& map.has(0)
&& map[Symbol.toStringTag];
}],
'es.math.acosh': function () {
// V8 bug: https://code.google.com/p/v8/issues/detail?id=3509
return Math.floor(Math.acosh(Number.MAX_VALUE)) == 710
// Tor Browser bug: Math.acosh(Infinity) -> NaN
&& Math.acosh(Infinity) == Infinity;
},
'es.math.asinh': function () {
return 1 / Math.asinh(0) > 0;
},
'es.math.atanh': function () {
return 1 / Math.atanh(-0) < 0;
},
'es.math.cbrt': function () {
return Math.cbrt;
},
'es.math.clz32': function () {
return Math.clz32;
},
'es.math.cosh': function () {
return Math.cosh(710) !== Infinity;
},
'es.math.expm1': function () {
// Old FF bug
return Math.expm1(10) <= 22025.465794806719 && Math.expm1(10) >= 22025.4657948067165168
// Tor Browser bug
&& Math.expm1(-2e-17) == -2e-17;
},
'es.math.fround': function () {
return Math.fround;
},
'es.math.hypot': function () {
return Math.hypot && Math.hypot(Infinity, NaN) === Infinity;
},
'es.math.imul': function () {
return Math.imul(0xFFFFFFFF, 5) == -5 && Math.imul.length == 2;
},
'es.math.log10': function () {
return Math.log10;
},
'es.math.log1p': function () {
return Math.log1p;
},
'es.math.log2': function () {
return Math.log2;
},
'es.math.sign': function () {
return Math.sign;
},
'es.math.sinh': function () {
return Math.sinh(-2e-17) == -2e-17;
},
'es.math.tanh': function () {
return Math.tanh;
},
'es.math.to-string-tag': function () {
return Math[Symbol.toStringTag];
},
'es.math.trunc': function () {
return Math.trunc;
},
'es.number.constructor': function () {
return Number(' 0o1') && Number('0b1') && !Number('+0x1');
},
'es.number.epsilon': function () {
return Number.EPSILON;
},
'es.number.is-finite': function () {
return Number.isFinite;
},
'es.number.is-integer': function () {
return Number.isInteger;
},
'es.number.is-nan': function () {
return Number.isNaN;
},
'es.number.is-safe-integer': function () {
return Number.isSafeInteger;
},
'es.number.max-safe-integer': function () {
return Number.MAX_SAFE_INTEGER;
},
'es.number.min-safe-integer': function () {
return Number.MIN_SAFE_INTEGER;
},
'es.number.parse-float': function () {
return Number.parseFloat === parseFloat
&& 1 / Number.parseFloat(WHITESPACES + '-0') === -Infinity;
},
'es.number.parse-int': function () {
return Number.parseInt === parseInt
&& Number.parseInt(WHITESPACES + '08') === 8
&& Number.parseInt(WHITESPACES + '0x16') === 22;
},
'es.number.to-fixed': function () {
try {
Number.prototype.toFixed.call({});
} catch (error) {
return 0.00008.toFixed(3) === '0.000'
&& 0.9.toFixed(0) === '1'
&& 1.255.toFixed(2) === '1.25'
&& 1000000000000000128.0.toFixed(0) === '1000000000000000128';
}
},
'es.number.to-precision': function () {
try {
Number.prototype.toPrecision.call({});
} catch (error) {
return 1.0.toPrecision(undefined) === '1';
}
},
'es.object.assign': function () {
if (DESCRIPTORS_SUPPORT && Object.assign({ b: 1 }, Object.assign(Object.defineProperty({}, 'a', {
enumerable: true,
get: function () {
Object.defineProperty(this, 'b', {
value: 3,
enumerable: false
});
}
}), { b: 2 })).b !== 1) return false;
var A = {};
var B = {};
var symbol = Symbol();
var alphabet = 'abcdefghijklmnopqrst';
A[symbol] = 7;
alphabet.split('').forEach(function (chr) { B[chr] = chr; });
return Object.assign({}, A)[symbol] == 7 && Object.keys(Object.assign({}, B)).join('') == alphabet;
},
'es.object.create': function () {
return Object.create;
},
'es.object.define-getter': OBJECT_PROTOTYPE_ACCESSORS_SUPPORT,
'es.object.define-properties': [DESCRIPTORS_SUPPORT, function () {
return Object.defineProperties;
}],
'es.object.define-property': DESCRIPTORS_SUPPORT,
'es.object.define-setter': OBJECT_PROTOTYPE_ACCESSORS_SUPPORT,
'es.object.entries': function () {
return Object.entries;
},
'es.object.freeze': function () {
return Object.freeze(true);
},
'es.object.from-entries': function () {
return Object.fromEntries;
},
'es.object.get-own-property-descriptor': [DESCRIPTORS_SUPPORT, function () {
return Object.getOwnPropertyDescriptor('qwe', '0');
}],
'es.object.get-own-property-descriptors': function () {
return Object.getOwnPropertyDescriptors;
},
'es.object.get-own-property-names': function () {
return Object.getOwnPropertyNames('qwe');
},
'es.object.get-prototype-of': function () {
return Object.getPrototypeOf('qwe');
},
'es.object.is': function () {
return Object.is;
},
'es.object.is-extensible': function () {
return !Object.isExtensible('qwe');
},
'es.object.is-frozen': function () {
return Object.isFrozen('qwe');
},
'es.object.is-sealed': function () {
return Object.isSealed('qwe');
},
'es.object.keys': function () {
return Object.keys('qwe');
},
'es.object.lookup-getter': OBJECT_PROTOTYPE_ACCESSORS_SUPPORT,
'es.object.lookup-setter': OBJECT_PROTOTYPE_ACCESSORS_SUPPORT,
'es.object.prevent-extensions': function () {
return Object.preventExtensions(true);
},
'es.object.seal': function () {
return Object.seal(true);
},
'es.object.set-prototype-of': function () {
return Object.setPrototypeOf;
},
'es.object.to-string': [SYMBOLS_SUPPORT, function () {
var O = {};
O[Symbol.toStringTag] = 'foo';
return String(O) === '[object foo]';
}],
'es.object.values': function () {
return Object.values;
},
'es.parse-float': function () {
return 1 / parseFloat(WHITESPACES + '-0') === -Infinity;
},
'es.parse-int': function () {
return parseInt(WHITESPACES + '08') === 8
&& parseInt(WHITESPACES + '0x16') === 22;
},
'es.promise': PROMISES_SUPPORT,
'es.promise.all-settled': function () {
return Promise.allSettled;
},
'es.promise.finally': [PROMISES_SUPPORT, function () {
return Promise.prototype['finally'].call({ then: function () { return this; } }, function () { /* empty */ });
}],
'es.reflect.apply': function () {
try {
return Reflect.apply(function () {
return false;
});
} catch (error) {
return Reflect.apply(function () {
return true;
}, null, []);
}
},
'es.reflect.construct': function () {
try {
return !Reflect.construct(function () { /* empty */ });
} catch (error) { /* empty */ }
function F() { /* empty */ }
return Reflect.construct(function () { /* empty */ }, [], F) instanceof F;
},
'es.reflect.define-property': function () {
return !Reflect.defineProperty(Object.defineProperty({}, 1, { value: 1 }), 1, { value: 2 });
},
'es.reflect.delete-property': function () {
return Reflect.deleteProperty;
},
'es.reflect.get': function () {
return Reflect.get;
},
'es.reflect.get-own-property-descriptor': function () {
return Reflect.getOwnPropertyDescriptor;
},
'es.reflect.get-prototype-of': function () {
return Reflect.getPrototypeOf;
},
'es.reflect.has': function () {
return Reflect.has;
},
'es.reflect.is-extensible': function () {
return Reflect.isExtensible;
},
'es.reflect.own-keys': function () {
return Reflect.ownKeys;
},
'es.reflect.prevent-extensions': function () {
return Reflect.preventExtensions;
},
'es.reflect.set': function () {
var object = Object.defineProperty({}, 'a', { configurable: true });
return Reflect.set(Object.getPrototypeOf(object), 'a', 1, object) === false;
},
'es.reflect.set-prototype-of': function () {
return Reflect.setPrototypeOf;
},
'es.regexp.constructor': function () {
var re1 = /a/g;
var re2 = /a/g;
re2[Symbol.match] = false;
return new RegExp(re1) !== re1
&& RegExp(re1) === re1
&& RegExp(re2) !== re2
&& RegExp(re1, 'i') == '/a/i'
&& new RegExp('a', 'y') // just check that it doesn't throw
&& RegExp[Symbol.species];
},
'es.regexp.exec': function () {
var re1 = /a/;
var re2 = /b*/g;
var reSticky = new RegExp('a', 'y');
var reStickyAnchored = new RegExp('^a', 'y');
re1.exec('a');
re2.exec('a');
return re1.lastIndex === 0 && re2.lastIndex === 0
&& /()??/.exec('')[1] === undefined
&& reSticky.exec('abc')[0] === 'a'
&& reSticky.exec('abc') === null
&& (reSticky.lastIndex = 1, reSticky.exec('bac')[0] === 'a')
&& (reStickyAnchored.lastIndex = 2, reStickyAnchored.exec('cba') === null);
},
'es.regexp.flags': function () {
return /./g.flags === 'g' && new RegExp('a', 'y').flags === 'y';
},
'es.regexp.sticky': function () {
return new RegExp('a', 'y').sticky === true;
},
'es.regexp.test': function () {
var execCalled = false;
var re = /[ac]/;
re.exec = function () {
execCalled = true;
return /./.exec.apply(this, arguments);
};
return re.test('abc') === true && execCalled;
},
'es.regexp.to-string': function () {
return RegExp.prototype.toString.call({ source: 'a', flags: 'b' }) === '/a/b'
&& RegExp.prototype.toString.name === 'toString';
},
'es.set': [SAFE_ITERATION_CLOSING_SUPPORT, function () {
var called = 0;
var iterable = {
next: function () {
return { done: !!called++, value: 1 };
}
};
iterable[Symbol.iterator] = function () {
return this;
};
var set = new Set(iterable);
return set.forEach
&& set[Symbol.iterator]().next()
&& set.has(1)
&& set.add(-0) == set
&& set.has(0)
&& set[Symbol.toStringTag];
}],
'es.string.code-point-at': function () {
return String.prototype.codePointAt;
},
'es.string.ends-with': createIsRegExpLogicTest('endsWith'),
'es.string.from-code-point': function () {
return String.fromCodePoint;
},
'es.string.includes': createIsRegExpLogicTest('includes'),
'es.string.iterator': [SYMBOLS_SUPPORT, function () {
return ''[Symbol.iterator];
}],
'es.string.match': function () {
var O = {};
O[Symbol.match] = function () { return 7; };
var execCalled = false;
var re = /a/;
re.exec = function () { execCalled = true; return null; };
re[Symbol.match]('');
return ''.match(O) == 7 && execCalled;
},
'es.string.match-all': function () {
try {
'a'.matchAll(/./);
} catch (error) {
return 'a'.matchAll(/./g);
}
},
'es.string.pad-end': function () {
return String.prototype.padEnd && !WEBKIT_STRING_PAD_BUG;
},
'es.string.pad-start': function () {
return String.prototype.padStart && !WEBKIT_STRING_PAD_BUG;
},
'es.string.raw': function () {
return String.raw;
},
'es.string.repeat': function () {
return String.prototype.repeat;
},
'es.string.replace': function () {
var O = {};
O[Symbol.replace] = function () { return 7; };
var execCalled = false;
var re = /a/;
re.exec = function () { execCalled = true; return null; };
re[Symbol.replace]('');
var re2 = /./;
re2.exec = function () {
var result = [];
result.groups = { a: '7' };
return result;
};
return ''.replace(O) == 7 && execCalled && ''.replace(re2, '$') === '7';
},
'es.string.search': function () {
var O = {};
O[Symbol.search] = function () { return 7; };
var execCalled = false;
var re = /a/;
re.exec = function () { execCalled = true; return null; };
re[Symbol.search]('');
return ''.search(O) == 7 && execCalled;
},
'es.string.split': function () {
var O = {};
O[Symbol.split] = function () { return 7; };
var execCalled = false;
var re = /a/;
re.exec = function () { execCalled = true; return null; };
re.constructor = {};
re.constructor[Symbol.species] = function () { return re; };
re[Symbol.split]('');
var re2 = /(?:)/;
var originalExec = re2.exec;
re2.exec = function () { return originalExec.apply(this, arguments); };
var result = 'ab'.split(re2);
return ''.split(O) == 7 && execCalled && result.length === 2 && result[0] === 'a' && result[1] === 'b';
},
'es.string.starts-with': createIsRegExpLogicTest('startsWith'),
'es.string.trim': createStringTrimMethodTest('trim'),
'es.string.trim-end': [createStringTrimMethodTest('trimEnd'), function () {
return String.prototype.trimRight === String.prototype.trimEnd;
}],
'es.string.trim-start': [createStringTrimMethodTest('trimStart'), function () {
return String.prototype.trimLeft === String.prototype.trimStart;
}],
'es.string.anchor': createStringHTMLMethodTest('anchor'),
'es.string.big': createStringHTMLMethodTest('big'),
'es.string.blink': createStringHTMLMethodTest('blink'),
'es.string.bold': createStringHTMLMethodTest('bold'),
'es.string.fixed': createStringHTMLMethodTest('fixed'),
'es.string.fontcolor': createStringHTMLMethodTest('fontcolor'),
'es.string.fontsize': createStringHTMLMethodTest('fontsize'),
'es.string.italics': createStringHTMLMethodTest('italics'),
'es.string.link': createStringHTMLMethodTest('link'),
'es.string.small': createStringHTMLMethodTest('small'),
'es.string.strike': createStringHTMLMethodTest('strike'),
'es.string.sub': createStringHTMLMethodTest('sub'),
'es.string.sup': createStringHTMLMethodTest('sup'),
'es.typed-array.float32-array': [
ARRAY_BUFFER_VIEWS_SUPPORT,
TYPED_ARRAY_CONSTRUCTORS_NOT_REQUIRES_WRAPPERS
],
'es.typed-array.float64-array': [
ARRAY_BUFFER_VIEWS_SUPPORT,
TYPED_ARRAY_CONSTRUCTORS_NOT_REQUIRES_WRAPPERS
],
'es.typed-array.int8-array': [
ARRAY_BUFFER_VIEWS_SUPPORT,
TYPED_ARRAY_CONSTRUCTORS_NOT_REQUIRES_WRAPPERS
],
'es.typed-array.int16-array': [
ARRAY_BUFFER_VIEWS_SUPPORT,
TYPED_ARRAY_CONSTRUCTORS_NOT_REQUIRES_WRAPPERS
],
'es.typed-array.int32-array': [
ARRAY_BUFFER_VIEWS_SUPPORT,
TYPED_ARRAY_CONSTRUCTORS_NOT_REQUIRES_WRAPPERS
],
'es.typed-array.uint8-array': [
ARRAY_BUFFER_VIEWS_SUPPORT,
TYPED_ARRAY_CONSTRUCTORS_NOT_REQUIRES_WRAPPERS
],
'es.typed-array.uint8-clamped-array': [
ARRAY_BUFFER_VIEWS_SUPPORT,
TYPED_ARRAY_CONSTRUCTORS_NOT_REQUIRES_WRAPPERS
],
'es.typed-array.uint16-array': [
ARRAY_BUFFER_VIEWS_SUPPORT,
TYPED_ARRAY_CONSTRUCTORS_NOT_REQUIRES_WRAPPERS
],
'es.typed-array.uint32-array': [
ARRAY_BUFFER_VIEWS_SUPPORT,
TYPED_ARRAY_CONSTRUCTORS_NOT_REQUIRES_WRAPPERS
],
'es.typed-array.copy-within': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.copyWithin;
}],
'es.typed-array.every': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.every;
}],
'es.typed-array.fill': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.fill;
}],
'es.typed-array.filter': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.filter;
}],
'es.typed-array.find': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.find;
}],
'es.typed-array.find-index': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.findIndex;
}],
'es.typed-array.for-each': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.forEach;
}],
'es.typed-array.from': [
ARRAY_BUFFER_VIEWS_SUPPORT,
TYPED_ARRAY_CONSTRUCTORS_NOT_REQUIRES_WRAPPERS,
function () {
return Int8Array.from;
}
],
'es.typed-array.includes': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.includes;
}],
'es.typed-array.index-of': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.indexOf;
}],
'es.typed-array.iterator': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype[Symbol.iterator].name === 'values'
&& Int8Array.prototype[Symbol.iterator] === Int8Array.prototype.values
&& Int8Array.prototype.keys
&& Int8Array.prototype.entries;
}],
'es.typed-array.join': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.join;
}],
'es.typed-array.last-index-of': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.lastIndexOf;
}],
'es.typed-array.map': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.map;
}],
'es.typed-array.of': [
ARRAY_BUFFER_VIEWS_SUPPORT,
TYPED_ARRAY_CONSTRUCTORS_NOT_REQUIRES_WRAPPERS,
function () {
return Int8Array.of;
}
],
'es.typed-array.reduce': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.reduce;
}],
'es.typed-array.reduce-right': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.reduceRight;
}],
'es.typed-array.reverse': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.reverse;
}],
'es.typed-array.set': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
new Int8Array(1).set({});
return true;
}],
'es.typed-array.slice': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return new Int8Array(1).slice();
}],
'es.typed-array.some': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.some;
}],
'es.typed-array.sort': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.sort;
}],
'es.typed-array.subarray': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.subarray;
}],
'es.typed-array.to-locale-string': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
try {
Int8Array.prototype.toLocaleString.call([1, 2]);
} catch (error) {
return [1, 2].toLocaleString() == new Int8Array([1, 2]).toLocaleString();
}
}],
'es.typed-array.to-string': [ARRAY_BUFFER_VIEWS_SUPPORT, function () {
return Int8Array.prototype.toString == Array.prototype.toString;
}],
'es.weak-map': [SAFE_ITERATION_CLOSING_SUPPORT, function () {
var key = Object.freeze({});
var called = 0;
var iterable = {
next: function () {
return { done: !!called++, value: [key, 1] };
}
};
iterable[Symbol.iterator] = function () {
return this;
};
var map = new WeakMap(iterable);
return map.get(key) == 1
&& map.get(null) == undefined
&& map.set({}, 2) == map
&& map[Symbol.toStringTag];
}],
'es.weak-set': [SAFE_ITERATION_CLOSING_SUPPORT, function () {
var key = {};
var called = 0;
var iterable = {
next: function () {
return { done: !!called++, value: key };
}
};
iterable[Symbol.iterator] = function () {
return this;
};
var set = new WeakSet(iterable);
return set.has(key)
&& !set.has(null)
&& set.add({}) == set
&& set[Symbol.toStringTag];
}],
'esnext.aggregate-error': function () {
return typeof AggregateError === 'function';
},
'esnext.array.last-index': function () {
return [1, 2, 3].lastIndex && Array.prototype[Symbol.unscopables].lastIndex;
},
'esnext.array.last-item': function () {
return [1, 2, 3].lastItem && Array.prototype[Symbol.unscopables].lastItem;
},
'esnext.async-iterator.constructor': function () {
return typeof AsyncIterator == 'function';
},
'esnext.async-iterator.as-indexed-pairs': function () {
return AsyncIterator.prototype.asIndexedPairs;
},
'esnext.async-iterator.drop': function () {
return AsyncIterator.prototype.drop;
},
'esnext.async-iterator.every': function () {
return AsyncIterator.prototype.every;
},
'esnext.async-iterator.filter': function () {
return AsyncIterator.prototype.filter;
},
'esnext.async-iterator.find': function () {
return AsyncIterator.prototype.find;
},
'esnext.async-iterator.flat-map': function () {
return AsyncIterator.prototype.flatMap;
},
'esnext.async-iterator.for-each': function () {
return AsyncIterator.prototype.forEach;
},
'esnext.async-iterator.from': function () {
return AsyncIterator.from;
},
'esnext.async-iterator.map': function () {
return AsyncIterator.prototype.map;
},
'esnext.async-iterator.reduce': function () {
return AsyncIterator.prototype.reduce;
},
'esnext.async-iterator.some': function () {
return AsyncIterator.prototype.some;
},
'esnext.async-iterator.take': function () {
return AsyncIterator.prototype.take;
},
'esnext.async-iterator.to-array': function () {
return AsyncIterator.prototype.toArray;
},
'esnext.composite-key': function () {
return compositeKey;
},
'esnext.composite-symbol': function () {
return compositeSymbol;
},
'esnext.iterator.constructor': function () {
return typeof Iterator == 'function'
&& Iterator.prototype === Object.getPrototypeOf(Object.getPrototypeOf([].values()));
},
'esnext.iterator.as-indexed-pairs': function () {
return Iterator.prototype.asIndexedPairs;
},
'esnext.iterator.drop': function () {
return Iterator.prototype.drop;
},
'esnext.iterator.every': function () {
return Iterator.prototype.every;
},
'esnext.iterator.filter': function () {
return Iterator.prototype.filter;
},
'esnext.iterator.find': function () {
return Iterator.prototype.find;
},
'esnext.iterator.flat-map': function () {
return Iterator.prototype.flatMap;
},
'esnext.iterator.for-each': function () {
return Iterator.prototype.forEach;
},
'esnext.iterator.from': function () {
return Iterator.from;
},
'esnext.iterator.map': function () {
return Iterator.prototype.map;
},
'esnext.iterator.reduce': function () {
return Iterator.prototype.reduce;
},
'esnext.iterator.some': function () {
return Iterator.prototype.some;
},
'esnext.iterator.take': function () {
return Iterator.prototype.take;
},
'esnext.iterator.to-array': function () {
return Iterator.prototype.toArray;
},
'esnext.map.delete-all': function () {
return Map.prototype.deleteAll;
},
'esnext.map.every': function () {
return Map.prototype.every;
},
'esnext.map.filter': function () {
return Map.prototype.filter;
},
'esnext.map.find': function () {
return Map.prototype.find;
},
'esnext.map.find-key': function () {
return Map.prototype.findKey;
},
'esnext.map.from': function () {
return Map.from;
},
'esnext.map.group-by': function () {
return Map.groupBy;
},
'esnext.map.includes': function () {
return Map.prototype.includes;
},
'esnext.map.key-by': function () {
return Map.keyBy;
},
'esnext.map.key-of': function () {
return Map.prototype.keyOf;
},
'esnext.map.map-keys': function () {
return Map.prototype.mapKeys;
},
'esnext.map.map-values': function () {
return Map.prototype.mapValues;
},
'esnext.map.merge': function () {
return Map.prototype.merge;
},
'esnext.map.of': function () {
return Map.of;
},
'esnext.map.reduce': function () {
return Map.prototype.reduce;
},
'esnext.map.some': function () {
return Map.prototype.some;
},
'esnext.map.update': function () {
return Map.prototype.update;
},
// TODO: Remove from `core-js@4`
'esnext.map.update-or-insert': function () {
return Map.prototype.updateOrInsert;
},
'esnext.map.upsert': function () {
return Map.prototype.upsert;
},
'esnext.math.clamp': function () {
return Math.clamp;
},
'esnext.math.deg-per-rad': function () {
return Math.DEG_PER_RAD;
},
'esnext.math.degrees': function () {
return Math.degrees;
},
'esnext.math.fscale': function () {
return Math.fscale;
},
// TODO: Remove from `core-js@4`
'esnext.math.iaddh': function () {
return Math.iaddh;
},
// TODO: Remove from `core-js@4`
'esnext.math.imulh': function () {
return Math.imulh;
},
// TODO: Remove from `core-js@4`
'esnext.math.isubh': function () {
return Math.isubh;
},
'esnext.math.rad-per-deg': function () {
return Math.RAD_PER_DEG;
},
'esnext.math.radians': function () {
return Math.radians;
},
'esnext.math.scale': function () {
return Math.scale;
},
'esnext.math.seeded-prng': function () {
return Math.seededPRNG;
},
'esnext.math.signbit': function () {
return Math.signbit;
},
// TODO: Remove from `core-js@4`
'esnext.math.umulh': function () {
return Math.umulh;
},
'esnext.number.from-string': function () {
return Number.fromString;
},
'esnext.object.iterate-entries': function () {
return Object.iterateEntries;
},
'esnext.object.iterate-keys': function () {
return Object.iterateKeys;
},
'esnext.object.iterate-values': function () {
return Object.iterateValues;
},
'esnext.observable': function () {
return Observable;
},
'esnext.promise.any': function () {
return Promise.any;
},
'esnext.promise.try': [PROMISES_SUPPORT, function () {
return Promise['try'];
}],
'esnext.reflect.define-metadata': function () {
return Reflect.defineMetadata;
},
'esnext.reflect.delete-metadata': function () {
return Reflect.deleteMetadata;
},
'esnext.reflect.get-metadata': function () {
return Reflect.getMetadata;
},
'esnext.reflect.get-metadata-keys': function () {
return Reflect.getMetadataKeys;
},
'esnext.reflect.get-own-metadata': function () {
return Reflect.getOwnMetadata;
},
'esnext.reflect.get-own-metadata-keys': function () {
return Reflect.getOwnMetadataKeys;
},
'esnext.reflect.has-metadata': function () {
return Reflect.hasMetadata;
},
'esnext.reflect.has-own-metadata': function () {
return Reflect.hasOwnMetadata;
},
'esnext.reflect.metadata': function () {
return Reflect.metadata;
},
'esnext.set.add-all': function () {
return Set.prototype.addAll;
},
'esnext.set.delete-all': function () {
return Set.prototype.deleteAll;
},
'esnext.set.difference': function () {
return Set.prototype.difference;
},
'esnext.set.every': function () {
return Set.prototype.every;
},
'esnext.set.filter': function () {
return Set.prototype.filter;
},
'esnext.set.find': function () {
return Set.prototype.find;
},
'esnext.set.from': function () {
return Set.from;
},
'esnext.set.intersection': function () {
return Set.prototype.intersection;
},
'esnext.set.is-disjoint-from': function () {
return Set.prototype.isDisjointFrom;
},
'esnext.set.is-subset-of': function () {
return Set.prototype.isSubsetOf;
},
'esnext.set.is-superset-of': function () {
return Set.prototype.isSupersetOf;
},
'esnext.set.join': function () {
return Set.prototype.join;
},
'esnext.set.map': function () {
return Set.prototype.map;
},
'esnext.set.of': function () {
return Set.of;
},
'esnext.set.reduce': function () {
return Set.prototype.reduce;
},
'esnext.set.some': function () {
return Set.prototype.some;
},
'esnext.set.symmetric-difference': function () {
return Set.prototype.symmetricDifference;
},
'esnext.set.union': function () {
return Set.prototype.union;
},
'esnext.string.at': function () {
return String.prototype.at;
},
'esnext.string.code-points': function () {
return String.prototype.codePoints;
},
'esnext.string.replace-all': function () {
return String.prototype.replaceAll;
},
'esnext.symbol.dispose': function () {
return Symbol.dispose;
},
'esnext.symbol.observable': function () {
return Symbol.observable;
},
'esnext.symbol.pattern-match': function () {
return Symbol.patternMatch;
},
// TODO: Remove from `core-js@4`
'esnext.symbol.replace-all': function () {
return Symbol.replaceAll;
},
'esnext.weak-map.delete-all': function () {
return WeakMap.prototype.deleteAll;
},
'esnext.weak-map.from': function () {
return WeakMap.from;
},
'esnext.weak-map.of': function () {
return WeakMap.of;
},
'esnext.weak-map.upsert': function () {
return WeakMap.prototype.upsert;
},
'esnext.weak-set.add-all': function () {
return WeakSet.prototype.addAll;
},
'esnext.weak-set.delete-all': function () {
return WeakSet.prototype.deleteAll;
},
'esnext.weak-set.from': function () {
return WeakSet.from;
},
'esnext.weak-set.of': function () {
return WeakSet.of;
},
'web.dom-collections.for-each': function () {
return (!GLOBAL.NodeList || (NodeList.prototype.forEach && NodeList.prototype.forEach === [].forEach))
&& (!GLOBAL.DOMTokenList || (DOMTokenList.prototype.forEach && DOMTokenList.prototype.forEach === [].forEach));
},
'web.dom-collections.iterator': function () {
var DOMIterables = {
CSSRuleList: 0,
CSSStyleDeclaration: 0,
CSSValueList: 0,
ClientRectList: 0,
DOMRectList: 0,
DOMStringList: 0,
DOMTokenList: 1,
DataTransferItemList: 0,
FileList: 0,
HTMLAllCollection: 0,
HTMLCollection: 0,
HTMLFormElement: 0,
HTMLSelectElement: 0,
MediaList: 0,
MimeTypeArray: 0,
NamedNodeMap: 0,
NodeList: 1,
PaintRequestList: 0,
Plugin: 0,
PluginArray: 0,
SVGLengthList: 0,
SVGNumberList: 0,
SVGPathSegList: 0,
SVGPointList: 0,
SVGStringList: 0,
SVGTransformList: 0,
SourceBufferList: 0,
StyleSheetList: 0,
TextTrackCueList: 0,
TextTrackList: 0,
TouchList: 0
};
for (var collection in DOMIterables) {
if (GLOBAL[collection]) {
if (
!GLOBAL[collection].prototype[Symbol.iterator] ||
GLOBAL[collection].prototype[Symbol.iterator] !== [].values
) return false;
if (DOMIterables[collection] && (
!GLOBAL[collection].prototype.keys ||
!GLOBAL[collection].prototype.values ||
!GLOBAL[collection].prototype.entries
)) return false;
}
}
return true;
},
'web.immediate': function () {
return setImmediate && clearImmediate;
},
'web.queue-microtask': function () {
return Object.getOwnPropertyDescriptor(GLOBAL, 'queueMicrotask').value;
},
'web.timers': function () {
return !/MSIE .\./.test(USERAGENT);
},
'web.url': URL_AND_URL_SEARCH_PARAMS_SUPPORT,
'web.url.to-json': [URL_AND_URL_SEARCH_PARAMS_SUPPORT, function () {
return URL.prototype.toJSON;
}],
'web.url-search-params': URL_AND_URL_SEARCH_PARAMS_SUPPORT
};
core-js-3.6.1/tests/helpers/ 0000775 0000000 0000000 00000000000 13600575677 0015707 5 ustar 00root root 0000000 0000000 core-js-3.6.1/tests/helpers/constants.js 0000664 0000000 0000000 00000002574 13600575677 0020271 0 ustar 00root root 0000000 0000000 export const DESCRIPTORS = !!(() => {
try {
return Object.defineProperty({}, 'a', {
get() {
return 7;
},
}).a === 7;
} catch { /* empty */ }
})();
export const GLOBAL = Function('return this')();
export const NATIVE = GLOBAL.NATIVE || false;
export const TYPED_ARRAYS = {
Float32Array: 4,
Float64Array: 8,
Int8Array: 1,
Int16Array: 2,
Int32Array: 4,
Uint8Array: 1,
Uint16Array: 2,
Uint32Array: 4,
Uint8ClampedArray: 1,
};
export const LITTLE_ENDIAN = (() => {
try {
return new GLOBAL.Uint8Array(new GLOBAL.Uint16Array([1]).buffer)[0] === 1;
} catch {
return true;
}
})();
export const PROTO = !!Object.setPrototypeOf || '__proto__' in Object.prototype;
export const STRICT = !function () {
return this;
}();
export const STRICT_THIS = (function () {
return this;
})();
export const FREEZING = !function () {
try {
return Object.isExtensible(Object.preventExtensions({}));
} catch {
return true;
}
}();
export const CORRECT_PROTOTYPE_GETTER = !function () {
try {
function F() { /* empty */ }
F.prototype.constructor = null;
return Object.getPrototypeOf(new F()) !== F.prototype;
} catch {
return true;
}
}();
export const WHITESPACES = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
core-js-3.6.1/tests/helpers/helpers.js 0000664 0000000 0000000 00000004635 13600575677 0017717 0 ustar 00root root 0000000 0000000 import Promise from 'core-js-pure/es/promise';
import ITERATOR from 'core-js-pure/features/symbol/iterator';
export function createIterator(elements, methods) {
let index = 0;
const iterator = {
called: false,
next() {
iterator.called = true;
return {
value: elements[index++],
done: index > elements.length,
};
},
};
if (methods) for (const key in methods) iterator[key] = methods[key];
return iterator;
}
export function createIterable(elements, methods) {
const iterable = {
called: false,
received: false,
[ITERATOR]() {
iterable.received = true;
let index = 0;
const iterator = {
next() {
iterable.called = true;
return {
value: elements[index++],
done: index > elements.length,
};
},
};
if (methods) for (const key in methods) iterator[key] = methods[key];
return iterator;
},
};
return iterable;
}
export function includes(target, wanted) {
for (const element of target) if (wanted === element) return true;
return false;
}
export function is(a, b) {
// eslint-disable-next-line no-self-compare
return a === b ? a !== 0 || 1 / a === 1 / b : a != a && b != b;
}
export const nativeSubclass = (() => {
try {
if (Function(`
'use strict';
class Subclass extends Object { /* empty */ };
return new Subclass() instanceof Subclass;
`)()) return Function('Parent', `
'use strict';
return class extends Parent { /* empty */ };
`);
} catch { /* empty */ }
})();
export function timeLimitedPromise(time, fn) {
return Promise.race([
new Promise(fn), new Promise((resolve, reject) => {
setTimeout(reject, time);
}),
]);
}
// This function is used to force RegExp.prototype[Symbol.*] methods
// to not use the native implementation.
export function patchRegExp$exec(run) {
return assert => {
const originalExec = RegExp.prototype.exec;
// eslint-disable-next-line no-extend-native
RegExp.prototype.exec = function () {
return originalExec.apply(this, arguments);
};
try {
return run(assert);
// In very old IE try / finally does not work without catch.
// eslint-disable-next-line no-useless-catch
} catch (error) {
throw error;
} finally {
// eslint-disable-next-line no-extend-native
RegExp.prototype.exec = originalExec;
}
};
}
core-js-3.6.1/tests/helpers/qunit-helpers.js 0000664 0000000 0000000 00000010033 13600575677 0021042 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL } from './constants';
import isIterable from 'core-js-pure/features/is-iterable';
import ASYNC_ITERATOR from 'core-js-pure/es/symbol/async-iterator';
import { is } from './helpers';
const { toString, propertyIsEnumerable } = Object.prototype.propertyIsEnumerable;
GLOBAL.USE_FUNCTION_CONSTRUCTOR = true;
QUnit.assert.arity = function (fn, length, message) {
this.pushResult({
result: fn.length === length,
actual: fn.length,
expected: length,
message: message || `arity is ${ length }`,
});
};
QUnit.assert.arrayEqual = function (a, b, message) {
let result = true;
if (a.length !== b.length) {
result = false;
} else {
for (let i = 0, { length } = a; i < length; ++i) {
if (!is(a[i], b[i])) {
result = false;
break;
}
}
}
this.pushResult({
result,
actual: [].slice.call(a),
expected: [].slice.call(b),
message,
});
};
QUnit.assert.epsilon = function (a, b, E, message) {
this.pushResult({
result: Math.abs(a - b) <= (E != null ? E : 1e-11),
actual: a,
expected: b,
message,
});
};
QUnit.assert.isFunction = function (fn, message) {
this.pushResult({
result: typeof fn === 'function' || toString.call(fn).slice(8, -1) === 'Function',
actual: false,
expected: true,
message: message || 'is function',
});
};
QUnit.assert.isAsyncIterable = function (it, message) {
this.pushResult({
result: typeof it == 'object' && typeof it[ASYNC_ITERATOR] == 'function',
actual: false,
expected: true,
message: message || 'is async iterable',
});
};
QUnit.assert.isIterable = function (it, message) {
this.pushResult({
result: isIterable(it),
actual: false,
expected: true,
message: message || 'is iterable',
});
};
QUnit.assert.isIterator = function (it, message) {
this.pushResult({
result: typeof it === 'object' && typeof it.next === 'function',
actual: false,
expected: true,
message: message || 'is iterator',
});
};
QUnit.assert.looksNative = function (fn, message) {
this.pushResult({
result: /native code/.test(Function.prototype.toString.call(fn)),
actual: false,
expected: true,
message: message || 'looks native',
});
};
QUnit.assert.name = function (fn, name, message) {
if (typeof fn == 'function' && 'name' in fn) {
this.pushResult({
result: fn.name === name,
actual: fn.name,
expected: name,
message: message || `name is '${ name }'`,
});
} else {
this.pushResult({
result: true,
actual: true,
expected: true,
message: 'Function#name property test makes no sense',
});
}
};
QUnit.assert.enumerable = function (O, key, message) {
if (DESCRIPTORS) {
this.pushResult({
result: propertyIsEnumerable.call(O, key),
actual: false,
expected: true,
message: message || `${ typeof key === 'symbol' ? 'method' : `'${ key }'` } is enumerable`,
});
} else {
this.pushResult({
result: true,
actual: true,
expected: true,
message: 'Enumerability is not applicable',
});
}
};
QUnit.assert.nonEnumerable = function (O, key, message) {
if (DESCRIPTORS) {
this.pushResult({
result: !propertyIsEnumerable.call(O, key),
actual: false,
expected: true,
message: message || `${ typeof key === 'symbol' ? 'method' : `'${ key }'` } is non-enumerable`,
});
} else {
this.pushResult({
result: true,
actual: true,
expected: true,
message: 'Enumerability is not applicable',
});
}
};
QUnit.assert.notThrows = function (fn, message) {
let throws, result, error;
try {
result = fn();
throws = false;
} catch (err) {
throws = true;
error = err;
}
this.pushResult({
result: !throws && result,
actual: throws ? error : result,
expected: throws ? undefined : true,
message: message || 'does not throw',
});
};
QUnit.assert.same = function (a, b, message) {
this.pushResult({
result: is(a, b),
actual: a,
expected: b,
message,
});
};
core-js-3.6.1/tests/observables/ 0000775 0000000 0000000 00000000000 13600575677 0016554 5 ustar 00root root 0000000 0000000 core-js-3.6.1/tests/observables/adapter-pure.js 0000664 0000000 0000000 00000000373 13600575677 0021506 0 ustar 00root root 0000000 0000000 'use strict';
const core = require('../../packages/core-js-pure');
global.Promise = core.Promise;
global.Symbol = core.Symbol;
// eslint-disable-next-line import/no-unresolved
require('../bundles/observables-tests/default').runTests(core.Observable);
core-js-3.6.1/tests/observables/adapter.js 0000664 0000000 0000000 00000000311 13600575677 0020525 0 ustar 00root root 0000000 0000000 'use strict';
delete global.Observable;
require('../../packages/core-js');
// eslint-disable-next-line import/no-unresolved
require('../bundles/observables-tests/default').runTests(global.Observable);
core-js-3.6.1/tests/promises-aplus-native.html 0000664 0000000 0000000 00000001606 13600575677 0021405 0 ustar 00root root 0000000 0000000
Promises/A+ Tests, Against Your Browser!
core-js-3.6.1/tests/promises-aplus.html 0000664 0000000 0000000 00000001704 13600575677 0020120 0 ustar 00root root 0000000 0000000
Promises/A+ Tests, Against Your Browser!
core-js-3.6.1/tests/promises-aplus/ 0000775 0000000 0000000 00000000000 13600575677 0017230 5 ustar 00root root 0000000 0000000 core-js-3.6.1/tests/promises-aplus/adapter.js 0000664 0000000 0000000 00000001232 13600575677 0021204 0 ustar 00root root 0000000 0000000 delete global.Promise;
var Promise = require('../../packages/core-js').Promise;
var assert = require('assert');
module.exports = {
deferred: function () {
var deferred = {};
deferred.promise = new Promise(function (resolve, reject) {
deferred.resolve = resolve;
deferred.reject = reject;
});
return deferred;
},
resolved: function (value) {
return Promise.resolve(value);
},
rejected: function (reason) {
return Promise.reject(reason);
},
defineGlobalPromise: function (global) {
global.Promise = Promise;
global.assert = assert;
},
removeGlobalPromise: function () {
delete global.Promise;
}
};
core-js-3.6.1/tests/pure.html 0000664 0000000 0000000 00000000456 13600575677 0016113 0 ustar 00root root 0000000 0000000
Core
core-js-3.6.1/tests/pure/ 0000775 0000000 0000000 00000000000 13600575677 0015220 5 ustar 00root root 0000000 0000000 core-js-3.6.1/tests/pure/es.array.concat.js 0000664 0000000 0000000 00000002740 13600575677 0020553 0 ustar 00root root 0000000 0000000 import Symbol from 'core-js-pure/features/symbol';
import concat from 'core-js-pure/features/array/concat';
/* eslint-disable no-sparse-arrays */
QUnit.test('Array#concat', assert => {
assert.isFunction(concat);
let array = [1, 2];
const sparseArray = [1, , 2];
const nonSpreadableArray = [1, 2];
nonSpreadableArray[Symbol.isConcatSpreadable] = false;
const arrayLike = { 0: 1, 1: 2, length: 2 };
const spreadableArrayLike = { 0: 1, 1: 2, length: 2, [Symbol.isConcatSpreadable]: true };
assert.deepEqual(concat(array), [1, 2], '#1');
assert.deepEqual(concat(sparseArray), [1, , 2], '#2');
assert.deepEqual(concat(nonSpreadableArray), [[1, 2]], '#3');
assert.deepEqual(concat(arrayLike), [{ 0: 1, 1: 2, length: 2 }], '#4');
assert.deepEqual(concat(spreadableArrayLike), [1, 2], '#5');
assert.deepEqual(concat([], array), [1, 2], '#6');
assert.deepEqual(concat([], sparseArray), [1, , 2], '#7');
assert.deepEqual(concat([], nonSpreadableArray), [[1, 2]], '#8');
assert.deepEqual(concat([], arrayLike), [{ 0: 1, 1: 2, length: 2 }], '#9');
assert.deepEqual(concat([], spreadableArrayLike), [1, 2], '#10');
assert.deepEqual(concat(array, sparseArray, nonSpreadableArray, arrayLike, spreadableArrayLike), [
1, 2, 1, , 2, [1, 2], { 0: 1, 1: 2, length: 2 }, 1, 2,
], '#11');
array = [];
array.constructor = { [Symbol.species]: function () { // eslint-disable-line object-shorthand
return { foo: 1 };
} };
assert.same(concat(array).foo, 1, '@@species');
});
core-js-3.6.1/tests/pure/es.array.copy-within.js 0000664 0000000 0000000 00000002423 13600575677 0021554 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import copyWithin from 'core-js-pure/features/array/copy-within';
QUnit.test('Array#copyWithin', assert => {
assert.isFunction(copyWithin);
const array = [1];
assert.strictEqual(copyWithin(array, 0), array);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 0, 3), [4, 5, 3, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 1, 3), [1, 4, 5, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 1, 2), [1, 3, 4, 5, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 2, 2), [1, 2, 3, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 0, 3, 4), [4, 2, 3, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 1, 3, 4), [1, 4, 3, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 1, 2, 4), [1, 3, 4, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 0, -2), [4, 5, 3, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], 0, -2, -1), [4, 2, 3, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], -4, -3, -2), [1, 3, 3, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], -4, -3, -1), [1, 3, 4, 4, 5]);
assert.deepEqual(copyWithin([1, 2, 3, 4, 5], -4, -3), [1, 3, 4, 5, 5]);
if (STRICT) {
assert.throws(() => copyWithin(null, 0), TypeError);
assert.throws(() => copyWithin(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/pure/es.array.every.js 0000664 0000000 0000000 00000002316 13600575677 0020435 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import every from 'core-js-pure/features/array/every';
QUnit.test('Array#every', assert => {
assert.isFunction(every);
const array = [1];
const context = {};
every(array, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.ok(every([1, 2, 3], it => typeof it === 'number'));
assert.ok(every([1, 2, 3], it => it < 4));
assert.ok(!every([1, 2, 3], it => it < 3));
assert.ok(!every([1, 2, 3], it => typeof it === 'string'));
assert.ok(every([1, 2, 3], function () {
return +this === 1;
}, 1));
let rez = '';
every([1, 2, 3], (value, key) => rez += key);
assert.ok(rez === '012');
const arr = [1, 2, 3];
assert.ok(every(arr, (value, key, that) => that === arr));
if (STRICT) {
assert.throws(() => every(null, () => { /* empty */ }), TypeError);
assert.throws(() => every(undefined, () => { /* empty */ }), TypeError);
}
});
core-js-3.6.1/tests/pure/es.array.fill.js 0000664 0000000 0000000 00000001464 13600575677 0020234 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import fill from 'core-js-pure/features/array/fill';
QUnit.test('Array#fill', assert => {
assert.isFunction(fill);
const array = fill(Array(5), 5);
assert.strictEqual(array, array);
assert.deepEqual(fill(Array(5), 5), [5, 5, 5, 5, 5]);
assert.deepEqual(fill(Array(5), 5, 1), [undefined, 5, 5, 5, 5]);
assert.deepEqual(fill(Array(5), 5, 1, 4), [undefined, 5, 5, 5, undefined]);
assert.deepEqual(fill(Array(5), 5, 6, 1), [undefined, undefined, undefined, undefined, undefined]);
assert.deepEqual(fill(Array(5), 5, -3, 4), [undefined, undefined, 5, 5, undefined]);
assert.arrayEqual(fill({ length: 5 }, 5), [5, 5, 5, 5, 5]);
if (STRICT) {
assert.throws(() => fill(null, 0), TypeError);
assert.throws(() => fill(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/pure/es.array.filter.js 0000664 0000000 0000000 00000002143 13600575677 0020566 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import Symbol from 'core-js-pure/features/symbol';
import filter from 'core-js-pure/features/array/filter';
QUnit.test('Array#filter', assert => {
assert.isFunction(filter);
let array = [1];
const context = {};
filter(array, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.deepEqual([1, 2, 3, 4, 5], filter([1, 2, 3, 'q', {}, 4, true, 5], it => typeof it === 'number'));
if (STRICT) {
assert.throws(() => filter(null, () => { /* empty */ }), TypeError);
assert.throws(() => filter(undefined, () => { /* empty */ }), TypeError);
}
array = [];
array.constructor = { [Symbol.species]: function () { // eslint-disable-line object-shorthand
return { foo: 1 };
} };
assert.same(filter(array, Boolean).foo, 1, '@@species');
});
core-js-3.6.1/tests/pure/es.array.find-index.js 0000664 0000000 0000000 00000001213 13600575677 0021323 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import findIndex from 'core-js-pure/features/array/find-index';
QUnit.test('Array#findIndex', assert => {
assert.isFunction(findIndex);
const array = [1];
const context = {};
findIndex(array, function (value, key, that) {
assert.strictEqual(this, context);
assert.strictEqual(value, 1);
assert.strictEqual(key, 0);
assert.strictEqual(that, array);
}, context);
assert.strictEqual(findIndex([1, 3, NaN, 42, {}], it => it === 42), 3);
if (STRICT) {
assert.throws(() => findIndex(null, 0), TypeError);
assert.throws(() => findIndex(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/pure/es.array.find.js 0000664 0000000 0000000 00000001260 13600575677 0020220 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import find from 'core-js-pure/features/array/find';
QUnit.test('Array#find', assert => {
assert.isFunction(find);
const array = [1];
const context = {};
find(array, function (value, key, that) {
assert.strictEqual(this, context);
assert.strictEqual(value, 1);
assert.strictEqual(key, 0);
assert.strictEqual(that, array);
}, context);
assert.strictEqual(find([1, 3, NaN, 42, {}], it => it === 42), 42);
assert.strictEqual(find([1, 3, NaN, 42, {}], it => it === 43), undefined);
if (STRICT) {
assert.throws(() => find(null, 0), TypeError);
assert.throws(() => find(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/pure/es.array.flat-map.js 0000664 0000000 0000000 00000001755 13600575677 0021012 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import flatMap from 'core-js-pure/features/array/flat-map';
QUnit.test('Array#flatMap', assert => {
assert.isFunction(flatMap);
assert.deepEqual(flatMap([], it => it), []);
assert.deepEqual(flatMap([1, 2, 3], it => it), [1, 2, 3]);
assert.deepEqual(flatMap([1, 2, 3], it => [it, it]), [1, 1, 2, 2, 3, 3]);
assert.deepEqual(flatMap([1, 2, 3], it => [[it], [it]]), [[1], [1], [2], [2], [3], [3]]);
assert.deepEqual(flatMap([1, [2, 3]], () => 1), [1, 1]);
const array = [1];
const context = {};
flatMap(array, function (value, index, that) {
assert.same(value, 1);
assert.same(index, 0);
assert.same(that, array);
assert.same(this, context);
}, context);
if (STRICT) {
assert.throws(() => flatMap(null, it => it), TypeError);
assert.throws(() => flatMap(undefined, it => it), TypeError);
}
assert.notThrows(() => flatMap({ length: -1 }, () => {
throw new Error();
}).length === 0, 'uses ToLength');
});
core-js-3.6.1/tests/pure/es.array.flat.js 0000664 0000000 0000000 00000001765 13600575677 0020240 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, STRICT } from '../helpers/constants';
import flat from 'core-js-pure/features/array/flat';
import defineProperty from 'core-js-pure/features/object/define-property';
QUnit.test('Array#flat', assert => {
assert.isFunction(flat);
assert.deepEqual(flat([]), []);
const array = [1, [2, 3], [4, [5, 6]]];
assert.deepEqual(flat(array, 0), array);
assert.deepEqual(flat(array, 1), [1, 2, 3, 4, [5, 6]]);
assert.deepEqual(flat(array), [1, 2, 3, 4, [5, 6]]);
assert.deepEqual(flat(array, 2), [1, 2, 3, 4, 5, 6]);
assert.deepEqual(flat(array, 3), [1, 2, 3, 4, 5, 6]);
assert.deepEqual(flat(array, -1), array);
assert.deepEqual(flat(array, Infinity), [1, 2, 3, 4, 5, 6]);
if (STRICT) {
assert.throws(() => flat(null), TypeError);
assert.throws(() => flat(undefined), TypeError);
}
if (DESCRIPTORS) {
assert.notThrows(() => flat(defineProperty({ length: -1 }, 0, {
get() {
throw new Error();
},
})).length === 0, 'uses ToLength');
}
});
core-js-3.6.1/tests/pure/es.array.for-each.js 0000664 0000000 0000000 00000002521 13600575677 0020765 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import forEach from 'core-js-pure/features/array/for-each';
QUnit.test('Array#forEach', assert => {
assert.isFunction(forEach);
let array = [1];
const context = {};
forEach(array, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
let result = '';
forEach([1, 2, 3], it => {
result += it;
});
assert.ok(result === '123');
result = '';
forEach([1, 2, 3], (value, key) => {
result += key;
});
assert.ok(result === '012');
result = '';
forEach([1, 2, 3], (value, key, that) => {
result += that;
});
assert.ok(result === '1,2,31,2,31,2,3');
result = '';
forEach([1, 2, 3], function () {
result += this;
}, 1);
assert.ok(result === '111');
result = '';
array = [];
array[5] = '';
forEach(array, (value, key) => {
result += key;
});
assert.ok(result === '5');
if (STRICT) {
assert.throws(() => forEach(null, () => { /* empty */ }), TypeError);
assert.throws(() => forEach(undefined, () => { /* empty */ }), TypeError);
}
});
core-js-3.6.1/tests/pure/es.array.from.js 0000664 0000000 0000000 00000010344 13600575677 0020246 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import { createIterable } from '../helpers/helpers';
import Symbol from 'core-js-pure/features/symbol';
import getIteratorMethod from 'core-js-pure/features/get-iterator-method';
import from from 'core-js-pure/features/array/from';
import defineProperty from 'core-js-pure/features/object/define-property';
QUnit.test('Array.from', assert => {
assert.isFunction(from);
assert.arity(from, 1);
let types = {
'array-like': {
length: '3',
0: '1',
1: '2',
2: '3',
},
arguments: function () {
return arguments;
}('1', '2', '3'),
array: ['1', '2', '3'],
iterable: createIterable(['1', '2', '3']),
string: '123',
};
for (const type in types) {
const data = types[type];
assert.arrayEqual(from(data), ['1', '2', '3'], `Works with ${ type }`);
assert.arrayEqual(from(data, it => it ** 2), [1, 4, 9], `Works with ${ type } + mapFn`);
}
types = {
'array-like': {
length: 1,
0: 1,
},
arguments: function () {
return arguments;
}(1),
array: [1],
iterable: createIterable([1]),
string: '1',
};
for (const type in types) {
const data = types[type];
const context = {};
assert.arrayEqual(from(data, function (value, key) {
assert.same(this, context, `Works with ${ type }, correct callback context`);
assert.same(value, type === 'string' ? '1' : 1, `Works with ${ type }, correct callback key`);
assert.same(key, 0, `Works with ${ type }, correct callback value`);
assert.same(arguments.length, 2, `Works with ${ type }, correct callback arguments number`);
return 42;
}, context), [42], `Works with ${ type }, correct result`);
}
const primitives = [false, true, 0];
for (const primitive of primitives) {
assert.arrayEqual(from(primitive), [], `Works with ${ primitive }`);
}
assert.throws(() => from(null), TypeError, 'Throws on null');
assert.throws(() => from(undefined), TypeError, 'Throws on undefined');
assert.arrayEqual(from('𠮷𠮷𠮷'), ['𠮷', '𠮷', '𠮷'], 'Uses correct string iterator');
let done = true;
from(createIterable([1, 2, 3], {
return() {
return done = false;
},
}), () => false);
assert.ok(done, '.return #default');
done = false;
try {
from(createIterable([1, 2, 3], {
return() {
return done = true;
},
}), () => {
throw new Error();
});
} catch { /* empty */ }
assert.ok(done, '.return #throw');
class C { /* empty */ }
let instance = from.call(C, createIterable([1, 2]));
assert.ok(instance instanceof C, 'generic, iterable case, instanceof');
assert.arrayEqual(instance, [1, 2], 'generic, iterable case, elements');
instance = from.call(C, {
0: 1,
1: 2,
length: 2,
});
assert.ok(instance instanceof C, 'generic, array-like case, instanceof');
assert.arrayEqual(instance, [1, 2], 'generic, array-like case, elements');
let array = [1, 2, 3];
done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
assert.arrayEqual(from(array), [1, 2, 3], 'Array with custom iterator, elements');
assert.ok(done, 'call @@iterator in Array with custom iterator');
array = [1, 2, 3];
delete array[1];
assert.arrayEqual(from(array, String), ['1', 'undefined', '3'], 'Ignores holes');
assert.notThrows(() => from({
length: -1,
0: 1,
}, () => {
throw new Error();
}), 'Uses ToLength');
assert.arrayEqual(from([], undefined), [], 'Works with undefined as asecond argument');
assert.throws(() => from([], null), TypeError, 'Throws with null as second argument');
assert.throws(() => from([], 0), TypeError, 'Throws with 0 as second argument');
assert.throws(() => from([], ''), TypeError, 'Throws with "" as second argument');
assert.throws(() => from([], false), TypeError, 'Throws with false as second argument');
assert.throws(() => from([], {}), TypeError, 'Throws with {} as second argument');
if (DESCRIPTORS) {
let called = false;
defineProperty(C.prototype, 0, {
set() {
called = true;
},
});
from.call(C, [1, 2, 3]);
assert.ok(!called, 'Should not call prototype accessors');
}
});
core-js-3.6.1/tests/pure/es.array.includes.js 0000664 0000000 0000000 00000001300 13600575677 0021101 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import includes from 'core-js-pure/features/array/includes';
QUnit.test('Array#includes', assert => {
assert.isFunction(includes);
const object = {};
const array = [1, 2, 3, -0, object];
assert.ok(includes(array, 1));
assert.ok(includes(array, -0));
assert.ok(includes(array, 0));
assert.ok(includes(array, object));
assert.ok(!includes(array, 4));
assert.ok(!includes(array, -0.5));
assert.ok(!includes(array, {}));
assert.ok(includes(Array(1), undefined));
assert.ok(includes([NaN], NaN));
if (STRICT) {
assert.throws(() => includes(null, 0), TypeError);
assert.throws(() => includes(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/pure/es.array.index-of.js 0000664 0000000 0000000 00000001365 13600575677 0021017 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import indexOf from 'core-js-pure/features/array/index-of';
QUnit.test('Array#indexOf', assert => {
assert.isFunction(indexOf);
assert.same(0, indexOf([1, 1, 1], 1));
assert.same(-1, indexOf([1, 2, 3], 1, 1));
assert.same(1, indexOf([1, 2, 3], 2, 1));
assert.same(-1, indexOf([1, 2, 3], 2, -1));
assert.same(1, indexOf([1, 2, 3], 2, -2));
assert.same(-1, indexOf([NaN], NaN));
assert.same(3, indexOf(Array(2).concat([1, 2, 3]), 2));
assert.same(-1, indexOf(Array(1), undefined));
assert.same(0, indexOf([1], 1, -0), "shouldn't return negative zero");
if (STRICT) {
assert.throws(() => indexOf(null, 0), TypeError);
assert.throws(() => indexOf(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/pure/es.array.is-array.js 0000664 0000000 0000000 00000000376 13600575677 0021036 0 ustar 00root root 0000000 0000000 import isArray from 'core-js-pure/features/array/is-array';
QUnit.test('Array.isArray', assert => {
assert.isFunction(isArray);
assert.ok(!isArray({}));
assert.ok(!isArray(function () {
return arguments;
}()));
assert.ok(isArray([]));
});
core-js-3.6.1/tests/pure/es.array.iterator.js 0000664 0000000 0000000 00000004720 13600575677 0021135 0 ustar 00root root 0000000 0000000 import { keys, values, entries } from 'core-js-pure/features/array';
import Symbol from 'core-js-pure/features/symbol';
import getIterator from 'core-js-pure/features/get-iterator';
QUnit.test('Array#@@iterator', assert => {
assert.isFunction(values);
const iterator = getIterator(['q', 'w', 'e']);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Array Iterator');
assert.strictEqual(String(iterator), '[object Array Iterator]');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Array#keys', assert => {
assert.isFunction(keys);
const iterator = keys(['q', 'w', 'e']);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Array Iterator');
assert.deepEqual(iterator.next(), {
value: 0,
done: false,
});
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
});
assert.deepEqual(iterator.next(), {
value: 2,
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Array#values', assert => {
assert.isFunction(values);
const iterator = values(['q', 'w', 'e']);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Array Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Array#entries', assert => {
assert.isFunction(entries);
const iterator = entries(['q', 'w', 'e']);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Array Iterator');
assert.deepEqual(iterator.next(), {
value: [0, 'q'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: [1, 'w'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: [2, 'e'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
core-js-3.6.1/tests/pure/es.array.join.js 0000664 0000000 0000000 00000000673 13600575677 0020246 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import join from 'core-js-pure/features/array/join';
QUnit.test('Array#join', assert => {
assert.isFunction(join);
assert.strictEqual(join([1, 2, 3], undefined), '1,2,3');
assert.strictEqual(join('123'), '1,2,3');
assert.strictEqual(join('123', '|'), '1|2|3');
if (STRICT) {
assert.throws(() => join(null), TypeError);
assert.throws(() => join(undefined), TypeError);
}
});
core-js-3.6.1/tests/pure/es.array.last-index-of.js 0000664 0000000 0000000 00000001457 13600575677 0021762 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import lastIndexOf from 'core-js-pure/features/array/last-index-of';
QUnit.test('Array#lastIndexOf', assert => {
assert.isFunction(lastIndexOf);
assert.same(2, lastIndexOf([1, 1, 1], 1));
assert.same(-1, lastIndexOf([1, 2, 3], 3, 1));
assert.same(1, lastIndexOf([1, 2, 3], 2, 1));
assert.same(-1, lastIndexOf([1, 2, 3], 2, -3));
assert.same(-1, lastIndexOf([1, 2, 3], 1, -4));
assert.same(1, lastIndexOf([1, 2, 3], 2, -2));
assert.same(-1, lastIndexOf([NaN], NaN));
assert.same(1, lastIndexOf([1, 2, 3].concat(Array(2)), 2));
assert.same(0, lastIndexOf([1], 1, -0), "shouldn't return negative zero");
if (STRICT) {
assert.throws(() => lastIndexOf(null, 0), TypeError);
assert.throws(() => lastIndexOf(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/pure/es.array.map.js 0000664 0000000 0000000 00000002300 13600575677 0020051 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import Symbol from 'core-js-pure/features/symbol';
import map from 'core-js-pure/features/array/map';
QUnit.test('Array#map', assert => {
assert.isFunction(map);
let array = [1];
const context = {};
map(array, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.deepEqual([2, 3, 4], map([1, 2, 3], it => it + 1));
assert.deepEqual([1, 3, 5], map([1, 2, 3], (value, key) => value + key));
assert.deepEqual([2, 2, 2], map([1, 2, 3], function () {
return +this;
}, 2));
if (STRICT) {
assert.throws(() => map(null, () => { /* empty */ }), TypeError);
assert.throws(() => map(undefined, () => { /* empty */ }), TypeError);
}
array = [];
array.constructor = { [Symbol.species]: function () { // eslint-disable-line object-shorthand
return { foo: 1 };
} };
assert.same(map(array, Boolean).foo, 1, '@@species');
});
core-js-3.6.1/tests/pure/es.array.of.js 0000664 0000000 0000000 00000001422 13600575677 0017704 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import of from 'core-js-pure/features/array/of';
import defineProperty from 'core-js-pure/features/object/define-property';
QUnit.test('Array.of', assert => {
assert.isFunction(of);
assert.arity(of, 0);
assert.deepEqual(of(1), [1]);
assert.deepEqual(of(1, 2, 3), [1, 2, 3]);
class C { /* empty */ }
const instance = of.call(C, 1, 2);
assert.ok(instance instanceof C);
assert.strictEqual(instance[0], 1);
assert.strictEqual(instance[1], 2);
assert.strictEqual(instance.length, 2);
if (DESCRIPTORS) {
let called = false;
defineProperty(C.prototype, 0, {
set() {
called = true;
},
});
of.call(C, 1, 2, 3);
assert.ok(!called, 'Should not call prototype accessors');
}
});
core-js-3.6.1/tests/pure/es.array.reduce-right.js 0000664 0000000 0000000 00000003124 13600575677 0021663 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import reduceRight from 'core-js-pure/features/array/reduce-right';
QUnit.test('Array#reduceRight', assert => {
assert.isFunction(reduceRight);
const array = [1];
const accumulator = {};
reduceRight(array, function (memo, value, key, that) {
assert.same(arguments.length, 4, 'correct number of callback arguments');
assert.same(memo, accumulator, 'correct callback accumulator');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
}, accumulator);
assert.same(reduceRight([1, 2, 3], ((a, b) => a + b), 1), 7, 'works with initial accumulator');
reduceRight([1, 2], (memo, value, key) => {
assert.same(memo, 2, 'correct default accumulator');
assert.same(value, 1, 'correct start value without initial accumulator');
assert.same(key, 0, 'correct start index without initial accumulator');
});
assert.same(reduceRight([1, 2, 3], (a, b) => a + b), 6, 'works without initial accumulator');
let values = '';
let keys = '';
reduceRight([1, 2, 3], (memo, value, key) => {
values += value;
keys += key;
}, 0);
assert.same(values, '321', 'correct order #1');
assert.same(keys, '210', 'correct order #2');
assert.same(reduceRight({
0: 1,
1: 2,
length: 2,
}, (a, b) => a + b), 3, 'generic');
if (STRICT) {
assert.throws(() => reduceRight(null, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduceRight(undefined, () => { /* empty */ }, 1), TypeError);
}
});
core-js-3.6.1/tests/pure/es.array.reduce.js 0000664 0000000 0000000 00000003027 13600575677 0020552 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import reduce from 'core-js-pure/features/array/reduce';
QUnit.test('Array#reduce', assert => {
assert.isFunction(reduce);
const array = [1];
const accumulator = {};
reduce(array, function (memo, value, key, that) {
assert.same(arguments.length, 4, 'correct number of callback arguments');
assert.same(memo, accumulator, 'correct callback accumulator');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
}, accumulator);
assert.same(reduce([1, 2, 3], ((a, b) => a + b), 1), 7, 'works with initial accumulator');
reduce([1, 2], (memo, value, key) => {
assert.same(memo, 1, 'correct default accumulator');
assert.same(value, 2, 'correct start value without initial accumulator');
assert.same(key, 1, 'correct start index without initial accumulator');
});
assert.same(reduce([1, 2, 3], (a, b) => a + b), 6, 'works without initial accumulator');
let values = '';
let keys = '';
reduce([1, 2, 3], (memo, value, key) => {
values += value;
keys += key;
}, 0);
assert.same(values, '123', 'correct order #1');
assert.same(keys, '012', 'correct order #2');
assert.same(reduce({
0: 1,
1: 2,
length: 2,
}, (a, b) => a + b), 3, 'generic');
if (STRICT) {
assert.throws(() => reduce(null, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce(undefined, () => { /* empty */ }, 1), TypeError);
}
});
core-js-3.6.1/tests/pure/es.array.reverse.js 0000664 0000000 0000000 00000000741 13600575677 0020756 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import reverse from 'core-js-pure/features/array/reverse';
QUnit.test('Array#reverse', assert => {
assert.isFunction(reverse);
const a = [1, 2.2, 3.3];
function fn() {
+a;
reverse(a);
}
fn();
assert.arrayEqual(a, [3.3, 2.2, 1]);
if (STRICT) {
assert.throws(() => reverse(null, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reverse(undefined, () => { /* empty */ }, 1), TypeError);
}
});
core-js-3.6.1/tests/pure/es.array.slice.js 0000664 0000000 0000000 00000002416 13600575677 0020403 0 ustar 00root root 0000000 0000000 import { GLOBAL } from '../helpers/constants';
import { slice, isArray } from 'core-js-pure/features/array';
import Symbol from 'core-js-pure/features/symbol';
QUnit.test('Array#slice', assert => {
assert.isFunction(slice);
let array = ['1', '2', '3', '4', '5'];
assert.deepEqual(slice(array), array);
assert.deepEqual(slice(array, 1, 3), ['2', '3']);
assert.deepEqual(slice(array, 1, undefined), ['2', '3', '4', '5']);
assert.deepEqual(slice(array, 1, -1), ['2', '3', '4']);
assert.deepEqual(slice(array, -2, -1), ['4']);
assert.deepEqual(slice(array, -2, -3), []);
const string = '12345';
assert.deepEqual(slice(string), array);
assert.deepEqual(slice(string, 1, 3), ['2', '3']);
assert.deepEqual(slice(string, 1, undefined), ['2', '3', '4', '5']);
assert.deepEqual(slice(string, 1, -1), ['2', '3', '4']);
assert.deepEqual(slice(string, -2, -1), ['4']);
assert.deepEqual(slice(string, -2, -3), []);
const list = GLOBAL.document && document.body && document.body.childNodes;
if (list) {
assert.notThrows(() => isArray(slice(list)), 'works with NodeList');
}
array = [];
array.constructor = { [Symbol.species]: function () { // eslint-disable-line object-shorthand
return { foo: 1 };
} };
assert.same(slice(array).foo, 1, '@@species');
});
core-js-3.6.1/tests/pure/es.array.some.js 0000664 0000000 0000000 00000002350 13600575677 0020244 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import some from 'core-js-pure/features/array/some';
QUnit.test('Array#some', assert => {
assert.isFunction(some);
let array = [1];
const context = {};
some(array, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.ok(some([1, '2', 3], it => typeof it === 'number'));
assert.ok(some([1, 2, 3], it => it < 3));
assert.ok(!some([1, 2, 3], it => it < 0));
assert.ok(!some([1, 2, 3], it => typeof it === 'string'));
assert.ok(!some([1, 2, 3], function () {
return +this !== 1;
}, 1));
let result = '';
some([1, 2, 3], (value, key) => {
result += key;
return false;
});
assert.ok(result === '012');
array = [1, 2, 3];
assert.ok(!some(array, (value, key, that) => that !== array));
if (STRICT) {
assert.throws(() => some(null, () => { /* empty */ }), TypeError);
assert.throws(() => some(undefined, () => { /* empty */ }), TypeError);
}
});
core-js-3.6.1/tests/pure/es.array.sort.js 0000664 0000000 0000000 00000001021 13600575677 0020262 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import sort from 'core-js-pure/features/array/sort';
QUnit.test('Array#sort', assert => {
assert.isFunction(sort);
assert.notThrows(() => sort([1, 2, 3], undefined), 'works with undefined');
assert.throws(() => sort([1, 2, 3], null), 'throws on null');
assert.throws(() => sort([1, 2, 3], {}), 'throws on {}');
if (STRICT) {
assert.throws(() => sort(null), TypeError, 'ToObject(this)');
assert.throws(() => sort(undefined), TypeError, 'ToObject(this)');
}
});
core-js-3.6.1/tests/pure/es.array.splice.js 0000664 0000000 0000000 00000002272 13600575677 0020563 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import splice from 'core-js-pure/features/array/splice';
import Symbol from 'core-js-pure/features/symbol';
QUnit.test('Array#splice', assert => {
assert.isFunction(splice);
let array = [1, 2, 3, 4, 5];
assert.deepEqual(splice(array, 2), [3, 4, 5]);
assert.deepEqual(array, [1, 2]);
array = [1, 2, 3, 4, 5];
assert.deepEqual(splice(array, -2), [4, 5]);
assert.deepEqual(array, [1, 2, 3]);
array = [1, 2, 3, 4, 5];
assert.deepEqual(splice(array, 2, 2), [3, 4]);
assert.deepEqual(array, [1, 2, 5]);
array = [1, 2, 3, 4, 5];
assert.deepEqual(splice(array, 2, -2), []);
assert.deepEqual(array, [1, 2, 3, 4, 5]);
array = [1, 2, 3, 4, 5];
assert.deepEqual(splice(array, 2, 2, 6, 7), [3, 4]);
assert.deepEqual(array, [1, 2, 6, 7, 5]);
if (STRICT) {
assert.throws(() => splice(null), TypeError);
assert.throws(() => splice(undefined), TypeError);
}
assert.deepEqual(splice({
length: -1,
0: 1,
}), [], 'uses ToLength');
array = [];
array.constructor = { [Symbol.species]: function () { // eslint-disable-line object-shorthand
return { foo: 1 };
} };
assert.same(splice(array).foo, 1, '@@species');
});
core-js-3.6.1/tests/pure/es.date.now.js 0000664 0000000 0000000 00000000265 13600575677 0017706 0 ustar 00root root 0000000 0000000 import now from 'core-js-pure/features/date/now';
QUnit.test('Date.now', assert => {
assert.isFunction(now);
assert.ok(+new Date() - now() < 10, 'Date.now() ~ +new Date');
});
core-js-3.6.1/tests/pure/es.date.to-iso-string.js 0000664 0000000 0000000 00000001377 13600575677 0021626 0 ustar 00root root 0000000 0000000 import toISOString from 'core-js-pure/features/date/to-iso-string';
QUnit.test('Date#toISOString', assert => {
assert.isFunction(toISOString);
assert.strictEqual(toISOString(new Date(0)), '1970-01-01T00:00:00.000Z');
assert.strictEqual(toISOString(new Date(1e12 + 1)), '2001-09-09T01:46:40.001Z');
assert.strictEqual(toISOString(new Date(-5e13 - 1)), '0385-07-25T07:06:39.999Z');
const future = toISOString(new Date(1e15 + 1));
assert.ok(future === '+033658-09-27T01:46:40.001Z' || future === '33658-09-27T01:46:40.001Z');
const prehistoric = toISOString(new Date(-1e15 + 1));
assert.ok(prehistoric === '-029719-04-05T22:13:20.001Z' || prehistoric === '-29719-04-05T22:13:20.001Z');
assert.throws(() => toISOString(new Date(NaN)), RangeError);
});
core-js-3.6.1/tests/pure/es.date.to-json.js 0000664 0000000 0000000 00000000634 13600575677 0020474 0 ustar 00root root 0000000 0000000 import { toJSON, toISOString } from 'core-js-pure/features/date';
QUnit.test('Date#toJSON', assert => {
assert.isFunction(toJSON);
if (Date.prototype.toISOString) {
const date = new Date();
assert.same(toJSON(date), toISOString(date), 'base');
}
assert.same(toJSON(new Date(NaN)), null, 'not finite');
assert.same(toJSON({
toISOString() {
return 42;
},
}), 42, 'generic');
});
core-js-3.6.1/tests/pure/es.function.bind.js 0000664 0000000 0000000 00000001526 13600575677 0020730 0 ustar 00root root 0000000 0000000 import bind from 'core-js-pure/features/function/bind';
QUnit.test('Function#bind', assert => {
assert.isFunction(bind);
const object = { a: 42 };
assert.ok(bind(function () {
return this.a;
}, object)() === 42);
assert.ok(new (bind(() => { /* empty */ }, object))().a === undefined);
function C(a, b) {
this.a = a;
this.b = b;
}
const instance = new (bind(C, null, 1))(2);
assert.ok(instance instanceof C);
assert.strictEqual(instance.a, 1);
assert.strictEqual(instance.b, 2);
assert.ok(bind((it => it), null, 42)() === 42);
const regExpTest = bind(RegExp.prototype.test, /a/);
assert.ok(regExpTest('a'));
const Date2017 = bind(Date, null, 2017);
const date = new Date2017(11);
assert.ok(date instanceof Date);
assert.strictEqual(date.getFullYear(), 2017);
assert.strictEqual(date.getMonth(), 11);
});
core-js-3.6.1/tests/pure/es.function.has-instance.js 0000664 0000000 0000000 00000000423 13600575677 0022364 0 ustar 00root root 0000000 0000000 import HAS_INSTANCE from 'core-js-pure/features/symbol/has-instance';
QUnit.test('Function#@@hasInstance', assert => {
assert.ok(HAS_INSTANCE in Function.prototype);
assert.ok(Function[HAS_INSTANCE](() => { /* empty */ }));
assert.ok(!Function[HAS_INSTANCE]({}));
});
core-js-3.6.1/tests/pure/es.global-this.js 0000664 0000000 0000000 00000000334 13600575677 0020371 0 ustar 00root root 0000000 0000000 import globalThis from 'core-js-pure/features/global-this';
QUnit.test('globalThis', assert => {
assert.same(globalThis, Object(globalThis), 'is object');
assert.same(globalThis.Math, Math, 'contains globals');
});
core-js-3.6.1/tests/pure/es.json.stringify.js 0000664 0000000 0000000 00000001623 13600575677 0021154 0 ustar 00root root 0000000 0000000 import { GLOBAL } from '../helpers/constants';
import stringify from 'core-js/es/json/stringify';
if (GLOBAL.JSON) {
QUnit.test('Well‑formed JSON.stringify', assert => {
assert.isFunction(stringify);
assert.arity(stringify, 3);
assert.name(stringify, 'stringify');
assert.same(stringify({ foo: 'bar' }), '{"foo":"bar"}', 'basic');
assert.same(stringify('\uDEAD'), '"\\udead"', 'r1');
assert.same(stringify('\uDF06\uD834'), '"\\udf06\\ud834"', 'r2');
assert.same(stringify('\uDF06ab\uD834'), '"\\udf06ab\\ud834"', 'r3');
assert.same(stringify('𠮷'), '"𠮷"', 'r4');
assert.same(stringify('\uD834\uDF06'), '"𝌆"', 'r5');
assert.same(stringify('\uD834\uD834\uDF06'), '"\\ud834𝌆"', 'r6');
assert.same(stringify('\uD834\uDF06\uDF06'), '"𝌆\\udf06"', 'r7');
assert.same(stringify({ '𠮷': ['\uDF06\uD834'] }), '{"𠮷":["\\udf06\\ud834"]}', 'r8');
});
}
core-js-3.6.1/tests/pure/es.map.js 0000664 0000000 0000000 00000025754 13600575677 0016756 0 ustar 00root root 0000000 0000000 /* eslint-disable sonarjs/no-element-overwrite */
import { createIterable, is, nativeSubclass } from '../helpers/helpers';
import { DESCRIPTORS } from '../helpers/constants';
import { Set, Map, Symbol } from 'core-js-pure';
import getIterator from 'core-js-pure/features/get-iterator';
import getIteratorMethod from 'core-js-pure/features/get-iterator-method';
import { freeze, getOwnPropertyDescriptor, keys, getOwnPropertyNames, getOwnPropertySymbols } from 'core-js-pure/features/object';
import ownKeys from 'core-js-pure/features/reflect/own-keys';
QUnit.test('Map', assert => {
assert.isFunction(Map);
assert.ok('clear' in Map.prototype, 'clear in Map.prototype');
assert.ok('delete' in Map.prototype, 'delete in Map.prototype');
assert.ok('forEach' in Map.prototype, 'forEach in Map.prototype');
assert.ok('get' in Map.prototype, 'get in Map.prototype');
assert.ok('has' in Map.prototype, 'has in Map.prototype');
assert.ok('set' in Map.prototype, 'set in Map.prototype');
assert.ok(new Map() instanceof Map, 'new Map instanceof Map');
assert.strictEqual(new Map(createIterable([[1, 1], [2, 2], [3, 3]])).size, 3, 'Init from iterable');
assert.strictEqual(new Map([[freeze({}), 1], [2, 3]]).size, 2, 'Support frozen objects');
let done = false;
try {
new Map(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
assert.ok(done, '.return #throw');
const array = [];
done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
new Map(array);
assert.ok(done);
const object = {};
new Map().set(object, 1);
if (DESCRIPTORS) {
const results = [];
for (const key in object) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(Map);
assert.ok(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.ok(new Subclass() instanceof Map, 'correct subclassing with native classes #2');
assert.strictEqual(new Subclass().set(1, 2).get(1), 2, 'correct subclassing with native classes #3');
}
});
QUnit.test('Map#clear', assert => {
assert.isFunction(Map.prototype.clear);
let map = new Map();
map.clear();
assert.strictEqual(map.size, 0);
map = new Map().set(1, 2).set(2, 3).set(1, 4);
map.clear();
assert.strictEqual(map.size, 0);
assert.ok(!map.has(1));
assert.ok(!map.has(2));
const frozen = freeze({});
map = new Map().set(1, 2).set(frozen, 3);
map.clear();
assert.strictEqual(map.size, 0, 'Support frozen objects');
assert.ok(!map.has(1));
assert.ok(!map.has(frozen));
});
QUnit.test('Map#delete', assert => {
assert.isFunction(Map.prototype.delete);
const object = {};
const map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 7);
map.set(2, 5);
map.set(1, 4);
map.set(object, 9);
assert.strictEqual(map.size, 5);
assert.ok(map.delete(NaN));
assert.strictEqual(map.size, 4);
assert.ok(!map.delete(4));
assert.strictEqual(map.size, 4);
map.delete([]);
assert.strictEqual(map.size, 4);
map.delete(object);
assert.strictEqual(map.size, 3);
const frozen = freeze({});
map.set(frozen, 42);
assert.strictEqual(map.size, 4);
map.delete(frozen);
assert.strictEqual(map.size, 3);
});
QUnit.test('Map#forEach', assert => {
assert.isFunction(Map.prototype.forEach);
let result = {};
let count = 0;
const object = {};
let map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 7);
map.set(2, 5);
map.set(1, 4);
map.set(object, 9);
map.forEach((value, key) => {
count++;
result[value] = key;
});
assert.strictEqual(count, 5);
assert.deepEqual(result, {
1: NaN,
7: 3,
5: 2,
4: 1,
9: object,
});
map = new Map();
map.set('0', 9);
map.set('1', 9);
map.set('2', 9);
map.set('3', 9);
result = '';
map.forEach((value, key) => {
result += key;
if (key === '2') {
map.delete('2');
map.delete('3');
map.delete('1');
map.set('4', 9);
}
});
assert.strictEqual(result, '0124');
map = new Map([['0', 1]]);
result = '';
map.forEach(it => {
map.delete('0');
if (result !== '') throw new Error();
result += it;
});
assert.strictEqual(result, '1');
assert.throws(() => Map.prototype.forEach.call(new Set(), () => { /* empty */ }), 'non-generic');
});
QUnit.test('Map#get', assert => {
assert.isFunction(Map.prototype.get);
const object = {};
const frozen = freeze({});
const map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 1);
map.set(2, 5);
map.set(1, 4);
map.set(frozen, 42);
map.set(object, object);
assert.strictEqual(map.get(NaN), 1);
assert.strictEqual(map.get(4), undefined);
assert.strictEqual(map.get({}), undefined);
assert.strictEqual(map.get(object), object);
assert.strictEqual(map.get(frozen), 42);
assert.strictEqual(map.get(2), 5);
});
QUnit.test('Map#has', assert => {
assert.isFunction(Map.prototype.has);
const object = {};
const frozen = freeze({});
const map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 1);
map.set(2, 5);
map.set(1, 4);
map.set(frozen, 42);
map.set(object, object);
assert.ok(map.has(NaN));
assert.ok(map.has(object));
assert.ok(map.has(2));
assert.ok(map.has(frozen));
assert.ok(!map.has(4));
assert.ok(!map.has({}));
});
QUnit.test('Map#set', assert => {
assert.isFunction(Map.prototype.set);
const object = {};
let map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 1);
map.set(2, 5);
map.set(1, 4);
map.set(object, object);
assert.ok(map.size === 5);
const chain = map.set(7, 2);
assert.strictEqual(chain, map);
map.set(7, 2);
assert.strictEqual(map.size, 6);
assert.strictEqual(map.get(7), 2);
assert.strictEqual(map.get(NaN), 1);
map.set(NaN, 42);
assert.strictEqual(map.size, 6);
assert.strictEqual(map.get(NaN), 42);
map.set({}, 11);
assert.strictEqual(map.size, 7);
assert.strictEqual(map.get(object), object);
map.set(object, 27);
assert.strictEqual(map.size, 7);
assert.strictEqual(map.get(object), 27);
map = new Map();
map.set(NaN, 2);
map.set(NaN, 3);
map.set(NaN, 4);
assert.strictEqual(map.size, 1);
const frozen = freeze({});
map = new Map().set(frozen, 42);
assert.strictEqual(map.get(frozen), 42);
});
QUnit.test('Map#size', assert => {
const map = new Map();
map.set(2, 1);
const { size } = map;
assert.strictEqual(typeof size, 'number', 'size is number');
assert.strictEqual(size, 1, 'size is correct');
if (DESCRIPTORS) {
const sizeDescriptor = getOwnPropertyDescriptor(Map.prototype, 'size');
assert.ok(sizeDescriptor && sizeDescriptor.get, 'size is getter');
assert.ok(sizeDescriptor && !sizeDescriptor.set, 'size isnt setter');
assert.throws(() => Map.prototype.size, TypeError);
}
});
QUnit.test('Map & -0', assert => {
let map = new Map();
map.set(-0, 1);
assert.strictEqual(map.size, 1);
assert.ok(map.has(0));
assert.ok(map.has(-0));
assert.strictEqual(map.get(0), 1);
assert.strictEqual(map.get(-0), 1);
map.forEach((val, key) => {
assert.ok(!is(key, -0));
});
map.delete(-0);
assert.strictEqual(map.size, 0);
map = new Map([[-0, 1]]);
map.forEach((val, key) => {
assert.ok(!is(key, -0));
});
map = new Map();
map.set(4, 4);
map.set(3, 3);
map.set(2, 2);
map.set(1, 1);
map.set(0, 0);
assert.ok(map.has(-0));
});
QUnit.test('Map#@@toStringTag', assert => {
assert.strictEqual(Map.prototype[Symbol.toStringTag], 'Map', 'Map::@@toStringTag is `Map`');
assert.strictEqual(String(new Map()), '[object Map]', 'correct stringification');
});
QUnit.test('Map Iterator', assert => {
const map = new Map();
map.set('a', 1);
map.set('b', 2);
map.set('c', 3);
map.set('d', 4);
const results = [];
const iterator = map.keys();
results.push(iterator.next().value);
assert.ok(map.delete('a'));
assert.ok(map.delete('b'));
assert.ok(map.delete('c'));
map.set('e');
results.push(iterator.next().value);
results.push(iterator.next().value);
assert.ok(iterator.next().done);
map.set('f');
assert.ok(iterator.next().done);
assert.deepEqual(results, ['a', 'd', 'e']);
});
QUnit.test('Map#keys', assert => {
assert.isFunction(Map.prototype.keys);
const map = new Map();
map.set('a', 'q');
map.set('s', 'w');
map.set('d', 'e');
const iterator = map.keys();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Map Iterator');
assert.deepEqual(iterator.next(), {
value: 'a',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 's',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'd',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Map#values', assert => {
assert.isFunction(Map.prototype.values);
const map = new Map();
map.set('a', 'q');
map.set('s', 'w');
map.set('d', 'e');
const iterator = map.values();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Map Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Map#entries', assert => {
assert.isFunction(Map.prototype.entries);
const map = new Map();
map.set('a', 'q');
map.set('s', 'w');
map.set('d', 'e');
const iterator = map.entries();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Map Iterator');
assert.deepEqual(iterator.next(), {
value: ['a', 'q'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['s', 'w'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['d', 'e'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Map#@@iterator', assert => {
const map = new Map();
map.set('a', 'q');
map.set('s', 'w');
map.set('d', 'e');
const iterator = getIterator(map);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Map Iterator');
assert.strictEqual(String(iterator), '[object Map Iterator]');
assert.deepEqual(iterator.next(), {
value: ['a', 'q'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['s', 'w'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['d', 'e'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
core-js-3.6.1/tests/pure/es.math.acosh.js 0000664 0000000 0000000 00000001233 13600575677 0020210 0 ustar 00root root 0000000 0000000 import acosh from 'core-js-pure/features/math/acosh';
import EPSILON from 'core-js-pure/features/number/epsilon';
QUnit.test('Math.acosh', assert => {
assert.isFunction(acosh);
assert.same(acosh(NaN), NaN);
assert.same(acosh(0.5), NaN);
assert.same(acosh(-1), NaN);
assert.same(acosh(-1e300), NaN);
assert.same(acosh(1), 0);
assert.strictEqual(acosh(Infinity), Infinity);
assert.epsilon(acosh(1234), 7.811163220849231);
assert.epsilon(acosh(8.88), 2.8737631531629235);
assert.epsilon(acosh(1e+160), 369.10676205960726);
assert.epsilon(acosh(Number.MAX_VALUE), 710.475860073944);
assert.epsilon(acosh(1 + EPSILON), 2.1073424255447017e-8);
});
core-js-3.6.1/tests/pure/es.math.asinh.js 0000664 0000000 0000000 00000001067 13600575677 0020222 0 ustar 00root root 0000000 0000000 import asinh from 'core-js-pure/features/math/asinh';
QUnit.test('Math.asinh', assert => {
assert.isFunction(asinh);
assert.same(asinh(NaN), NaN);
assert.same(asinh(0), 0);
assert.same(asinh(-0), -0);
assert.strictEqual(asinh(Infinity), Infinity);
assert.strictEqual(asinh(-Infinity), -Infinity);
assert.epsilon(asinh(1234), 7.811163549201245);
assert.epsilon(asinh(9.99), 2.997227420191335);
assert.epsilon(asinh(1e150), 346.0809111296668);
assert.epsilon(asinh(1e7), 16.811242831518268);
assert.epsilon(asinh(-1e7), -16.811242831518268);
});
core-js-3.6.1/tests/pure/es.math.atanh.js 0000664 0000000 0000000 00000001212 13600575677 0020203 0 ustar 00root root 0000000 0000000 import atanh from 'core-js-pure/features/math/atanh';
QUnit.test('Math.atanh', assert => {
assert.isFunction(atanh);
assert.same(atanh(NaN), NaN);
assert.same(atanh(-2), NaN);
assert.same(atanh(-1.5), NaN);
assert.same(atanh(2), NaN);
assert.same(atanh(1.5), NaN);
assert.strictEqual(atanh(-1), -Infinity);
assert.strictEqual(atanh(1), Infinity);
assert.same(atanh(0), 0);
assert.same(atanh(-0), -0);
assert.same(atanh(-1e300), NaN);
assert.same(atanh(1e300), NaN);
assert.epsilon(atanh(0.5), 0.5493061443340549);
assert.epsilon(atanh(-0.5), -0.5493061443340549);
assert.epsilon(atanh(0.444), 0.47720201260109457);
});
core-js-3.6.1/tests/pure/es.math.cbrt.js 0000664 0000000 0000000 00000000675 13600575677 0020056 0 ustar 00root root 0000000 0000000 import cbrt from 'core-js-pure/features/math/cbrt';
QUnit.test('Math.cbrt', assert => {
assert.isFunction(cbrt);
assert.same(cbrt(NaN), NaN);
assert.same(cbrt(0), 0);
assert.same(cbrt(-0), -0);
assert.strictEqual(cbrt(Infinity), Infinity);
assert.strictEqual(cbrt(-Infinity), -Infinity);
assert.strictEqual(cbrt(-8), -2);
assert.strictEqual(cbrt(8), 2);
assert.epsilon(cbrt(-1000), -10);
assert.epsilon(cbrt(1000), 10);
});
core-js-3.6.1/tests/pure/es.math.clz32.js 0000664 0000000 0000000 00000000527 13600575677 0020055 0 ustar 00root root 0000000 0000000 import clz32 from 'core-js-pure/features/math/clz32';
QUnit.test('Math.clz32', assert => {
assert.isFunction(clz32);
assert.strictEqual(clz32(0), 32);
assert.strictEqual(clz32(1), 31);
assert.same(clz32(-1), 0);
assert.strictEqual(clz32(0.6), 32);
assert.same(clz32(2 ** 32 - 1), 0);
assert.strictEqual(clz32(2 ** 32), 32);
});
core-js-3.6.1/tests/pure/es.math.cosh.js 0000664 0000000 0000000 00000001142 13600575677 0020046 0 ustar 00root root 0000000 0000000 import cosh from 'core-js-pure/features/math/cosh';
QUnit.test('Math.cosh', assert => {
assert.isFunction(cosh);
assert.same(cosh(NaN), NaN);
assert.strictEqual(cosh(0), 1);
assert.strictEqual(cosh(-0), 1);
assert.strictEqual(cosh(Infinity), Infinity);
assert.strictEqual(cosh(-Infinity), Infinity);
assert.epsilon(cosh(12), 81377.395712574, 1e-9);
assert.epsilon(cosh(22), 1792456423.065795780980053377, 1e-5);
assert.epsilon(cosh(-10), 11013.23292010332313972137);
assert.epsilon(cosh(-23), 4872401723.1244513000, 1e-5);
assert.epsilon(cosh(710), 1.1169973830808557e+308, 1e+295);
});
core-js-3.6.1/tests/pure/es.math.expm1.js 0000664 0000000 0000000 00000000627 13600575677 0020153 0 ustar 00root root 0000000 0000000 import expm1 from 'core-js-pure/features/math/expm1';
QUnit.test('Math.expm1', assert => {
assert.isFunction(expm1);
assert.same(expm1(NaN), NaN);
assert.same(expm1(0), 0);
assert.same(expm1(-0), -0);
assert.strictEqual(expm1(Infinity), Infinity);
assert.strictEqual(expm1(-Infinity), -1);
assert.epsilon(expm1(10), 22025.465794806718);
assert.epsilon(expm1(-10), -0.9999546000702375);
});
core-js-3.6.1/tests/pure/es.math.fround.js 0000664 0000000 0000000 00000002454 13600575677 0020416 0 ustar 00root root 0000000 0000000 import fround from 'core-js-pure/features/math/fround';
QUnit.test('Math.fround', assert => {
assert.isFunction(fround);
assert.same(fround(undefined), NaN);
assert.same(fround(NaN), NaN);
assert.same(fround(0), 0);
assert.same(fround(-0), -0);
assert.same(fround(Number.MIN_VALUE), 0);
assert.same(fround(-Number.MIN_VALUE), -0);
assert.strictEqual(fround(Infinity), Infinity);
assert.strictEqual(fround(-Infinity), -Infinity);
assert.strictEqual(fround(1.7976931348623157e+308), Infinity);
assert.strictEqual(fround(-1.7976931348623157e+308), -Infinity);
assert.strictEqual(fround(3.4028235677973366e+38), Infinity);
assert.strictEqual(fround(3), 3);
assert.strictEqual(fround(-3), -3);
const maxFloat32 = 3.4028234663852886e+38;
const minFloat32 = 1.401298464324817e-45;
assert.strictEqual(fround(maxFloat32), maxFloat32);
assert.strictEqual(fround(-maxFloat32), -maxFloat32);
assert.strictEqual(fround(maxFloat32 + 2 ** 102), maxFloat32);
assert.strictEqual(fround(minFloat32), minFloat32);
assert.strictEqual(fround(-minFloat32), -minFloat32);
assert.same(fround(minFloat32 / 2), 0);
assert.same(fround(-minFloat32 / 2), -0);
assert.strictEqual(fround(minFloat32 / 2 + 2 ** -202), minFloat32);
assert.strictEqual(fround(-minFloat32 / 2 - 2 ** -202), -minFloat32);
});
core-js-3.6.1/tests/pure/es.math.hypot.js 0000664 0000000 0000000 00000003464 13600575677 0020266 0 ustar 00root root 0000000 0000000 import hypot from 'core-js-pure/features/math/hypot';
QUnit.test('Math.hypot', assert => {
const { sqrt } = Math;
assert.isFunction(hypot);
assert.strictEqual(hypot(), 0);
assert.strictEqual(hypot(1), 1);
assert.same(hypot('', 0), 0);
assert.same(hypot(0, ''), 0);
assert.strictEqual(hypot(Infinity, 0), Infinity, 'Infinity, 0');
assert.strictEqual(hypot(-Infinity, 0), Infinity, '-Infinity, 0');
assert.strictEqual(hypot(0, Infinity), Infinity, '0, Infinity');
assert.strictEqual(hypot(0, -Infinity), Infinity, '0, -Infinity');
assert.strictEqual(hypot(Infinity, NaN), Infinity, 'Infinity, NaN');
assert.strictEqual(hypot(NaN, -Infinity), Infinity, 'NaN, -Infinity');
assert.same(hypot(NaN, 0), NaN, 'NaN, 0');
assert.same(hypot(0, NaN), NaN, '0, NaN');
assert.same(hypot(0, -0), 0);
assert.same(hypot(0, 0), 0);
assert.same(hypot(-0, -0), 0);
assert.same(hypot(-0, 0), 0);
assert.strictEqual(hypot(0, 1), 1);
assert.strictEqual(hypot(0, -1), 1);
assert.strictEqual(hypot(-0, 1), 1);
assert.strictEqual(hypot(-0, -1), 1);
assert.same(hypot(0), 0);
assert.strictEqual(hypot(1), 1);
assert.strictEqual(hypot(2), 2);
assert.strictEqual(hypot(0, 0, 1), 1);
assert.strictEqual(hypot(0, 1, 0), 1);
assert.strictEqual(hypot(1, 0, 0), 1);
assert.strictEqual(hypot(2, 3, 4), sqrt(2 * 2 + 3 * 3 + 4 * 4));
assert.strictEqual(hypot(2, 3, 4, 5), sqrt(2 * 2 + 3 * 3 + 4 * 4 + 5 * 5));
assert.epsilon(hypot(66, 66), 93.33809511662427);
assert.epsilon(hypot(0.1, 100), 100.0000499999875);
assert.strictEqual(hypot(1e+300, 1e+300), 1.4142135623730952e+300);
assert.strictEqual(Math.floor(hypot(1e-300, 1e-300) * 1e308), 141421356);
assert.strictEqual(hypot(1e+300, 1e+300, 2, 3), 1.4142135623730952e+300);
assert.strictEqual(hypot(-3, 4), 5);
assert.strictEqual(hypot(3, -4), 5);
});
core-js-3.6.1/tests/pure/es.math.imul.js 0000664 0000000 0000000 00000002651 13600575677 0020066 0 ustar 00root root 0000000 0000000 import imul from 'core-js-pure/features/math/imul';
QUnit.test('Math.imul', assert => {
assert.isFunction(imul);
assert.same(imul(0, 0), 0);
assert.strictEqual(imul(123, 456), 56088);
assert.strictEqual(imul(-123, 456), -56088);
assert.strictEqual(imul(123, -456), -56088);
assert.strictEqual(imul(19088743, 4275878552), 602016552);
assert.same(imul(false, 7), 0);
assert.same(imul(7, false), 0);
assert.same(imul(false, false), 0);
assert.strictEqual(imul(true, 7), 7);
assert.strictEqual(imul(7, true), 7);
assert.strictEqual(imul(true, true), 1);
assert.same(imul(undefined, 7), 0);
assert.same(imul(7, undefined), 0);
assert.same(imul(undefined, undefined), 0);
assert.same(imul('str', 7), 0);
assert.same(imul(7, 'str'), 0);
assert.same(imul({}, 7), 0);
assert.same(imul(7, {}), 0);
assert.same(imul([], 7), 0);
assert.same(imul(7, []), 0);
assert.strictEqual(imul(0xFFFFFFFF, 5), -5);
assert.strictEqual(imul(0xFFFFFFFE, 5), -10);
assert.strictEqual(imul(2, 4), 8);
assert.strictEqual(imul(-1, 8), -8);
assert.strictEqual(imul(-2, -2), 4);
assert.same(imul(-0, 7), 0);
assert.same(imul(7, -0), 0);
assert.same(imul(0.1, 7), 0);
assert.same(imul(7, 0.1), 0);
assert.same(imul(0.9, 7), 0);
assert.same(imul(7, 0.9), 0);
assert.strictEqual(imul(1.1, 7), 7);
assert.strictEqual(imul(7, 1.1), 7);
assert.strictEqual(imul(1.9, 7), 7);
assert.strictEqual(imul(7, 1.9), 7);
});
core-js-3.6.1/tests/pure/es.math.log10.js 0000664 0000000 0000000 00000001171 13600575677 0020036 0 ustar 00root root 0000000 0000000 import log10 from 'core-js-pure/features/math/log10';
QUnit.test('Math.log10', assert => {
assert.isFunction(log10);
assert.same(log10(''), log10(0));
assert.same(log10(NaN), NaN);
assert.same(log10(-1), NaN);
assert.same(log10(0), -Infinity);
assert.same(log10(-0), -Infinity);
assert.same(log10(1), 0);
assert.same(log10(Infinity), Infinity);
assert.epsilon(log10(0.1), -1);
assert.epsilon(log10(0.5), -0.3010299956639812);
assert.epsilon(log10(1.5), 0.17609125905568124);
assert.epsilon(log10(5), 0.6989700043360189);
assert.epsilon(log10(50), 1.6989700043360187);
assert.epsilon(log10(1000), 3);
});
core-js-3.6.1/tests/pure/es.math.log1p.js 0000664 0000000 0000000 00000000710 13600575677 0020134 0 ustar 00root root 0000000 0000000 import log1p from 'core-js-pure/features/math/log1p';
QUnit.test('Math.log1p', assert => {
assert.isFunction(log1p);
assert.same(log1p(''), log1p(0));
assert.same(log1p(NaN), NaN);
assert.same(log1p(-2), NaN);
assert.same(log1p(-1), -Infinity);
assert.same(log1p(0), 0);
assert.same(log1p(-0), -0);
assert.same(log1p(Infinity), Infinity);
assert.epsilon(log1p(5), 1.791759469228055);
assert.epsilon(log1p(50), 3.9318256327243257);
});
core-js-3.6.1/tests/pure/es.math.log2.js 0000664 0000000 0000000 00000000712 13600575677 0017757 0 ustar 00root root 0000000 0000000 import log2 from 'core-js-pure/features/math/log2';
QUnit.test('Math.log2', assert => {
assert.isFunction(log2);
assert.same(log2(''), log2(0));
assert.same(log2(NaN), NaN);
assert.same(log2(-1), NaN);
assert.same(log2(0), -Infinity);
assert.same(log2(-0), -Infinity);
assert.same(log2(1), 0);
assert.same(log2(Infinity), Infinity);
assert.same(log2(0.5), -1);
assert.same(log2(32), 5);
assert.epsilon(log2(5), 2.321928094887362);
});
core-js-3.6.1/tests/pure/es.math.sign.js 0000664 0000000 0000000 00000000761 13600575677 0020060 0 ustar 00root root 0000000 0000000 import sign from 'core-js-pure/features/math/sign';
QUnit.test('Math.sign', assert => {
assert.isFunction(sign);
assert.same(sign(NaN), NaN);
assert.same(sign(), NaN);
assert.same(sign(-0), -0);
assert.same(sign(0), 0);
assert.strictEqual(sign(Infinity), 1);
assert.strictEqual(sign(-Infinity), -1);
assert.strictEqual(sign(13510798882111488), 1);
assert.strictEqual(sign(-13510798882111488), -1);
assert.strictEqual(sign(42.5), 1);
assert.strictEqual(sign(-42.5), -1);
});
core-js-3.6.1/tests/pure/es.math.sinh.js 0000664 0000000 0000000 00000000674 13600575677 0020064 0 ustar 00root root 0000000 0000000 import sinh from 'core-js-pure/features/math/sinh';
QUnit.test('Math.sinh', assert => {
assert.isFunction(sinh);
assert.same(sinh(NaN), NaN);
assert.same(sinh(0), 0);
assert.same(sinh(-0), -0);
assert.strictEqual(sinh(Infinity), Infinity);
assert.strictEqual(sinh(-Infinity), -Infinity);
assert.epsilon(sinh(-5), -74.20321057778875);
assert.epsilon(sinh(2), 3.6268604078470186);
assert.strictEqual(sinh(-2e-17), -2e-17);
});
core-js-3.6.1/tests/pure/es.math.tanh.js 0000664 0000000 0000000 00000000513 13600575677 0020045 0 ustar 00root root 0000000 0000000 import tanh from 'core-js-pure/features/math/tanh';
QUnit.test('Math.tanh', assert => {
assert.isFunction(tanh);
assert.same(tanh(NaN), NaN);
assert.same(tanh(0), 0);
assert.same(tanh(-0), -0);
assert.strictEqual(tanh(Infinity), 1);
assert.strictEqual(tanh(90), 1);
assert.epsilon(tanh(10), 0.9999999958776927);
});
core-js-3.6.1/tests/pure/es.math.trunc.js 0000664 0000000 0000000 00000001756 13600575677 0020260 0 ustar 00root root 0000000 0000000 import trunc from 'core-js-pure/features/math/trunc';
QUnit.test('Math.trunc', assert => {
assert.isFunction(trunc);
assert.same(trunc(NaN), NaN, 'NaN -> NaN');
assert.same(trunc(-0), -0, '-0 -> -0');
assert.same(trunc(0), 0, '0 -> 0');
assert.same(trunc(Infinity), Infinity, 'Infinity -> Infinity');
assert.same(trunc(-Infinity), -Infinity, '-Infinity -> -Infinity');
assert.same(trunc(null), 0, 'null -> 0');
assert.same(trunc({}), NaN, '{} -> NaN');
assert.strictEqual(trunc([]), 0, '[] -> 0');
assert.strictEqual(trunc(1.01), 1, '1.01 -> 0');
assert.strictEqual(trunc(1.99), 1, '1.99 -> 0');
assert.strictEqual(trunc(-1), -1, '-1 -> -1');
assert.strictEqual(trunc(-1.99), -1, '-1.99 -> -1');
assert.strictEqual(trunc(-555.555), -555, '-555.555 -> -555');
assert.strictEqual(trunc(0x20000000000001), 0x20000000000001, '0x20000000000001 -> 0x20000000000001');
assert.strictEqual(trunc(-0x20000000000001), -0x20000000000001, '-0x20000000000001 -> -0x20000000000001');
});
core-js-3.6.1/tests/pure/es.number.epsilon.js 0000664 0000000 0000000 00000000427 13600575677 0021127 0 ustar 00root root 0000000 0000000 import EPSILON from 'core-js-pure/features/number/epsilon';
QUnit.test('Number.EPSILON', assert => {
assert.strictEqual(EPSILON, 2 ** -52, 'Is 2^-52');
assert.ok(1 !== 1 + EPSILON, '1 isnt 1 + EPSILON');
assert.strictEqual(1, 1 + EPSILON / 2, '1 is 1 + EPSILON / 2');
});
core-js-3.6.1/tests/pure/es.number.is-finite.js 0000664 0000000 0000000 00000001574 13600575677 0021351 0 ustar 00root root 0000000 0000000 import isFinite from 'core-js-pure/features/number/is-finite';
import create from 'core-js-pure/features/object/create';
QUnit.test('Number.isFinite', assert => {
assert.isFunction(isFinite);
const finite = [
1,
0.1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
];
for (const value of finite) {
assert.ok(isFinite(value), `isFinite ${ typeof value } ${ value }`);
}
const notFinite = [
NaN,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notFinite) {
assert.ok(!isFinite(value), `not isFinite ${ typeof value } ${ value }`);
}
assert.ok(!isFinite(create(null)), 'Number.isFinite(Object.create(null)) -> false');
});
core-js-3.6.1/tests/pure/es.number.is-integer.js 0000664 0000000 0000000 00000001616 13600575677 0021525 0 ustar 00root root 0000000 0000000 import isInteger from 'core-js-pure/features/number/is-integer';
import create from 'core-js-pure/features/object/create';
QUnit.test('Number.isInteger', assert => {
assert.isFunction(isInteger);
const integers = [
1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
];
for (const value of integers) {
assert.ok(isInteger(value), `isInteger ${ typeof value } ${ value }`);
}
const notIntegers = [
NaN,
0.1,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notIntegers) {
assert.ok(!isInteger(value), `not isInteger ${ typeof value } ${ value }`);
}
assert.ok(!isInteger(create(null)), 'Number.isInteger(Object.create(null)) -> false');
});
core-js-3.6.1/tests/pure/es.number.is-nan.js 0000664 0000000 0000000 00000001406 13600575677 0020641 0 ustar 00root root 0000000 0000000 import isNaN from 'core-js-pure/features/number/is-nan';
import create from 'core-js-pure/features/object/create';
QUnit.test('Number.isNaN', assert => {
assert.isFunction(isNaN);
assert.ok(isNaN(NaN), 'Number.isNaN NaN');
const notNaNs = [
1,
0.1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notNaNs) {
assert.ok(!isNaN(value), `not Number.isNaN ${ typeof value } ${ value }`);
}
assert.ok(!isNaN(create(null)), 'Number.isNaN(Object.create(null)) -> false');
});
core-js-3.6.1/tests/pure/es.number.is-safe-integer.js 0000664 0000000 0000000 00000002041 13600575677 0022432 0 ustar 00root root 0000000 0000000 import isSafeInteger from 'core-js-pure/features/number/is-safe-integer';
import create from 'core-js-pure/features/object/create';
QUnit.test('Number.isSafeInteger', assert => {
assert.isFunction(isSafeInteger);
const safeIntegers = [
1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
9007199254740991,
-9007199254740991,
];
for (const value of safeIntegers) {
assert.ok(isSafeInteger(value), `isSafeInteger ${ typeof value } ${ value }`);
}
const notSafeIntegers = [
9007199254740992,
-9007199254740992,
NaN,
0.1,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notSafeIntegers) {
assert.ok(!isSafeInteger(value), `not isSafeInteger ${ typeof value } ${ value }`);
}
assert.ok(!isSafeInteger(create(null)), 'Number.isSafeInteger(Object.create(null)) -> false');
});
core-js-3.6.1/tests/pure/es.number.max-safe-integer.js 0000664 0000000 0000000 00000000311 13600575677 0022602 0 ustar 00root root 0000000 0000000 import MAX_SAFE_INTEGER from 'core-js-pure/features/number/max-safe-integer';
QUnit.test('Number.MAX_SAFE_INTEGER', assert => {
assert.strictEqual(MAX_SAFE_INTEGER, 2 ** 53 - 1, 'Is 2^53 - 1');
});
core-js-3.6.1/tests/pure/es.number.min-safe-integer.js 0000664 0000000 0000000 00000000315 13600575677 0022604 0 ustar 00root root 0000000 0000000 import MIN_SAFE_INTEGER from 'core-js-pure/features/number/min-safe-integer';
QUnit.test('Number.MIN_SAFE_INTEGER', assert => {
assert.strictEqual(MIN_SAFE_INTEGER, -(2 ** 53) + 1, 'Is -2^53 + 1');
});
core-js-3.6.1/tests/pure/es.number.parse-float.js 0000664 0000000 0000000 00000001176 13600575677 0021675 0 ustar 00root root 0000000 0000000 import { WHITESPACES } from '../helpers/constants';
import parseFloat from 'core-js-pure/features/number/parse-float';
QUnit.test('Number.parseFloat', assert => {
assert.isFunction(parseFloat);
assert.arity(parseFloat, 1);
assert.same(parseFloat('0'), 0);
assert.same(parseFloat(' 0'), 0);
assert.same(parseFloat('+0'), 0);
assert.same(parseFloat(' +0'), 0);
assert.same(parseFloat('-0'), -0);
assert.same(parseFloat(' -0'), -0);
assert.same(parseFloat(`${ WHITESPACES }+0`), 0);
assert.same(parseFloat(`${ WHITESPACES }-0`), -0);
assert.same(parseFloat(null), NaN);
assert.same(parseFloat(undefined), NaN);
});
core-js-3.6.1/tests/pure/es.number.parse-int.js 0000664 0000000 0000000 00000003171 13600575677 0021357 0 ustar 00root root 0000000 0000000 import { WHITESPACES } from '../helpers/constants';
import parseInt from 'core-js-pure/features/number/parse-int';
QUnit.test('Number.parseInt', assert => {
assert.isFunction(parseInt);
assert.arity(parseInt, 2);
for (let radix = 2; radix <= 36; ++radix) {
assert.same(parseInt('10', radix), radix, `radix ${ radix }`);
}
const strings = ['01', '08', '10', '42'];
for (const string of strings) {
assert.same(parseInt(string), parseInt(string, 10), `default radix is 10: ${ string }`);
}
assert.same(parseInt('0x16'), parseInt('0x16', 16), 'default radix is 16: 0x16');
assert.same(parseInt(' 0x16'), parseInt('0x16', 16), 'ignores leading whitespace #1');
assert.same(parseInt(' 42'), parseInt('42', 10), 'ignores leading whitespace #2');
assert.same(parseInt(' 08'), parseInt('08', 10), 'ignores leading whitespace #3');
assert.same(parseInt(`${ WHITESPACES }08`), parseInt('08', 10), 'ignores leading whitespace #4');
assert.same(parseInt(`${ WHITESPACES }0x16`), parseInt('0x16', 16), 'ignores leading whitespace #5');
const fakeZero = {
valueOf() {
return 0;
},
};
assert.same(parseInt('08', fakeZero), parseInt('08', 10), 'valueOf #1');
assert.same(parseInt('0x16', fakeZero), parseInt('0x16', 16), 'valueOf #2');
assert.same(parseInt('-0xF'), -15, 'signed hex #1');
assert.same(parseInt('-0xF', 16), -15, 'signed hex #2');
assert.same(parseInt('+0xF'), 15, 'signed hex #3');
assert.same(parseInt('+0xF', 16), 15, 'signed hex #4');
assert.same(parseInt('10', -4294967294), 2, 'radix uses ToUint32');
assert.same(parseInt(null), NaN);
assert.same(parseInt(undefined), NaN);
});
core-js-3.6.1/tests/pure/es.number.to-fixed.js 0000664 0000000 0000000 00000006360 13600575677 0021177 0 ustar 00root root 0000000 0000000 import toFixed from 'core-js-pure/features/number/to-fixed';
QUnit.test('Number#toFixed', assert => {
assert.isFunction(toFixed);
assert.same(toFixed(0.00008, 3), '0.000');
assert.same(toFixed(0.9, 0), '1');
assert.same(toFixed(1.255, 2), '1.25');
assert.same(toFixed(1843654265.0774949, 5), '1843654265.07749');
assert.same(toFixed(1000000000000000128, 0), '1000000000000000128');
assert.same(toFixed(1), '1');
assert.same(toFixed(1, 0), '1');
assert.same(toFixed(1, 1), '1.0');
assert.same(toFixed(1, 1.1), '1.0');
assert.same(toFixed(1, 0.9), '1');
assert.same(toFixed(1, '0'), '1');
assert.same(toFixed(1, '1'), '1.0');
assert.same(toFixed(1, '1.1'), '1.0');
assert.same(toFixed(1, '0.9'), '1');
assert.same(toFixed(1, NaN), '1');
assert.same(toFixed(1, 'some string'), '1');
assert.notThrows(() => toFixed(1, -0.1) === '1');
assert.same(toFixed(Object(1)), '1');
assert.same(toFixed(Object(1), 0), '1');
assert.same(toFixed(Object(1), 1), '1.0');
assert.same(toFixed(Object(1), 1.1), '1.0');
assert.same(toFixed(Object(1), 0.9), '1');
assert.same(toFixed(Object(1), '0'), '1');
assert.same(toFixed(Object(1), '1'), '1.0');
assert.same(toFixed(Object(1), '1.1'), '1.0');
assert.same(toFixed(Object(1), '0.9'), '1');
assert.same(toFixed(Object(1), NaN), '1');
assert.same(toFixed(Object(1), 'some string'), '1');
assert.notThrows(() => toFixed(Object(1), -0.1) === '1');
assert.same(toFixed(NaN), 'NaN');
assert.same(toFixed(NaN, 0), 'NaN');
assert.same(toFixed(NaN, 1), 'NaN');
assert.same(toFixed(NaN, 1.1), 'NaN');
assert.same(toFixed(NaN, 0.9), 'NaN');
assert.same(toFixed(NaN, '0'), 'NaN');
assert.same(toFixed(NaN, '1'), 'NaN');
assert.same(toFixed(NaN, '1.1'), 'NaN');
assert.same(toFixed(NaN, '0.9'), 'NaN');
assert.same(toFixed(NaN, NaN), 'NaN');
assert.same(toFixed(NaN, 'some string'), 'NaN');
assert.notThrows(() => toFixed(NaN, -0.1) === 'NaN');
assert.same(toFixed(1e21), String(1e21));
assert.same(toFixed(1e21, 0), String(1e21));
assert.same(toFixed(1e21, 1), String(1e21));
assert.same(toFixed(1e21, 1.1), String(1e21));
assert.same(toFixed(1e21, 0.9), String(1e21));
assert.same(toFixed(1e21, '0'), String(1e21));
assert.same(toFixed(1e21, '1'), String(1e21));
assert.same(toFixed(1e21, '1.1'), String(1e21));
assert.same(toFixed(1e21, '0.9'), String(1e21));
assert.same(toFixed(1e21, NaN), String(1e21));
assert.same(toFixed(1e21, 'some string'), String(1e21));
assert.notThrows(() => toFixed(1e21, -0.1) === String(1e21));
assert.throws(() => toFixed(1, -101), RangeError, 'If f < 0 or f > 20, throw a RangeError exception.');
assert.throws(() => toFixed(1, 101), RangeError, 'If f < 0 or f > 20, throw a RangeError exception.');
assert.throws(() => toFixed(NaN, Infinity), RangeError, 'If f < 0 or f > 20, throw a RangeError exception.');
assert.throws(() => toFixed({}, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toFixed('123', 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toFixed(false, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toFixed(null, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toFixed(undefined, 1), TypeError, '? thisNumberValue(this value)');
});
core-js-3.6.1/tests/pure/es.number.to-precision.js 0000664 0000000 0000000 00000002536 13600575677 0022074 0 ustar 00root root 0000000 0000000 import toPrecision from 'core-js-pure/features/number/to-precision';
QUnit.test('Number#toPrecision', assert => {
assert.isFunction(toPrecision);
assert.same(toPrecision(0.00008, 3), '0.0000800', '0.00008.toPrecision(3)');
assert.same(toPrecision(1.255, 2), '1.3', '1.255.toPrecision(2)');
assert.same(toPrecision(1843654265.0774949, 13), '1843654265.077', '1843654265.0774949.toPrecision(13)');
assert.same(toPrecision(NaN, 1), 'NaN', 'If x is NaN, return the String "NaN".');
assert.same(toPrecision(123.456), '123.456', 'If precision is undefined, return ! ToString(x).');
assert.same(toPrecision(123.456, undefined), '123.456', 'If precision is undefined, return ! ToString(x).');
assert.throws(() => toPrecision(0.9, 0), RangeError, 'If p < 1 or p > 21, throw a RangeError exception.');
assert.throws(() => toPrecision(0.9, 101), RangeError, 'If p < 1 or p > 21, throw a RangeError exception.');
assert.throws(() => toPrecision({}, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toPrecision('123', 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toPrecision(false, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toPrecision(null, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toPrecision(undefined, 1), TypeError, '? thisNumberValue(this value)');
});
core-js-3.6.1/tests/pure/es.object.assign.js 0000664 0000000 0000000 00000004407 13600575677 0020722 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import Symbol from 'core-js-pure/features/symbol';
import { assign, keys, defineProperty } from 'core-js-pure/features/object';
QUnit.test('Object.assign', assert => {
assert.isFunction(assign);
let object = { q: 1 };
assert.strictEqual(object, assign(object, { bar: 2 }), 'assign return target');
assert.strictEqual(object.bar, 2, 'assign define properties');
assert.deepEqual(assign({}, { q: 1 }, { w: 2 }), { q: 1, w: 2 });
assert.deepEqual(assign({}, 'qwe'), { 0: 'q', 1: 'w', 2: 'e' });
assert.throws(() => assign(null, { q: 1 }), TypeError);
assert.throws(() => assign(undefined, { q: 1 }), TypeError);
let string = assign('qwe', { q: 1 });
assert.strictEqual(typeof string, 'object');
assert.strictEqual(String(string), 'qwe');
assert.strictEqual(string.q, 1);
assert.same(assign({}, { valueOf: 42 }).valueOf, 42, 'IE enum keys bug');
if (DESCRIPTORS) {
object = { baz: 1 };
assign(object, defineProperty({}, 'bar', {
get() {
return this.baz + 1;
},
}));
assert.ok(object.bar === undefined, "assign don't copy descriptors");
object = { a: 'a' };
const c = Symbol('c');
const d = Symbol('d');
object[c] = 'c';
defineProperty(object, 'b', { value: 'b' });
defineProperty(object, d, { value: 'd' });
const object2 = assign({}, object);
assert.strictEqual(object2.a, 'a', 'a');
assert.strictEqual(object2.b, undefined, 'b');
assert.strictEqual(object2[c], 'c', 'c');
assert.strictEqual(object2[d], undefined, 'd');
try {
assert.strictEqual(Function('assign', `
return assign({ b: 1 }, { get a() {
delete this.b;
}, b: 2 });
`)(assign).b, 1);
} catch { /* empty */ }
try {
assert.strictEqual(Function('assign', `
return assign({ b: 1 }, { get a() {
Object.defineProperty(this, "b", {
value: 4,
enumerable: false
});
}, b: 2 });
`)(assign).b, 1);
} catch { /* empty */ }
}
string = 'abcdefghijklmnopqrst';
const result = {};
for (let i = 0, { length } = string; i < length; ++i) {
const char = string.charAt(i);
result[char] = char;
}
assert.strictEqual(keys(assign({}, result)).join(''), string);
});
core-js-3.6.1/tests/pure/es.object.create.js 0000664 0000000 0000000 00000002173 13600575677 0020677 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import { create, getPrototypeOf, getOwnPropertyNames } from 'core-js-pure/features/object';
QUnit.test('Object.create', assert => {
function getPropertyNames(object) {
let result = [];
do {
result = result.concat(getOwnPropertyNames(object));
} while (object = getPrototypeOf(object));
return result;
}
assert.isFunction(create);
assert.arity(create, 2);
let object = { q: 1 };
assert.ok({}.isPrototypeOf.call(object, create(object)));
assert.ok(create(object).q === 1);
function C() {
return this.a = 1;
}
assert.ok(create(new C()) instanceof C);
assert.ok(C.prototype === getPrototypeOf(getPrototypeOf(create(new C()))));
assert.ok(create(new C()).a === 1);
assert.ok(create({}, { a: { value: 42 } }).a === 42);
object = create(null, { w: { value: 2 } });
assert.same(object, Object(object));
assert.ok(!('toString' in object));
assert.ok(object.w === 2);
assert.deepEqual(getPropertyNames(create(null)), []);
});
QUnit.test('Object.create.sham flag', assert => {
assert.same(create.sham, DESCRIPTORS ? undefined : true);
});
core-js-3.6.1/tests/pure/es.object.define-getter.js 0000664 0000000 0000000 00000001523 13600575677 0022154 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, STRICT } from '../helpers/constants';
import { __defineGetter__, __defineSetter__ } from 'core-js-pure/features/object';
if (DESCRIPTORS) {
QUnit.test('Object#__defineGetter__', assert => {
assert.isFunction(__defineGetter__);
const object = {};
assert.same(__defineGetter__(object, 'key', () => 42), undefined, 'void');
assert.same(object.key, 42, 'works');
__defineSetter__(object, 'key', function () {
this.foo = 43;
});
object.key = 44;
assert.ok(object.key === 42 && object.foo === 43, 'works with setter');
if (STRICT) {
assert.throws(() => __defineGetter__(null, 1, () => { /* empty */ }), TypeError, 'Throws on null as `this`');
assert.throws(() => __defineGetter__(undefined, 1, () => { /* empty */ }), TypeError, 'Throws on undefined as `this`');
}
});
}
core-js-3.6.1/tests/pure/es.object.define-properties.js 0000664 0000000 0000000 00000001117 13600575677 0023055 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import defineProperties from 'core-js-pure/features/object/define-properties';
QUnit.test('Object.defineProperties', assert => {
assert.isFunction(defineProperties);
assert.arity(defineProperties, 2);
const source = {};
const result = defineProperties(source, { q: { value: 42 }, w: { value: 33 } });
assert.same(result, source);
assert.same(result.q, 42);
assert.same(result.w, 33);
});
QUnit.test('Object.defineProperties.sham flag', assert => {
assert.same(defineProperties.sham, DESCRIPTORS ? undefined : true);
});
core-js-3.6.1/tests/pure/es.object.define-property.js 0000664 0000000 0000000 00000001261 13600575677 0022545 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import { defineProperty, create } from 'core-js-pure/features/object';
QUnit.test('Object.defineProperty', assert => {
assert.isFunction(defineProperty);
assert.arity(defineProperty, 3);
const source = {};
const result = defineProperty(source, 'q', {
value: 42,
});
assert.same(result, source);
assert.same(result.q, 42);
assert.throws(() => defineProperty(42, 1, {}));
assert.throws(() => defineProperty({}, create(null), {}));
assert.throws(() => defineProperty({}, 1, 1));
});
QUnit.test('Object.defineProperty.sham flag', assert => {
assert.same(defineProperty.sham, DESCRIPTORS ? undefined : true);
});
core-js-3.6.1/tests/pure/es.object.define-setter.js 0000664 0000000 0000000 00000001706 13600575677 0022173 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, STRICT } from '../helpers/constants';
import { __defineGetter__, __defineSetter__ } from 'core-js-pure/features/object';
if (DESCRIPTORS) {
QUnit.test('Object#__defineSetter__', assert => {
assert.isFunction(__defineSetter__);
let object = {};
assert.same(__defineSetter__(object, 'key', function () {
this.foo = 43;
}), undefined, 'void');
object.key = 44;
assert.same(object.foo, 43, 'works');
object = {};
__defineSetter__(object, 'key', function () {
this.foo = 43;
});
__defineGetter__(object, 'key', () => 42);
object.key = 44;
assert.ok(object.key === 42 && object.foo === 43, 'works with getter');
if (STRICT) {
assert.throws(() => __defineSetter__(null, 1, () => { /* empty */ }), TypeError, 'Throws on null as `this`');
assert.throws(() => __defineSetter__(undefined, 1, () => { /* empty */ }), TypeError, 'Throws on undefined as `this`');
}
});
}
core-js-3.6.1/tests/pure/es.object.entries.js 0000664 0000000 0000000 00000002107 13600575677 0021102 0 ustar 00root root 0000000 0000000 import { entries, create, assign } from 'core-js-pure/features/object';
QUnit.test('Object.entries', assert => {
assert.isFunction(entries);
assert.arity(entries, 1);
assert.name(entries, 'entries');
assert.deepEqual(entries({ q: 1, w: 2, e: 3 }), [['q', 1], ['w', 2], ['e', 3]]);
assert.deepEqual(entries(new String('qwe')), [['0', 'q'], ['1', 'w'], ['2', 'e']]);
assert.deepEqual(entries(assign(create({ q: 1, w: 2, e: 3 }), { a: 4, s: 5, d: 6 })), [['a', 4], ['s', 5], ['d', 6]]);
assert.deepEqual(entries({ valueOf: 42 }), [['valueOf', 42]], 'IE enum keys bug');
try {
assert.deepEqual(Function('entries', `
return entries({ a: 1, get b() {
delete this.c;
return 2;
}, c: 3 });
`)(entries), [['a', 1], ['b', 2]]);
} catch { /* empty */ }
try {
assert.deepEqual(Function('entries', `
return entries({ a: 1, get b() {
Object.defineProperty(this, "c", {
value: 4,
enumerable: false
});
return 2
}, c: 3 });
`)(entries), [['a', 1], ['b', 2]]);
} catch { /* empty */ }
});
core-js-3.6.1/tests/pure/es.object.freeze.js 0000664 0000000 0000000 00000001555 13600575677 0020717 0 ustar 00root root 0000000 0000000 import { freeze, keys, getOwnPropertyNames, getOwnPropertySymbols } from 'core-js-pure/features/object';
import ownKeys from 'core-js-pure/features/reflect/own-keys';
QUnit.test('Object.freeze', assert => {
assert.isFunction(freeze);
assert.arity(freeze, 1);
const data = [42, 'foo', false, null, undefined, {}];
for (const value of data) {
assert.notThrows(() => freeze(value) || true, `accept ${ {}.toString.call(value).slice(8, -1) }`);
assert.same(freeze(value), value, `returns target on ${ {}.toString.call(value).slice(8, -1) }`);
}
const results = [];
for (const key in freeze({})) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(freeze({})), []);
assert.arrayEqual(getOwnPropertyNames(freeze({})), []);
assert.arrayEqual(getOwnPropertySymbols(freeze({})), []);
assert.arrayEqual(ownKeys(freeze({})), []);
});
core-js-3.6.1/tests/pure/es.object.from-entries.js 0000664 0000000 0000000 00000001522 13600575677 0022043 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
import fromEntries from 'core-js-pure/features/object/from-entries';
import Set from 'core-js-pure/features/set';
QUnit.test('Object.fromEntries', assert => {
assert.isFunction(fromEntries);
assert.arity(fromEntries, 1);
assert.name(fromEntries, 'fromEntries');
assert.ok(fromEntries([]) instanceof Object);
assert.same(fromEntries([['foo', 1]]).foo, 1);
assert.same(fromEntries(createIterable([['bar', 2]])).bar, 2);
class Unit {
constructor(id) {
this.id = id;
}
toString() {
return `unit${ this.id }`;
}
}
const units = new Set([new Unit(101), new Unit(102), new Unit(103)]);
const object = fromEntries(units.entries());
assert.same(object.unit101.id, 101);
assert.same(object.unit102.id, 102);
assert.same(object.unit103.id, 103);
});
core-js-3.6.1/tests/pure/es.object.get-own-property-descriptor.js 0000664 0000000 0000000 00000002007 13600575677 0025046 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import getOwnPropertyDescriptor from 'core-js-pure/features/object/get-own-property-descriptor';
QUnit.test('Object.getOwnPropertyDescriptor', assert => {
assert.isFunction(getOwnPropertyDescriptor);
assert.arity(getOwnPropertyDescriptor, 2);
assert.deepEqual(getOwnPropertyDescriptor({ q: 42 }, 'q'), {
writable: true,
enumerable: true,
configurable: true,
value: 42,
});
assert.ok(getOwnPropertyDescriptor({}, 'toString') === undefined);
const primitives = [42, 'foo', false];
for (const value of primitives) {
assert.notThrows(() => getOwnPropertyDescriptor(value) || true, `accept ${ typeof value }`);
}
assert.throws(() => getOwnPropertyDescriptor(null), TypeError, 'throws on null');
assert.throws(() => getOwnPropertyDescriptor(undefined), TypeError, 'throws on undefined');
});
QUnit.test('Object.getOwnPropertyDescriptor.sham flag', assert => {
assert.same(getOwnPropertyDescriptor.sham, DESCRIPTORS ? undefined : true);
});
core-js-3.6.1/tests/pure/es.object.get-own-property-descriptors.js 0000664 0000000 0000000 00000002211 13600575677 0025226 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import Symbol from 'core-js-pure/features/symbol';
import { create, getOwnPropertyDescriptors } from 'core-js-pure/features/object';
QUnit.test('Object.getOwnPropertyDescriptors', assert => {
assert.isFunction(getOwnPropertyDescriptors);
const object = create({ q: 1 }, { e: { value: 3 } });
object.w = 2;
const symbol = Symbol('4');
object[symbol] = 4;
const descriptors = getOwnPropertyDescriptors(object);
assert.strictEqual(descriptors.q, undefined);
assert.deepEqual(descriptors.w, {
enumerable: true,
configurable: true,
writable: true,
value: 2,
});
if (DESCRIPTORS) {
assert.deepEqual(descriptors.e, {
enumerable: false,
configurable: false,
writable: false,
value: 3,
});
} else {
assert.deepEqual(descriptors.e, {
enumerable: true,
configurable: true,
writable: true,
value: 3,
});
}
assert.strictEqual(descriptors[symbol].value, 4);
});
QUnit.test('Object.getOwnPropertyDescriptors.sham flag', assert => {
assert.same(getOwnPropertyDescriptors.sham, DESCRIPTORS ? undefined : true);
});
core-js-3.6.1/tests/pure/es.object.get-own-property-names.js 0000664 0000000 0000000 00000003316 13600575677 0023777 0 ustar 00root root 0000000 0000000 import { GLOBAL } from '../helpers/constants';
import { includes } from '../helpers/helpers';
import getOwnPropertyNames from 'core-js-pure/features/object/get-own-property-names';
QUnit.test('Object.getOwnPropertyNames', assert => {
assert.isFunction(getOwnPropertyNames);
assert.arity(getOwnPropertyNames, 1);
function F1() {
this.w = 1;
}
function F2() {
this.toString = 1;
}
F1.prototype.q = F2.prototype.q = 1;
const names = getOwnPropertyNames([1, 2, 3]);
assert.strictEqual(names.length, 4);
assert.ok(includes(names, '0'));
assert.ok(includes(names, '1'));
assert.ok(includes(names, '2'));
assert.ok(includes(names, 'length'));
assert.deepEqual(getOwnPropertyNames(new F1()), ['w']);
assert.deepEqual(getOwnPropertyNames(new F2()), ['toString']);
assert.ok(includes(getOwnPropertyNames(Array.prototype), 'toString'));
assert.ok(includes(getOwnPropertyNames(Object.prototype), 'toString'));
assert.ok(includes(getOwnPropertyNames(Object.prototype), 'constructor'));
const primitives = [42, 'foo', false];
for (const value of primitives) {
assert.notThrows(() => getOwnPropertyNames(value), `accept ${ typeof value }`);
}
assert.throws(() => getOwnPropertyNames(null), TypeError, 'throws on null');
assert.throws(() => getOwnPropertyNames(undefined), TypeError, 'throws on undefined');
if (GLOBAL.document) {
assert.notThrows(() => {
const iframe = document.createElement('iframe');
iframe.src = 'http://example.com';
document.documentElement.appendChild(iframe);
const window = iframe.contentWindow;
document.documentElement.removeChild(iframe);
return getOwnPropertyNames(window);
}, 'IE11 bug with iframe and window');
}
});
core-js-3.6.1/tests/pure/es.object.get-prototype-of.js 0000664 0000000 0000000 00000002577 13600575677 0022670 0 ustar 00root root 0000000 0000000 import { CORRECT_PROTOTYPE_GETTER } from '../helpers/constants';
import { create, getPrototypeOf } from 'core-js-pure/features/object';
QUnit.test('Object.getPrototypeOf', assert => {
assert.isFunction(getPrototypeOf);
assert.arity(getPrototypeOf, 1);
assert.ok(getPrototypeOf({}) === Object.prototype);
assert.ok(getPrototypeOf([]) === Array.prototype);
function F() { /* empty */ }
assert.ok(getPrototypeOf(new F()) === F.prototype);
const object = { q: 1 };
assert.ok(getPrototypeOf(create(object)) === object);
assert.ok(getPrototypeOf(create(null)) === null);
assert.ok(getPrototypeOf(getPrototypeOf({})) === null);
function Foo() { /* empty */ }
Foo.prototype.foo = 'foo';
function Bar() { /* empty */ }
Bar.prototype = create(Foo.prototype);
Bar.prototype.constructor = Bar;
assert.strictEqual(getPrototypeOf(Bar.prototype).foo, 'foo');
const primitives = [42, 'foo', false];
for (const value of primitives) {
assert.notThrows(() => getPrototypeOf(value), `accept ${ typeof value }`);
}
assert.throws(() => getPrototypeOf(null), TypeError, 'throws on null');
assert.throws(() => getPrototypeOf(undefined), TypeError, 'throws on undefined');
assert.strictEqual(getPrototypeOf('foo'), String.prototype);
});
QUnit.test('Object.getPrototypeOf.sham flag', assert => {
assert.same(getPrototypeOf.sham, CORRECT_PROTOTYPE_GETTER ? undefined : true);
});
core-js-3.6.1/tests/pure/es.object.is-extensible.js 0000664 0000000 0000000 00000000744 13600575677 0022211 0 ustar 00root root 0000000 0000000 import isExtensible from 'core-js-pure/features/object/is-extensible';
QUnit.test('Object.isExtensible', assert => {
assert.isFunction(isExtensible);
assert.arity(isExtensible, 1);
const primitives = [42, 'string', false, null, undefined];
for (const value of primitives) {
assert.notThrows(() => isExtensible(value) || true, `accept ${ value }`);
assert.same(isExtensible(value), false, `returns false on ${ value }`);
}
assert.same(isExtensible({}), true);
});
core-js-3.6.1/tests/pure/es.object.is-frozen.js 0000664 0000000 0000000 00000000703 13600575677 0021345 0 ustar 00root root 0000000 0000000 import isFrozen from 'core-js-pure/features/object/is-frozen';
QUnit.test('Object.isFrozen', assert => {
assert.isFunction(isFrozen);
assert.arity(isFrozen, 1);
const primitives = [42, 'string', false, null, undefined];
for (const value of primitives) {
assert.notThrows(() => isFrozen(value) || true, `accept ${ value }`);
assert.same(isFrozen(value), true, `returns true on ${ value }`);
}
assert.same(isFrozen({}), false);
});
core-js-3.6.1/tests/pure/es.object.is-sealed.js 0000664 0000000 0000000 00000000703 13600575677 0021277 0 ustar 00root root 0000000 0000000 import isSealed from 'core-js-pure/features/object/is-sealed';
QUnit.test('Object.isSealed', assert => {
assert.isFunction(isSealed);
assert.arity(isSealed, 1);
const primitives = [42, 'string', false, null, undefined];
for (const value of primitives) {
assert.notThrows(() => isSealed(value) || true, `accept ${ value }`);
assert.same(isSealed(value), true, `returns true on ${ value }`);
}
assert.same(isSealed({}), false);
});
core-js-3.6.1/tests/pure/es.object.is.js 0000664 0000000 0000000 00000000410 13600575677 0020037 0 ustar 00root root 0000000 0000000 import is from 'core-js-pure/features/object/is';
QUnit.test('Object.is', assert => {
assert.isFunction(is);
assert.ok(is(1, 1), '1 is 1');
assert.ok(is(NaN, NaN), '1 is 1');
assert.ok(!is(0, -0), '0 isnt -0');
assert.ok(!is({}, {}), '{} isnt {}');
});
core-js-3.6.1/tests/pure/es.object.keys.js 0000664 0000000 0000000 00000001451 13600575677 0020405 0 ustar 00root root 0000000 0000000 import { includes } from '../helpers/helpers';
import keys from 'core-js-pure/features/object/keys';
QUnit.test('Object.keys', assert => {
assert.isFunction(keys);
assert.arity(keys, 1);
function F1() {
this.w = 1;
}
function F2() {
this.toString = 1;
}
F1.prototype.q = F2.prototype.q = 1;
assert.deepEqual(keys([1, 2, 3]), ['0', '1', '2']);
assert.deepEqual(keys(new F1()), ['w']);
assert.deepEqual(keys(new F2()), ['toString']);
assert.ok(!includes(keys(Array.prototype), 'push'));
const primitives = [42, 'foo', false];
for (const value of primitives) {
assert.notThrows(() => keys(value), `accept ${ typeof value }`);
}
assert.throws(() => keys(null), TypeError, 'throws on null');
assert.throws(() => keys(undefined), TypeError, 'throws on undefined');
});
core-js-3.6.1/tests/pure/es.object.lookup-getter.js 0000664 0000000 0000000 00000002021 13600575677 0022225 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, STRICT } from '../helpers/constants';
import { __lookupGetter__, __defineGetter__, create } from 'core-js-pure/features/object';
if (DESCRIPTORS) {
QUnit.test('Object#__lookupGetter__', assert => {
assert.isFunction(__lookupGetter__);
assert.same(__lookupGetter__({}, 'key'), undefined, 'empty object');
assert.same(__lookupGetter__({ key: 42 }, 'key'), undefined, 'data descriptor');
const object = {};
function getter() { /* empty */ }
__defineGetter__(object, 'key', getter);
assert.same(__lookupGetter__(object, 'key'), getter, 'own getter');
assert.same(__lookupGetter__(create(object), 'key'), getter, 'proto getter');
assert.same(__lookupGetter__(create(object), 'foo'), undefined, 'empty proto');
if (STRICT) {
assert.throws(() => __lookupGetter__(null, 1, () => { /* empty */ }), TypeError, 'Throws on null as `this`');
assert.throws(() => __lookupGetter__(undefined, 1, () => { /* empty */ }), TypeError, 'Throws on undefined as `this`');
}
});
}
core-js-3.6.1/tests/pure/es.object.lookup-setter.js 0000664 0000000 0000000 00000002021 13600575677 0022241 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, STRICT } from '../helpers/constants';
import { __lookupSetter__, __defineSetter__, create } from 'core-js-pure/features/object';
if (DESCRIPTORS) {
QUnit.test('Object#__lookupSetter__', assert => {
assert.isFunction(__lookupSetter__);
assert.same(__lookupSetter__({}, 'key'), undefined, 'empty object');
assert.same(__lookupSetter__({ key: 42 }, 'key'), undefined, 'data descriptor');
const object = {};
function setter() { /* empty */ }
__defineSetter__(object, 'key', setter);
assert.same(__lookupSetter__(object, 'key'), setter, 'own getter');
assert.same(__lookupSetter__(create(object), 'key'), setter, 'proto getter');
assert.same(__lookupSetter__(create(object), 'foo'), undefined, 'empty proto');
if (STRICT) {
assert.throws(() => __lookupSetter__(null, 1, () => { /* empty */ }), TypeError, 'Throws on null as `this`');
assert.throws(() => __lookupSetter__(undefined, 1, () => { /* empty */ }), TypeError, 'Throws on undefined as `this`');
}
});
}
core-js-3.6.1/tests/pure/es.object.prevent-extensions.js 0000664 0000000 0000000 00000001746 13600575677 0023321 0 ustar 00root root 0000000 0000000 import { preventExtensions, keys, getOwnPropertyNames, getOwnPropertySymbols } from 'core-js-pure/features/object';
import ownKeys from 'core-js-pure/features/reflect/own-keys';
QUnit.test('Object.preventExtensions', assert => {
assert.isFunction(preventExtensions);
assert.arity(preventExtensions, 1);
const data = [42, 'foo', false, null, undefined, {}];
for (const value of data) {
assert.notThrows(() => preventExtensions(value) || true, `accept ${ {}.toString.call(value).slice(8, -1) }`);
assert.same(preventExtensions(value), value, `returns target on ${ {}.toString.call(value).slice(8, -1) }`);
}
const results = [];
for (const key in preventExtensions({})) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(preventExtensions({})), []);
assert.arrayEqual(getOwnPropertyNames(preventExtensions({})), []);
assert.arrayEqual(getOwnPropertySymbols(preventExtensions({})), []);
assert.arrayEqual(ownKeys(preventExtensions({})), []);
});
core-js-3.6.1/tests/pure/es.object.seal.js 0000664 0000000 0000000 00000001527 13600575677 0020362 0 ustar 00root root 0000000 0000000 import { seal, keys, getOwnPropertyNames, getOwnPropertySymbols } from 'core-js-pure/features/object';
import ownKeys from 'core-js-pure/features/reflect/own-keys';
QUnit.test('Object.seal', assert => {
assert.isFunction(seal);
assert.arity(seal, 1);
const data = [42, 'foo', false, null, undefined, {}];
for (const value of data) {
assert.notThrows(() => seal(value) || true, `accept ${ {}.toString.call(value).slice(8, -1) }`);
assert.same(seal(value), value, `returns target on ${ {}.toString.call(value).slice(8, -1) }`);
}
const results = [];
for (const key in seal({})) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(seal({})), []);
assert.arrayEqual(getOwnPropertyNames(seal({})), []);
assert.arrayEqual(getOwnPropertySymbols(seal({})), []);
assert.arrayEqual(ownKeys(seal({})), []);
});
core-js-3.6.1/tests/pure/es.object.set-prototype-of.js 0000664 0000000 0000000 00000001233 13600575677 0022670 0 ustar 00root root 0000000 0000000 import { PROTO } from '../helpers/constants';
import setPrototypeOf from 'core-js-pure/features/object/set-prototype-of';
if (PROTO) QUnit.test('Object.setPrototypeOf', assert => {
assert.isFunction(setPrototypeOf);
assert.ok('apply' in setPrototypeOf({}, Function.prototype), 'Parent properties in target');
assert.strictEqual(setPrototypeOf({ a: 2 }, {
b() {
return this.a ** 2;
},
}).b(), 4, 'Child and parent properties in target');
const object = {};
assert.strictEqual(setPrototypeOf(object, { a: 1 }), object, 'setPrototypeOf return target');
assert.ok(!('toString' in setPrototypeOf({}, null)), 'Can set null as prototype');
});
core-js-3.6.1/tests/pure/es.object.values.js 0000664 0000000 0000000 00000001717 13600575677 0020736 0 ustar 00root root 0000000 0000000 import { values, create, assign } from 'core-js-pure/features/object';
QUnit.test('Object.values', assert => {
assert.isFunction(values);
assert.arity(values, 1);
assert.name(values, 'values');
assert.deepEqual(values({ q: 1, w: 2, e: 3 }), [1, 2, 3]);
assert.deepEqual(values(new String('qwe')), ['q', 'w', 'e']);
assert.deepEqual(values(assign(create({ q: 1, w: 2, e: 3 }), { a: 4, s: 5, d: 6 })), [4, 5, 6]);
assert.deepEqual(values({ valueOf: 42 }), [42], 'IE enum keys bug');
try {
assert.deepEqual(Function('values', `
return values({ a: 1, get b() {
delete this.c;
return 2;
}, c: 3 });
`)(values), [1, 2]);
} catch { /* empty */ }
try {
assert.deepEqual(Function('values', `
return values({ a: 1, get b() {
Object.defineProperty(this, "c", {
value: 4,
enumerable: false
});
return 2;
}, c: 3 });
`)(values), [1, 2]);
} catch { /* empty */ }
});
core-js-3.6.1/tests/pure/es.parse-float.js 0000664 0000000 0000000 00000001157 13600575677 0020405 0 ustar 00root root 0000000 0000000 import { WHITESPACES } from '../helpers/constants';
import parseFloat from 'core-js-pure/features/parse-float';
QUnit.test('parseFloat', assert => {
assert.isFunction(parseFloat);
assert.arity(parseFloat, 1);
assert.same(parseFloat('0'), 0);
assert.same(parseFloat(' 0'), 0);
assert.same(parseFloat('+0'), 0);
assert.same(parseFloat(' +0'), 0);
assert.same(parseFloat('-0'), -0);
assert.same(parseFloat(' -0'), -0);
assert.same(parseFloat(`${ WHITESPACES }+0`), 0);
assert.same(parseFloat(`${ WHITESPACES }-0`), -0);
assert.same(parseFloat(null), NaN);
assert.same(parseFloat(undefined), NaN);
});
core-js-3.6.1/tests/pure/es.parse-int.js 0000664 0000000 0000000 00000003152 13600575677 0020067 0 ustar 00root root 0000000 0000000 import { WHITESPACES } from '../helpers/constants';
import parseInt from 'core-js-pure/features/parse-int';
QUnit.test('parseInt', assert => {
assert.isFunction(parseInt);
assert.arity(parseInt, 2);
for (let radix = 2; radix <= 36; ++radix) {
assert.same(parseInt('10', radix), radix, `radix ${ radix }`);
}
const strings = ['01', '08', '10', '42'];
for (const string of strings) {
assert.same(parseInt(string), parseInt(string, 10), `default radix is 10: ${ string }`);
}
assert.same(parseInt('0x16'), parseInt('0x16', 16), 'default radix is 16: 0x16');
assert.same(parseInt(' 0x16'), parseInt('0x16', 16), 'ignores leading whitespace #1');
assert.same(parseInt(' 42'), parseInt('42', 10), 'ignores leading whitespace #2');
assert.same(parseInt(' 08'), parseInt('08', 10), 'ignores leading whitespace #3');
assert.same(parseInt(`${ WHITESPACES }08`), parseInt('08', 10), 'ignores leading whitespace #4');
assert.same(parseInt(`${ WHITESPACES }0x16`), parseInt('0x16', 16), 'ignores leading whitespace #5');
const fakeZero = {
valueOf() {
return 0;
},
};
assert.same(parseInt('08', fakeZero), parseInt('08', 10), 'valueOf #1');
assert.same(parseInt('0x16', fakeZero), parseInt('0x16', 16), 'valueOf #2');
assert.same(parseInt('-0xF'), -15, 'signed hex #1');
assert.same(parseInt('-0xF', 16), -15, 'signed hex #2');
assert.same(parseInt('+0xF'), 15, 'signed hex #3');
assert.same(parseInt('+0xF', 16), 15, 'signed hex #4');
assert.same(parseInt('10', -4294967294), 2, 'radix uses ToUint32');
assert.same(parseInt(null), NaN);
assert.same(parseInt(undefined), NaN);
});
core-js-3.6.1/tests/pure/es.promise.all-settled.js 0000664 0000000 0000000 00000001614 13600575677 0022055 0 ustar 00root root 0000000 0000000 import Promise from 'core-js-pure/es/promise';
QUnit.test('Promise.allSettled', assert => {
assert.isFunction(Promise.allSettled);
assert.arity(Promise.allSettled, 1);
assert.ok(Promise.allSettled([1, 2, 3]) instanceof Promise, 'returns a promise');
});
QUnit.test('Promise.allSettled, resolved', assert => {
assert.expect(1);
const async = assert.async();
Promise.allSettled([
Promise.resolve(1),
Promise.reject(2),
Promise.resolve(3),
]).then(it => {
assert.deepEqual(it, [
{ value: 1, status: 'fulfilled' },
{ reason: 2, status: 'rejected' },
{ value: 3, status: 'fulfilled' },
], 'resolved with a correct value');
async();
});
});
QUnit.test('Promise.allSettled, rejected', assert => {
assert.expect(1);
const async = assert.async();
Promise.allSettled().catch(() => {
assert.ok(true, 'rejected as expected');
async();
});
});
core-js-3.6.1/tests/pure/es.promise.finally.js 0000664 0000000 0000000 00000002331 13600575677 0021276 0 ustar 00root root 0000000 0000000 import Promise from 'core-js-pure/features/promise';
QUnit.test('Promise#finally', assert => {
assert.isFunction(Promise.prototype.finally);
assert.arity(Promise.prototype.finally, 1);
assert.nonEnumerable(Promise.prototype, 'finally');
assert.ok(Promise.resolve(42).finally(() => { /* empty */ }) instanceof Promise, 'returns a promise');
});
QUnit.test('Promise#finally, resolved', assert => {
assert.expect(3);
const async = assert.async();
let called = 0;
let argument = null;
Promise.resolve(42).finally(it => {
called++;
argument = it;
}).then(it => {
assert.same(it, 42, 'resolved with a correct value');
assert.same(called, 1, 'onFinally function called one time');
assert.same(argument, undefined, 'onFinally function called with a correct argument');
async();
});
});
QUnit.test('Promise#finally, rejected', assert => {
assert.expect(2);
const async = assert.async();
let called = 0;
let argument = null;
Promise.reject(42).finally(it => {
called++;
argument = it;
}).catch(() => {
assert.same(called, 1, 'onFinally function called one time');
assert.same(argument, undefined, 'onFinally function called with a correct argument');
async();
});
});
core-js-3.6.1/tests/pure/es.promise.js 0000664 0000000 0000000 00000035533 13600575677 0017653 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, PROTO, STRICT } from '../helpers/constants';
import { createIterable } from '../helpers/helpers';
import { Promise, Symbol } from 'core-js-pure';
import getIteratorMethod from 'core-js-pure/features/get-iterator-method';
import { setPrototypeOf, create } from 'core-js-pure/features/object';
import bind from 'core-js-pure/features/function/bind';
QUnit.test('Promise', assert => {
assert.isFunction(Promise);
assert.throws(() => {
Promise();
}, 'throws w/o `new`');
new Promise(function (resolve, reject) {
assert.isFunction(resolve, 'resolver is function');
assert.isFunction(reject, 'rejector is function');
if (STRICT) assert.same(this, undefined, 'correct executor context');
});
});
if (DESCRIPTORS) QUnit.test('Promise operations order', assert => {
let resolve, resolve2;
assert.expect(1);
const EXPECTED_ORDER = 'DEHAFGBC';
const async = assert.async();
let result = '';
const promise1 = new Promise(r => {
resolve = r;
});
resolve({
then() {
result += 'A';
throw Error();
},
});
promise1.catch(() => {
result += 'B';
});
promise1.catch(() => {
result += 'C';
assert.same(result, EXPECTED_ORDER);
async();
});
const promise2 = new Promise(r => {
resolve2 = r;
});
resolve2(Object.defineProperty({}, 'then', {
get() {
result += 'D';
throw Error();
},
}));
result += 'E';
promise2.catch(() => {
result += 'F';
});
promise2.catch(() => {
result += 'G';
});
result += 'H';
setTimeout(() => {
if (!~result.indexOf('C')) {
assert.same(result, EXPECTED_ORDER);
async();
}
}, 1e3);
});
QUnit.test('Promise#then', assert => {
assert.isFunction(Promise.prototype.then);
assert.nonEnumerable(Promise.prototype, 'then');
let promise = new Promise(resolve => {
resolve(42);
});
let FakePromise1 = promise.constructor = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
const FakePromise2 = FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
assert.ok(promise.then(() => { /* empty */ }) instanceof FakePromise2, 'subclassing, @@species pattern');
promise = new Promise(resolve => {
resolve(42);
});
promise.constructor = FakePromise1 = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
assert.ok(promise.then(() => { /* empty */ }) instanceof Promise, 'subclassing, incorrect `this` pattern');
promise = new Promise(resolve => {
resolve(42);
});
promise.constructor = FakePromise1 = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
FakePromise1[Symbol.species] = function () { /* empty */ };
assert.throws(() => {
promise.then(() => { /* empty */ });
}, 'NewPromiseCapability validations, #1');
FakePromise1[Symbol.species] = function (executor) {
executor(null, () => { /* empty */ });
};
assert.throws(() => {
promise.then(() => { /* empty */ });
}, 'NewPromiseCapability validations, #2');
FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, null);
};
assert.throws(() => {
promise.then(() => { /* empty */ });
}, 'NewPromiseCapability validations, #3');
});
QUnit.test('Promise#catch', assert => {
assert.isFunction(Promise.prototype.catch);
assert.nonEnumerable(Promise.prototype, 'catch');
let promise = new Promise(resolve => {
resolve(42);
});
let FakePromise1 = promise.constructor = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
const FakePromise2 = FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
assert.ok(promise.catch(() => { /* empty */ }) instanceof FakePromise2, 'subclassing, @@species pattern');
promise = new Promise(resolve => {
resolve(42);
});
promise.constructor = FakePromise1 = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
assert.ok(promise.catch(() => { /* empty */ }) instanceof Promise, 'subclassing, incorrect `this` pattern');
promise = new Promise(resolve => {
resolve(42);
});
promise.constructor = FakePromise1 = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
FakePromise1[Symbol.species] = function () { /* empty */ };
assert.throws(() => {
promise.catch(() => { /* empty */ });
}, 'NewPromiseCapability validations, #1');
FakePromise1[Symbol.species] = function (executor) {
executor(null, () => { /* empty */ });
};
assert.throws(() => {
promise.catch(() => { /* empty */ });
}, 'NewPromiseCapability validations, #2');
FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, null);
};
assert.throws(() => {
promise.catch(() => { /* empty */ });
}, 'NewPromiseCapability validations, #3');
assert.same(Promise.prototype.catch.call({
then(x, y) {
return y;
},
}, 42), 42, 'calling `.then`');
});
QUnit.test('Promise#@@toStringTag', assert => {
assert.ok(Promise.prototype[Symbol.toStringTag] === 'Promise', 'Promise::@@toStringTag is `Promise`');
assert.strictEqual(String(new Promise(() => { /* empty */ })), '[object Promise]', 'correct stringification');
});
QUnit.test('Promise.all', assert => {
const { all, resolve } = Promise;
assert.isFunction(all);
assert.arity(all, 1);
const iterable = createIterable([1, 2, 3]);
Promise.all(iterable).catch(() => { /* empty */ });
assert.ok(iterable.received, 'works with iterables: iterator received');
assert.ok(iterable.called, 'works with iterables: next called');
const array = [];
let done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
Promise.all(array);
assert.ok(done);
assert.throws(() => {
all.call(null, []).catch(() => { /* empty */ });
}, TypeError, 'throws without context');
done = false;
try {
Promise.resolve = function () {
throw new Error();
};
Promise.all(createIterable([1, 2, 3], {
return() {
done = true;
},
})).catch(() => { /* empty */ });
} catch (error) { /* empty */ }
Promise.resolve = resolve;
assert.ok(done, 'iteration closing');
let FakePromise1 = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
let FakePromise2 = FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
FakePromise1.resolve = FakePromise2.resolve = bind(Promise.resolve, Promise);
assert.ok(all.call(FakePromise1, [1, 2, 3]) instanceof FakePromise1, 'subclassing, `this` pattern');
FakePromise1 = function () { /* empty */ };
FakePromise2 = function (executor) {
executor(null, () => { /* empty */ });
};
const FakePromise3 = function (executor) {
executor(() => { /* empty */ }, null);
};
FakePromise1.resolve = FakePromise2.resolve = FakePromise3.resolve = bind(Promise.resolve, Promise);
assert.throws(() => {
all.call(FakePromise1, [1, 2, 3]);
}, 'NewPromiseCapability validations, #1');
assert.throws(() => {
all.call(FakePromise2, [1, 2, 3]);
}, 'NewPromiseCapability validations, #2');
assert.throws(() => {
all.call(FakePromise3, [1, 2, 3]);
}, 'NewPromiseCapability validations, #3');
});
QUnit.test('Promise.race', assert => {
const { race, resolve } = Promise;
assert.isFunction(race);
assert.arity(race, 1);
const iterable = createIterable([1, 2, 3]);
Promise.race(iterable).catch(() => { /* empty */ });
assert.ok(iterable.received, 'works with iterables: iterator received');
assert.ok(iterable.called, 'works with iterables: next called');
const array = [];
let done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
Promise.race(array);
assert.ok(done);
assert.throws(() => {
race.call(null, []).catch(() => { /* empty */ });
}, TypeError, 'throws without context');
done = false;
try {
Promise.resolve = function () {
throw new Error();
};
Promise.race(createIterable([1, 2, 3], {
return() {
done = true;
},
})).catch(() => { /* empty */ });
} catch (error) { /* empty */ }
Promise.resolve = resolve;
assert.ok(done, 'iteration closing');
let FakePromise1 = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
let FakePromise2 = FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
FakePromise1.resolve = FakePromise2.resolve = bind(Promise.resolve, Promise);
assert.ok(race.call(FakePromise1, [1, 2, 3]) instanceof FakePromise1, 'subclassing, `this` pattern');
FakePromise1 = function () { /* empty */ };
FakePromise2 = function (executor) {
executor(null, () => { /* empty */ });
};
const FakePromise3 = function (executor) {
executor(() => { /* empty */ }, null);
};
FakePromise1.resolve = FakePromise2.resolve = FakePromise3.resolve = bind(Promise.resolve, Promise);
assert.throws(() => {
race.call(FakePromise1, [1, 2, 3]);
}, 'NewPromiseCapability validations, #1');
assert.throws(() => {
race.call(FakePromise2, [1, 2, 3]);
}, 'NewPromiseCapability validations, #2');
assert.throws(() => {
race.call(FakePromise3, [1, 2, 3]);
}, 'NewPromiseCapability validations, #3');
});
QUnit.test('Promise.resolve', assert => {
const { resolve } = Promise;
assert.isFunction(resolve);
assert.throws(() => {
resolve.call(null, 1).catch(() => { /* empty */ });
}, TypeError, 'throws without context');
function FakePromise1(executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
}
FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
assert.ok(resolve.call(FakePromise1, 42) instanceof FakePromise1, 'subclassing, `this` pattern');
assert.throws(() => {
resolve.call(() => { /* empty */ }, 42);
}, 'NewPromiseCapability validations, #1');
assert.throws(() => {
resolve.call(executor => {
executor(null, () => { /* empty */ });
}, 42);
}, 'NewPromiseCapability validations, #2');
assert.throws(() => {
resolve.call(executor => {
executor(() => { /* empty */ }, null);
}, 42);
}, 'NewPromiseCapability validations, #3');
});
QUnit.test('Promise.reject', assert => {
const { reject } = Promise;
assert.isFunction(reject);
assert.throws(() => {
reject.call(null, 1).catch(() => { /* empty */ });
}, TypeError, 'throws without context');
function FakePromise1(executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
}
FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
assert.ok(reject.call(FakePromise1, 42) instanceof FakePromise1, 'subclassing, `this` pattern');
assert.throws(() => {
reject.call(() => { /* empty */ }, 42);
}, 'NewPromiseCapability validations, #1');
assert.throws(() => {
reject.call(executor => {
executor(null, () => { /* empty */ });
}, 42);
}, 'NewPromiseCapability validations, #2');
assert.throws(() => {
reject.call(executor => {
executor(() => { /* empty */ }, null);
}, 42);
}, 'NewPromiseCapability validations, #3');
});
if (PROTO) QUnit.test('Promise subclassing', assert => {
function SubPromise(executor) {
const self = new Promise(executor);
setPrototypeOf(self, SubPromise.prototype);
self.mine = 'subclass';
return self;
}
setPrototypeOf(SubPromise, Promise);
SubPromise.prototype = create(Promise.prototype);
SubPromise.prototype.constructor = SubPromise;
let promise1 = SubPromise.resolve(5);
assert.strictEqual(promise1.mine, 'subclass');
promise1 = promise1.then(it => {
assert.strictEqual(it, 5);
});
assert.strictEqual(promise1.mine, 'subclass');
let promise2 = new SubPromise(resolve => {
resolve(6);
});
assert.strictEqual(promise2.mine, 'subclass');
promise2 = promise2.then(it => {
assert.strictEqual(it, 6);
});
assert.strictEqual(promise2.mine, 'subclass');
const promise3 = SubPromise.all([promise1, promise2]);
assert.strictEqual(promise3.mine, 'subclass');
assert.ok(promise3 instanceof Promise);
assert.ok(promise3 instanceof SubPromise);
promise3.then(assert.async(), it => {
assert.ok(it, false);
});
});
// qunit@2.5 strange bug
QUnit.skip('Unhandled rejection tracking', assert => {
let done = false;
const resume = assert.async();
if (GLOBAL.process) {
assert.expect(3);
function onunhandledrejection(reason, promise) {
process.removeListener('unhandledRejection', onunhandledrejection);
assert.same(promise, $promise, 'unhandledRejection, promise');
assert.same(reason, 42, 'unhandledRejection, reason');
$promise.catch(() => {
// empty
});
}
function onrejectionhandled(promise) {
process.removeListener('rejectionHandled', onrejectionhandled);
assert.same(promise, $promise, 'rejectionHandled, promise');
done || resume();
done = true;
}
process.on('unhandledRejection', onunhandledrejection);
process.on('rejectionHandled', onrejectionhandled);
} else {
if (GLOBAL.addEventListener) {
assert.expect(8);
function onunhandledrejection(it) {
assert.same(it.promise, $promise, 'addEventListener(unhandledrejection), promise');
assert.same(it.reason, 42, 'addEventListener(unhandledrejection), reason');
GLOBAL.removeEventListener('unhandledrejection', onunhandledrejection);
}
GLOBAL.addEventListener('rejectionhandled', onunhandledrejection);
function onrejectionhandled(it) {
assert.same(it.promise, $promise, 'addEventListener(rejectionhandled), promise');
assert.same(it.reason, 42, 'addEventListener(rejectionhandled), reason');
GLOBAL.removeEventListener('rejectionhandled', onrejectionhandled);
}
GLOBAL.addEventListener('rejectionhandled', onrejectionhandled);
} else assert.expect(4);
GLOBAL.onunhandledrejection = function (it) {
assert.same(it.promise, $promise, 'onunhandledrejection, promise');
assert.same(it.reason, 42, 'onunhandledrejection, reason');
setTimeout(() => {
$promise.catch(() => {
// empty
});
}, 1);
GLOBAL.onunhandledrejection = null;
};
GLOBAL.onrejectionhandled = function (it) {
assert.same(it.promise, $promise, 'onrejectionhandled, promise');
assert.same(it.reason, 42, 'onrejectionhandled, reason');
GLOBAL.onrejectionhandled = null;
done || resume();
done = true;
};
}
Promise.reject(43).catch(() => {
// empty
});
const $promise = Promise.reject(42);
setTimeout(() => {
done || resume();
done = true;
}, 3e3);
});
core-js-3.6.1/tests/pure/es.reflect.apply.js 0000664 0000000 0000000 00000001370 13600575677 0020735 0 ustar 00root root 0000000 0000000 import apply from 'core-js-pure/features/reflect/apply';
QUnit.test('Reflect.apply', assert => {
assert.isFunction(apply);
assert.arity(apply, 3);
if ('name' in apply) {
assert.name(apply, 'apply');
}
assert.strictEqual(apply(Array.prototype.push, [1, 2], [3, 4, 5]), 5);
function F(a, b, c) {
return a + b + c;
}
F.apply = 42;
assert.strictEqual(apply(F, null, ['foo', 'bar', 'baz']), 'foobarbaz', 'works with redefined apply');
assert.throws(() => apply(42, null, []), TypeError, 'throws on primitive');
assert.throws(() => apply(() => { /* empty */ }, null), TypeError, 'throws without third argument');
assert.throws(() => apply(() => { /* empty */ }, null, '123'), TypeError, 'throws on primitive as third argument');
});
core-js-3.6.1/tests/pure/es.reflect.construct.js 0000664 0000000 0000000 00000002335 13600575677 0021636 0 ustar 00root root 0000000 0000000 import construct from 'core-js-pure/features/reflect/construct';
import getPrototypeOf from 'core-js-pure/features/object/get-prototype-of';
QUnit.test('Reflect.construct', assert => {
assert.isFunction(construct);
assert.arity(construct, 2);
if ('name' in construct) {
assert.name(construct, 'construct');
}
function A(a, b, c) {
this.qux = a + b + c;
}
assert.strictEqual(construct(A, ['foo', 'bar', 'baz']).qux, 'foobarbaz', 'basic');
A.apply = 42;
assert.strictEqual(construct(A, ['foo', 'bar', 'baz']).qux, 'foobarbaz', 'works with redefined apply');
const instance = construct(function () {
this.x = 42;
}, [], Array);
assert.strictEqual(instance.x, 42, 'constructor with newTarget');
assert.ok(instance instanceof Array, 'prototype with newTarget');
assert.throws(() => construct(42, []), TypeError, 'throws on primitive');
function B() { /* empty */ }
B.prototype = 42;
assert.notThrows(() => getPrototypeOf(construct(B, [])) === Object.prototype);
assert.notThrows(() => typeof construct(Date, []).getTime() === 'number', 'works with native constructors with 2 arguments');
assert.throws(() => construct(() => { /* empty */ }), 'throws when the second argument is not an object');
});
core-js-3.6.1/tests/pure/es.reflect.define-property.js 0000664 0000000 0000000 00000002470 13600575677 0022726 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import defineProperty from 'core-js-pure/features/reflect/define-property';
import { getOwnPropertyDescriptor, create } from 'core-js-pure/features/object';
QUnit.test('Reflect.defineProperty', assert => {
assert.isFunction(defineProperty);
assert.arity(defineProperty, 3);
if ('name' in defineProperty) {
assert.name(defineProperty, 'defineProperty');
}
let object = {};
assert.strictEqual(defineProperty(object, 'foo', { value: 123 }), true);
assert.strictEqual(object.foo, 123);
if (DESCRIPTORS) {
object = {};
defineProperty(object, 'foo', {
value: 123,
enumerable: true,
});
assert.deepEqual(getOwnPropertyDescriptor(object, 'foo'), {
value: 123,
enumerable: true,
configurable: false,
writable: false,
});
assert.strictEqual(defineProperty(object, 'foo', {
value: 42,
}), false);
}
assert.throws(() => defineProperty(42, 'foo', {
value: 42,
}), TypeError, 'throws on primitive');
assert.throws(() => defineProperty(42, 1, {}));
assert.throws(() => defineProperty({}, create(null), {}));
assert.throws(() => defineProperty({}, 1, 1));
});
QUnit.test('Reflect.defineProperty.sham flag', assert => {
assert.same(defineProperty.sham, DESCRIPTORS ? undefined : true);
});
core-js-3.6.1/tests/pure/es.reflect.delete-property.js 0000664 0000000 0000000 00000001367 13600575677 0022742 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import deleteProperty from 'core-js-pure/features/reflect/delete-property';
import { defineProperty, keys } from 'core-js-pure/features/object';
QUnit.test('Reflect.deleteProperty', assert => {
assert.isFunction(deleteProperty);
assert.arity(deleteProperty, 2);
if ('name' in deleteProperty) {
assert.name(deleteProperty, 'deleteProperty');
}
const object = { bar: 456 };
assert.strictEqual(deleteProperty(object, 'bar'), true);
assert.ok(keys(object).length === 0);
if (DESCRIPTORS) {
assert.strictEqual(deleteProperty(defineProperty({}, 'foo', {
value: 42,
}), 'foo'), false);
}
assert.throws(() => deleteProperty(42, 'foo'), TypeError, 'throws on primitive');
});
core-js-3.6.1/tests/pure/es.reflect.get-own-property-descriptor.js 0000664 0000000 0000000 00000001462 13600575677 0025230 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import getOwnPropertyDescriptor from 'core-js-pure/features/reflect/get-own-property-descriptor';
QUnit.test('Reflect.getOwnPropertyDescriptor', assert => {
assert.isFunction(getOwnPropertyDescriptor);
assert.arity(getOwnPropertyDescriptor, 2);
if ('name' in getOwnPropertyDescriptor) {
assert.name(getOwnPropertyDescriptor, 'getOwnPropertyDescriptor');
}
const object = { baz: 789 };
const descriptor = getOwnPropertyDescriptor(object, 'baz');
assert.strictEqual(descriptor.value, 789);
assert.throws(() => getOwnPropertyDescriptor(42, 'constructor'), TypeError, 'throws on primitive');
});
QUnit.test('Reflect.getOwnPropertyDescriptor.sham flag', assert => {
assert.same(getOwnPropertyDescriptor.sham, DESCRIPTORS ? undefined : true);
});
core-js-3.6.1/tests/pure/es.reflect.get-prototype-of.js 0000664 0000000 0000000 00000001177 13600575677 0023041 0 ustar 00root root 0000000 0000000 import { CORRECT_PROTOTYPE_GETTER } from '../helpers/constants';
import getPrototypeOf from 'core-js-pure/features/reflect/get-prototype-of';
QUnit.test('Reflect.getPrototypeOf', assert => {
assert.isFunction(getPrototypeOf);
assert.arity(getPrototypeOf, 1);
if ('name' in getPrototypeOf) {
assert.name(getPrototypeOf, 'getPrototypeOf');
}
assert.strictEqual(getPrototypeOf([]), Array.prototype);
assert.throws(() => getPrototypeOf(42), TypeError, 'throws on primitive');
});
QUnit.test('Reflect.getPrototypeOf.sham flag', assert => {
assert.same(getPrototypeOf.sham, CORRECT_PROTOTYPE_GETTER ? undefined : true);
});
core-js-3.6.1/tests/pure/es.reflect.get.js 0000664 0000000 0000000 00000002040 13600575677 0020362 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import get from 'core-js-pure/features/reflect/get';
import { defineProperty, create } from 'core-js-pure/features/object';
QUnit.test('Reflect.get', assert => {
assert.isFunction(get);
if ('name' in get) {
assert.name(get, 'get');
}
assert.strictEqual(get({ qux: 987 }, 'qux'), 987);
if (DESCRIPTORS) {
const target = create(defineProperty({ z: 3 }, 'w', {
get() {
return this;
},
}), {
x: {
value: 1,
},
y: {
get() {
return this;
},
},
});
const receiver = {};
assert.strictEqual(get(target, 'x', receiver), 1, 'get x');
assert.strictEqual(get(target, 'y', receiver), receiver, 'get y');
assert.strictEqual(get(target, 'z', receiver), 3, 'get z');
assert.strictEqual(get(target, 'w', receiver), receiver, 'get w');
assert.strictEqual(get(target, 'u', receiver), undefined, 'get u');
}
assert.throws(() => get(42, 'constructor'), TypeError, 'throws on primitive');
});
core-js-3.6.1/tests/pure/es.reflect.has.js 0000664 0000000 0000000 00000000720 13600575677 0020361 0 ustar 00root root 0000000 0000000 import has from 'core-js-pure/features/reflect/has';
QUnit.test('Reflect.has', assert => {
assert.isFunction(has);
assert.arity(has, 2);
if ('name' in has) {
assert.name(has, 'has');
}
const object = { qux: 987 };
assert.strictEqual(has(object, 'qux'), true);
assert.strictEqual(has(object, 'qwe'), false);
assert.strictEqual(has(object, 'toString'), true);
assert.throws(() => has(42, 'constructor'), TypeError, 'throws on primitive');
});
core-js-3.6.1/tests/pure/es.reflect.is-extensible.js 0000664 0000000 0000000 00000001121 13600575677 0022355 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import isExtensible from 'core-js-pure/features/reflect/is-extensible';
import preventExtensions from 'core-js-pure/features/object/prevent-extensions';
QUnit.test('Reflect.isExtensible', assert => {
assert.isFunction(isExtensible);
assert.arity(isExtensible, 1);
if ('name' in isExtensible) {
assert.name(isExtensible, 'isExtensible');
}
assert.ok(isExtensible({}));
if (DESCRIPTORS) {
assert.ok(!isExtensible(preventExtensions({})));
}
assert.throws(() => isExtensible(42), TypeError, 'throws on primitive');
});
core-js-3.6.1/tests/pure/es.reflect.own-keys.js 0000664 0000000 0000000 00000001763 13600575677 0021372 0 ustar 00root root 0000000 0000000 import { includes } from '../helpers/helpers';
import Symbol from 'core-js-pure/features/symbol';
import ownKeys from 'core-js-pure/features/reflect/own-keys';
import { defineProperty, create } from 'core-js-pure/features/object';
QUnit.test('Reflect.ownKeys', assert => {
assert.isFunction(ownKeys);
assert.arity(ownKeys, 1);
if ('name' in ownKeys) {
assert.name(ownKeys, 'ownKeys');
}
const object = { a: 1 };
defineProperty(object, 'b', {
value: 2,
});
object[Symbol('c')] = 3;
let keys = ownKeys(object);
assert.strictEqual(keys.length, 3, 'ownKeys return all own keys');
assert.ok(includes(keys, 'a'), 'ownKeys return all own keys: simple');
assert.ok(includes(keys, 'b'), 'ownKeys return all own keys: hidden');
assert.strictEqual(object[keys[2]], 3, 'ownKeys return all own keys: symbol');
keys = ownKeys(create(object));
assert.strictEqual(keys.length, 0, 'ownKeys return only own keys');
assert.throws(() => ownKeys(42), TypeError, 'throws on primitive');
});
core-js-3.6.1/tests/pure/es.reflect.prevent-extensions.js 0000664 0000000 0000000 00000001432 13600575677 0023467 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, FREEZING } from '../helpers/constants';
import preventExtensions from 'core-js-pure/features/reflect/prevent-extensions';
import isExtensible from 'core-js-pure/features/object/is-extensible';
QUnit.test('Reflect.preventExtensions', assert => {
assert.isFunction(preventExtensions);
assert.arity(preventExtensions, 1);
if ('name' in preventExtensions) {
assert.name(preventExtensions, 'preventExtensions');
}
const object = {};
assert.ok(preventExtensions(object), true);
if (DESCRIPTORS) {
assert.ok(!isExtensible(object));
}
assert.throws(() => preventExtensions(42), TypeError, 'throws on primitive');
});
QUnit.test('Reflect.preventExtensions.sham flag', assert => {
assert.same(preventExtensions.sham, FREEZING ? undefined : true);
});
core-js-3.6.1/tests/pure/es.reflect.set-prototype-of.js 0000664 0000000 0000000 00000001241 13600575677 0023045 0 ustar 00root root 0000000 0000000 import { PROTO } from '../helpers/constants';
import setPrototypeOf from 'core-js-pure/features/reflect/set-prototype-of';
if (PROTO) QUnit.test('Reflect.setPrototypeOf', assert => {
assert.isFunction(setPrototypeOf);
if ('name' in setPrototypeOf) {
assert.name(setPrototypeOf, 'setPrototypeOf');
}
let object = {};
assert.ok(setPrototypeOf(object, Array.prototype), true);
assert.ok(object instanceof Array);
assert.throws(() => setPrototypeOf({}, 42), TypeError);
assert.throws(() => setPrototypeOf(42, {}), TypeError, 'throws on primitive');
object = {};
assert.ok(setPrototypeOf(object, object) === false, 'false on recursive __proto__');
});
core-js-3.6.1/tests/pure/es.reflect.set.js 0000664 0000000 0000000 00000005376 13600575677 0020415 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import set from 'core-js-pure/features/reflect/set';
import { defineProperty, getOwnPropertyDescriptor, create, getPrototypeOf } from 'core-js-pure/features/object';
QUnit.test('Reflect.set', assert => {
assert.isFunction(set);
if ('name' in set) {
assert.name(set, 'set');
}
const object = {};
assert.ok(set(object, 'quux', 654), true);
assert.strictEqual(object.quux, 654);
let target = {};
const receiver = {};
set(target, 'foo', 1, receiver);
assert.strictEqual(target.foo, undefined, 'target.foo === undefined');
assert.strictEqual(receiver.foo, 1, 'receiver.foo === 1');
if (DESCRIPTORS) {
defineProperty(receiver, 'bar', {
value: 0,
writable: true,
enumerable: false,
configurable: true,
});
set(target, 'bar', 1, receiver);
assert.strictEqual(receiver.bar, 1, 'receiver.bar === 1');
assert.strictEqual(getOwnPropertyDescriptor(receiver, 'bar').enumerable, false, 'enumerability not overridden');
let out = null;
target = create(defineProperty({ z: 3 }, 'w', {
set() {
out = this;
},
}), {
x: {
value: 1,
writable: true,
configurable: true,
},
y: {
set() {
out = this;
},
},
c: {
value: 1,
writable: false,
configurable: false,
},
});
assert.strictEqual(set(target, 'x', 2, target), true, 'set x');
assert.strictEqual(target.x, 2, 'set x');
out = null;
assert.strictEqual(set(target, 'y', 2, target), true, 'set y');
assert.strictEqual(out, target, 'set y');
assert.strictEqual(set(target, 'z', 4, target), true);
assert.strictEqual(target.z, 4, 'set z');
out = null;
assert.strictEqual(set(target, 'w', 1, target), true, 'set w');
assert.strictEqual(out, target, 'set w');
assert.strictEqual(set(target, 'u', 0, target), true, 'set u');
assert.strictEqual(target.u, 0, 'set u');
assert.strictEqual(set(target, 'c', 2, target), false, 'set c');
assert.strictEqual(target.c, 1, 'set c');
// https://github.com/zloirock/core-js/issues/392
let o = defineProperty({}, 'test', {
writable: false,
configurable: true,
});
assert.strictEqual(set(getPrototypeOf(o), 'test', 1, o), false);
// https://github.com/zloirock/core-js/issues/393
o = defineProperty({}, 'test', {
get() { /* empty */ },
});
assert.notThrows(() => !set(getPrototypeOf(o), 'test', 1, o));
o = defineProperty({}, 'test', {
// eslint-disable-next-line no-unused-vars
set(v) { /* empty */ },
});
assert.notThrows(() => !set(getPrototypeOf(o), 'test', 1, o));
}
assert.throws(() => set(42, 'q', 42), TypeError, 'throws on primitive');
});
core-js-3.6.1/tests/pure/es.set.js 0000664 0000000 0000000 00000024440 13600575677 0016763 0 ustar 00root root 0000000 0000000 /* eslint-disable sonarjs/no-element-overwrite */
import { createIterable, is, nativeSubclass } from '../helpers/helpers';
import { DESCRIPTORS } from '../helpers/constants';
import { Set, Map, Symbol } from 'core-js-pure';
import getIterator from 'core-js-pure/features/get-iterator';
import getIteratorMethod from 'core-js-pure/features/get-iterator-method';
import { freeze, getOwnPropertyDescriptor, keys, getOwnPropertyNames, getOwnPropertySymbols } from 'core-js-pure/features/object';
import ownKeys from 'core-js-pure/features/reflect/own-keys';
import from from 'core-js-pure/features/array/from';
QUnit.test('Set', assert => {
assert.isFunction(Set);
assert.ok('add' in Set.prototype, 'add in Set.prototype');
assert.ok('clear' in Set.prototype, 'clear in Set.prototype');
assert.ok('delete' in Set.prototype, 'delete in Set.prototype');
assert.ok('forEach' in Set.prototype, 'forEach in Set.prototype');
assert.ok('has' in Set.prototype, 'has in Set.prototype');
assert.ok(new Set() instanceof Set, 'new Set instanceof Set');
const set = new Set();
set.add(1);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
assert.strictEqual(set.size, 3);
const result = [];
set.forEach(val => {
result.push(val);
});
assert.deepEqual(result, [1, 2, 3]);
assert.strictEqual(new Set(createIterable([1, 2, 3])).size, 3, 'Init from iterable');
assert.strictEqual(new Set([freeze({}), 1]).size, 2, 'Support frozen objects');
assert.strictEqual(new Set([NaN, NaN, NaN]).size, 1);
assert.deepEqual(from(new Set([3, 4]).add(2).add(1)), [3, 4, 2, 1]);
let done = false;
const { add } = Set.prototype;
Set.prototype.add = function () {
throw new Error();
};
try {
new Set(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
Set.prototype.add = add;
assert.ok(done, '.return #throw');
const array = [];
done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
new Set(array);
assert.ok(done);
const object = {};
new Set().add(object);
if (DESCRIPTORS) {
const results = [];
for (const key in results) keys.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(Set);
assert.ok(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.ok(new Subclass() instanceof Set, 'correct subclassing with native classes #2');
assert.ok(new Subclass().add(2).has(2), 'correct subclassing with native classes #3');
}
});
QUnit.test('Set#add', assert => {
assert.isFunction(Set.prototype.add);
const array = [];
let set = new Set();
set.add(NaN);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.add(array);
assert.strictEqual(set.size, 5);
const chain = set.add(NaN);
assert.strictEqual(chain, set);
assert.strictEqual(set.size, 5);
set.add(2);
assert.strictEqual(set.size, 5);
set.add(array);
assert.strictEqual(set.size, 5);
set.add([]);
assert.strictEqual(set.size, 6);
set.add(4);
assert.strictEqual(set.size, 7);
const frozen = freeze({});
set = new Set();
set.add(frozen);
assert.ok(set.has(frozen));
});
QUnit.test('Set#clear', assert => {
assert.isFunction(Set.prototype.clear);
let set = new Set();
set.clear();
assert.strictEqual(set.size, 0);
set = new Set();
set.add(1);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.clear();
assert.strictEqual(set.size, 0);
assert.ok(!set.has(1));
assert.ok(!set.has(2));
assert.ok(!set.has(3));
const frozen = freeze({});
set = new Set();
set.add(1);
set.add(frozen);
set.clear();
assert.strictEqual(set.size, 0, 'Support frozen objects');
assert.ok(!set.has(1));
assert.ok(!set.has(frozen));
});
QUnit.test('Set#delete', assert => {
assert.isFunction(Set.prototype.delete);
const array = [];
const set = new Set();
set.add(NaN);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.add(array);
assert.strictEqual(set.size, 5);
assert.strictEqual(set.delete(NaN), true);
assert.strictEqual(set.size, 4);
assert.strictEqual(set.delete(4), false);
assert.strictEqual(set.size, 4);
set.delete([]);
assert.strictEqual(set.size, 4);
set.delete(array);
assert.strictEqual(set.size, 3);
const frozen = freeze({});
set.add(frozen);
assert.strictEqual(set.size, 4);
set.delete(frozen);
assert.strictEqual(set.size, 3);
});
QUnit.test('Set#forEach', assert => {
assert.isFunction(Set.prototype.forEach);
let result = [];
let count = 0;
let set = new Set();
set.add(1);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.forEach(value => {
count++;
result.push(value);
});
assert.strictEqual(count, 3);
assert.deepEqual(result, [1, 2, 3]);
set = new Set();
set.add('0');
set.add('1');
set.add('2');
set.add('3');
result = '';
set.forEach(it => {
result += it;
if (it === '2') {
set.delete('2');
set.delete('3');
set.delete('1');
set.add('4');
}
});
assert.strictEqual(result, '0124');
set = new Set();
set.add('0');
result = '';
set.forEach(it => {
set.delete('0');
if (result !== '') throw new Error();
result += it;
});
assert.strictEqual(result, '0');
assert.throws(() => {
Set.prototype.forEach.call(new Map(), () => { /* empty */ });
}, 'non-generic');
});
QUnit.test('Set#has', assert => {
assert.isFunction(Set.prototype.has);
const array = [];
const frozen = freeze({});
const set = new Set();
set.add(NaN);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.add(frozen);
set.add(array);
assert.ok(set.has(NaN));
assert.ok(set.has(array));
assert.ok(set.has(frozen));
assert.ok(set.has(2));
assert.ok(!set.has(4));
assert.ok(!set.has([]));
});
QUnit.test('Set#size', assert => {
const set = new Set();
set.add(1);
const { size } = set;
assert.strictEqual(typeof size, 'number', 'size is number');
assert.strictEqual(size, 1, 'size is correct');
if (DESCRIPTORS) {
const sizeDescriptor = getOwnPropertyDescriptor(Set.prototype, 'size');
assert.ok(sizeDescriptor && sizeDescriptor.get, 'size is getter');
assert.ok(sizeDescriptor && !sizeDescriptor.set, 'size isnt setter');
assert.throws(() => {
Set.prototype.size;
}, TypeError);
}
});
QUnit.test('Set & -0', assert => {
let set = new Set();
set.add(-0);
assert.strictEqual(set.size, 1);
assert.ok(set.has(0));
assert.ok(set.has(-0));
set.forEach(it => {
assert.ok(!is(it, -0));
});
set.delete(-0);
assert.strictEqual(set.size, 0);
set = new Set([-0]);
set.forEach(key => {
assert.ok(!is(key, -0));
});
set = new Set();
set.add(4);
set.add(3);
set.add(2);
set.add(1);
set.add(0);
assert.ok(set.has(-0));
});
QUnit.test('Set#@@toStringTag', assert => {
assert.strictEqual(Set.prototype[Symbol.toStringTag], 'Set', 'Set::@@toStringTag is `Set`');
assert.strictEqual(String(new Set()), '[object Set]', 'correct stringification');
});
QUnit.test('Set Iterator', assert => {
const set = new Set();
set.add('a');
set.add('b');
set.add('c');
set.add('d');
const results = [];
const iterator = set.keys();
results.push(iterator.next().value);
assert.ok(set.delete('a'));
assert.ok(set.delete('b'));
assert.ok(set.delete('c'));
set.add('e');
results.push(iterator.next().value);
results.push(iterator.next().value);
assert.ok(iterator.next().done);
set.add('f');
assert.ok(iterator.next().done);
assert.deepEqual(results, ['a', 'd', 'e']);
});
QUnit.test('Set#keys', assert => {
assert.isFunction(Set.prototype.keys);
const set = new Set();
set.add('q');
set.add('w');
set.add('e');
const iterator = set.keys();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Set Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Set#values', assert => {
assert.isFunction(Set.prototype.values);
const set = new Set();
set.add('q');
set.add('w');
set.add('e');
const iterator = set.values();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Set Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Set#entries', assert => {
assert.isFunction(Set.prototype.entries);
const set = new Set();
set.add('q');
set.add('w');
set.add('e');
const iterator = set.entries();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Set Iterator');
assert.deepEqual(iterator.next(), {
value: ['q', 'q'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['w', 'w'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['e', 'e'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Set#@@iterator', assert => {
const set = new Set();
set.add('q');
set.add('w');
set.add('e');
const iterator = getIterator(set);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Set Iterator');
assert.strictEqual(String(iterator), '[object Set Iterator]');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
core-js-3.6.1/tests/pure/es.string.anchor.js 0000664 0000000 0000000 00000000424 13600575677 0020743 0 ustar 00root root 0000000 0000000 import anchor from 'core-js-pure/features/string/anchor';
QUnit.test('String#anchor', assert => {
assert.isFunction(anchor);
assert.same(anchor('a', 'b'), ' a ', 'lower case');
assert.same(anchor('a', '"'), 'a ', 'escape quotes');
});
core-js-3.6.1/tests/pure/es.string.big.js 0000664 0000000 0000000 00000000257 13600575677 0020236 0 ustar 00root root 0000000 0000000 import big from 'core-js-pure/features/string/big';
QUnit.test('String#big', assert => {
assert.isFunction(big);
assert.same(big('a'), 'a ', 'lower case');
});
core-js-3.6.1/tests/pure/es.string.blink.js 0000664 0000000 0000000 00000000275 13600575677 0020574 0 ustar 00root root 0000000 0000000 import blink from 'core-js-pure/features/string/blink';
QUnit.test('String#blink', assert => {
assert.isFunction(blink);
assert.same(blink('a'), 'a ', 'lower case');
});
core-js-3.6.1/tests/pure/es.string.bold.js 0000664 0000000 0000000 00000000260 13600575677 0020407 0 ustar 00root root 0000000 0000000 import bold from 'core-js-pure/features/string/bold';
QUnit.test('String#bold', assert => {
assert.isFunction(bold);
assert.same(bold('a'), 'a ', 'lower case');
});
core-js-3.6.1/tests/pure/es.string.code-point-at.js 0000664 0000000 0000000 00000006767 13600575677 0022154 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import codePointAt from 'core-js-pure/features/string/code-point-at';
QUnit.test('String#codePointAt', assert => {
assert.isFunction(codePointAt);
assert.strictEqual(codePointAt('abc\uD834\uDF06def', ''), 0x61);
assert.strictEqual(codePointAt('abc\uD834\uDF06def', '_'), 0x61);
assert.strictEqual(codePointAt('abc\uD834\uDF06def'), 0x61);
assert.strictEqual(codePointAt('abc\uD834\uDF06def', -Infinity), undefined);
assert.strictEqual(codePointAt('abc\uD834\uDF06def', -1), undefined);
assert.strictEqual(codePointAt('abc\uD834\uDF06def', -0), 0x61);
assert.strictEqual(codePointAt('abc\uD834\uDF06def', 0), 0x61);
assert.strictEqual(codePointAt('abc\uD834\uDF06def', 3), 0x1D306);
assert.strictEqual(codePointAt('abc\uD834\uDF06def', 4), 0xDF06);
assert.strictEqual(codePointAt('abc\uD834\uDF06def', 5), 0x64);
assert.strictEqual(codePointAt('abc\uD834\uDF06def', 42), undefined);
assert.strictEqual(codePointAt('abc\uD834\uDF06def', Infinity), undefined);
assert.strictEqual(codePointAt('abc\uD834\uDF06def', Infinity), undefined);
assert.strictEqual(codePointAt('abc\uD834\uDF06def', NaN), 0x61);
assert.strictEqual(codePointAt('abc\uD834\uDF06def', false), 0x61);
assert.strictEqual(codePointAt('abc\uD834\uDF06def', null), 0x61);
assert.strictEqual(codePointAt('abc\uD834\uDF06def', undefined), 0x61);
assert.strictEqual(codePointAt('\uD834\uDF06def', ''), 0x1D306);
assert.strictEqual(codePointAt('\uD834\uDF06def', '1'), 0xDF06);
assert.strictEqual(codePointAt('\uD834\uDF06def', '_'), 0x1D306);
assert.strictEqual(codePointAt('\uD834\uDF06def'), 0x1D306);
assert.strictEqual(codePointAt('\uD834\uDF06def', -1), undefined);
assert.strictEqual(codePointAt('\uD834\uDF06def', -0), 0x1D306);
assert.strictEqual(codePointAt('\uD834\uDF06def', 0), 0x1D306);
assert.strictEqual(codePointAt('\uD834\uDF06def', 1), 0xDF06);
assert.strictEqual(codePointAt('\uD834\uDF06def', 42), undefined);
assert.strictEqual(codePointAt('\uD834\uDF06def', false), 0x1D306);
assert.strictEqual(codePointAt('\uD834\uDF06def', null), 0x1D306);
assert.strictEqual(codePointAt('\uD834\uDF06def', undefined), 0x1D306);
assert.strictEqual(codePointAt('\uD834abc', ''), 0xD834);
assert.strictEqual(codePointAt('\uD834abc', '_'), 0xD834);
assert.strictEqual(codePointAt('\uD834abc'), 0xD834);
assert.strictEqual(codePointAt('\uD834abc', -1), undefined);
assert.strictEqual(codePointAt('\uD834abc', -0), 0xD834);
assert.strictEqual(codePointAt('\uD834abc', 0), 0xD834);
assert.strictEqual(codePointAt('\uD834abc', false), 0xD834);
assert.strictEqual(codePointAt('\uD834abc', NaN), 0xD834);
assert.strictEqual(codePointAt('\uD834abc', null), 0xD834);
assert.strictEqual(codePointAt('\uD834abc', undefined), 0xD834);
assert.strictEqual(codePointAt('\uDF06abc', ''), 0xDF06);
assert.strictEqual(codePointAt('\uDF06abc', '_'), 0xDF06);
assert.strictEqual(codePointAt('\uDF06abc'), 0xDF06);
assert.strictEqual(codePointAt('\uDF06abc', -1), undefined);
assert.strictEqual(codePointAt('\uDF06abc', -0), 0xDF06);
assert.strictEqual(codePointAt('\uDF06abc', 0), 0xDF06);
assert.strictEqual(codePointAt('\uDF06abc', false), 0xDF06);
assert.strictEqual(codePointAt('\uDF06abc', NaN), 0xDF06);
assert.strictEqual(codePointAt('\uDF06abc', null), 0xDF06);
assert.strictEqual(codePointAt('\uDF06abc', undefined), 0xDF06);
if (STRICT) {
assert.throws(() => codePointAt(null, 0), TypeError);
assert.throws(() => codePointAt(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/pure/es.string.ends-with.js 0000664 0000000 0000000 00000002323 13600575677 0021373 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import Symbol from 'core-js-pure/features/symbol';
import endsWith from 'core-js-pure/features/string/ends-with';
QUnit.test('String#endsWith', assert => {
assert.isFunction(endsWith);
assert.ok(endsWith('undefined'));
assert.ok(!endsWith('undefined', null));
assert.ok(endsWith('abc', ''));
assert.ok(endsWith('abc', 'c'));
assert.ok(endsWith('abc', 'bc'));
assert.ok(!endsWith('abc', 'ab'));
assert.ok(endsWith('abc', '', NaN));
assert.ok(!endsWith('abc', 'c', -1));
assert.ok(endsWith('abc', 'a', 1));
assert.ok(endsWith('abc', 'c', Infinity));
assert.ok(endsWith('abc', 'a', true));
assert.ok(!endsWith('abc', 'c', 'x'));
assert.ok(!endsWith('abc', 'a', 'x'));
if (STRICT) {
assert.throws(() => endsWith(null, '.'), TypeError);
assert.throws(() => endsWith(undefined, '.'), TypeError);
}
const regexp = /./;
assert.throws(() => endsWith('/./', regexp), TypeError);
regexp[Symbol.match] = false;
assert.notThrows(() => endsWith('/./', regexp));
const object = {};
assert.notThrows(() => endsWith('[object Object]', object));
object[Symbol.match] = true;
assert.throws(() => endsWith('[object Object]', object), TypeError);
});
core-js-3.6.1/tests/pure/es.string.fixed.js 0000664 0000000 0000000 00000000267 13600575677 0020575 0 ustar 00root root 0000000 0000000 import fixed from 'core-js-pure/features/string/fixed';
QUnit.test('String#fixed', assert => {
assert.isFunction(fixed);
assert.same(fixed('a'), 'a ', 'lower case');
});
core-js-3.6.1/tests/pure/es.string.fontcolor.js 0000664 0000000 0000000 00000000464 13600575677 0021502 0 ustar 00root root 0000000 0000000 import fontcolor from 'core-js-pure/features/string/fontcolor';
QUnit.test('String#fontcolor', assert => {
assert.isFunction(fontcolor);
assert.same(fontcolor('a', 'b'), 'a ', 'lower case');
assert.same(fontcolor('a', '"'), 'a ', 'escape quotes');
});
core-js-3.6.1/tests/pure/es.string.fontsize.js 0000664 0000000 0000000 00000000454 13600575677 0021335 0 ustar 00root root 0000000 0000000 import fontsize from 'core-js-pure/features/string/fontsize';
QUnit.test('String#fontsize', assert => {
assert.isFunction(fontsize);
assert.same(fontsize('a', 'b'), 'a ', 'lower case');
assert.same(fontsize('a', '"'), 'a ', 'escape quotes');
});
core-js-3.6.1/tests/pure/es.string.from-code-point.js 0000664 0000000 0000000 00000003764 13600575677 0022505 0 ustar 00root root 0000000 0000000 import fromCodePoint from 'core-js-pure/features/string/from-code-point';
QUnit.test('String.fromCodePoint', assert => {
assert.isFunction(fromCodePoint);
assert.arity(fromCodePoint, 1);
if ('name' in fromCodePoint) {
assert.name(fromCodePoint, 'fromCodePoint');
}
assert.strictEqual(fromCodePoint(''), '\0');
assert.strictEqual(fromCodePoint(), '');
assert.strictEqual(fromCodePoint(-0), '\0');
assert.strictEqual(fromCodePoint(0), '\0');
assert.strictEqual(fromCodePoint(0x1D306), '\uD834\uDF06');
assert.strictEqual(fromCodePoint(0x1D306, 0x61, 0x1D307), '\uD834\uDF06a\uD834\uDF07');
assert.strictEqual(fromCodePoint(0x61, 0x62, 0x1D307), 'ab\uD834\uDF07');
assert.strictEqual(fromCodePoint(false), '\0');
assert.strictEqual(fromCodePoint(null), '\0');
assert.throws(() => fromCodePoint('_'), RangeError);
assert.throws(() => fromCodePoint('+Infinity'), RangeError);
assert.throws(() => fromCodePoint('-Infinity'), RangeError);
assert.throws(() => fromCodePoint(-1), RangeError);
assert.throws(() => fromCodePoint(0x10FFFF + 1), RangeError);
assert.throws(() => fromCodePoint(3.14), RangeError);
assert.throws(() => fromCodePoint(3e-2), RangeError);
assert.throws(() => fromCodePoint(-Infinity), RangeError);
assert.throws(() => fromCodePoint(Infinity), RangeError);
assert.throws(() => fromCodePoint(NaN), RangeError);
assert.throws(() => fromCodePoint(undefined), RangeError);
assert.throws(() => fromCodePoint({}), RangeError);
assert.throws(() => fromCodePoint(/./), RangeError);
let number = 0x60;
assert.strictEqual(fromCodePoint({
valueOf() {
return ++number;
},
}), 'a');
assert.strictEqual(number, 0x61);
// one code unit per symbol
let counter = 2 ** 15 * 3 / 2;
let result = [];
while (--counter >= 0) result.push(0);
// should not throw
fromCodePoint.apply(null, result);
counter = 2 ** 15 * 3 / 2;
result = [];
while (--counter >= 0) result.push(0xFFFF + 1);
// should not throw
fromCodePoint.apply(null, result);
});
core-js-3.6.1/tests/pure/es.string.includes.js 0000664 0000000 0000000 00000001510 13600575677 0021274 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import Symbol from 'core-js-pure/features/symbol';
import includes from 'core-js-pure/features/string/includes';
QUnit.test('String#includes', assert => {
assert.isFunction(includes);
assert.ok(!includes('abc'));
assert.ok(includes('aundefinedb'));
assert.ok(includes('abcd', 'b', 1));
assert.ok(!includes('abcd', 'b', 2));
if (STRICT) {
assert.throws(() => includes(null, '.'), TypeError);
assert.throws(() => includes(undefined, '.'), TypeError);
}
const re = /./;
assert.throws(() => includes('/./', re), TypeError);
re[Symbol.match] = false;
assert.notThrows(() => includes('/./', re));
const O = {};
assert.notThrows(() => includes('[object Object]', O));
O[Symbol.match] = true;
assert.throws(() => includes('[object Object]', O), TypeError);
});
core-js-3.6.1/tests/pure/es.string.italics.js 0000664 0000000 0000000 00000000277 13600575677 0021127 0 ustar 00root root 0000000 0000000 import italics from 'core-js-pure/features/string/italics';
QUnit.test('String#italics', assert => {
assert.isFunction(italics);
assert.same(italics('a'), 'a ', 'lower case');
});
core-js-3.6.1/tests/pure/es.string.iterator.js 0000664 0000000 0000000 00000002201 13600575677 0021315 0 ustar 00root root 0000000 0000000 import Symbol from 'core-js-pure/features/symbol';
import getIterator from 'core-js-pure/features/get-iterator';
import from from 'core-js-pure/features/array/from';
QUnit.test('String#@@iterator', assert => {
let iterator = getIterator('qwe');
assert.isIterator(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'String Iterator');
assert.strictEqual(String(iterator), '[object String Iterator]');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.strictEqual(from('𠮷𠮷𠮷').length, 3);
iterator = getIterator('𠮷𠮷𠮷');
assert.deepEqual(iterator.next(), {
value: '𠮷',
done: false,
});
assert.deepEqual(iterator.next(), {
value: '𠮷',
done: false,
});
assert.deepEqual(iterator.next(), {
value: '𠮷',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
core-js-3.6.1/tests/pure/es.string.link.js 0000664 0000000 0000000 00000000410 13600575677 0020421 0 ustar 00root root 0000000 0000000 import link from 'core-js-pure/features/string/link';
QUnit.test('String#link', assert => {
assert.isFunction(link);
assert.same(link('a', 'b'), 'a ', 'lower case');
assert.same(link('a', '"'), 'a ', 'escape quotes');
});
core-js-3.6.1/tests/pure/es.string.match-all.js 0000664 0000000 0000000 00000006515 13600575677 0021342 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import matchAll from 'core-js-pure/es/string/match-all';
import Symbol from 'core-js-pure/es/symbol';
import assign from 'core-js-pure/es/object/assign';
QUnit.test('String#matchAll', assert => {
assert.isFunction(matchAll);
let data = ['aabc', { toString() {
return 'aabc';
} }];
for (const target of data) {
const iterator = matchAll(target, /[ac]/g);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: assign(['a'], {
input: 'aabc',
index: 0,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['a'], {
input: 'aabc',
index: 1,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['c'], {
input: 'aabc',
index: 3,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
}
let iterator = matchAll('1111a2b3cccc', /(\d)(\D)/g);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'RegExp String Iterator');
assert.strictEqual(String(iterator), '[object RegExp String Iterator]');
assert.deepEqual(iterator.next(), {
value: assign(['1a', '1', 'a'], {
input: '1111a2b3cccc',
index: 3,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['2b', '2', 'b'], {
input: '1111a2b3cccc',
index: 5,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['3c', '3', 'c'], {
input: '1111a2b3cccc',
index: 7,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.throws(() => matchAll('1111a2b3cccc', /(\d)(\D)/), TypeError);
iterator = matchAll('1111a2b3cccc', '(\\d)(\\D)');
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: assign(['1a', '1', 'a'], {
input: '1111a2b3cccc',
index: 3,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['2b', '2', 'b'], {
input: '1111a2b3cccc',
index: 5,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['3c', '3', 'c'], {
input: '1111a2b3cccc',
index: 7,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
/* IE8- issue
iterator = matchAll('abc', /\B/g);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: assign([''], {
input: 'abc',
index: 1,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign([''], {
input: 'abc',
index: 2,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
*/
data = [null, undefined, NaN, 42, {}, []];
for (const target of data) {
assert.notThrows(() => matchAll('', target), `Not throws on ${ target } as the first argument`);
}
if (STRICT) {
assert.throws(() => matchAll(null, /./g), TypeError, 'Throws on null as `this`');
assert.throws(() => matchAll(undefined, /./g), TypeError, 'Throws on undefined as `this`');
}
});
core-js-3.6.1/tests/pure/es.string.pad-end.js 0000664 0000000 0000000 00000001214 13600575677 0020777 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import padEnd from 'core-js-pure/features/string/pad-end';
QUnit.test('String#padEnd', assert => {
assert.isFunction(padEnd);
assert.strictEqual(padEnd('abc', 5), 'abc ');
assert.strictEqual(padEnd('abc', 4, 'de'), 'abcd');
assert.strictEqual(padEnd('abc'), 'abc');
assert.strictEqual(padEnd('abc', 5, '_'), 'abc__');
assert.strictEqual(padEnd('', 0), '');
assert.strictEqual(padEnd('foo', 1), 'foo');
assert.strictEqual(padEnd('foo', 5, ''), 'foo');
if (STRICT) {
assert.throws(() => padEnd(null, 0), TypeError);
assert.throws(() => padEnd(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/pure/es.string.pad-start.js 0000664 0000000 0000000 00000001246 13600575677 0021373 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import padStart from 'core-js-pure/features/string/pad-start';
QUnit.test('String#padStart', assert => {
assert.isFunction(padStart);
assert.strictEqual(padStart('abc', 5), ' abc');
assert.strictEqual(padStart('abc', 4, 'de'), 'dabc');
assert.strictEqual(padStart('abc'), 'abc');
assert.strictEqual(padStart('abc', 5, '_'), '__abc');
assert.strictEqual(padStart('', 0), '');
assert.strictEqual(padStart('foo', 1), 'foo');
assert.strictEqual(padStart('foo', 5, ''), 'foo');
if (STRICT) {
assert.throws(() => padStart(null, 0), TypeError);
assert.throws(() => padStart(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/pure/es.string.raw.js 0000664 0000000 0000000 00000001040 13600575677 0020255 0 ustar 00root root 0000000 0000000 import raw from 'core-js-pure/features/string/raw';
QUnit.test('String.raw', assert => {
assert.isFunction(raw);
assert.arity(raw, 1);
if ('name' in raw) {
assert.name(raw, 'raw');
}
assert.strictEqual(raw({ raw: ['Hi\\n', '!'] }, 'Bob'), 'Hi\\nBob!', 'raw is array');
assert.strictEqual(raw({ raw: 'test' }, 0, 1, 2), 't0e1s2t', 'raw is string');
assert.strictEqual(raw({ raw: 'test' }, 0), 't0est', 'lacks substituting');
assert.throws(() => raw({}), TypeError);
assert.throws(() => raw({ raw: null }), TypeError);
});
core-js-3.6.1/tests/pure/es.string.repeat.js 0000664 0000000 0000000 00000001022 13600575677 0020744 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import repeat from 'core-js-pure/features/string/repeat';
QUnit.test('String#repeat', assert => {
assert.isFunction(repeat);
assert.strictEqual(repeat('qwe', 3), 'qweqweqwe');
assert.strictEqual(repeat('qwe', 2.5), 'qweqwe');
assert.throws(() => repeat('qwe', -1), RangeError);
assert.throws(() => repeat('qwe', Infinity), RangeError);
if (STRICT) {
assert.throws(() => repeat(null, 1), TypeError);
assert.throws(() => repeat(undefined, 1), TypeError);
}
});
core-js-3.6.1/tests/pure/es.string.small.js 0000664 0000000 0000000 00000000275 13600575677 0020605 0 ustar 00root root 0000000 0000000 import small from 'core-js-pure/features/string/small';
QUnit.test('String#small', assert => {
assert.isFunction(small);
assert.same(small('a'), 'a ', 'lower case');
});
core-js-3.6.1/tests/pure/es.string.starts-with.js 0000664 0000000 0000000 00000002326 13600575677 0021765 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import Symbol from 'core-js-pure/features/symbol';
import startsWith from 'core-js-pure/features/string/starts-with';
QUnit.test('String#startsWith', assert => {
assert.isFunction(startsWith);
assert.ok(startsWith('undefined'));
assert.ok(!startsWith('undefined', null));
assert.ok(startsWith('abc', ''));
assert.ok(startsWith('abc', 'a'));
assert.ok(startsWith('abc', 'ab'));
assert.ok(!startsWith('abc', 'bc'));
assert.ok(startsWith('abc', '', NaN));
assert.ok(startsWith('abc', 'a', -1));
assert.ok(!startsWith('abc', 'a', 1));
assert.ok(!startsWith('abc', 'a', Infinity));
assert.ok(startsWith('abc', 'b', true));
assert.ok(startsWith('abc', 'a', 'x'));
if (STRICT) {
assert.throws(() => startsWith(null, '.'), TypeError);
assert.throws(() => startsWith(undefined, '.'), TypeError);
}
const regexp = /./;
assert.throws(() => startsWith('/./', regexp), TypeError);
regexp[Symbol.match] = false;
assert.notThrows(() => startsWith('/./', regexp));
const object = {};
assert.notThrows(() => startsWith('[object Object]', object));
object[Symbol.match] = true;
assert.throws(() => startsWith('[object Object]', object), TypeError);
});
core-js-3.6.1/tests/pure/es.string.strike.js 0000664 0000000 0000000 00000000304 13600575677 0020767 0 ustar 00root root 0000000 0000000 import strike from 'core-js-pure/features/string/strike';
QUnit.test('String#strike', assert => {
assert.isFunction(strike);
assert.same(strike('a'), 'a ', 'lower case');
});
core-js-3.6.1/tests/pure/es.string.sub.js 0000664 0000000 0000000 00000000257 13600575677 0020266 0 ustar 00root root 0000000 0000000 import sub from 'core-js-pure/features/string/sub';
QUnit.test('String#sub', assert => {
assert.isFunction(sub);
assert.same(sub('a'), 'a ', 'lower case');
});
core-js-3.6.1/tests/pure/es.string.sup.js 0000664 0000000 0000000 00000000257 13600575677 0020304 0 ustar 00root root 0000000 0000000 import sup from 'core-js-pure/features/string/sup';
QUnit.test('String#sup', assert => {
assert.isFunction(sup);
assert.same(sup('a'), 'a ', 'lower case');
});
core-js-3.6.1/tests/pure/es.string.trim-end.js 0000664 0000000 0000000 00000002144 13600575677 0021211 0 ustar 00root root 0000000 0000000 import { STRICT, WHITESPACES } from '../helpers/constants';
import { trimRight, trimEnd } from 'core-js-pure/features/string';
QUnit.test('String#trimRight', assert => {
assert.isFunction(trimRight);
assert.strictEqual(trimRight(' \n q w e \n '), ' \n q w e', 'removes whitespaces at right side of string');
assert.strictEqual(trimRight(WHITESPACES), '', 'removes all whitespaces');
assert.strictEqual(trimRight('\u200B\u0085'), '\u200B\u0085', "shouldn't remove this symbols");
if (STRICT) {
assert.throws(() => trimRight(null, 0), TypeError);
assert.throws(() => trimRight(undefined, 0), TypeError);
}
});
QUnit.test('String#trimEnd', assert => {
assert.isFunction(trimEnd);
assert.strictEqual(trimEnd(' \n q w e \n '), ' \n q w e', 'removes whitespaces at right side of string');
assert.strictEqual(trimEnd(WHITESPACES), '', 'removes all whitespaces');
assert.strictEqual(trimEnd('\u200B\u0085'), '\u200B\u0085', "shouldn't remove this symbols");
if (STRICT) {
assert.throws(() => trimEnd(null, 0), TypeError);
assert.throws(() => trimEnd(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/pure/es.string.trim-start.js 0000664 0000000 0000000 00000002152 13600575677 0021577 0 ustar 00root root 0000000 0000000 import { STRICT, WHITESPACES } from '../helpers/constants';
import { trimLeft, trimStart } from 'core-js-pure/features/string';
QUnit.test('String#trimLeft', assert => {
assert.isFunction(trimLeft);
assert.strictEqual(trimLeft(' \n q w e \n '), 'q w e \n ', 'removes whitespaces at left side of string');
assert.strictEqual(trimLeft(WHITESPACES), '', 'removes all whitespaces');
assert.strictEqual(trimLeft('\u200B\u0085'), '\u200B\u0085', "shouldn't remove this symbols");
if (STRICT) {
assert.throws(() => trimLeft(null, 0), TypeError);
assert.throws(() => trimLeft(undefined, 0), TypeError);
}
});
QUnit.test('String#trimStart', assert => {
assert.isFunction(trimStart);
assert.strictEqual(trimStart(' \n q w e \n '), 'q w e \n ', 'removes whitespaces at left side of string');
assert.strictEqual(trimStart(WHITESPACES), '', 'removes all whitespaces');
assert.strictEqual(trimStart('\u200B\u0085'), '\u200B\u0085', "shouldn't remove this symbols");
if (STRICT) {
assert.throws(() => trimStart(null, 0), TypeError);
assert.throws(() => trimStart(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/pure/es.string.trim.js 0000664 0000000 0000000 00000001113 13600575677 0020440 0 ustar 00root root 0000000 0000000 import { STRICT, WHITESPACES } from '../helpers/constants';
import trim from 'core-js-pure/features/string/trim';
QUnit.test('String#trim', assert => {
assert.isFunction(trim);
assert.strictEqual(trim(' \n q w e \n '), 'q w e', 'removes whitespaces at left & right side of string');
assert.strictEqual(trim(WHITESPACES), '', 'removes all whitespaces');
assert.strictEqual(trim('\u200B\u0085'), '\u200B\u0085', "shouldn't remove this symbols");
if (STRICT) {
assert.throws(() => trim(null, 0), TypeError);
assert.throws(() => trim(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/pure/es.symbol.async-iterator.js 0000664 0000000 0000000 00000000420 13600575677 0022430 0 ustar 00root root 0000000 0000000 import Symbol from 'core-js-pure/features/symbol';
QUnit.test('Symbol.asyncIterator', assert => {
assert.ok('asyncIterator' in Symbol, 'Symbol.asyncIterator available');
assert.ok(Object(Symbol.asyncIterator) instanceof Symbol, 'Symbol.asyncIterator is symbol');
});
core-js-3.6.1/tests/pure/es.symbol.js 0000664 0000000 0000000 00000022207 13600575677 0017474 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import core from 'core-js-pure';
import {
defineProperty,
defineProperties,
getOwnPropertyDescriptor,
getOwnPropertyNames,
getOwnPropertySymbols,
keys,
create,
} from 'core-js-pure/features/object';
import ownKeys from 'core-js-pure/features/reflect/own-keys';
const { Symbol, JSON } = core;
QUnit.test('Symbol', assert => {
assert.isFunction(Symbol);
const symbol1 = Symbol('symbol');
const symbol2 = Symbol('symbol');
assert.ok(symbol1 !== symbol2, 'Symbol("symbol") !== Symbol("symbol")');
const object = {};
object[symbol1] = 42;
assert.ok(object[symbol1] === 42, 'Symbol() work as key');
assert.ok(object[symbol2] !== 42, 'Various symbols from one description are various keys');
if (DESCRIPTORS) {
let count = 0;
// eslint-disable-next-line no-unused-vars
for (const key in object) count++;
assert.ok(count === 0, 'object[Symbol()] is not enumerable');
}
});
QUnit.test('Well-known Symbols', assert => {
const wks = [
'hasInstance',
'isConcatSpreadable',
'iterator',
'match',
'matchAll',
'replace',
'search',
'species',
'split',
'toPrimitive',
'toStringTag',
'unscopables',
];
for (const name of wks) {
assert.ok(name in Symbol, `Symbol.${ name } available`);
assert.ok(Object(Symbol[name]) instanceof Symbol, `Symbol.${ name } is symbol`);
}
});
QUnit.test('Global symbol registry', assert => {
assert.isFunction(Symbol.for, 'Symbol.for is function');
assert.isFunction(Symbol.keyFor, 'Symbol.keyFor is function');
const symbol = Symbol.for('foo');
assert.strictEqual(Symbol.for('foo'), symbol);
assert.strictEqual(Symbol.keyFor(symbol), 'foo');
assert.throws(() => Symbol.keyFor('foo'), 'throws on non-symbol');
});
QUnit.test('Symbol#@@toPrimitive', assert => {
const symbol = Symbol();
assert.isFunction(Symbol.prototype[Symbol.toPrimitive]);
assert.same(symbol, symbol[Symbol.toPrimitive](), 'works');
});
QUnit.test('Symbol#@@toStringTag', assert => {
assert.ok(Symbol.prototype[Symbol.toStringTag] === 'Symbol', 'Symbol::@@toStringTag is `Symbol`');
});
QUnit.test('Object.getOwnPropertySymbols', assert => {
assert.isFunction(getOwnPropertySymbols);
const prototype = { q: 1, w: 2, e: 3 };
prototype[Symbol()] = 42;
prototype[Symbol()] = 43;
assert.deepEqual(getOwnPropertyNames(prototype).sort(), ['e', 'q', 'w']);
assert.strictEqual(getOwnPropertySymbols(prototype).length, 2);
const object = create(prototype);
object.a = 1;
object.s = 2;
object.d = 3;
object[Symbol()] = 44;
assert.deepEqual(getOwnPropertyNames(object).sort(), ['a', 'd', 's']);
assert.strictEqual(getOwnPropertySymbols(object).length, 1);
assert.strictEqual(getOwnPropertySymbols(Object.prototype).length, 0);
const primitives = [42, 'foo', false];
for (const value of primitives) {
assert.notThrows(() => getOwnPropertySymbols(value), `accept ${ typeof value }`);
}
});
if (JSON) {
QUnit.test('Symbols & JSON.stringify', assert => {
assert.strictEqual(JSON.stringify([
1,
Symbol('foo'),
false,
Symbol('bar'),
{},
]), '[1,null,false,null,{}]', 'array value');
assert.strictEqual(JSON.stringify({
symbol: Symbol('symbol'),
}), '{}', 'object value');
if (DESCRIPTORS) {
const object = { bar: 2 };
object[Symbol('symbol')] = 1;
assert.strictEqual(JSON.stringify(object), '{"bar":2}', 'object key');
}
assert.strictEqual(JSON.stringify(Symbol('symbol')), undefined, 'symbol value');
if (typeof Symbol() === 'symbol') {
assert.strictEqual(JSON.stringify(Object(Symbol('symbol'))), '{}', 'boxed symbol');
}
assert.strictEqual(JSON.stringify(undefined, () => 42), '42', 'replacer works with top-level undefined');
});
}
if (DESCRIPTORS) {
QUnit.test('Symbols & descriptors', assert => {
const d = Symbol('d');
const e = Symbol('e');
const f = Symbol('f');
const i = Symbol('i');
const j = Symbol('j');
const prototype = { g: 'g' };
prototype[i] = 'i';
defineProperty(prototype, 'h', {
value: 'h',
});
defineProperty(prototype, 'j', {
value: 'j',
});
const object = create(prototype);
object.a = 'a';
object[d] = 'd';
defineProperty(object, 'b', {
value: 'b',
});
defineProperty(object, 'c', {
value: 'c',
enumerable: true,
});
defineProperty(object, e, {
configurable: true,
writable: true,
value: 'e',
});
const descriptor = {
value: 'f',
enumerable: true,
};
defineProperty(object, f, descriptor);
assert.strictEqual(descriptor.enumerable, true, 'defineProperty not changes descriptor object');
assert.deepEqual(getOwnPropertyDescriptor(object, 'a'), {
configurable: true,
writable: true,
enumerable: true,
value: 'a',
}, 'getOwnPropertyDescriptor a');
assert.deepEqual(getOwnPropertyDescriptor(object, 'b'), {
configurable: false,
writable: false,
enumerable: false,
value: 'b',
}, 'getOwnPropertyDescriptor b');
assert.deepEqual(getOwnPropertyDescriptor(object, 'c'), {
configurable: false,
writable: false,
enumerable: true,
value: 'c',
}, 'getOwnPropertyDescriptor c');
assert.deepEqual(getOwnPropertyDescriptor(object, d), {
configurable: true,
writable: true,
enumerable: true,
value: 'd',
}, 'getOwnPropertyDescriptor d');
assert.deepEqual(getOwnPropertyDescriptor(object, e), {
configurable: true,
writable: true,
enumerable: false,
value: 'e',
}, 'getOwnPropertyDescriptor e');
assert.deepEqual(getOwnPropertyDescriptor(object, f), {
configurable: false,
writable: false,
enumerable: true,
value: 'f',
}, 'getOwnPropertyDescriptor f');
assert.strictEqual(getOwnPropertyDescriptor(object, 'g'), undefined, 'getOwnPropertyDescriptor g');
assert.strictEqual(getOwnPropertyDescriptor(object, 'h'), undefined, 'getOwnPropertyDescriptor h');
assert.strictEqual(getOwnPropertyDescriptor(object, i), undefined, 'getOwnPropertyDescriptor i');
assert.strictEqual(getOwnPropertyDescriptor(object, j), undefined, 'getOwnPropertyDescriptor j');
assert.strictEqual(getOwnPropertyDescriptor(object, 'k'), undefined, 'getOwnPropertyDescriptor k');
assert.strictEqual(getOwnPropertyDescriptor(Object.prototype, 'toString').enumerable, false, 'getOwnPropertyDescriptor on Object.prototype');
assert.strictEqual(getOwnPropertyDescriptor(Object.prototype, d), undefined, 'getOwnPropertyDescriptor on Object.prototype missed symbol');
assert.strictEqual(keys(object).length, 2, 'Object.keys');
assert.strictEqual(getOwnPropertyNames(object).length, 3, 'Object.getOwnPropertyNames');
assert.strictEqual(getOwnPropertySymbols(object).length, 3, 'Object.getOwnPropertySymbols');
assert.strictEqual(ownKeys(object).length, 6, 'Reflect.ownKeys');
delete object[e];
object[e] = 'e';
assert.deepEqual(getOwnPropertyDescriptor(object, e), {
configurable: true,
writable: true,
enumerable: true,
value: 'e',
}, 'redefined non-enum key');
});
QUnit.test('Symbols & Object.defineProperties', assert => {
const c = Symbol('c');
const d = Symbol('d');
const descriptors = {
a: {
value: 'a',
},
};
descriptors[c] = {
value: 'c',
};
defineProperty(descriptors, 'b', {
value: {
value: 'b',
},
});
defineProperty(descriptors, d, {
value: {
value: 'd',
},
});
const object = defineProperties({}, descriptors);
assert.strictEqual(object.a, 'a', 'a');
assert.strictEqual(object.b, undefined, 'b');
assert.strictEqual(object[c], 'c', 'c');
assert.strictEqual(object[d], undefined, 'd');
});
QUnit.test('Symbols & Object.create', assert => {
const c = Symbol('c');
const d = Symbol('d');
const descriptors = {
a: {
value: 'a',
},
};
descriptors[c] = {
value: 'c',
};
defineProperty(descriptors, 'b', {
value: {
value: 'b',
},
});
defineProperty(descriptors, d, {
value: {
value: 'd',
},
});
const object = create(null, descriptors);
assert.strictEqual(object.a, 'a', 'a');
assert.strictEqual(object.b, undefined, 'b');
assert.strictEqual(object[c], 'c', 'c');
assert.strictEqual(object[d], undefined, 'd');
});
const constructors = ['Map', 'Set', 'Promise'];
for (const name of constructors) {
QUnit.test(`${ name }@@species`, assert => {
assert.strictEqual(core[name][Symbol.species], core[name], `${ name }@@species === ${ name }`);
const Subclass = create(core[name]);
assert.strictEqual(Subclass[Symbol.species], Subclass, `${ name } subclass`);
});
}
QUnit.test('Array@@species', assert => {
assert.strictEqual(Array[Symbol.species], Array, 'Array@@species === Array');
const Subclass = create(Array);
assert.strictEqual(Subclass[Symbol.species], Subclass, 'Array subclass');
});
QUnit.test('Symbol.sham flag', assert => {
assert.same(Symbol.sham, typeof Symbol() === 'symbol' ? undefined : true);
});
}
core-js-3.6.1/tests/pure/es.weak-map.js 0000664 0000000 0000000 00000014034 13600575677 0017670 0 ustar 00root root 0000000 0000000 import { createIterable, nativeSubclass } from '../helpers/helpers';
import { DESCRIPTORS } from '../helpers/constants';
import { Symbol, WeakMap } from 'core-js-pure';
import getIteratorMethod from 'core-js-pure/features/get-iterator-method';
import { freeze, keys, getOwnPropertyNames, getOwnPropertySymbols } from 'core-js-pure/features/object';
import ownKeys from 'core-js-pure/features/reflect/own-keys';
QUnit.test('WeakMap', assert => {
assert.isFunction(WeakMap);
assert.ok('delete' in WeakMap.prototype, 'delete in WeakMap.prototype');
assert.ok('get' in WeakMap.prototype, 'get in WeakMap.prototype');
assert.ok('has' in WeakMap.prototype, 'has in WeakMap.prototype');
assert.ok('set' in WeakMap.prototype, 'set in WeakMap.prototype');
assert.ok(new WeakMap() instanceof WeakMap, 'new WeakMap instanceof WeakMap');
let object = {};
assert.strictEqual(new WeakMap(createIterable([[object, 42]])).get(object), 42, 'Init from iterable');
let weakmap = new WeakMap();
const frozen = freeze({});
weakmap.set(frozen, 42);
assert.strictEqual(weakmap.get(frozen), 42, 'Support frozen objects');
weakmap = new WeakMap();
weakmap.set(frozen, 42);
assert.strictEqual(weakmap.has(frozen), true, 'works with frozen objects, #1');
assert.strictEqual(weakmap.get(frozen), 42, 'works with frozen objects, #2');
weakmap.delete(frozen);
assert.strictEqual(weakmap.has(frozen), false, 'works with frozen objects, #3');
assert.strictEqual(weakmap.get(frozen), undefined, 'works with frozen objects, #4');
let done = false;
try {
new WeakMap(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
assert.ok(done, '.return #throw');
assert.ok(!('clear' in WeakMap.prototype), 'should not contains `.clear` method');
const array = [];
done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
new WeakMap(array);
assert.ok(done);
object = {};
new WeakMap().set(object, 1);
if (DESCRIPTORS) {
const results = [];
for (const key in object) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(WeakMap);
assert.ok(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.ok(new Subclass() instanceof WeakMap, 'correct subclassing with native classes #2');
object = {};
assert.same(new Subclass().set(object, 2).get(object), 2, 'correct subclassing with native classes #3');
}
});
QUnit.test('WeakMap#delete', assert => {
assert.isFunction(WeakMap.prototype.delete);
const a = {};
const b = {};
const weakmap = new WeakMap();
weakmap.set(a, 42);
weakmap.set(b, 21);
assert.ok(weakmap.has(a) && weakmap.has(b), 'WeakMap has values before .delete()');
weakmap.delete(a);
assert.ok(!weakmap.has(a) && weakmap.has(b), 'WeakMap hasn`t value after .delete()');
assert.notThrows(() => !weakmap.delete(1), 'return false on primitive');
const object = {};
weakmap.set(object, 42);
freeze(object);
assert.ok(weakmap.has(object), 'works with frozen objects #1');
weakmap.delete(object);
assert.ok(!weakmap.has(object), 'works with frozen objects #2');
});
QUnit.test('WeakMap#get', assert => {
assert.isFunction(WeakMap.prototype.get);
const weakmap = new WeakMap();
assert.strictEqual(weakmap.get({}), undefined, 'WeakMap .get() before .set() return undefined');
let object = {};
weakmap.set(object, 42);
assert.strictEqual(weakmap.get(object), 42, 'WeakMap .get() return value');
weakmap.delete(object);
assert.strictEqual(weakmap.get(object), undefined, 'WeakMap .get() after .delete() return undefined');
assert.notThrows(() => weakmap.get(1) === undefined, 'return undefined on primitive');
object = {};
weakmap.set(object, 42);
freeze(object);
assert.same(weakmap.get(object), 42, 'works with frozen objects #1');
weakmap.delete(object);
assert.same(weakmap.get(object), undefined, 'works with frozen objects #2');
});
QUnit.test('WeakMap#has', assert => {
assert.isFunction(WeakMap.prototype.has);
const weakmap = new WeakMap();
assert.ok(!weakmap.has({}), 'WeakMap .has() before .set() return false');
let object = {};
weakmap.set(object, 42);
assert.ok(weakmap.has(object), 'WeakMap .has() return true');
weakmap.delete(object);
assert.ok(!weakmap.has(object), 'WeakMap .has() after .delete() return false');
assert.notThrows(() => !weakmap.has(1), 'return false on primitive');
object = {};
weakmap.set(object, 42);
freeze(object);
assert.ok(weakmap.has(object), 'works with frozen objects #1');
weakmap.delete(object);
assert.ok(!weakmap.has(object), 'works with frozen objects #2');
});
QUnit.test('WeakMap#set', assert => {
assert.isFunction(WeakMap.prototype.set);
const weakmap = new WeakMap();
const object = {};
weakmap.set(object, 33);
assert.same(weakmap.get(object), 33, 'works with object as keys');
assert.ok(weakmap.set({}, 42) === weakmap, 'chaining');
assert.throws(() => new WeakMap().set(42, 42), 'throws with primitive keys');
const object1 = freeze({});
const object2 = {};
weakmap.set(object1, 42);
weakmap.set(object2, 42);
freeze(object);
assert.same(weakmap.get(object1), 42, 'works with frozen objects #1');
assert.same(weakmap.get(object2), 42, 'works with frozen objects #2');
weakmap.delete(object1);
weakmap.delete(object2);
assert.same(weakmap.get(object1), undefined, 'works with frozen objects #3');
assert.same(weakmap.get(object2), undefined, 'works with frozen objects #4');
});
QUnit.test('WeakMap#@@toStringTag', assert => {
assert.strictEqual(WeakMap.prototype[Symbol.toStringTag], 'WeakMap', 'WeakMap::@@toStringTag is `WeakMap`');
assert.strictEqual(String(new WeakMap()), '[object WeakMap]', 'correct stringification');
});
core-js-3.6.1/tests/pure/es.weak-set.js 0000664 0000000 0000000 00000007433 13600575677 0017713 0 ustar 00root root 0000000 0000000 import { createIterable, nativeSubclass } from '../helpers/helpers';
import { DESCRIPTORS } from '../helpers/constants';
import { Symbol, WeakSet } from 'core-js-pure';
import getIteratorMethod from 'core-js-pure/features/get-iterator-method';
import { freeze, keys, getOwnPropertyNames, getOwnPropertySymbols } from 'core-js-pure/features/object';
import ownKeys from 'core-js-pure/features/reflect/own-keys';
QUnit.test('WeakSet', assert => {
assert.isFunction(WeakSet);
assert.ok('add' in WeakSet.prototype, 'add in WeakSet.prototype');
assert.ok('delete' in WeakSet.prototype, 'delete in WeakSet.prototype');
assert.ok('has' in WeakSet.prototype, 'has in WeakSet.prototype');
assert.ok(new WeakSet() instanceof WeakSet, 'new WeakSet instanceof WeakSet');
let object = {};
assert.ok(new WeakSet(createIterable([object])).has(object), 'Init from iterable');
const weakset = new WeakSet();
const frozen = freeze({});
weakset.add(frozen);
assert.strictEqual(weakset.has(frozen), true, 'works with frozen objects, #1');
weakset.delete(frozen);
assert.strictEqual(weakset.has(frozen), false, 'works with frozen objects, #2');
let done = false;
try {
new WeakSet(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
assert.ok(done, '.return #throw');
assert.ok(!('clear' in WeakSet.prototype), 'should not contains `.clear` method');
const array = [];
done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return getIteratorMethod([]).call(this);
};
new WeakSet(array);
assert.ok(done);
object = {};
new WeakSet().add(object);
if (DESCRIPTORS) {
const results = [];
for (const key in object) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(WeakSet);
assert.ok(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.ok(new Subclass() instanceof WeakSet, 'correct subclassing with native classes #2');
object = {};
assert.ok(new Subclass().add(object).has(object), 'correct subclassing with native classes #3');
}
});
QUnit.test('WeakSet#add', assert => {
assert.isFunction(WeakSet.prototype.add);
const weakset = new WeakSet();
assert.ok(weakset.add({}) === weakset, 'chaining');
assert.throws(() => new WeakSet().add(42), 'throws with primitive keys');
});
QUnit.test('WeakSet#delete', assert => {
assert.isFunction(WeakSet.prototype.delete);
const a = {};
const b = {};
const weakset = new WeakSet().add(a).add(b);
assert.ok(weakset.has(a) && weakset.has(b), 'WeakSet has values before .delete()');
weakset.delete(a);
assert.ok(!weakset.has(a) && weakset.has(b), 'WeakSet has`nt value after .delete()');
assert.notThrows(() => !weakset.delete(1), 'return false on primitive');
});
QUnit.test('WeakSet#has', assert => {
assert.isFunction(WeakSet.prototype.has);
const weakset = new WeakSet();
assert.ok(!weakset.has({}), 'WeakSet has`nt value');
const object = {};
weakset.add(object);
assert.ok(weakset.has(object), 'WeakSet has value after .add()');
weakset.delete(object);
assert.ok(!weakset.has(object), 'WeakSet hasn`t value after .delete()');
assert.notThrows(() => !weakset.has(1), 'return false on primitive');
});
QUnit.test('WeakSet::@@toStringTag', assert => {
assert.strictEqual(WeakSet.prototype[Symbol.toStringTag], 'WeakSet', 'WeakSet::@@toStringTag is `WeakSet`');
assert.strictEqual(String(new WeakSet()), '[object WeakSet]', 'correct stringification');
});
core-js-3.6.1/tests/pure/esnext.aggregate-error.js 0000664 0000000 0000000 00000001114 13600575677 0022135 0 ustar 00root root 0000000 0000000 import AggregateError from 'core-js-pure/features/aggregate-error';
QUnit.test('AggregateError', assert => {
assert.isFunction(AggregateError);
assert.arity(AggregateError, 2);
assert.name(AggregateError, 'AggregateError');
assert.ok(new AggregateError([1]) instanceof AggregateError);
assert.ok(new AggregateError([1]) instanceof Error);
assert.ok(AggregateError([1]) instanceof AggregateError);
assert.ok(AggregateError([1]) instanceof Error);
assert.same(AggregateError([1], 'foo').message, 'foo');
assert.deepEqual(AggregateError([1, 2, 3]).errors, [1, 2, 3]);
});
core-js-3.6.1/tests/pure/esnext.array.is-template-object.js 0000664 0000000 0000000 00000001520 13600575677 0023666 0 ustar 00root root 0000000 0000000 import isTemplateObject from 'core-js-pure/features/array/is-template-object';
import freeze from 'core-js-pure/features/object/freeze';
QUnit.test('Array.isTemplateObject', assert => {
assert.isFunction(isTemplateObject);
assert.arity(isTemplateObject, 1);
assert.name(isTemplateObject, 'isTemplateObject');
assert.ok(!isTemplateObject(undefined));
assert.ok(!isTemplateObject(null));
assert.ok(!isTemplateObject({}));
assert.ok(!isTemplateObject(function () {
return arguments;
}()));
assert.ok(!isTemplateObject([]));
assert.ok(!isTemplateObject(freeze([])));
const template = (() => {
try {
// eslint-disable-next-line no-template-curly-in-string
return Function('return (it => it)`qwe${ 123 }asd`')();
} catch { /* empty */ }
})();
if (template) assert.ok(isTemplateObject(template));
});
core-js-3.6.1/tests/pure/esnext.async-iterator.as-indexed-pairs.js 0000664 0000000 0000000 00000001644 13600575677 0025170 0 ustar 00root root 0000000 0000000 import AsyncIterator from 'core-js-pure/features/async-iterator';
import { createIterator } from '../helpers/helpers';
QUnit.test('AsyncIterator#asIndexedPairs', assert => {
assert.expect(8);
const async = assert.async();
const { asIndexedPairs } = AsyncIterator.prototype;
assert.isFunction(asIndexedPairs);
assert.arity(asIndexedPairs, 0);
assert.nonEnumerable(AsyncIterator.prototype, 'asIndexedPairs');
asIndexedPairs.call(createIterator(['a', 'b', 'c'])).toArray().then(it => {
assert.same(it.toString(), '0,a,1,b,2,c', 'basic functionality');
async();
});
assert.throws(() => asIndexedPairs.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => asIndexedPairs.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => asIndexedPairs.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => asIndexedPairs.call([], () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.async-iterator.constructor.js 0000664 0000000 0000000 00000001635 13600575677 0024420 0 ustar 00root root 0000000 0000000 import AsyncIterator from 'core-js-pure/features/async-iterator';
import Symbol from 'core-js-pure/features/symbol';
QUnit.test('AsyncIterator', assert => {
assert.isFunction(AsyncIterator);
assert.arity(AsyncIterator, 0);
assert.ok(AsyncIterator.from([1, 2, 3]) instanceof AsyncIterator, 'Async From Proxy');
assert.ok(AsyncIterator.from([1, 2, 3]).drop(1) instanceof AsyncIterator, 'Async Drop Proxy');
assert.ok(new AsyncIterator() instanceof AsyncIterator, 'constructor');
assert.throws(() => AsyncIterator(), 'throws w/o `new`');
});
QUnit.test('AsyncIterator#constructor', assert => {
assert.strictEqual(AsyncIterator.prototype.constructor, AsyncIterator, 'AsyncIterator#constructor is AsyncIterator');
});
QUnit.test('AsyncIterator#@@toStringTag', assert => {
assert.strictEqual(AsyncIterator.prototype[Symbol.toStringTag], 'AsyncIterator', 'AsyncIterator::@@toStringTag is `AsyncIterator`');
});
core-js-3.6.1/tests/pure/esnext.async-iterator.drop.js 0000664 0000000 0000000 00000002264 13600575677 0022776 0 ustar 00root root 0000000 0000000 import AsyncIterator from 'core-js-pure/features/async-iterator';
import { createIterator } from '../helpers/helpers';
QUnit.test('AsyncIterator#drop', assert => {
assert.expect(12);
const async = assert.async();
const { drop } = AsyncIterator.prototype;
assert.isFunction(drop);
assert.arity(drop, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'drop');
drop.call(createIterator([1, 2, 3]), 1).toArray().then(it => {
assert.arrayEqual(it, [2, 3], 'basic functionality');
return drop.call(createIterator([1, 2, 3]), 1.5).toArray();
}).then(it => {
assert.arrayEqual(it, [2, 3], 'float');
return drop.call(createIterator([1, 2, 3]), 4).toArray();
}).then(it => {
assert.arrayEqual(it, [], 'big');
return drop.call(createIterator([1, 2, 3]), 0).toArray();
}).then(it => {
assert.arrayEqual(it, [1, 2, 3], 'zero');
}).then(() => async());
assert.throws(() => drop.call(undefined, 1), TypeError);
assert.throws(() => drop.call(null, 1), TypeError);
assert.throws(() => drop.call({}, 1), TypeError);
assert.throws(() => drop.call([], 1), TypeError);
assert.throws(() => drop.call(createIterator([1, 2, 3]), -1), RangeError, 'negative');
});
core-js-3.6.1/tests/pure/esnext.async-iterator.every.js 0000664 0000000 0000000 00000003146 13600575677 0023164 0 ustar 00root root 0000000 0000000 import AsyncIterator from 'core-js-pure/features/async-iterator';
import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('AsyncIterator#every', assert => {
assert.expect(16);
const async = assert.async();
const { every } = AsyncIterator.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'every');
every.call(createIterator([1, 2, 3]), it => typeof it === 'number').then(result => {
assert.ok(result, 'basic functionality, +');
return every.call(createIterator([1, 2, 3]), it => it === 2);
}).then(result => {
assert.ok(!result, 'basic functionality, -');
return every.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
});
}).then(() => {
return every.call(createIterator([1]), () => { throw 42; });
}).catch(error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => async());
assert.throws(() => every.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => every.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => every.call([], () => { /* empty */ }), TypeError);
assert.throws(() => every.call(createIterator([1]), undefined), TypeError);
assert.throws(() => every.call(createIterator([1]), null), TypeError);
assert.throws(() => every.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/pure/esnext.async-iterator.filter.js 0000664 0000000 0000000 00000002776 13600575677 0023327 0 ustar 00root root 0000000 0000000 import AsyncIterator from 'core-js-pure/features/async-iterator';
import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('AsyncIterator#filter', assert => {
assert.expect(15);
const async = assert.async();
const { filter } = AsyncIterator.prototype;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'filter');
filter.call(createIterator([1, 2, 3]), it => it % 2).toArray().then(it => {
assert.arrayEqual(it, [1, 3], 'basic functionality');
return filter.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
}).toArray();
}).then(() => {
return filter.call(createIterator([1]), () => { throw 42; }).toArray();
}).catch(error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => async());
assert.throws(() => filter.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call([], () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(createIterator([1]), undefined), TypeError);
assert.throws(() => filter.call(createIterator([1]), null), TypeError);
assert.throws(() => filter.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/pure/esnext.async-iterator.find.js 0000664 0000000 0000000 00000003127 13600575677 0022751 0 ustar 00root root 0000000 0000000 import AsyncIterator from 'core-js-pure/features/async-iterator';
import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('AsyncIterator#find', assert => {
assert.expect(16);
const async = assert.async();
const { find } = AsyncIterator.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'find');
find.call(createIterator([2, 3, 4]), it => it % 2).then(result => {
assert.same(result, 3, 'basic functionality, +');
return find.call(createIterator([1, 2, 3]), it => it === 4);
}).then(result => {
assert.same(result, undefined, 'basic functionality, -');
return find.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
});
}).then(() => {
return find.call(createIterator([1]), () => { throw 42; });
}).catch(error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => async());
assert.throws(() => find.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => find.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => find.call([], () => { /* empty */ }), TypeError);
assert.throws(() => find.call(createIterator([1]), undefined), TypeError);
assert.throws(() => find.call(createIterator([1]), null), TypeError);
assert.throws(() => find.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/pure/esnext.async-iterator.flat-map.js 0000664 0000000 0000000 00000003214 13600575677 0023527 0 ustar 00root root 0000000 0000000 import AsyncIterator from 'core-js-pure/features/async-iterator';
import { createIterator, createIterable } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('AsyncIterator#flatMap', assert => {
assert.expect(15);
const async = assert.async();
const { flatMap } = AsyncIterator.prototype;
assert.isFunction(flatMap);
assert.arity(flatMap, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'flatMap');
flatMap.call(createIterator([1, [], 2, createIterable([3, 4]), [5, 6], 'ab']), it => typeof it == 'number' ? [-it] : it).toArray().then(it => {
assert.arrayEqual(it, [-1, -2, 3, 4, 5, 6, 'a', 'b'], 'basic functionality');
return flatMap.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
return [arg];
}).toArray();
}).then(() => {
return flatMap.call(createIterator([1]), () => { throw 42; }).toArray();
}).catch(error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => async());
assert.throws(() => flatMap.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call([], () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), undefined), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), null), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/pure/esnext.async-iterator.for-each.js 0000664 0000000 0000000 00000003022 13600575677 0023507 0 ustar 00root root 0000000 0000000 import AsyncIterator from 'core-js-pure/features/async-iterator';
import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('AsyncIterator#forEach', assert => {
assert.expect(15);
const async = assert.async();
const { forEach } = AsyncIterator.prototype;
assert.isFunction(forEach);
assert.arity(forEach, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'forEach');
const array = [];
forEach.call(createIterator([1, 2, 3]), it => array.push(it)).then(() => {
assert.arrayEqual(array, [1, 2, 3], 'basic functionality');
return forEach.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
});
}).then(() => {
return forEach.call(createIterator([1]), () => { throw 42; });
}).catch(error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => async());
assert.throws(() => forEach.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call([], () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call(createIterator([1]), undefined), TypeError);
assert.throws(() => forEach.call(createIterator([1]), null), TypeError);
assert.throws(() => forEach.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/pure/esnext.async-iterator.from.js 0000664 0000000 0000000 00000001776 13600575677 0023004 0 ustar 00root root 0000000 0000000 import AsyncIterator from 'core-js-pure/features/async-iterator';
import assign from 'core-js-pure/features/object/assign';
import values from 'core-js-pure/features/array/values';
QUnit.test('AsyncIterator.from', assert => {
assert.expect(9);
const async = assert.async();
const { from } = AsyncIterator;
assert.isFunction(from);
assert.arity(from, 1);
assert.ok(AsyncIterator.from(values([])) instanceof AsyncIterator, 'proxy, iterator');
assert.ok(AsyncIterator.from([]) instanceof AsyncIterator, 'proxy, iterable');
AsyncIterator.from([1, 2, 3]).toArray().then(result => {
assert.arrayEqual(result, [1, 2, 3], 'just a proxy');
async();
});
const asyncIterator = assign(new AsyncIterator(), {
next: () => { /* empty */ },
});
assert.same(AsyncIterator.from(asyncIterator), asyncIterator, 'does not wrap AsyncIterator instanses');
assert.throws(() => from(undefined), TypeError);
assert.throws(() => from(null), TypeError);
assert.throws(() => from({}), TypeError);
});
core-js-3.6.1/tests/pure/esnext.async-iterator.map.js 0000664 0000000 0000000 00000002725 13600575677 0022611 0 ustar 00root root 0000000 0000000 import AsyncIterator from 'core-js-pure/features/async-iterator';
import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('AsyncIterator#map', assert => {
assert.expect(15);
const async = assert.async();
const { map } = AsyncIterator.prototype;
assert.isFunction(map);
assert.arity(map, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'map');
map.call(createIterator([1, 2, 3]), it => it ** 2).toArray().then(it => {
assert.arrayEqual(it, [1, 4, 9], 'basic functionality');
return map.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
}).toArray();
}).then(() => {
return map.call(createIterator([1]), () => { throw 42; }).toArray();
}).catch(error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => async());
assert.throws(() => map.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => map.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => map.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => map.call([], () => { /* empty */ }), TypeError);
assert.throws(() => map.call(createIterator([1]), undefined), TypeError);
assert.throws(() => map.call(createIterator([1]), null), TypeError);
assert.throws(() => map.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/pure/esnext.async-iterator.reduce.js 0000664 0000000 0000000 00000003511 13600575677 0023275 0 ustar 00root root 0000000 0000000 import AsyncIterator from 'core-js-pure/features/async-iterator';
import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('AsyncIterator#reduce', assert => {
assert.expect(18);
const async = assert.async();
const { reduce } = AsyncIterator.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'reduce');
reduce.call(createIterator([1, 2, 3]), (a, b) => a + b, 1).then(it => {
assert.same(it, 7, 'basic functionality, initial');
return reduce.call(createIterator([2]), function (a, b) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(a, 1, 'argument 1');
assert.same(b, 2, 'argument 2');
}, 1);
}).then(() => {
return reduce.call(createIterator([1, 2, 3]), (a, b) => a + b);
}).then(it => {
assert.same(it, 6, 'basic functionality, no initial');
return reduce.call(createIterator([]), (a, b) => a + b);
}).catch(() => {
assert.ok(true, 'reduce an empty interble with no initial');
return reduce.call(createIterator([1]), () => { throw 42; }, 1);
}).catch(error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => async());
assert.throws(() => reduce.call(undefined, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(null, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call({}, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call([], () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(createIterator([1]), undefined, 1), TypeError);
assert.throws(() => reduce.call(createIterator([1]), null, 1), TypeError);
assert.throws(() => reduce.call(createIterator([1]), {}, 1), TypeError);
});
core-js-3.6.1/tests/pure/esnext.async-iterator.some.js 0000664 0000000 0000000 00000003110 13600575677 0022764 0 ustar 00root root 0000000 0000000 import AsyncIterator from 'core-js-pure/features/async-iterator';
import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('AsyncIterator#some', assert => {
assert.expect(16);
const async = assert.async();
const { some } = AsyncIterator.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'some');
some.call(createIterator([1, 2, 3]), it => it === 2).then(result => {
assert.ok(result, 'basic functionality, +');
return some.call(createIterator([1, 2, 3]), it => it === 4);
}).then(result => {
assert.ok(!result, 'basic functionality, -');
return some.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
});
}).then(() => {
return some.call(createIterator([1]), () => { throw 42; });
}).catch(error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => async());
assert.throws(() => some.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => some.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => some.call([], () => { /* empty */ }), TypeError);
assert.throws(() => some.call(createIterator([1]), undefined), TypeError);
assert.throws(() => some.call(createIterator([1]), null), TypeError);
assert.throws(() => some.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/pure/esnext.async-iterator.take.js 0000664 0000000 0000000 00000002261 13600575677 0022753 0 ustar 00root root 0000000 0000000 import AsyncIterator from 'core-js-pure/features/async-iterator';
import { createIterator } from '../helpers/helpers';
QUnit.test('AsyncIterator#take', assert => {
assert.expect(12);
const async = assert.async();
const { take } = AsyncIterator.prototype;
assert.isFunction(take);
assert.arity(take, 1);
assert.nonEnumerable(AsyncIterator.prototype, 'take');
take.call(createIterator([1, 2, 3]), 2).toArray().then(it => {
assert.arrayEqual(it, [1, 2], 'basic functionality');
return take.call(createIterator([1, 2, 3]), 1.5).toArray();
}).then(it => {
assert.arrayEqual(it, [1], 'float');
return take.call(createIterator([1, 2, 3]), 4).toArray();
}).then(it => {
assert.arrayEqual(it, [1, 2, 3], 'big');
return take.call(createIterator([1, 2, 3]), 0).toArray();
}).then(it => {
assert.arrayEqual(it, [], 'zero');
}).then(() => async());
assert.throws(() => take.call(undefined, 1), TypeError);
assert.throws(() => take.call(null, 1), TypeError);
assert.throws(() => take.call({}, 1), TypeError);
assert.throws(() => take.call([], 1), TypeError);
assert.throws(() => take.call(createIterator([1, 2, 3]), -1), RangeError, 'negative');
});
core-js-3.6.1/tests/pure/esnext.async-iterator.to-array.js 0000664 0000000 0000000 00000001322 13600575677 0023562 0 ustar 00root root 0000000 0000000 import AsyncIterator from 'core-js-pure/features/async-iterator';
import { createIterator } from '../helpers/helpers';
QUnit.test('AsyncIterator#toArray', assert => {
assert.expect(8);
const async = assert.async();
const { toArray } = AsyncIterator.prototype;
assert.isFunction(toArray);
assert.arity(toArray, 0);
assert.nonEnumerable(AsyncIterator.prototype, 'toArray');
toArray.call(createIterator([1, 2, 3])).then(it => {
assert.arrayEqual(it, [1, 2, 3]);
async();
});
assert.throws(() => toArray.call(undefined), TypeError);
assert.throws(() => toArray.call(null), TypeError);
assert.throws(() => toArray.call({}), TypeError);
assert.throws(() => toArray.call([]), TypeError);
});
core-js-3.6.1/tests/pure/esnext.composite-key.js 0000664 0000000 0000000 00000004022 13600575677 0021651 0 ustar 00root root 0000000 0000000 /* eslint-disable no-self-compare */
import { FREEZING } from '../helpers/constants';
import compositeKey from 'core-js-pure/features/composite-key';
import { getPrototypeOf, isFrozen } from 'core-js-pure/features/object';
QUnit.test('compositeKey', assert => {
assert.isFunction(compositeKey);
if (compositeKey.name) assert.name(compositeKey, 'compositeKey');
const key = compositeKey({});
assert.same(typeof key, 'object');
assert.same({}.toString.call(key), '[object Object]');
assert.same(getPrototypeOf(key), null);
if (FREEZING) assert.ok(isFrozen(key));
const a = ['a'];
const b = ['b'];
const c = ['c'];
assert.ok(compositeKey(a) === compositeKey(a));
assert.ok(compositeKey(a) !== compositeKey(['a']));
assert.ok(compositeKey(a) !== compositeKey(a, 1));
assert.ok(compositeKey(a) !== compositeKey(a, b));
assert.ok(compositeKey(a, 1) === compositeKey(a, 1));
assert.ok(compositeKey(a, b) === compositeKey(a, b));
assert.ok(compositeKey(a, b) !== compositeKey(b, a));
assert.ok(compositeKey(a, b, c) === compositeKey(a, b, c));
assert.ok(compositeKey(a, b, c) !== compositeKey(c, b, a));
assert.ok(compositeKey(a, b, c) !== compositeKey(a, c, b));
assert.ok(compositeKey(a, b, c, 1) !== compositeKey(a, b, c));
assert.ok(compositeKey(a, b, c, 1) === compositeKey(a, b, c, 1));
assert.ok(compositeKey(1, a) === compositeKey(1, a));
assert.ok(compositeKey(1, a) !== compositeKey(a, 1));
assert.ok(compositeKey(1, a, 2, b) === compositeKey(1, a, 2, b));
assert.ok(compositeKey(1, a, 2, b) !== compositeKey(1, a, b, 2));
assert.ok(compositeKey(1, 2, a, b) === compositeKey(1, 2, a, b));
assert.ok(compositeKey(1, 2, a, b) !== compositeKey(1, a, b, 2));
assert.ok(compositeKey(a, a) === compositeKey(a, a));
assert.ok(compositeKey(a, a) !== compositeKey(a, ['a']));
assert.ok(compositeKey(a, a) !== compositeKey(a, b));
assert.throws(() => compositeKey(), TypeError);
assert.throws(() => compositeKey(1, 2), TypeError);
assert.throws(() => compositeKey('foo', null, true), TypeError);
});
core-js-3.6.1/tests/pure/esnext.composite-symbol.js 0000664 0000000 0000000 00000004146 13600575677 0022375 0 ustar 00root root 0000000 0000000 /* eslint-disable no-self-compare */
import compositeSymbol from 'core-js-pure/features/composite-symbol';
import Symbol from 'core-js-pure/features/symbol';
QUnit.test('compositeSymbol', assert => {
assert.isFunction(compositeSymbol);
if (compositeSymbol.name) assert.name(compositeSymbol, 'compositeSymbol');
assert.ok(Object(compositeSymbol({})) instanceof Symbol);
const a = ['a'];
const b = ['b'];
const c = ['c'];
assert.ok(compositeSymbol(a) === compositeSymbol(a));
assert.ok(compositeSymbol(a) !== compositeSymbol(['a']));
assert.ok(compositeSymbol(a) !== compositeSymbol(a, 1));
assert.ok(compositeSymbol(a) !== compositeSymbol(a, b));
assert.ok(compositeSymbol(a, 1) === compositeSymbol(a, 1));
assert.ok(compositeSymbol(a, b) === compositeSymbol(a, b));
assert.ok(compositeSymbol(a, b) !== compositeSymbol(b, a));
assert.ok(compositeSymbol(a, b, c) === compositeSymbol(a, b, c));
assert.ok(compositeSymbol(a, b, c) !== compositeSymbol(c, b, a));
assert.ok(compositeSymbol(a, b, c) !== compositeSymbol(a, c, b));
assert.ok(compositeSymbol(a, b, c, 1) !== compositeSymbol(a, b, c));
assert.ok(compositeSymbol(a, b, c, 1) === compositeSymbol(a, b, c, 1));
assert.ok(compositeSymbol(1, a) === compositeSymbol(1, a));
assert.ok(compositeSymbol(1, a) !== compositeSymbol(a, 1));
assert.ok(compositeSymbol(1, a, 2, b) === compositeSymbol(1, a, 2, b));
assert.ok(compositeSymbol(1, a, 2, b) !== compositeSymbol(1, a, b, 2));
assert.ok(compositeSymbol(1, 2, a, b) === compositeSymbol(1, 2, a, b));
assert.ok(compositeSymbol(1, 2, a, b) !== compositeSymbol(1, a, b, 2));
assert.ok(compositeSymbol(a, a) === compositeSymbol(a, a));
assert.ok(compositeSymbol(a, a) !== compositeSymbol(a, ['a']));
assert.ok(compositeSymbol(a, a) !== compositeSymbol(a, b));
assert.ok(compositeSymbol() === compositeSymbol());
assert.ok(compositeSymbol(1, 2) === compositeSymbol(1, 2));
assert.ok(compositeSymbol(1, 2) !== compositeSymbol(2, 1));
assert.ok(compositeSymbol('foo', null, true) === compositeSymbol('foo', null, true));
assert.ok(compositeSymbol('string') === Symbol.for('string'));
});
core-js-3.6.1/tests/pure/esnext.iterator.as-indexed-pairs.js 0000664 0000000 0000000 00000001331 13600575677 0024046 0 ustar 00root root 0000000 0000000 import Iterator from 'core-js-pure/features/iterator';
import { createIterator } from '../helpers/helpers';
QUnit.test('Iterator#asIndexedPairs', assert => {
const { asIndexedPairs } = Iterator.prototype;
assert.isFunction(asIndexedPairs);
assert.arity(asIndexedPairs, 0);
assert.nonEnumerable(Iterator.prototype, 'asIndexedPairs');
assert.arrayEqual(asIndexedPairs.call(createIterator(['a', 'b', 'c'])).toArray().toString(), '0,a,1,b,2,c', 'basic functionality');
assert.throws(() => asIndexedPairs.call(undefined, TypeError));
assert.throws(() => asIndexedPairs.call(null, TypeError));
assert.throws(() => asIndexedPairs.call({}, TypeError));
assert.throws(() => asIndexedPairs.call([], TypeError));
});
core-js-3.6.1/tests/pure/esnext.iterator.constructor.js 0000664 0000000 0000000 00000001427 13600575677 0023304 0 ustar 00root root 0000000 0000000 import Iterator from 'core-js-pure/features/iterator';
import Symbol from 'core-js-pure/features/symbol';
import { createIterator } from '../helpers/helpers';
QUnit.test('Iterator', assert => {
assert.isFunction(Iterator);
assert.arity(Iterator, 0);
assert.ok(Iterator.from(createIterator([1, 2, 3])) instanceof Iterator, 'From Proxy');
assert.ok(new Iterator() instanceof Iterator, 'constructor');
assert.throws(() => Iterator(), 'throws w/o `new`');
});
QUnit.test('Iterator#constructor', assert => {
assert.strictEqual(Iterator.prototype.constructor, Iterator, 'Iterator#constructor is Iterator');
});
QUnit.test('Iterator#@@toStringTag', assert => {
assert.strictEqual(Iterator.prototype[Symbol.toStringTag], 'Iterator', 'Iterator::@@toStringTag is `Iterator`');
});
core-js-3.6.1/tests/pure/esnext.iterator.drop.js 0000664 0000000 0000000 00000001716 13600575677 0021664 0 ustar 00root root 0000000 0000000 import Iterator from 'core-js-pure/features/iterator';
import { createIterator } from '../helpers/helpers';
QUnit.test('Iterator#drop', assert => {
const { drop } = Iterator.prototype;
assert.isFunction(drop);
assert.arity(drop, 1);
assert.nonEnumerable(Iterator.prototype, 'drop');
assert.arrayEqual(drop.call(createIterator([1, 2, 3]), 1).toArray(), [2, 3], 'basic functionality');
assert.arrayEqual(drop.call(createIterator([1, 2, 3]), 1.5).toArray(), [2, 3], 'float');
assert.arrayEqual(drop.call(createIterator([1, 2, 3]), 4).toArray(), [], 'big');
assert.arrayEqual(drop.call(createIterator([1, 2, 3]), 0).toArray(), [1, 2, 3], 'zero');
assert.throws(() => drop.call(undefined, 1), TypeError);
assert.throws(() => drop.call(null, 1), TypeError);
assert.throws(() => drop.call({}, 1), TypeError);
assert.throws(() => drop.call([], 1), TypeError);
assert.throws(() => drop.call(createIterator([1, 2, 3]), -1), RangeError, 'negative');
});
core-js-3.6.1/tests/pure/esnext.iterator.every.js 0000664 0000000 0000000 00000002374 13600575677 0022053 0 ustar 00root root 0000000 0000000 import Iterator from 'core-js-pure/features/iterator';
import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('Iterator#every', assert => {
const { every } = Iterator.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.nonEnumerable(Iterator.prototype, 'every');
assert.ok(every.call(createIterator([1, 2, 3]), it => typeof it == 'number'), 'basic functionality #1');
assert.ok(!every.call(createIterator([1, 2, 3]), it => it % 2), 'basic functionality #2');
every.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
});
assert.throws(() => every.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => every.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => every.call([], () => { /* empty */ }), TypeError);
assert.throws(() => every.call(createIterator([1]), undefined), TypeError);
assert.throws(() => every.call(createIterator([1]), null), TypeError);
assert.throws(() => every.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/pure/esnext.iterator.filter.js 0000664 0000000 0000000 00000002277 13600575677 0022210 0 ustar 00root root 0000000 0000000 import Iterator from 'core-js-pure/features/iterator';
import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('Iterator#filter', assert => {
const { filter } = Iterator.prototype;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.nonEnumerable(Iterator.prototype, 'filter');
assert.arrayEqual(filter.call(createIterator([1, 2, 3]), it => it % 2).toArray(), [1, 3], 'basic functionality');
filter.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
}).toArray();
assert.throws(() => filter.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call([], () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(createIterator([1]), undefined), TypeError);
assert.throws(() => filter.call(createIterator([1]), null), TypeError);
assert.throws(() => filter.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/pure/esnext.iterator.find.js 0000664 0000000 0000000 00000002207 13600575677 0021634 0 ustar 00root root 0000000 0000000 import Iterator from 'core-js-pure/features/iterator';
import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('Iterator#find', assert => {
const { find } = Iterator.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.nonEnumerable(Iterator.prototype, 'find');
assert.same(find.call(createIterator([1, 2, 3]), it => !(it % 2)), 2, 'basic functionality');
find.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
});
assert.throws(() => find.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => find.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => find.call([], () => { /* empty */ }), TypeError);
assert.throws(() => find.call(createIterator([1]), undefined), TypeError);
assert.throws(() => find.call(createIterator([1]), null), TypeError);
assert.throws(() => find.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/pure/esnext.iterator.flat-map.js 0000664 0000000 0000000 00000002661 13600575677 0022421 0 ustar 00root root 0000000 0000000 import Iterator from 'core-js-pure/features/iterator';
import { createIterator, createIterable } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('Iterator#flatMap', assert => {
const { flatMap } = Iterator.prototype;
assert.isFunction(flatMap);
assert.arity(flatMap, 1);
assert.nonEnumerable(Iterator.prototype, 'flatMap');
assert.arrayEqual(
flatMap.call(createIterator([1, [], 2, createIterable([3, 4]), [5, 6], 'ab']), it => typeof it == 'number' ? [-it] : it).toArray(),
[-1, -2, 3, 4, 5, 6, 'a', 'b'],
'basic functionality',
);
flatMap.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
return [arg];
}).toArray();
assert.throws(() => flatMap.call(createIterator([1]), it => it).next(), TypeError);
assert.throws(() => flatMap.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call([], () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), undefined), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), null), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/pure/esnext.iterator.for-each.js 0000664 0000000 0000000 00000002344 13600575677 0022402 0 ustar 00root root 0000000 0000000 import Iterator from 'core-js-pure/features/iterator';
import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('Iterator#forEach', assert => {
const { forEach } = Iterator.prototype;
assert.isFunction(forEach);
assert.arity(forEach, 1);
assert.nonEnumerable(Iterator.prototype, 'forEach');
const array = [];
forEach.call(createIterator([1, 2, 3]), it => array.push(it));
assert.arrayEqual(array, [1, 2, 3], 'basic functionality');
forEach.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
});
assert.throws(() => forEach.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call([], () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call(createIterator([1]), undefined), TypeError);
assert.throws(() => forEach.call(createIterator([1]), null), TypeError);
assert.throws(() => forEach.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/pure/esnext.iterator.from.js 0000664 0000000 0000000 00000001255 13600575677 0021661 0 ustar 00root root 0000000 0000000 import Iterator from 'core-js-pure/features/iterator';
import { createIterable, createIterator } from '../helpers/helpers';
QUnit.test('Iterator.from', assert => {
const { from } = Iterator;
assert.isFunction(from);
assert.arity(from, 1);
assert.ok(Iterator.from(createIterator([1, 2, 3])) instanceof Iterator, 'proxy, iterator');
assert.ok(Iterator.from(createIterable([1, 2, 3])) instanceof Iterator, 'proxy, iterable');
assert.arrayEqual(Iterator.from(createIterable([1, 2, 3])).toArray(), [1, 2, 3], 'just a proxy');
assert.throws(() => from(undefined), TypeError);
assert.throws(() => from(null), TypeError);
assert.throws(() => from({}), TypeError);
});
core-js-3.6.1/tests/pure/esnext.iterator.map.js 0000664 0000000 0000000 00000002231 13600575677 0021466 0 ustar 00root root 0000000 0000000 import Iterator from 'core-js-pure/features/iterator';
import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('Iterator#map', assert => {
const { map } = Iterator.prototype;
assert.isFunction(map);
assert.arity(map, 1);
assert.nonEnumerable(Iterator.prototype, 'map');
assert.arrayEqual(map.call(createIterator([1, 2, 3]), it => it ** 2).toArray(), [1, 4, 9], 'basic functionality');
map.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
}).toArray();
assert.throws(() => map.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => map.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => map.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => map.call([], () => { /* empty */ }), TypeError);
assert.throws(() => map.call(createIterator([1]), undefined), TypeError);
assert.throws(() => map.call(createIterator([1]), null), TypeError);
assert.throws(() => map.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/pure/esnext.iterator.reduce.js 0000664 0000000 0000000 00000002467 13600575677 0022173 0 ustar 00root root 0000000 0000000 import Iterator from 'core-js-pure/features/iterator';
import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('Iterator#reduce', assert => {
const { reduce } = Iterator.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.nonEnumerable(Iterator.prototype, 'reduce');
assert.same(reduce.call(createIterator([1, 2, 3]), (a, b) => a + b, 1), 7, 'basic functionality');
assert.same(reduce.call(createIterator([1, 2, 3]), (a, b) => a + b), 6, 'basic functionality, no init');
reduce.call(createIterator([2]), function (a, b) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(a, 1, 'argument 1');
assert.same(b, 2, 'argument 2');
}, 1);
assert.throws(() => reduce.call(undefined, (a, b) => a + b, 0), TypeError);
assert.throws(() => reduce.call(null, (a, b) => a + b, 0), TypeError);
assert.throws(() => reduce.call({}, (a, b) => a + b, 0), TypeError);
assert.throws(() => reduce.call([], (a, b) => a + b, 0), TypeError);
assert.throws(() => reduce.call(createIterator([1]), undefined, 1), TypeError);
assert.throws(() => reduce.call(createIterator([1]), null, 1), TypeError);
assert.throws(() => reduce.call(createIterator([1]), {}, 1), TypeError);
});
core-js-3.6.1/tests/pure/esnext.iterator.some.js 0000664 0000000 0000000 00000002355 13600575677 0021663 0 ustar 00root root 0000000 0000000 import Iterator from 'core-js-pure/features/iterator';
import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('Iterator#some', assert => {
const { some } = Iterator.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.nonEnumerable(Iterator.prototype, 'some');
assert.ok(some.call(createIterator([1, 2, 3]), it => it % 2), 'basic functionality #1');
assert.ok(!some.call(createIterator([1, 2, 3]), it => typeof it == 'string'), 'basic functionality #2');
some.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
});
assert.throws(() => some.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => some.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => some.call([], () => { /* empty */ }), TypeError);
assert.throws(() => some.call(createIterator([1]), undefined), TypeError);
assert.throws(() => some.call(createIterator([1]), null), TypeError);
assert.throws(() => some.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/pure/esnext.iterator.take.js 0000664 0000000 0000000 00000001713 13600575677 0021641 0 ustar 00root root 0000000 0000000 import Iterator from 'core-js-pure/features/iterator';
import { createIterator } from '../helpers/helpers';
QUnit.test('Iterator#take', assert => {
const { take } = Iterator.prototype;
assert.isFunction(take);
assert.arity(take, 1);
assert.nonEnumerable(Iterator.prototype, 'take');
assert.arrayEqual(take.call(createIterator([1, 2, 3]), 2).toArray(), [1, 2], 'basic functionality');
assert.arrayEqual(take.call(createIterator([1, 2, 3]), 1.5).toArray(), [1], 'float');
assert.arrayEqual(take.call(createIterator([1, 2, 3]), 4).toArray(), [1, 2, 3], 'big');
assert.arrayEqual(take.call(createIterator([1, 2, 3]), 0).toArray(), [], 'zero');
assert.throws(() => take.call(undefined, 1), TypeError);
assert.throws(() => take.call(null, 1), TypeError);
assert.throws(() => take.call({}, 1), TypeError);
assert.throws(() => take.call([], 1), TypeError);
assert.throws(() => take.call(createIterator([1, 2, 3]), -1), RangeError, 'negative');
});
core-js-3.6.1/tests/pure/esnext.iterator.to-array.js 0000664 0000000 0000000 00000001410 13600575677 0022445 0 ustar 00root root 0000000 0000000 import Iterator from 'core-js-pure/features/iterator';
import { createIterable, createIterator } from '../helpers/helpers';
QUnit.test('Iterator#toArray', assert => {
const { toArray } = Iterator.prototype;
assert.isFunction(toArray);
assert.arity(toArray, 0);
assert.nonEnumerable(Iterator.prototype, 'toArray');
assert.arrayEqual(Iterator.from('123').toArray(), ['1', '2', '3']);
assert.arrayEqual(Iterator.from(createIterable([1, 2, 3])).toArray(), [1, 2, 3]);
assert.arrayEqual(toArray.call(createIterator([1, 2, 3])), [1, 2, 3]);
assert.throws(() => toArray.call(undefined), TypeError);
assert.throws(() => toArray.call(null), TypeError);
assert.throws(() => toArray.call({}), TypeError);
assert.throws(() => toArray.call([]), TypeError);
});
core-js-3.6.1/tests/pure/esnext.map.delete-all.js 0000664 0000000 0000000 00000002150 13600575677 0021645 0 ustar 00root root 0000000 0000000 import Map from 'core-js-pure/features/map';
import from from 'core-js-pure/features/array/from';
QUnit.test('Map#deleteAll', assert => {
const { deleteAll } = Map.prototype;
assert.isFunction(deleteAll);
assert.arity(deleteAll, 0);
assert.nonEnumerable(Map.prototype, 'deleteAll');
let set = new Map([[1, 2], [2, 3], [3, 4]]);
assert.same(set.deleteAll(1, 2), true);
assert.deepEqual(from(set), [[3, 4]]);
set = new Map([[1, 2], [2, 3], [3, 4]]);
assert.same(set.deleteAll(3, 4), false);
assert.deepEqual(from(set), [[1, 2], [2, 3]]);
set = new Map([[1, 2], [2, 3], [3, 4]]);
assert.same(set.deleteAll(4, 5), false);
assert.deepEqual(from(set), [[1, 2], [2, 3], [3, 4]]);
set = new Map([[1, 2], [2, 3], [3, 4]]);
assert.same(set.deleteAll(), true);
assert.deepEqual(from(set), [[1, 2], [2, 3], [3, 4]]);
assert.notThrows(() => !deleteAll.call({ delete() { /* empty */ } }, 1, 2, 3));
assert.throws(() => deleteAll.call({}, 1, 2, 3), TypeError);
assert.throws(() => deleteAll.call(undefined, 1, 2, 3), TypeError);
assert.throws(() => deleteAll.call(null, 1, 2, 3), TypeError);
});
core-js-3.6.1/tests/pure/esnext.map.every.js 0000664 0000000 0000000 00000002516 13600575677 0020775 0 ustar 00root root 0000000 0000000 import Map from 'core-js-pure/features/map';
QUnit.test('Map#every', assert => {
const { every } = Map.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.name(every, 'every');
assert.nonEnumerable(Map.prototype, 'every');
let map = new Map([[9, 1]]);
const context = {};
map.every(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 9, 'correct index in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
map = new Map([[0, 1], [1, 2], [2, 3]]);
assert.ok(map.every(it => typeof it === 'number'));
assert.ok(map.every(it => it < 4));
assert.ok(!map.every(it => it < 3));
assert.ok(!map.every(it => typeof it === 'string'));
assert.ok(map.every(function () {
return +this === 1;
}, 1));
let result = '';
map.every((value, key) => result += key);
assert.ok(result === '012');
assert.ok(map.every((value, key, that) => that === map));
assert.throws(() => every.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.map.filter.js 0000664 0000000 0000000 00000002410 13600575677 0021121 0 ustar 00root root 0000000 0000000 import Map from 'core-js-pure/features/map';
import from from 'core-js-pure/features/array/from';
QUnit.test('Map#filter', assert => {
const { filter } = Map.prototype;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.name(filter, 'filter');
assert.nonEnumerable(Map.prototype, 'filter');
const map = new Map([[1, 2]]);
const context = {};
map.filter(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.deepEqual(from(new Map([
['a', 1],
[1, 2],
['b', 3],
[2, 'q'],
['c', {}],
[3, 4],
['d', true],
[4, 5],
]).filter(it => typeof it === 'number')), [
['a', 1],
[1, 2],
['b', 3],
[3, 4],
[4, 5],
]);
assert.ok(new Map().filter(it => it) instanceof Map);
assert.throws(() => filter.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.map.find-key.js 0000664 0000000 0000000 00000002007 13600575677 0021344 0 ustar 00root root 0000000 0000000 import Map from 'core-js-pure/features/map';
QUnit.test('Map#findKey', assert => {
const { findKey } = Map.prototype;
assert.isFunction(findKey);
assert.arity(findKey, 1);
assert.nonEnumerable(Map.prototype, 'findKey');
const set = new Map([[1, 2]]);
const context = {};
set.findKey(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new Map([[1, 2], [2, 3], [3, 4]]).findKey(it => it % 2), 2);
assert.same(new Map().findKey(it => it === 42), undefined);
assert.throws(() => findKey.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => findKey.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => findKey.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.map.find.js 0000664 0000000 0000000 00000001746 13600575677 0020567 0 ustar 00root root 0000000 0000000 import Map from 'core-js-pure/features/map';
QUnit.test('Map#find', assert => {
const { find } = Map.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.nonEnumerable(Map.prototype, 'find');
const set = new Map([[1, 2]]);
const context = {};
set.find(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new Map([[1, 2], [2, 3], [3, 4]]).find(it => it % 2), 3);
assert.same(new Map().find(it => it === 42), undefined);
assert.throws(() => find.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.map.from.js 0000664 0000000 0000000 00000001762 13600575677 0020610 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
import Map from 'core-js-pure/features/map';
import toArray from 'core-js-pure/features/array/from';
QUnit.test('Map.from', assert => {
const { from } = Map;
assert.isFunction(from);
assert.arity(from, 1);
assert.ok(Map.from() instanceof Map);
assert.deepEqual(toArray(Map.from([])), []);
assert.deepEqual(toArray(Map.from([[1, 2]])), [[1, 2]]);
assert.deepEqual(toArray(Map.from([[1, 2], [2, 3], [1, 4]])), [[1, 4], [2, 3]]);
assert.deepEqual(toArray(Map.from(createIterable([[1, 2], [2, 3], [1, 4]]))), [[1, 4], [2, 3]]);
const pair = [1, 2];
const context = {};
Map.from([pair], function (element, index) {
assert.same(element, pair);
assert.same(index, 0);
assert.same(this, context);
return element;
}, context);
assert.throws(() => from([1, 2]));
let arg = null;
function F(it) {
return arg = it;
}
from.call(F, createIterable([1, 2, 3]), it => it ** 2);
assert.deepEqual(arg, [1, 4, 9]);
});
core-js-3.6.1/tests/pure/esnext.map.group-by.js 0000664 0000000 0000000 00000001523 13600575677 0021404 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
import Map from 'core-js-pure/features/map';
import toArray from 'core-js-pure/features/array/from';
QUnit.test('Map.groupBy', assert => {
const { groupBy } = Map;
assert.isFunction(groupBy);
assert.arity(groupBy, 2);
assert.name(groupBy, 'groupBy');
assert.ok(Map.groupBy([], it => it) instanceof Map);
assert.deepEqual(toArray(Map.groupBy([], it => it)), []);
assert.deepEqual(toArray(Map.groupBy([1, 2], it => it ** 2)), [[1, [1]], [4, [2]]]);
assert.deepEqual(toArray(Map.groupBy([1, 2, 1], it => it ** 2)), [[1, [1, 1]], [4, [2]]]);
assert.deepEqual(toArray(Map.groupBy(createIterable([1, 2]), it => it ** 2)), [[1, [1]], [4, [2]]]);
const element = {};
Map.groupBy([element], it => assert.same(it, element));
assert.throws(() => groupBy([1, 2], it => it));
});
core-js-3.6.1/tests/pure/esnext.map.includes.js 0000664 0000000 0000000 00000001453 13600575677 0021450 0 ustar 00root root 0000000 0000000 import Map from 'core-js-pure/features/map';
QUnit.test('Map#includes', assert => {
const { includes } = Map.prototype;
assert.isFunction(includes);
assert.name(includes, 'includes');
assert.arity(includes, 1);
assert.nonEnumerable(Map.prototype, 'includes');
const object = {};
const map = new Map([[1, 1], [2, 2], [3, 3], [4, -0], [5, object], [6, NaN]]);
assert.ok(map.includes(1));
assert.ok(map.includes(-0));
assert.ok(map.includes(0));
assert.ok(map.includes(object));
assert.ok(!map.includes(4));
assert.ok(!map.includes(-0.5));
assert.ok(!map.includes({}));
assert.ok(map.includes(NaN));
assert.throws(() => includes.call({}, 1), TypeError);
assert.throws(() => includes.call(undefined, 1), TypeError);
assert.throws(() => includes.call(null, 1), TypeError);
});
core-js-3.6.1/tests/pure/esnext.map.key-by.js 0000664 0000000 0000000 00000001452 13600575677 0021041 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
import Map from 'core-js-pure/features/map';
import toArray from 'core-js-pure/features/array/from';
QUnit.test('Map.keyBy', assert => {
const { keyBy } = Map;
assert.isFunction(keyBy);
assert.arity(keyBy, 2);
assert.name(keyBy, 'keyBy');
assert.ok(Map.keyBy([], it => it) instanceof Map);
assert.deepEqual(toArray(Map.keyBy([], it => it)), []);
assert.deepEqual(toArray(Map.keyBy([1, 2], it => it ** 2)), [[1, 1], [4, 2]]);
assert.deepEqual(toArray(Map.keyBy([1, 2, 1], it => it ** 2)), [[1, 1], [4, 2]]);
assert.deepEqual(toArray(Map.keyBy(createIterable([1, 2]), it => it ** 2)), [[1, 1], [4, 2]]);
const element = {};
Map.keyBy([element], it => assert.same(it, element));
assert.throws(() => keyBy([1, 2], it => it));
});
core-js-3.6.1/tests/pure/esnext.map.key-of.js 0000664 0000000 0000000 00000001433 13600575677 0021032 0 ustar 00root root 0000000 0000000 import Map from 'core-js-pure/features/map';
QUnit.test('Map#keyOf', assert => {
const { keyOf } = Map.prototype;
assert.isFunction(keyOf);
assert.arity(keyOf, 1);
assert.nonEnumerable(Map.prototype, 'keyOf');
const object = {};
const map = new Map([[1, 1], [2, 2], [3, 3], [4, -0], [5, object], [6, NaN]]);
assert.same(map.keyOf(1), 1);
assert.same(map.keyOf(-0), 4);
assert.same(map.keyOf(0), 4);
assert.same(map.keyOf(object), 5);
assert.same(map.keyOf(4), undefined);
assert.same(map.keyOf(-0.5), undefined);
assert.same(map.keyOf({}), undefined);
assert.same(map.keyOf(NaN), undefined);
assert.throws(() => keyOf.call({}, 1), TypeError);
assert.throws(() => keyOf.call(undefined, 1), TypeError);
assert.throws(() => keyOf.call(null, 1), TypeError);
});
core-js-3.6.1/tests/pure/esnext.map.map-keys.js 0000664 0000000 0000000 00000002554 13600575677 0021373 0 ustar 00root root 0000000 0000000 import Map from 'core-js-pure/features/map';
import from from 'core-js-pure/features/array/from';
QUnit.test('Map#mapKeys', assert => {
const { mapKeys } = Map.prototype;
assert.isFunction(mapKeys);
assert.arity(mapKeys, 1);
assert.name(mapKeys, 'mapKeys');
assert.nonEnumerable(Map.prototype, 'mapKeys');
const map = new Map([[1, 2]]);
const context = {};
map.mapKeys(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.ok(new Map().mapKeys(it => it) instanceof Map);
assert.deepEqual(from(new Map([
['a', 1],
[1, 2],
['b', 3],
[2, 'q'],
['c', {}],
[3, 4],
['d', true],
[4, 5],
]).mapKeys((value, key) => `${ key }${ value }`)), [
['a1', 1],
['12', 2],
['b3', 3],
['2q', 'q'],
['c[object Object]', {}],
['34', 4],
['dtrue', true],
['45', 5],
]);
assert.throws(() => mapKeys.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => mapKeys.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => mapKeys.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.map.map-values.js 0000664 0000000 0000000 00000002610 13600575677 0021710 0 ustar 00root root 0000000 0000000 import Map from 'core-js-pure/features/map';
import from from 'core-js-pure/features/array/from';
QUnit.test('Map#mapValues', assert => {
const { mapValues } = Map.prototype;
assert.isFunction(mapValues);
assert.arity(mapValues, 1);
assert.name(mapValues, 'mapValues');
assert.nonEnumerable(Map.prototype, 'mapValues');
const map = new Map([[1, 2]]);
const context = {};
map.mapValues(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.ok(new Map().mapValues(it => it) instanceof Map);
assert.deepEqual(from(new Map([
['a', 1],
[1, 2],
['b', 3],
[2, 'q'],
['c', {}],
[3, 4],
['d', true],
[4, 5],
]).mapValues((value, key) => `${ key }${ value }`)), [
['a', 'a1'],
[1, '12'],
['b', 'b3'],
[2, '2q'],
['c', 'c[object Object]'],
[3, '34'],
['d', 'dtrue'],
[4, '45'],
]);
assert.throws(() => mapValues.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => mapValues.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => mapValues.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.map.merge.js 0000664 0000000 0000000 00000001775 13600575677 0020750 0 ustar 00root root 0000000 0000000 import Map from 'core-js-pure/features/map';
import from from 'core-js-pure/features/array/from';
QUnit.test('Map#merge', assert => {
const { merge } = Map.prototype;
assert.isFunction(merge);
assert.arity(merge, 1);
assert.name(merge, 'merge');
assert.nonEnumerable(Map.prototype, 'merge');
const map = new Map([[1, 2]]);
const result = map.merge([[3, 4]]);
assert.ok(result === map);
assert.ok(result instanceof Map);
assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([[5, 6]])), [[1, 2], [3, 4], [5, 6]]);
assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([[3, 5], [5, 6]])), [[1, 2], [3, 5], [5, 6]]);
assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([])), [[1, 2], [3, 4]]);
assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([[3, 5]], [[5, 6]])), [[1, 2], [3, 5], [5, 6]]);
assert.throws(() => merge.call({}, [[1, 2]]), TypeError);
assert.throws(() => merge.call(undefined, [[1, 2]]), TypeError);
assert.throws(() => merge.call(null, [[1, 2]]), TypeError);
});
core-js-3.6.1/tests/pure/esnext.map.of.js 0000664 0000000 0000000 00000001024 13600575677 0020240 0 ustar 00root root 0000000 0000000 import Map from 'core-js-pure/features/map';
import toArray from 'core-js-pure/features/array/from';
QUnit.test('Map.of', assert => {
const { of } = Map;
assert.isFunction(of);
assert.arity(of, 0);
assert.ok(Map.of() instanceof Map);
assert.deepEqual(toArray(Map.of([1, 2])), [[1, 2]]);
assert.deepEqual(toArray(Map.of([1, 2], [2, 3], [1, 4])), [[1, 4], [2, 3]]);
assert.throws(() => of(1));
let arg = null;
function F(it) {
return arg = it;
}
of.call(F, 1, 2, 3);
assert.deepEqual(arg, [1, 2, 3]);
});
core-js-3.6.1/tests/pure/esnext.map.reduce.js 0000664 0000000 0000000 00000003434 13600575677 0021112 0 ustar 00root root 0000000 0000000 import Map from 'core-js-pure/features/map';
QUnit.test('Map#reduce', assert => {
const { reduce } = Map.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.name(reduce, 'reduce');
assert.nonEnumerable(Map.prototype, 'reduce');
const set = new Map([['a', 1]]);
const accumulator = {};
set.reduce(function (memo, value, key, that) {
assert.same(arguments.length, 4, 'correct number of callback arguments');
assert.same(memo, accumulator, 'correct callback accumulator');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 'a', 'correct index in callback');
assert.same(that, set, 'correct link to set in callback');
}, accumulator);
assert.same(new Map([
['a', 1],
['b', 2],
['c', 3],
]).reduce(((a, b) => a + b), 1), 7, 'works with initial accumulator');
new Map([
['a', 1],
['b', 2],
]).reduce((memo, value, key) => {
assert.same(memo, 1, 'correct default accumulator');
assert.same(value, 2, 'correct start value without initial accumulator');
assert.same(key, 'b', 'correct start index without initial accumulator');
});
assert.same(new Map([
['a', 1],
['b', 2],
['c', 3],
]).reduce((a, b) => a + b), 6, 'works without initial accumulator');
let values = '';
let keys = '';
new Map([
['a', 1],
['b', 2],
['c', 3],
]).reduce((memo, value, key, s) => {
s.delete('b');
values += value;
keys += key;
}, 0);
assert.same(values, '13', 'correct order #1');
assert.same(keys, 'ac', 'correct order #2');
assert.throws(() => reduce.call({}, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(undefined, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(null, () => { /* empty */ }, 1), TypeError);
});
core-js-3.6.1/tests/pure/esnext.map.some.js 0000664 0000000 0000000 00000002532 13600575677 0020604 0 ustar 00root root 0000000 0000000 import Map from 'core-js-pure/features/map';
QUnit.test('Map#some', assert => {
const { some } = Map.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.name(some, 'some');
assert.nonEnumerable(Map.prototype, 'some');
let map = new Map([[9, 1]]);
const context = {};
map.some(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 9, 'correct index in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
map = new Map([[0, 1], [1, '2'], [2, 3]]);
assert.ok(map.some(it => typeof it === 'number'));
assert.ok(map.some(it => it < 3));
assert.ok(!map.some(it => it < 0));
assert.ok(map.some(it => typeof it === 'string'));
assert.ok(!map.some(function () {
return +this !== 1;
}, 1));
let result = '';
map.some((value, key) => {
result += key;
return false;
});
assert.same(result, '012');
assert.ok(map.some((value, key, that) => that === map));
assert.throws(() => some.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.map.update-or-insert.js 0000664 0000000 0000000 00000003333 13600575677 0023043 0 ustar 00root root 0000000 0000000 import Map from 'core-js-pure/features/map';
QUnit.test('Map#updateOrInsert', assert => {
const { updateOrInsert } = Map.prototype;
assert.isFunction(updateOrInsert);
assert.arity(updateOrInsert, 2);
assert.name(updateOrInsert, 'upsert');
assert.nonEnumerable(Map.prototype, 'updateOrInsert');
const map = new Map([['a', 2]]);
assert.same(map.updateOrInsert('a', function (value) {
assert.same(arguments.length, 1, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
return value ** 2;
}, () => {
assert.ok(false, 'should not be called');
return 3;
}), 4, 'returns a correct value');
assert.same(map.updateOrInsert('b', value => {
assert.ok(false, 'should not be called');
return value ** 2;
}, function () {
assert.same(arguments.length, 0, 'correct number of callback arguments');
return 3;
}), 3, 'returns a correct value');
assert.same(map.size, 2, 'correct size');
assert.same(map.get('a'), 4, 'correct result #1');
assert.same(map.get('b'), 3, 'correct result #2');
assert.same(new Map([['a', 2]]).updateOrInsert('b', null, () => 3), 3);
assert.same(new Map([['a', 2]]).updateOrInsert('a', value => value ** 2), 4);
assert.throws(() => new Map().updateOrInsert('a'), TypeError);
assert.throws(() => updateOrInsert.call({}, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => updateOrInsert.call([], 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => updateOrInsert.call(undefined, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => updateOrInsert.call(null, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.map.update.js 0000664 0000000 0000000 00000003570 13600575677 0021126 0 ustar 00root root 0000000 0000000 import Map from 'core-js-pure/features/map';
QUnit.test('Map#update', assert => {
const { update } = Map.prototype;
assert.isFunction(update);
assert.arity(update, 2);
assert.name(update, 'update');
assert.nonEnumerable(Map.prototype, 'update');
let map = new Map([[9, 2]]);
assert.same(map.update(9, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 9, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
return value * 2;
}), map, 'returns this');
assert.same(map.size, 1, 'correct size');
assert.same(map.get(9), 4, 'correct result');
map = new Map([[4, 5]]);
map.update(9, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 9, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
return value * 2;
}, function (key, that) {
assert.same(arguments.length, 2, 'correct number of thunk arguments');
assert.same(key, 9, 'correct key in thunk');
assert.same(that, map, 'correct link to map in thunk');
return 2;
});
assert.same(map.size, 2, 'correct size');
assert.same(map.get(4), 5, 'correct result #1');
assert.same(map.get(9), 4, 'correct result #2');
assert.throws(() => new Map([[9, 2]]).update(9), TypeError);
assert.throws(() => new Map().update(9, () => { /* empty */ }), TypeError);
assert.throws(() => update.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => update.call([], () => { /* empty */ }), TypeError);
assert.throws(() => update.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => update.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.map.upsert.js 0000664 0000000 0000000 00000003143 13600575677 0021162 0 ustar 00root root 0000000 0000000 import Map from 'core-js-pure/features/map';
QUnit.test('Map#upsert', assert => {
const { upsert } = Map.prototype;
assert.isFunction(upsert);
assert.arity(upsert, 2);
assert.name(upsert, 'upsert');
assert.nonEnumerable(Map.prototype, 'upsert');
const map = new Map([['a', 2]]);
assert.same(map.upsert('a', function (value) {
assert.same(arguments.length, 1, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
return value ** 2;
}, () => {
assert.ok(false, 'should not be called');
return 3;
}), 4, 'returns a correct value');
assert.same(map.upsert('b', value => {
assert.ok(false, 'should not be called');
return value ** 2;
}, function () {
assert.same(arguments.length, 0, 'correct number of callback arguments');
return 3;
}), 3, 'returns a correct value');
assert.same(map.size, 2, 'correct size');
assert.same(map.get('a'), 4, 'correct result #1');
assert.same(map.get('b'), 3, 'correct result #2');
assert.same(new Map([['a', 2]]).upsert('b', null, () => 3), 3);
assert.same(new Map([['a', 2]]).upsert('a', value => value ** 2), 4);
assert.throws(() => new Map().upsert('a'), TypeError);
assert.throws(() => upsert.call({}, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call([], 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call(undefined, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call(null, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.math.clamp.js 0000664 0000000 0000000 00000000374 13600575677 0021113 0 ustar 00root root 0000000 0000000 import clamp from 'core-js-pure/features/math/clamp';
QUnit.test('Math.clamp', assert => {
assert.isFunction(clamp);
assert.arity(clamp, 3);
assert.same(clamp(2, 4, 6), 4);
assert.same(clamp(4, 2, 6), 4);
assert.same(clamp(6, 2, 4), 4);
});
core-js-3.6.1/tests/pure/esnext.math.deg-per-rad.js 0000664 0000000 0000000 00000000270 13600575677 0022101 0 ustar 00root root 0000000 0000000 import DEG_PER_RAD from 'core-js-pure/features/math/deg-per-rad';
QUnit.test('Math.DEG_PER_RAD', assert => {
assert.strictEqual(DEG_PER_RAD, Math.PI / 180, 'Is Math.PI / 180');
});
core-js-3.6.1/tests/pure/esnext.math.degrees.js 0000664 0000000 0000000 00000000473 13600575677 0021435 0 ustar 00root root 0000000 0000000 import degrees from 'core-js-pure/features/math/degrees';
QUnit.test('Math.degrees', assert => {
assert.isFunction(degrees);
assert.arity(degrees, 1);
assert.same(degrees(0), 0);
assert.same(degrees(Math.PI / 2), 90);
assert.same(degrees(Math.PI), 180);
assert.same(degrees(3 * Math.PI / 2), 270);
});
core-js-3.6.1/tests/pure/esnext.math.fscale.js 0000664 0000000 0000000 00000000511 13600575677 0021245 0 ustar 00root root 0000000 0000000 import fscale from 'core-js-pure/features/math/fscale';
QUnit.test('Math.fscale', assert => {
assert.isFunction(fscale);
assert.arity(fscale, 5);
assert.same(fscale(3, 1, 2, 1, 2), 3);
assert.same(fscale(0, 3, 5, 8, 10), 5);
assert.same(fscale(1, 1, 1, 1, 1), NaN);
assert.same(fscale(-1, -1, -1, -1, -1), NaN);
});
core-js-3.6.1/tests/pure/esnext.math.iaddh.js 0000664 0000000 0000000 00000000541 13600575677 0021064 0 ustar 00root root 0000000 0000000 import iaddh from 'core-js-pure/features/math/iaddh';
QUnit.test('Math.iaddh', assert => {
assert.isFunction(iaddh);
assert.arity(iaddh, 4);
assert.same(iaddh(0, 2, 1, 0), 2);
assert.same(iaddh(0, 4, 1, 1), 5);
assert.same(iaddh(2, 4, 1, 1), 5);
assert.same(iaddh(0xFFFFFFFF, 4, 1, 1), 6);
assert.same(iaddh(1, 4, 0xFFFFFFFF, 1), 6);
});
core-js-3.6.1/tests/pure/esnext.math.imulh.js 0000664 0000000 0000000 00000000447 13600575677 0021136 0 ustar 00root root 0000000 0000000 import imulh from 'core-js-pure/features/math/imulh';
QUnit.test('Math.imulh', assert => {
assert.isFunction(imulh);
assert.arity(imulh, 2);
assert.same(imulh(0xFFFFFFFF, 7), -1);
assert.same(imulh(0xFFFFFFF, 77), 4);
assert.same(imulh(1, 7), 0);
assert.same(imulh(-1, 7), -1);
});
core-js-3.6.1/tests/pure/esnext.math.isubh.js 0000664 0000000 0000000 00000000541 13600575677 0021125 0 ustar 00root root 0000000 0000000 import isubh from 'core-js-pure/features/math/isubh';
QUnit.test('Math.isubh', assert => {
assert.isFunction(isubh);
assert.arity(isubh, 4);
assert.same(isubh(0, 2, 1, 0), 1);
assert.same(isubh(0, 4, 1, 1), 2);
assert.same(isubh(2, 4, 1, 1), 3);
assert.same(isubh(0xFFFFFFFF, 4, 1, 1), 3);
assert.same(isubh(1, 4, 0xFFFFFFFF, 1), 2);
});
core-js-3.6.1/tests/pure/esnext.math.rad-per-deg.js 0000664 0000000 0000000 00000000270 13600575677 0022101 0 ustar 00root root 0000000 0000000 import RAD_PER_DEG from 'core-js-pure/features/math/rad-per-deg';
QUnit.test('Math.RAD_PER_DEG', assert => {
assert.strictEqual(RAD_PER_DEG, 180 / Math.PI, 'Is 180 / Math.PI');
});
core-js-3.6.1/tests/pure/esnext.math.radians.js 0000664 0000000 0000000 00000000473 13600575677 0021440 0 ustar 00root root 0000000 0000000 import radians from 'core-js-pure/features/math/radians';
QUnit.test('Math.radians', assert => {
assert.isFunction(radians);
assert.arity(radians, 1);
assert.same(radians(0), 0);
assert.same(radians(90), Math.PI / 2);
assert.same(radians(180), Math.PI);
assert.same(radians(270), 3 * Math.PI / 2);
});
core-js-3.6.1/tests/pure/esnext.math.scale.js 0000664 0000000 0000000 00000000500 13600575677 0021075 0 ustar 00root root 0000000 0000000 import scale from 'core-js-pure/features/math/scale';
QUnit.test('Math.scale', assert => {
assert.isFunction(scale);
assert.arity(scale, 5);
assert.same(scale(3, 1, 2, 1, 2), 3);
assert.same(scale(0, 3, 5, 8, 10), 5);
assert.same(scale(1, 1, 1, 1, 1), NaN);
assert.same(scale(-1, -1, -1, -1, -1), NaN);
});
core-js-3.6.1/tests/pure/esnext.math.seeded-prng.js 0000664 0000000 0000000 00000002402 13600575677 0022206 0 ustar 00root root 0000000 0000000 import seededPRNG from 'core-js-pure/features/math/seeded-prng';
QUnit.test('Math.seededPRNG', assert => {
assert.isFunction(seededPRNG);
assert.arity(seededPRNG, 1);
for (const gen of [seededPRNG({ seed: 42 }), seededPRNG({ seed: 42 })]) {
assert.deepEqual(gen.next(), { value: 0.16461519912315087, done: false });
assert.deepEqual(gen.next(), { value: 0.2203933906000046, done: false });
assert.deepEqual(gen.next(), { value: 0.8249682894209105, done: false });
assert.deepEqual(gen.next(), { value: 0.10750079537509083, done: false });
assert.deepEqual(gen.next(), { value: 0.004673248161257476, done: false });
}
for (const gen of [seededPRNG({ seed: 43 }), seededPRNG({ seed: 43 })]) {
assert.deepEqual(gen.next(), { value: 0.1923438591811283, done: false });
assert.deepEqual(gen.next(), { value: 0.7896811578326683, done: false });
assert.deepEqual(gen.next(), { value: 0.9518230761883996, done: false });
assert.deepEqual(gen.next(), { value: 0.1414634102410296, done: false });
assert.deepEqual(gen.next(), { value: 0.7379838030207752, done: false });
}
assert.throws(() => seededPRNG(), TypeError);
assert.throws(() => seededPRNG(5), TypeError);
assert.throws(() => seededPRNG({ seed: null }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.math.signbit.js 0000664 0000000 0000000 00000001123 13600575677 0021447 0 ustar 00root root 0000000 0000000 import signbit from 'core-js-pure/features/math/signbit';
QUnit.test('Math.signbit', assert => {
assert.isFunction(signbit);
assert.strictEqual(signbit(NaN), false);
assert.strictEqual(signbit(), false);
assert.strictEqual(signbit(-0), true);
assert.strictEqual(signbit(0), false);
assert.strictEqual(signbit(Infinity), false);
assert.strictEqual(signbit(-Infinity), true);
assert.strictEqual(signbit(13510798882111488), false);
assert.strictEqual(signbit(-13510798882111488), true);
assert.strictEqual(signbit(42.5), false);
assert.strictEqual(signbit(-42.5), true);
});
core-js-3.6.1/tests/pure/esnext.math.umulh.js 0000664 0000000 0000000 00000000445 13600575677 0021150 0 ustar 00root root 0000000 0000000 import umulh from 'core-js-pure/features/math/umulh';
QUnit.test('Math.umulh', assert => {
assert.isFunction(umulh);
assert.arity(umulh, 2);
assert.same(umulh(0xFFFFFFFF, 7), 6);
assert.same(umulh(0xFFFFFFF, 77), 4);
assert.same(umulh(1, 7), 0);
assert.same(umulh(-1, 7), 6);
});
core-js-3.6.1/tests/pure/esnext.number.from-string.js 0000664 0000000 0000000 00000003740 13600575677 0022625 0 ustar 00root root 0000000 0000000 import fromString from 'core-js-pure/features/number/from-string';
QUnit.test('Number.fromString', assert => {
assert.isFunction(fromString);
assert.name(fromString, 'fromString');
assert.arity(fromString, 2);
assert.throws(() => fromString(undefined), TypeError, 'The first argument should be a string #1');
assert.throws(() => fromString(Object('10')), TypeError, 'The first argument should be a string #1');
assert.throws(() => fromString(''), SyntaxError, 'Empty string');
assert.same(fromString('-10', 2), -2, 'Works with negative numbers');
assert.throws(() => fromString('-'), SyntaxError, '-');
assert.same(fromString('10'), 10, 'Default radix is 10 #1');
assert.same(fromString('10', undefined), 10, 'Default radix is 10 #2');
for (let radix = 2; radix <= 36; ++radix) {
assert.same(fromString('10', radix), radix, `Radix ${ radix }`);
}
assert.throws(() => fromString('10', -4294967294), RangeError, 'Radix uses ToInteger #1');
assert.same(fromString('10', 2.5), 2, 'Radix uses ToInteger #2');
assert.same(fromString('42'), 42);
assert.same(fromString('42', 10), 42);
assert.throws(() => fromString('0xc0ffee'), SyntaxError);
assert.throws(() => fromString('0o755'), SyntaxError);
assert.throws(() => fromString('0b00101010'), SyntaxError);
assert.throws(() => fromString('C0FFEE', 16), SyntaxError);
assert.same(fromString('c0ffee', 16), 12648430);
assert.same(fromString('755', 8), 493);
assert.throws(() => fromString(''), SyntaxError);
assert.throws(() => fromString(' '), SyntaxError);
assert.throws(() => fromString(' 1'), SyntaxError);
assert.throws(() => fromString(' \n '), SyntaxError);
assert.throws(() => fromString('x'), SyntaxError);
assert.throws(() => fromString('1234', 0), RangeError);
assert.throws(() => fromString('1234', 1), RangeError);
assert.throws(() => fromString('1234', 37), RangeError);
assert.throws(() => fromString('010'), SyntaxError);
assert.throws(() => fromString('1_000_000_000'), SyntaxError);
});
core-js-3.6.1/tests/pure/esnext.object.iterate-entries.js 0000664 0000000 0000000 00000001454 13600575677 0023440 0 ustar 00root root 0000000 0000000 import iterateEntries from 'core-js-pure/features/object/iterate-entries';
import TO_STRING_TAG from 'core-js-pure/features/symbol/to-string-tag';
QUnit.test('Object.iterateEntries', assert => {
assert.isFunction(iterateEntries);
assert.name(iterateEntries, 'iterateEntries');
assert.arity(iterateEntries, 1);
const object = {
q: 1,
w: 2,
e: 3,
};
const iterator = iterateEntries(object);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[TO_STRING_TAG], 'Object Iterator');
assert.deepEqual(iterator.next(), {
value: ['q', 1],
done: false,
});
delete object.w;
assert.deepEqual(iterator.next(), {
value: ['e', 3],
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
core-js-3.6.1/tests/pure/esnext.object.iterate-keys.js 0000664 0000000 0000000 00000001412 13600575677 0022734 0 ustar 00root root 0000000 0000000 import iterateKeys from 'core-js-pure/features/object/iterate-keys';
import TO_STRING_TAG from 'core-js-pure/features/symbol/to-string-tag';
QUnit.test('Object.iterateKeys', assert => {
assert.isFunction(iterateKeys);
assert.name(iterateKeys, 'iterateKeys');
assert.arity(iterateKeys, 1);
const object = {
q: 1,
w: 2,
e: 3,
};
const iterator = iterateKeys(object);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[TO_STRING_TAG], 'Object Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
delete object.w;
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
core-js-3.6.1/tests/pure/esnext.object.iterate-values.js 0000664 0000000 0000000 00000001426 13600575677 0023265 0 ustar 00root root 0000000 0000000 import iterateValues from 'core-js-pure/features/object/iterate-values';
import TO_STRING_TAG from 'core-js-pure/features/symbol/to-string-tag';
QUnit.test('Object.iterateValues', assert => {
assert.isFunction(iterateValues);
assert.name(iterateValues, 'iterateValues');
assert.arity(iterateValues, 1);
const object = {
q: 1,
w: 2,
e: 3,
};
const iterator = iterateValues(object);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[TO_STRING_TAG], 'Object Iterator');
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
});
delete object.w;
assert.deepEqual(iterator.next(), {
value: 3,
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
core-js-3.6.1/tests/pure/esnext.observable.js 0000664 0000000 0000000 00000003626 13600575677 0021216 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import { Observable, Symbol } from 'core-js-pure';
QUnit.test('Observable', assert => {
assert.isFunction(Observable);
assert.arity(Observable, 1);
assert.throws(() => Observable(() => { /* empty */ }), 'throws w/o `new`');
const observable = new Observable(function (subscriptionObserver) {
assert.same(typeof subscriptionObserver, 'object', 'Subscription observer is object');
assert.same(subscriptionObserver.constructor, Object);
const { next, error, complete } = subscriptionObserver;
assert.isFunction(next);
assert.isFunction(error);
assert.isFunction(complete);
assert.arity(next, 1);
assert.arity(error, 1);
assert.arity(complete, 0);
if (STRICT) {
assert.same(this, undefined, 'correct executor context');
}
});
observable.subscribe({});
assert.ok(observable instanceof Observable);
});
QUnit.test('Observable#subscribe', assert => {
assert.isFunction(Observable.prototype.subscribe);
assert.arity(Observable.prototype.subscribe, 1);
const subscription = new Observable(() => { /* empty */ }).subscribe({});
assert.same(typeof subscription, 'object', 'Subscription is object');
assert.same(subscription.constructor, Object);
assert.isFunction(subscription.unsubscribe);
assert.arity(subscription.unsubscribe, 0);
});
QUnit.test('Observable#constructor', assert => {
assert.same(Observable.prototype.constructor, Observable);
});
QUnit.test('Observable#@@observable', assert => {
assert.isFunction(Observable.prototype[Symbol.observable]);
const observable = new Observable(() => { /* empty*/ });
assert.same(observable[Symbol.observable](), observable);
});
QUnit.test('Observable.of', assert => {
assert.isFunction(Observable.of);
assert.arity(Observable.of, 0);
});
QUnit.test('Observable.from', assert => {
assert.isFunction(Observable.from);
assert.arity(Observable.from, 1);
});
core-js-3.6.1/tests/pure/esnext.promise.any.js 0000664 0000000 0000000 00000002642 13600575677 0021333 0 ustar 00root root 0000000 0000000 import { AggregateError, Promise } from 'core-js-pure/features';
QUnit.test('Promise.any', assert => {
assert.isFunction(Promise.any);
assert.arity(Promise.any, 1);
assert.ok(Promise.any([1, 2, 3]) instanceof Promise, 'returns a promise');
});
QUnit.test('Promise.any, resolved', assert => {
assert.expect(1);
const async = assert.async();
Promise.any([
Promise.resolve(1),
Promise.reject(2),
Promise.resolve(3),
]).then(it => {
assert.same(it, 1, 'resolved with a correct value');
async();
});
});
QUnit.test('Promise.any, rejected #1', assert => {
assert.expect(2);
const async = assert.async();
Promise.any([
Promise.reject(1),
Promise.reject(2),
Promise.reject(3),
]).catch(error => {
assert.ok(error instanceof AggregateError, 'instanceof AggregateError');
assert.deepEqual(error.errors, [1, 2, 3], 'rejected with a correct value');
async();
});
});
QUnit.test('Promise.any, rejected #2', assert => {
assert.expect(1);
const async = assert.async();
Promise.any().catch(() => {
assert.ok(true, 'rejected as expected');
async();
});
});
QUnit.test('Promise.any, rejected #3', assert => {
assert.expect(2);
const async = assert.async();
Promise.any([]).catch(error => {
assert.ok(error instanceof AggregateError, 'instanceof AggregateError');
assert.deepEqual(error.errors, [], 'rejected with a correct value');
async();
});
});
core-js-3.6.1/tests/pure/esnext.promise.try.js 0000664 0000000 0000000 00000001262 13600575677 0021357 0 ustar 00root root 0000000 0000000 import Promise from 'core-js-pure/features/promise';
QUnit.test('Promise.try', assert => {
assert.isFunction(Promise.try);
assert.arity(Promise.try, 1);
assert.ok(Promise.try(() => 42) instanceof Promise, 'returns a promise');
});
QUnit.test('Promise.try, resolved', assert => {
assert.expect(1);
const async = assert.async();
Promise.try(() => 42).then(it => {
assert.same(it, 42, 'resolved with a correct value');
async();
});
});
QUnit.test('Promise.try, rejected', assert => {
assert.expect(1);
const async = assert.async();
Promise.try(() => {
throw new Error();
}).catch(() => {
assert.ok(true, 'rejected as expected');
async();
});
});
core-js-3.6.1/tests/pure/esnext.reflect.define-metadata.js 0000664 0000000 0000000 00000000661 13600575677 0023521 0 ustar 00root root 0000000 0000000 import defineMetadata from 'core-js-pure/features/reflect/define-metadata';
QUnit.test('Reflect.defineMetadata', assert => {
assert.isFunction(defineMetadata);
assert.arity(defineMetadata, 3);
assert.throws(() => defineMetadata('key', 'value', undefined, undefined), TypeError);
assert.same(defineMetadata('key', 'value', {}, undefined), undefined);
assert.same(defineMetadata('key', 'value', {}, 'name'), undefined);
});
core-js-3.6.1/tests/pure/esnext.reflect.delete-metadata.js 0000664 0000000 0000000 00000001565 13600575677 0023535 0 ustar 00root root 0000000 0000000 import { defineMetadata, hasOwnMetadata, deleteMetadata } from 'core-js-pure/features/reflect';
import create from 'core-js-pure/features/object/create';
QUnit.test('Reflect.deleteMetadata', assert => {
assert.isFunction(deleteMetadata);
assert.arity(deleteMetadata, 2);
assert.throws(() => deleteMetadata('key', undefined, undefined), TypeError);
assert.same(deleteMetadata('key', {}, undefined), false);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.same(deleteMetadata('key', object, undefined), true);
const prototype = {};
defineMetadata('key', 'value', prototype, undefined);
assert.same(deleteMetadata('key', create(prototype), undefined), false);
object = {};
defineMetadata('key', 'value', object, undefined);
deleteMetadata('key', object, undefined);
assert.same(hasOwnMetadata('key', object, undefined), false);
});
core-js-3.6.1/tests/pure/esnext.reflect.get-metadata-keys.js 0000664 0000000 0000000 00000004432 13600575677 0024017 0 ustar 00root root 0000000 0000000 import { defineMetadata, getMetadataKeys } from 'core-js-pure/features/reflect';
import create from 'core-js-pure/features/object/create';
QUnit.test('Reflect.getMetadataKeys', assert => {
assert.isFunction(getMetadataKeys);
assert.arity(getMetadataKeys, 1);
assert.throws(() => getMetadataKeys(undefined, undefined), TypeError);
assert.deepEqual(getMetadataKeys({}, undefined), []);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key']);
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key']);
object = {};
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key0', 'key1']);
object = {};
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
defineMetadata('key0', 'value', object, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key0', 'key1']);
prototype = {};
defineMetadata('key2', 'value', prototype, undefined);
object = create(prototype);
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key0', 'key1', 'key2']);
object = {};
assert.deepEqual(getMetadataKeys({}, 'name'), []);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.deepEqual(getMetadataKeys(object, 'name'), ['key']);
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.deepEqual(getMetadataKeys(object, 'name'), ['key']);
object = {};
defineMetadata('key0', 'value', object, 'name');
defineMetadata('key1', 'value', object, 'name');
defineMetadata('key0', 'value', object, 'name');
assert.deepEqual(getMetadataKeys(object, 'name'), ['key0', 'key1']);
prototype = {};
defineMetadata('key2', 'value', prototype, 'name');
object = create(prototype);
defineMetadata('key0', 'value', object, 'name');
defineMetadata('key1', 'value', object, 'name');
assert.deepEqual(getMetadataKeys(object, 'name'), ['key0', 'key1', 'key2']);
});
core-js-3.6.1/tests/pure/esnext.reflect.get-metadata.js 0000664 0000000 0000000 00000002017 13600575677 0023043 0 ustar 00root root 0000000 0000000 import { defineMetadata, getMetadata } from 'core-js-pure/features/reflect';
import create from 'core-js-pure/features/object/create';
QUnit.test('Reflect.getMetadata', assert => {
assert.isFunction(getMetadata);
assert.arity(getMetadata, 2);
assert.throws(() => getMetadata('key', undefined, undefined), TypeError);
assert.same(getMetadata('key', {}, undefined), undefined);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.same(getMetadata('key', object, undefined), 'value');
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.same(getMetadata('key', object, undefined), 'value');
assert.same(getMetadata('key', {}, 'name'), undefined);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.same(getMetadata('key', object, 'name'), 'value');
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.same(getMetadata('key', object, 'name'), 'value');
});
core-js-3.6.1/tests/pure/esnext.reflect.get-own-matadata.js 0000664 0000000 0000000 00000002064 13600575677 0023642 0 ustar 00root root 0000000 0000000 import { defineMetadata, getOwnMetadata } from 'core-js-pure/features/reflect';
import create from 'core-js-pure/features/object/create';
QUnit.test('Reflect.getOwnMetadata', assert => {
assert.isFunction(getOwnMetadata);
assert.arity(getOwnMetadata, 2);
assert.throws(() => getOwnMetadata('key', undefined, undefined), TypeError);
assert.same(getOwnMetadata('key', {}, undefined), undefined);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.same(getOwnMetadata('key', object, undefined), 'value');
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.same(getOwnMetadata('key', object, undefined), undefined);
assert.same(getOwnMetadata('key', {}, 'name'), undefined);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.same(getOwnMetadata('key', object, 'name'), 'value');
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.same(getOwnMetadata('key', object, 'name'), undefined);
});
core-js-3.6.1/tests/pure/esnext.reflect.get-own-metadata-keys.js 0000664 0000000 0000000 00000004460 13600575677 0024621 0 ustar 00root root 0000000 0000000 import { defineMetadata, getOwnMetadataKeys } from 'core-js-pure/features/reflect';
import create from 'core-js-pure/features/object/create';
QUnit.test('Reflect.getOwnMetadataKeys', assert => {
assert.isFunction(getOwnMetadataKeys);
assert.arity(getOwnMetadataKeys, 1);
assert.throws(() => getOwnMetadataKeys(undefined, undefined), TypeError);
assert.deepEqual(getOwnMetadataKeys({}, undefined), []);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.deepEqual(getOwnMetadataKeys(object, undefined), ['key']);
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.deepEqual(getOwnMetadataKeys(object, undefined), []);
object = {};
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
assert.deepEqual(getOwnMetadataKeys(object, undefined), ['key0', 'key1']);
object = {};
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
defineMetadata('key0', 'value', object, undefined);
assert.deepEqual(getOwnMetadataKeys(object, undefined), ['key0', 'key1']);
prototype = {};
defineMetadata('key2', 'value', prototype, undefined);
object = create(prototype);
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
assert.deepEqual(getOwnMetadataKeys(object, undefined), ['key0', 'key1']);
object = {};
assert.deepEqual(getOwnMetadataKeys({}, 'name'), []);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.deepEqual(getOwnMetadataKeys(object, 'name'), ['key']);
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.deepEqual(getOwnMetadataKeys(object, 'name'), []);
object = {};
defineMetadata('key0', 'value', object, 'name');
defineMetadata('key1', 'value', object, 'name');
defineMetadata('key0', 'value', object, 'name');
assert.deepEqual(getOwnMetadataKeys(object, 'name'), ['key0', 'key1']);
prototype = {};
defineMetadata('key2', 'value', prototype, 'name');
object = create(prototype);
defineMetadata('key0', 'value', object, 'name');
defineMetadata('key1', 'value', object, 'name');
assert.deepEqual(getOwnMetadataKeys(object, 'name'), ['key0', 'key1']);
});
core-js-3.6.1/tests/pure/esnext.reflect.has-metadata.js 0000664 0000000 0000000 00000001773 13600575677 0023047 0 ustar 00root root 0000000 0000000 import { defineMetadata, hasMetadata } from 'core-js-pure/features/reflect';
import create from 'core-js-pure/features/object/create';
QUnit.test('Reflect.hasMetadata', assert => {
assert.isFunction(hasMetadata);
assert.arity(hasMetadata, 2);
assert.throws(() => hasMetadata('key', undefined, undefined), TypeError);
assert.same(hasMetadata('key', {}, undefined), false);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.same(hasMetadata('key', object, undefined), true);
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.same(hasMetadata('key', object, undefined), true);
assert.same(hasMetadata('key', {}, 'name'), false);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.same(hasMetadata('key', object, 'name'), true);
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.same(hasMetadata('key', object, 'name'), true);
});
core-js-3.6.1/tests/pure/esnext.reflect.has-own-metadata.js 0000664 0000000 0000000 00000002036 13600575677 0023641 0 ustar 00root root 0000000 0000000 import { defineMetadata, hasOwnMetadata } from 'core-js-pure/features/reflect';
import create from 'core-js-pure/features/object/create';
QUnit.test('Reflect.hasOwnMetadata', assert => {
assert.isFunction(hasOwnMetadata);
assert.arity(hasOwnMetadata, 2);
assert.throws(() => hasOwnMetadata('key', undefined, undefined), TypeError);
assert.same(hasOwnMetadata('key', {}, undefined), false);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.same(hasOwnMetadata('key', object, undefined), true);
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.same(hasOwnMetadata('key', object, undefined), false);
assert.same(hasOwnMetadata('key', {}, 'name'), false);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.same(hasOwnMetadata('key', object, 'name'), true);
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.same(hasOwnMetadata('key', object, 'name'), false);
});
core-js-3.6.1/tests/pure/esnext.reflect.metadata.js 0000664 0000000 0000000 00000001073 13600575677 0022267 0 ustar 00root root 0000000 0000000 import { metadata, hasOwnMetadata } from 'core-js-pure/features/reflect';
QUnit.test('Reflect.metadata', assert => {
assert.isFunction(metadata);
assert.arity(metadata, 2);
assert.isFunction(metadata('key', 'value'));
const decorator = metadata('key', 'value');
assert.throws(() => decorator(undefined, 'name'), TypeError);
let target = function () { /* empty */ };
decorator(target);
assert.same(hasOwnMetadata('key', target, undefined), true);
target = {};
decorator(target, 'name');
assert.same(hasOwnMetadata('key', target, 'name'), true);
});
core-js-3.6.1/tests/pure/esnext.set.add-all.js 0000664 0000000 0000000 00000001534 13600575677 0021156 0 ustar 00root root 0000000 0000000 import Set from 'core-js-pure/features/set';
import from from 'core-js-pure/features/array/from';
QUnit.test('Set#addAll', assert => {
const { addAll } = Set.prototype;
assert.isFunction(addAll);
assert.arity(addAll, 0);
assert.name(addAll, 'addAll');
assert.nonEnumerable(Set.prototype, 'addAll');
const set = new Set([1]);
assert.same(set.addAll(2), set);
assert.deepEqual(from(new Set([1, 2, 3]).addAll(4, 5)), [1, 2, 3, 4, 5]);
assert.deepEqual(from(new Set([1, 2, 3]).addAll(3, 4)), [1, 2, 3, 4]);
assert.deepEqual(from(new Set([1, 2, 3]).addAll()), [1, 2, 3]);
assert.notThrows(() => addAll.call({ add() { /* empty */ } }, 1, 2, 3));
assert.throws(() => addAll.call({}, 1, 2, 3), TypeError);
assert.throws(() => addAll.call(undefined, 1, 2, 3), TypeError);
assert.throws(() => addAll.call(null, 1, 2, 3), TypeError);
});
core-js-3.6.1/tests/pure/esnext.set.delete-all.js 0000664 0000000 0000000 00000002046 13600575677 0021667 0 ustar 00root root 0000000 0000000 import Set from 'core-js-pure/features/set';
import from from 'core-js-pure/features/array/from';
QUnit.test('Set#deleteAll', assert => {
const { deleteAll } = Set.prototype;
assert.isFunction(deleteAll);
assert.arity(deleteAll, 0);
assert.name(deleteAll, 'deleteAll');
assert.nonEnumerable(Set.prototype, 'deleteAll');
let set = new Set([1, 2, 3]);
assert.same(set.deleteAll(1, 2), true);
assert.deepEqual(from(set), [3]);
set = new Set([1, 2, 3]);
assert.same(set.deleteAll(3, 4), false);
assert.deepEqual(from(set), [1, 2]);
set = new Set([1, 2, 3]);
assert.same(set.deleteAll(4, 5), false);
assert.deepEqual(from(set), [1, 2, 3]);
set = new Set([1, 2, 3]);
assert.same(set.deleteAll(), true);
assert.deepEqual(from(set), [1, 2, 3]);
assert.notThrows(() => !deleteAll.call({ delete() { /* empty */ } }, 1, 2, 3));
assert.throws(() => deleteAll.call({}, 1, 2, 3), TypeError);
assert.throws(() => deleteAll.call(undefined, 1, 2, 3), TypeError);
assert.throws(() => deleteAll.call(null, 1, 2, 3), TypeError);
});
core-js-3.6.1/tests/pure/esnext.set.difference.js 0000664 0000000 0000000 00000001727 13600575677 0021756 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
import Set from 'core-js-pure/features/set';
import from from 'core-js-pure/features/array/from';
QUnit.test('Set#difference', assert => {
const { difference } = Set.prototype;
assert.isFunction(difference);
assert.arity(difference, 1);
assert.name(difference, 'difference');
assert.nonEnumerable(Set.prototype, 'difference');
const set = new Set([1]);
assert.ok(set.difference([2]) !== set);
assert.deepEqual(from(new Set([1, 2, 3]).difference([4, 5])), [1, 2, 3]);
assert.deepEqual(from(new Set([1, 2, 3]).difference([3, 4])), [1, 2]);
assert.deepEqual(from(new Set([1, 2, 3]).difference(createIterable([3, 4]))), [1, 2]);
assert.throws(() => new Set([1, 2, 3]).difference(), TypeError);
assert.throws(() => difference.call({}, [1, 2, 3]), TypeError);
assert.throws(() => difference.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => difference.call(null, [1, 2, 3]), TypeError);
});
core-js-3.6.1/tests/pure/esnext.set.every.js 0000664 0000000 0000000 00000002272 13600575677 0021012 0 ustar 00root root 0000000 0000000 import Set from 'core-js-pure/features/set';
QUnit.test('Set#every', assert => {
const { every } = Set.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.name(every, 'every');
assert.nonEnumerable(Set.prototype, 'every');
const set = new Set([1]);
const context = {};
set.every(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new Set([1, 2, 3]).every(it => typeof it === 'number'), true);
assert.same(new Set(['1', '2', '3']).some(it => typeof it === 'number'), false);
assert.same(new Set([1, '2', 3]).every(it => typeof it === 'number'), false);
assert.same(new Set().every(it => typeof it === 'number'), true);
assert.throws(() => every.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.set.filter.js 0000664 0000000 0000000 00000002170 13600575677 0021142 0 ustar 00root root 0000000 0000000 import Set from 'core-js-pure/features/set';
import from from 'core-js-pure/features/array/from';
QUnit.test('Set#filter', assert => {
const { filter } = Set.prototype;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.name(filter, 'filter');
assert.nonEnumerable(Set.prototype, 'filter');
const set = new Set([1]);
const context = {};
set.filter(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.ok(new Set().filter(it => it) instanceof Set);
assert.deepEqual(from(new Set([1, 2, 3, 'q', {}, 4, true, 5]).filter(it => typeof it === 'number')), [1, 2, 3, 4, 5]);
assert.throws(() => filter.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.set.find.js 0000664 0000000 0000000 00000001757 13600575677 0020607 0 ustar 00root root 0000000 0000000 import Set from 'core-js-pure/features/set';
QUnit.test('Set#find', assert => {
const { find } = Set.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.name(find, 'find');
assert.nonEnumerable(Set.prototype, 'find');
const set = new Set([1]);
const context = {};
set.find(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new Set([2, 3, 4]).find(it => it % 2), 3);
assert.same(new Set().find(it => it === 42), undefined);
assert.throws(() => find.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.set.from.js 0000664 0000000 0000000 00000001646 13600575677 0020627 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
import Set from 'core-js-pure/features/set';
import toArray from 'core-js-pure/features/array/from';
QUnit.test('Set.from', assert => {
const { from } = Set;
assert.isFunction(from);
assert.arity(from, 1);
assert.ok(Set.from() instanceof Set);
assert.deepEqual(toArray(Set.from([])), []);
assert.deepEqual(toArray(Set.from([1])), [1]);
assert.deepEqual(toArray(Set.from([1, 2, 3, 2, 1])), [1, 2, 3]);
assert.deepEqual(toArray(Set.from(createIterable([1, 2, 3, 2, 1]))), [1, 2, 3]);
const context = {};
Set.from([1], function (element, index) {
assert.same(element, 1);
assert.same(index, 0);
assert.same(this, context);
return element;
}, context);
assert.throws(() => from(1));
let arg = null;
function F(it) {
return arg = it;
}
from.call(F, createIterable([1, 2, 3]), it => it ** 2);
assert.deepEqual(arg, [1, 4, 9]);
});
core-js-3.6.1/tests/pure/esnext.set.intersection.js 0000664 0000000 0000000 00000001764 13600575677 0022373 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
import Set from 'core-js-pure/features/set';
import from from 'core-js-pure/features/array/from';
QUnit.test('Set#intersection', assert => {
const { intersection } = Set.prototype;
assert.isFunction(intersection);
assert.arity(intersection, 1);
assert.name(intersection, 'intersection');
assert.nonEnumerable(Set.prototype, 'intersection');
const set = new Set([1]);
assert.ok(set.intersection([2]) !== set);
assert.deepEqual(from(new Set([1, 2, 3]).intersection([4, 5])), []);
assert.deepEqual(from(new Set([1, 2, 3]).intersection([2, 3, 4])), [2, 3]);
assert.deepEqual(from(new Set([1, 2, 3]).intersection(createIterable([2, 3, 4]))), [2, 3]);
assert.throws(() => new Set([1, 2, 3]).intersection(), TypeError);
assert.throws(() => intersection.call({}, [1, 2, 3]), TypeError);
assert.throws(() => intersection.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => intersection.call(null, [1, 2, 3]), TypeError);
});
core-js-3.6.1/tests/pure/esnext.set.is-disjoint-from.js 0000664 0000000 0000000 00000001756 13600575677 0023063 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
import Set from 'core-js-pure/features/set';
QUnit.test('Set#isDisjointFrom', assert => {
const { isDisjointFrom } = Set.prototype;
assert.isFunction(isDisjointFrom);
assert.arity(isDisjointFrom, 1);
assert.name(isDisjointFrom, 'isDisjointFrom');
assert.nonEnumerable(Set.prototype, 'isDisjointFrom');
assert.ok(new Set([1]).isDisjointFrom([2]));
assert.ok(!new Set([1]).isDisjointFrom([1]));
assert.ok(new Set([1, 2, 3]).isDisjointFrom([4, 5, 6]));
assert.ok(!new Set([1, 2, 3]).isDisjointFrom([5, 4, 3]));
assert.ok(new Set([1]).isDisjointFrom(createIterable([2])));
assert.ok(!new Set([1]).isDisjointFrom(createIterable([1])));
assert.throws(() => new Set([1, 2, 3]).isDisjointFrom(), TypeError);
assert.throws(() => isDisjointFrom.call({}, [1, 2, 3]), TypeError);
assert.throws(() => isDisjointFrom.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => isDisjointFrom.call(null, [1, 2, 3]), TypeError);
});
core-js-3.6.1/tests/pure/esnext.set.is-subset-of.js 0000664 0000000 0000000 00000002246 13600575677 0022201 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
import Set from 'core-js-pure/features/set';
QUnit.test('Set#isSubsetOf', assert => {
const { isSubsetOf } = Set.prototype;
assert.isFunction(isSubsetOf);
assert.arity(isSubsetOf, 1);
assert.name(isSubsetOf, 'isSubsetOf');
assert.nonEnumerable(Set.prototype, 'isSubsetOf');
assert.ok(new Set([1]).isSubsetOf([1, 2, 3]));
assert.ok(!new Set([1]).isSubsetOf([2, 3, 4]));
assert.ok(new Set([1, 2, 3]).isSubsetOf([5, 4, 3, 2, 1]));
assert.ok(!new Set([1, 2, 3]).isSubsetOf([5, 4, 3, 2]));
assert.ok(new Set([1]).isSubsetOf(createIterable([1, 2, 3])));
assert.ok(!new Set([1]).isSubsetOf(createIterable([2, 3, 4])));
assert.ok(new Set([1]).isSubsetOf({ has: () => true }));
assert.ok(!new Set([1]).isSubsetOf({ has: () => false }));
assert.ok(isSubsetOf.call('ab', ['a', 'b', 'c']));
assert.ok(!isSubsetOf.call('ab', ['a']));
assert.throws(() => new Set([1, 2, 3]).isSubsetOf(), TypeError);
assert.throws(() => isSubsetOf.call({}, [1, 2, 3]), TypeError);
assert.throws(() => isSubsetOf.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => isSubsetOf.call(null, [1, 2, 3]), TypeError);
});
core-js-3.6.1/tests/pure/esnext.set.is-superset-of.js 0000664 0000000 0000000 00000001755 13600575677 0022552 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
import Set from 'core-js-pure/features/set';
QUnit.test('Set#isSupersetOf', assert => {
const { isSupersetOf } = Set.prototype;
assert.isFunction(isSupersetOf);
assert.arity(isSupersetOf, 1);
assert.name(isSupersetOf, 'isSupersetOf');
assert.nonEnumerable(Set.prototype, 'isSupersetOf');
assert.ok(new Set([1, 2, 3]).isSupersetOf([1]));
assert.ok(!new Set([2, 3, 4]).isSupersetOf([1]));
assert.ok(new Set([5, 4, 3, 2, 1]).isSupersetOf([1, 2, 3]));
assert.ok(!new Set([5, 4, 3, 2]).isSupersetOf([1, 2, 3]));
assert.ok(new Set([1, 2, 3]).isSupersetOf(createIterable([1])));
assert.ok(!new Set([2, 3, 4]).isSupersetOf(createIterable([1])));
assert.throws(() => new Set([1, 2, 3]).isSupersetOf(), TypeError);
assert.throws(() => isSupersetOf.call({}, [1, 2, 3]), TypeError);
assert.throws(() => isSupersetOf.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => isSupersetOf.call(null, [1, 2, 3]), TypeError);
});
core-js-3.6.1/tests/pure/esnext.set.join.js 0000664 0000000 0000000 00000001120 13600575677 0020606 0 ustar 00root root 0000000 0000000 import Set from 'core-js-pure/features/set';
QUnit.test('Set#join', assert => {
const { join } = Set.prototype;
assert.isFunction(join);
assert.arity(join, 1);
assert.name(join, 'join');
assert.nonEnumerable(Set.prototype, 'join');
assert.strictEqual(new Set([1, 2, 3]).join(), '1,2,3');
assert.strictEqual(new Set([1, 2, 3]).join(undefined), '1,2,3');
assert.strictEqual(new Set([1, 2, 3]).join('|'), '1|2|3');
assert.throws(() => join.call({}), TypeError);
assert.throws(() => join.call(undefined), TypeError);
assert.throws(() => join.call(null), TypeError);
});
core-js-3.6.1/tests/pure/esnext.set.map.js 0000664 0000000 0000000 00000002157 13600575677 0020437 0 ustar 00root root 0000000 0000000 import Set from 'core-js-pure/features/set';
import from from 'core-js-pure/features/array/from';
QUnit.test('Set#map', assert => {
const { map } = Set.prototype;
assert.isFunction(map);
assert.arity(map, 1);
assert.name(map, 'map');
assert.nonEnumerable(Set.prototype, 'map');
const set = new Set([1]);
const context = {};
set.map(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.ok(new Set().map(it => it) instanceof Set);
assert.deepEqual(from(new Set([1, 2, 3]).map(it => it ** 2)), [1, 4, 9]);
assert.deepEqual(from(new Set([1, 2, 3]).map(it => it % 2)), [1, 0]);
assert.throws(() => map.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => map.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => map.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.set.of.js 0000664 0000000 0000000 00000000772 13600575677 0020267 0 ustar 00root root 0000000 0000000 import Set from 'core-js-pure/features/set';
import toArray from 'core-js-pure/features/array/from';
QUnit.test('Set.of', assert => {
const { of } = Set;
assert.isFunction(of);
assert.arity(of, 0);
assert.ok(Set.of() instanceof Set);
assert.deepEqual(toArray(Set.of(1)), [1]);
assert.deepEqual(toArray(Set.of(1, 2, 3, 2, 1)), [1, 2, 3]);
assert.throws(() => of(1));
let arg = null;
function F(it) {
return arg = it;
}
of.call(F, 1, 2, 3);
assert.deepEqual(arg, [1, 2, 3]);
});
core-js-3.6.1/tests/pure/esnext.set.reduce.js 0000664 0000000 0000000 00000003202 13600575677 0021121 0 ustar 00root root 0000000 0000000 import Set from 'core-js-pure/features/set';
QUnit.test('Set#reduce', assert => {
const { reduce } = Set.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.name(reduce, 'reduce');
assert.nonEnumerable(Set.prototype, 'reduce');
const set = new Set([1]);
const accumulator = {};
set.reduce(function (memo, value, key, that) {
assert.same(arguments.length, 4, 'correct number of callback arguments');
assert.same(memo, accumulator, 'correct callback accumulator');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 1, 'correct index in callback');
assert.same(that, set, 'correct link to set in callback');
}, accumulator);
assert.same(new Set([1, 2, 3]).reduce(((a, b) => a + b), 1), 7, 'works with initial accumulator');
new Set([1, 2]).reduce((memo, value, key) => {
assert.same(memo, 1, 'correct default accumulator');
assert.same(value, 2, 'correct start value without initial accumulator');
assert.same(key, 2, 'correct start index without initial accumulator');
});
assert.same(new Set([1, 2, 3]).reduce((a, b) => a + b), 6, 'works without initial accumulator');
let values = '';
let keys = '';
new Set([1, 2, 3]).reduce((memo, value, key, s) => {
s.delete(2);
values += value;
keys += key;
}, 0);
assert.same(values, '13', 'correct order #1');
assert.same(keys, '13', 'correct order #2');
assert.throws(() => reduce.call({}, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(undefined, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(null, () => { /* empty */ }, 1), TypeError);
});
core-js-3.6.1/tests/pure/esnext.set.some.js 0000664 0000000 0000000 00000002254 13600575677 0020623 0 ustar 00root root 0000000 0000000 import Set from 'core-js-pure/features/set';
QUnit.test('Set#some', assert => {
const { some } = Set.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.name(some, 'some');
assert.nonEnumerable(Set.prototype, 'some');
const set = new Set([1]);
const context = {};
set.some(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new Set([1, 2, 3]).some(it => typeof it === 'number'), true);
assert.same(new Set(['1', '2', '3']).some(it => typeof it === 'number'), false);
assert.same(new Set([1, '2', 3]).some(it => typeof it === 'number'), true);
assert.same(new Set().some(it => typeof it === 'number'), false);
assert.throws(() => some.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.set.symmetric-difference.js 0000664 0000000 0000000 00000002152 13600575677 0023761 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
import Set from 'core-js-pure/features/set';
import from from 'core-js-pure/features/array/from';
QUnit.test('Set#symmetricDifference', assert => {
const { symmetricDifference } = Set.prototype;
assert.isFunction(symmetricDifference);
assert.arity(symmetricDifference, 1);
assert.name(symmetricDifference, 'symmetricDifference');
assert.nonEnumerable(Set.prototype, 'symmetricDifference');
const set = new Set([1]);
assert.ok(set.symmetricDifference([2]) !== set);
assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference([4, 5])), [1, 2, 3, 4, 5]);
assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference([3, 4])), [1, 2, 4]);
assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference(createIterable([3, 4]))), [1, 2, 4]);
assert.throws(() => new Set([1, 2, 3]).symmetricDifference(), TypeError);
assert.throws(() => symmetricDifference.call({}, [1, 2, 3]), TypeError);
assert.throws(() => symmetricDifference.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => symmetricDifference.call(null, [1, 2, 3]), TypeError);
});
core-js-3.6.1/tests/pure/esnext.set.union.js 0000664 0000000 0000000 00000001636 13600575677 0021013 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
import Set from 'core-js-pure/features/set';
import from from 'core-js-pure/features/array/from';
QUnit.test('Set#union', assert => {
const { union } = Set.prototype;
assert.isFunction(union);
assert.arity(union, 1);
assert.name(union, 'union');
assert.nonEnumerable(Set.prototype, 'union');
const set = new Set([1]);
assert.ok(set.union([2]) !== set);
assert.deepEqual(from(new Set([1, 2, 3]).union([4, 5])), [1, 2, 3, 4, 5]);
assert.deepEqual(from(new Set([1, 2, 3]).union([3, 4])), [1, 2, 3, 4]);
assert.deepEqual(from(new Set([1, 2, 3]).union(createIterable([3, 4]))), [1, 2, 3, 4]);
assert.throws(() => new Set([1, 2, 3]).union(), TypeError);
assert.throws(() => union.call({}, [1, 2, 3]), TypeError);
assert.throws(() => union.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => union.call(null, [1, 2, 3]), TypeError);
});
core-js-3.6.1/tests/pure/esnext.string.at.js 0000664 0000000 0000000 00000011061 13600575677 0020773 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import at from 'core-js-pure/features/string/at';
QUnit.test('String#at', assert => {
assert.isFunction(at);
// String that starts with a BMP symbol
assert.strictEqual(at('abc\uD834\uDF06def', -Infinity), '');
assert.strictEqual(at('abc\uD834\uDF06def', -1), '');
assert.strictEqual(at('abc\uD834\uDF06def', -0), 'a');
assert.strictEqual(at('abc\uD834\uDF06def', +0), 'a');
assert.strictEqual(at('abc\uD834\uDF06def', 1), 'b');
assert.strictEqual(at('abc\uD834\uDF06def', 3), '\uD834\uDF06');
assert.strictEqual(at('abc\uD834\uDF06def', 4), '\uDF06');
assert.strictEqual(at('abc\uD834\uDF06def', 5), 'd');
assert.strictEqual(at('abc\uD834\uDF06def', 42), '');
assert.strictEqual(at('abc\uD834\uDF06def', Infinity), '');
assert.strictEqual(at('abc\uD834\uDF06def', null), 'a');
assert.strictEqual(at('abc\uD834\uDF06def', undefined), 'a');
assert.strictEqual(at('abc\uD834\uDF06def'), 'a');
assert.strictEqual(at('abc\uD834\uDF06def', false), 'a');
assert.strictEqual(at('abc\uD834\uDF06def', NaN), 'a');
assert.strictEqual(at('abc\uD834\uDF06def', ''), 'a');
assert.strictEqual(at('abc\uD834\uDF06def', '_'), 'a');
assert.strictEqual(at('abc\uD834\uDF06def', '1'), 'b');
assert.strictEqual(at('abc\uD834\uDF06def', []), 'a');
assert.strictEqual(at('abc\uD834\uDF06def', {}), 'a');
assert.strictEqual(at('abc\uD834\uDF06def', -0.9), 'a');
assert.strictEqual(at('abc\uD834\uDF06def', 1.9), 'b');
assert.strictEqual(at('abc\uD834\uDF06def', 7.9), 'f');
assert.strictEqual(at('abc\uD834\uDF06def', 2 ** 32), '');
// String that starts with an astral symbol
assert.strictEqual(at('\uD834\uDF06def', -Infinity), '');
assert.strictEqual(at('\uD834\uDF06def', -1), '');
assert.strictEqual(at('\uD834\uDF06def', -0), '\uD834\uDF06');
assert.strictEqual(at('\uD834\uDF06def', 0), '\uD834\uDF06');
assert.strictEqual(at('\uD834\uDF06def', 1), '\uDF06');
assert.strictEqual(at('\uD834\uDF06def', 2), 'd');
assert.strictEqual(at('\uD834\uDF06def', 3), 'e');
assert.strictEqual(at('\uD834\uDF06def', 4), 'f');
assert.strictEqual(at('\uD834\uDF06def', 42), '');
assert.strictEqual(at('\uD834\uDF06def', Infinity), '');
assert.strictEqual(at('\uD834\uDF06def', null), '\uD834\uDF06');
assert.strictEqual(at('\uD834\uDF06def', undefined), '\uD834\uDF06');
assert.strictEqual(at('\uD834\uDF06def'), '\uD834\uDF06');
assert.strictEqual(at('\uD834\uDF06def', false), '\uD834\uDF06');
assert.strictEqual(at('\uD834\uDF06def', NaN), '\uD834\uDF06');
assert.strictEqual(at('\uD834\uDF06def', ''), '\uD834\uDF06');
assert.strictEqual(at('\uD834\uDF06def', '_'), '\uD834\uDF06');
assert.strictEqual(at('\uD834\uDF06def', '1'), '\uDF06');
// Lone high surrogates
assert.strictEqual(at('\uD834abc', -Infinity), '');
assert.strictEqual(at('\uD834abc', -1), '');
assert.strictEqual(at('\uD834abc', -0), '\uD834');
assert.strictEqual(at('\uD834abc', 0), '\uD834');
assert.strictEqual(at('\uD834abc', 1), 'a');
assert.strictEqual(at('\uD834abc', 42), '');
assert.strictEqual(at('\uD834abc', Infinity), '');
assert.strictEqual(at('\uD834abc', null), '\uD834');
assert.strictEqual(at('\uD834abc', undefined), '\uD834');
assert.strictEqual(at('\uD834abc'), '\uD834');
assert.strictEqual(at('\uD834abc', false), '\uD834');
assert.strictEqual(at('\uD834abc', NaN), '\uD834');
assert.strictEqual(at('\uD834abc', ''), '\uD834');
assert.strictEqual(at('\uD834abc', '_'), '\uD834');
assert.strictEqual(at('\uD834abc', '1'), 'a');
// Lone low surrogates
assert.strictEqual(at('\uDF06abc', -Infinity), '');
assert.strictEqual(at('\uDF06abc', -1), '');
assert.strictEqual(at('\uDF06abc', -0), '\uDF06');
assert.strictEqual(at('\uDF06abc', 0), '\uDF06');
assert.strictEqual(at('\uDF06abc', 1), 'a');
assert.strictEqual(at('\uDF06abc', 42), '');
assert.strictEqual(at('\uDF06abc', Infinity), '');
assert.strictEqual(at('\uDF06abc', null), '\uDF06');
assert.strictEqual(at('\uDF06abc', undefined), '\uDF06');
assert.strictEqual(at('\uDF06abc'), '\uDF06');
assert.strictEqual(at('\uDF06abc', false), '\uDF06');
assert.strictEqual(at('\uDF06abc', NaN), '\uDF06');
assert.strictEqual(at('\uDF06abc', ''), '\uDF06');
assert.strictEqual(at('\uDF06abc', '_'), '\uDF06');
assert.strictEqual(at('\uDF06abc', '1'), 'a');
assert.strictEqual(at(42, 0), '4');
assert.strictEqual(at(42, 1), '2');
assert.strictEqual(at({
toString() {
return 'abc';
},
}, 2), 'c');
if (STRICT) {
assert.throws(() => at(null, 0), TypeError);
assert.throws(() => at(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/pure/esnext.string.code-points.js 0000664 0000000 0000000 00000002401 13600575677 0022611 0 ustar 00root root 0000000 0000000 import Symbol from 'core-js-pure/features/symbol';
import codePoints from 'core-js-pure/features/string/code-points';
QUnit.test('String#codePoints', assert => {
assert.isFunction(codePoints);
let iterator = codePoints('qwe');
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'String Iterator');
assert.strictEqual(String(iterator), '[object String Iterator]');
assert.deepEqual(iterator.next(), {
value: { codePoint: 113, position: 0 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: { codePoint: 119, position: 1 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: { codePoint: 101, position: 2 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
iterator = codePoints('𠮷𠮷𠮷');
assert.deepEqual(iterator.next(), {
value: { codePoint: 134071, position: 0 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: { codePoint: 134071, position: 2 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: { codePoint: 134071, position: 4 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
core-js-3.6.1/tests/pure/esnext.string.replace-all.js 0000664 0000000 0000000 00000003106 13600575677 0022551 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
import replaceAll from 'core-js-pure/features/string/replace-all';
import Symbol from 'core-js-pure/features/symbol';
QUnit.test('String#replaceAll', assert => {
assert.isFunction(replaceAll);
assert.same(replaceAll('q=query+string+parameters', '+', ' '), 'q=query string parameters');
assert.same(replaceAll('foo', 'o', {}), 'f[object Object][object Object]');
assert.same(replaceAll('[object Object]x[object Object]', {}, 'y'), 'yxy');
assert.same(replaceAll({}, 'bject', 'lolo'), '[ololo Ololo]');
assert.same(replaceAll('aba', 'b', (search, i, string) => {
assert.same(search, 'b', '`search` is `b`');
assert.same(i, 1, '`i` is 1');
assert.same(string, 'aba', '`string` is `aba`');
return 'c';
}), 'aca');
const searcher = {
[Symbol.replace](O, replaceValue) {
assert.same(this, searcher, '`this` is `searcher`');
assert.same(String(O), 'aba', '`O` is `aba`');
assert.same(String(replaceValue), 'c', '`replaceValue` is `c`');
return 'foo';
},
};
assert.same(replaceAll('aba', searcher, 'c'), 'foo');
assert.same(replaceAll('aba', 'b'), 'aundefineda');
assert.same(replaceAll('xxx', '', '_'), '_x_x_x_');
if (STRICT) {
assert.throws(() => replaceAll(null, 'a', 'b'), TypeError);
assert.throws(() => replaceAll(undefined, 'a', 'b'), TypeError);
}
assert.throws(() => replaceAll('b.b.b.b.b', /\./, 'a'), TypeError);
assert.same(replaceAll('b.b.b.b.b', /\./g, 'a'), 'babababab');
const object = {};
assert.same(replaceAll('[object Object]', object, 'a'), 'a');
});
core-js-3.6.1/tests/pure/esnext.symbol.async-dispose.js 0000664 0000000 0000000 00000000413 13600575677 0023146 0 ustar 00root root 0000000 0000000 import Symbol from 'core-js-pure/features/symbol';
QUnit.test('Symbol.asyncDispose', assert => {
assert.ok('asyncDispose' in Symbol, 'Symbol.asyncDispose available');
assert.ok(Object(Symbol.asyncDispose) instanceof Symbol, 'Symbol.asyncDispose is symbol');
});
core-js-3.6.1/tests/pure/esnext.symbol.dispose.js 0000664 0000000 0000000 00000000362 13600575677 0022036 0 ustar 00root root 0000000 0000000 import Symbol from 'core-js-pure/features/symbol';
QUnit.test('Symbol.dispose', assert => {
assert.ok('dispose' in Symbol, 'Symbol.dispose available');
assert.ok(Object(Symbol.dispose) instanceof Symbol, 'Symbol.dispose is symbol');
});
core-js-3.6.1/tests/pure/esnext.symbol.observable.js 0000664 0000000 0000000 00000000401 13600575677 0022506 0 ustar 00root root 0000000 0000000 import Symbol from 'core-js-pure/features/symbol';
QUnit.test('Symbol.observable', assert => {
assert.ok('observable' in Symbol, 'Symbol.observable available');
assert.ok(Object(Symbol.observable) instanceof Symbol, 'Symbol.observable is symbol');
});
core-js-3.6.1/tests/pure/esnext.symbol.pattern-match.js 0000664 0000000 0000000 00000000413 13600575677 0023134 0 ustar 00root root 0000000 0000000 import Symbol from 'core-js-pure/features/symbol';
QUnit.test('Symbol.patternMatch', assert => {
assert.ok('patternMatch' in Symbol, 'Symbol.patternMatch available');
assert.ok(Object(Symbol.patternMatch) instanceof Symbol, 'Symbol.patternMatch is symbol');
});
core-js-3.6.1/tests/pure/esnext.symbol.replace-all.js 0000664 0000000 0000000 00000000404 13600575677 0022546 0 ustar 00root root 0000000 0000000 import Symbol from 'core-js-pure/features/symbol';
QUnit.test('Symbol.replaceAll', assert => {
assert.ok('replaceAll' in Symbol, 'Symbol.replaceAll is available');
assert.ok(Object(Symbol.replaceAll) instanceof Symbol, 'Symbol.replaceAll is symbol');
});
core-js-3.6.1/tests/pure/esnext.weak-map.delete-all.js 0000664 0000000 0000000 00000002734 13600575677 0022602 0 ustar 00root root 0000000 0000000 import WeakMap from 'core-js-pure/features/weak-map';
QUnit.test('WeakMap#deleteAll', assert => {
const { deleteAll } = WeakMap.prototype;
assert.isFunction(deleteAll);
assert.arity(deleteAll, 0);
assert.nonEnumerable(WeakMap.prototype, 'deleteAll');
const a = [];
const b = [];
const c = [];
const d = [];
const e = [];
let set = new WeakMap([[a, 1], [b, 2], [c, 3]]);
assert.same(set.deleteAll(a, b), true);
assert.ok(!set.has(a));
assert.ok(!set.has(b));
assert.ok(set.has(c));
assert.ok(!set.has(d));
assert.ok(!set.has(e));
set = new WeakMap([[a, 1], [b, 2], [c, 3]]);
assert.same(set.deleteAll(c, d), false);
assert.ok(set.has(a));
assert.ok(set.has(b));
assert.ok(!set.has(c));
assert.ok(!set.has(d));
assert.ok(!set.has(e));
set = new WeakMap([[a, 1], [b, 2], [c, 3]]);
assert.same(set.deleteAll(d, e), false);
assert.ok(set.has(a));
assert.ok(set.has(b));
assert.ok(set.has(c));
assert.ok(!set.has(d));
assert.ok(!set.has(e));
set = new WeakMap([[a, 1], [b, 2], [c, 3]]);
assert.same(set.deleteAll(), true);
assert.ok(set.has(a));
assert.ok(set.has(b));
assert.ok(set.has(c));
assert.ok(!set.has(d));
assert.ok(!set.has(e));
assert.notThrows(() => !deleteAll.call({ delete() { /* empty */ } }, a, b, c));
assert.throws(() => deleteAll.call({}, a, b, c), TypeError);
assert.throws(() => deleteAll.call(undefined, a, b, c), TypeError);
assert.throws(() => deleteAll.call(null, a, b, c), TypeError);
});
core-js-3.6.1/tests/pure/esnext.weak-map.from.js 0000664 0000000 0000000 00000001517 13600575677 0021533 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
import WeakMap from 'core-js-pure/features/weak-map';
QUnit.test('WeakMap.from', assert => {
const { from } = WeakMap;
assert.isFunction(from);
assert.arity(from, 1);
assert.ok(WeakMap.from() instanceof WeakMap);
const array = [];
assert.same(WeakMap.from([[array, 2]]).get(array), 2);
assert.same(WeakMap.from(createIterable([[array, 2]])).get(array), 2);
const pair = [{}, 1];
const context = {};
WeakMap.from([pair], function (element, index) {
assert.same(element, pair);
assert.same(index, 0);
assert.same(this, context);
return element;
}, context);
assert.throws(() => from([{}, 1]));
let arg = null;
function F(it) {
return arg = it;
}
from.call(F, createIterable([1, 2, 3]), it => it ** 2);
assert.deepEqual(arg, [1, 4, 9]);
});
core-js-3.6.1/tests/pure/esnext.weak-map.of.js 0000664 0000000 0000000 00000000670 13600575677 0021173 0 ustar 00root root 0000000 0000000 import WeakMap from 'core-js-pure/features/weak-map';
QUnit.test('WeakMap.of', assert => {
const { of } = WeakMap;
assert.isFunction(of);
assert.arity(of, 0);
const array = [];
assert.ok(WeakMap.of() instanceof WeakMap);
assert.same(WeakMap.of([array, 2]).get(array), 2);
assert.throws(() => of(1));
let arg = null;
function F(it) {
return arg = it;
}
of.call(F, 1, 2, 3);
assert.deepEqual(arg, [1, 2, 3]);
});
core-js-3.6.1/tests/pure/esnext.weak-map.upsert.js 0000664 0000000 0000000 00000003141 13600575677 0022105 0 ustar 00root root 0000000 0000000 import WeakMap from 'core-js-pure/features/weak-map';
QUnit.test('WeakMap#upsert', assert => {
const { upsert } = WeakMap.prototype;
assert.isFunction(upsert);
assert.arity(upsert, 2);
assert.name(upsert, 'upsert');
assert.nonEnumerable(WeakMap.prototype, 'upsert');
const a = {};
const b = {};
const map = new WeakMap([[a, 2]]);
assert.same(map.upsert(a, function (value) {
assert.same(arguments.length, 1, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
return value ** 2;
}, () => {
assert.ok(false, 'should not be called');
return 3;
}), 4, 'returns a correct value');
assert.same(map.upsert(b, value => {
assert.ok(false, 'should not be called');
return value ** 2;
}, function () {
assert.same(arguments.length, 0, 'correct number of callback arguments');
return 3;
}), 3, 'returns a correct value');
assert.same(map.get(a), 4, 'correct result #1');
assert.same(map.get(b), 3, 'correct result #2');
assert.same(new WeakMap([[a, 2]]).upsert(b, null, () => 3), 3);
assert.same(new WeakMap([[a, 2]]).upsert(a, value => value ** 2), 4);
assert.throws(() => new WeakMap().upsert(a), TypeError);
assert.throws(() => upsert.call({}, a, () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call([], a, () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call(undefined, a, () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call(null, a, () => { /* empty */ }, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/pure/esnext.weak-set.add-all.js 0000664 0000000 0000000 00000001641 13600575677 0022102 0 ustar 00root root 0000000 0000000 import WeakSet from 'core-js-pure/features/weak-set';
QUnit.test('WeakSet#addAll', assert => {
const { addAll } = WeakSet.prototype;
assert.isFunction(addAll);
assert.arity(addAll, 0);
assert.name(addAll, 'addAll');
assert.nonEnumerable(WeakSet.prototype, 'addAll');
const a = [];
const b = [];
const c = [];
let set = new WeakSet([a]);
assert.same(set.addAll(b), set);
set = new WeakSet([a]).addAll(b, c);
assert.ok(set.has(a));
assert.ok(set.has(b));
assert.ok(set.has(c));
set = new WeakSet([a]).addAll(a, b);
assert.ok(set.has(a));
assert.ok(set.has(b));
set = new WeakSet([a]).addAll();
assert.ok(set.has(a));
assert.notThrows(() => addAll.call({ add() { /* empty */ } }, a, b, c));
assert.throws(() => addAll.call({}, a, b, c), TypeError);
assert.throws(() => addAll.call(undefined, a, b, c), TypeError);
assert.throws(() => addAll.call(null, a, b, c), TypeError);
});
core-js-3.6.1/tests/pure/esnext.weak-set.delete-all.js 0000664 0000000 0000000 00000002707 13600575677 0022620 0 ustar 00root root 0000000 0000000 import WeakSet from 'core-js-pure/features/weak-set';
QUnit.test('WeakSet#deleteAll', assert => {
const { deleteAll } = WeakSet.prototype;
assert.isFunction(deleteAll);
assert.arity(deleteAll, 0);
assert.name(deleteAll, 'deleteAll');
assert.nonEnumerable(WeakSet.prototype, 'deleteAll');
const a = [];
const b = [];
const c = [];
const d = [];
const e = [];
let set = new WeakSet([a, b, c]);
assert.same(set.deleteAll(a, b), true);
assert.ok(!set.has(a));
assert.ok(!set.has(b));
assert.ok(set.has(c));
assert.ok(!set.has(d));
assert.ok(!set.has(e));
set = new WeakSet([a, b, c]);
assert.same(set.deleteAll(c, d), false);
assert.ok(set.has(a));
assert.ok(set.has(b));
assert.ok(!set.has(c));
assert.ok(!set.has(d));
assert.ok(!set.has(e));
set = new WeakSet([a, b, c]);
assert.same(set.deleteAll(d, e), false);
assert.ok(set.has(a));
assert.ok(set.has(b));
assert.ok(set.has(c));
assert.ok(!set.has(d));
assert.ok(!set.has(e));
set = new WeakSet([a, b, c]);
assert.same(set.deleteAll(), true);
assert.ok(set.has(a));
assert.ok(set.has(b));
assert.ok(set.has(c));
assert.ok(!set.has(d));
assert.ok(!set.has(e));
assert.notThrows(() => !deleteAll.call({ delete() { /* empty */ } }, a, b, c));
assert.throws(() => deleteAll.call({}, a, b, c), TypeError);
assert.throws(() => deleteAll.call(undefined, a, b, c), TypeError);
assert.throws(() => deleteAll.call(null, a, b, c), TypeError);
});
core-js-3.6.1/tests/pure/esnext.weak-set.from.js 0000664 0000000 0000000 00000001467 13600575677 0021555 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
import WeakSet from 'core-js-pure/features/weak-set';
QUnit.test('WeakSet.from', assert => {
const { from } = WeakSet;
assert.isFunction(from);
assert.arity(from, 1);
assert.ok(WeakSet.from() instanceof WeakSet);
const array = [];
assert.ok(WeakSet.from([array]).has(array));
assert.ok(WeakSet.from(createIterable([array])).has(array));
const object = {};
const context = {};
WeakSet.from([object], function (element, index) {
assert.same(element, object);
assert.same(index, 0);
assert.same(this, context);
return element;
}, context);
assert.throws(() => from({}));
let arg = null;
function F(it) {
return arg = it;
}
from.call(F, createIterable([1, 2, 3]), it => it ** 2);
assert.deepEqual(arg, [1, 4, 9]);
});
core-js-3.6.1/tests/pure/esnext.weak-set.of.js 0000664 0000000 0000000 00000000647 13600575677 0021215 0 ustar 00root root 0000000 0000000 import WeakSet from 'core-js-pure/features/weak-set';
QUnit.test('WeakSet.of', assert => {
const { of } = WeakSet;
assert.isFunction(of);
assert.arity(of, 0);
const array = [];
assert.ok(WeakSet.of() instanceof WeakSet);
assert.ok(WeakSet.of(array).has(array));
assert.throws(() => of(1));
let arg = null;
function F(it) {
arg = it;
}
of.call(F, 1, 2, 3);
assert.deepEqual(arg, [1, 2, 3]);
});
core-js-3.6.1/tests/pure/helpers.get-iterator-method.js 0000664 0000000 0000000 00000001157 13600575677 0023107 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
import getIteratorMethod from 'core-js-pure/features/get-iterator-method';
QUnit.test('getIteratorMethod helper', assert => {
assert.isFunction(getIteratorMethod);
const iterable = createIterable([]);
const iterFn = getIteratorMethod(iterable);
assert.isFunction(iterFn);
assert.isIterator(iterFn.call(iterable));
assert.isFunction(getIteratorMethod([]));
assert.isFunction(getIteratorMethod(function () {
return arguments;
}()));
assert.isFunction(getIteratorMethod(Array.prototype));
assert.strictEqual(getIteratorMethod({}), undefined);
});
core-js-3.6.1/tests/pure/helpers.get-iterator.js 0000664 0000000 0000000 00000000644 13600575677 0021631 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
import getIterator from 'core-js-pure/features/get-iterator';
QUnit.test('getIterator helper', assert => {
assert.isFunction(getIterator);
assert.isIterator(getIterator([]));
assert.isIterator(getIterator(function () {
return arguments;
}()));
assert.isIterator(getIterator(createIterable([])));
assert.throws(() => getIterator({}), TypeError);
});
core-js-3.6.1/tests/pure/helpers.is-iterable.js 0000664 0000000 0000000 00000000632 13600575677 0021420 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
import isIterable from 'core-js-pure/features/is-iterable';
QUnit.test('isIterable helper', assert => {
assert.isFunction(isIterable);
assert.ok(isIterable(createIterable([])));
assert.ok(isIterable([]));
assert.ok(isIterable(function () {
return arguments;
}()));
assert.ok(isIterable(Array.prototype));
assert.ok(!isIterable({}));
});
core-js-3.6.1/tests/pure/index.js 0000664 0000000 0000000 00000020745 13600575677 0016675 0 ustar 00root root 0000000 0000000 /* eslint-disable import/first */
import '../helpers/qunit-helpers';
import { GLOBAL } from '../helpers/constants';
QUnit.module('ES');
import './es.array.concat';
import './es.array.copy-within';
import './es.array.every';
import './es.array.fill';
import './es.array.filter';
import './es.array.find-index';
import './es.array.find';
import './es.array.for-each';
import './es.array.flat';
import './es.array.flat-map';
import './es.array.from';
import './es.array.includes';
import './es.array.index-of';
import './es.array.is-array';
import './es.array.iterator';
import './es.array.join';
import './es.array.last-index-of';
import './es.array.map';
import './es.array.of';
import './es.array.reduce-right';
import './es.array.reduce';
import './es.array.reverse';
import './es.array.slice';
import './es.array.some';
import './es.array.sort';
import './es.array.splice';
import './es.date.now';
import './es.date.to-iso-string';
import './es.date.to-json';
import './es.function.bind';
import './es.function.has-instance';
import './es.global-this';
import './es.json.stringify';
import './es.map';
import './es.math.acosh';
import './es.math.asinh';
import './es.math.atanh';
import './es.math.cbrt';
import './es.math.clz32';
import './es.math.cosh';
import './es.math.expm1';
import './es.math.fround';
import './es.math.hypot';
import './es.math.imul';
import './es.math.log10';
import './es.math.log1p';
import './es.math.log2';
import './es.math.sign';
import './es.math.sinh';
import './es.math.tanh';
import './es.math.trunc';
import './es.number.epsilon';
import './es.number.is-finite';
import './es.number.is-integer';
import './es.number.is-nan';
import './es.number.is-safe-integer';
import './es.number.max-safe-integer';
import './es.number.min-safe-integer';
import './es.number.parse-float';
import './es.number.parse-int';
import './es.number.to-fixed';
import './es.number.to-precision';
import './es.object.assign';
import './es.object.create';
import './es.object.define-getter';
import './es.object.define-properties';
import './es.object.define-property';
import './es.object.define-setter';
import './es.object.entries';
import './es.object.freeze';
import './es.object.from-entries';
import './es.object.get-own-property-descriptor';
import './es.object.get-own-property-descriptors';
import './es.object.get-own-property-names';
import './es.object.get-prototype-of';
import './es.object.is-extensible';
import './es.object.is-frozen';
import './es.object.is-sealed';
import './es.object.is';
import './es.object.keys';
import './es.object.lookup-getter';
import './es.object.lookup-setter';
import './es.object.prevent-extensions';
import './es.object.seal';
import './es.object.set-prototype-of';
import './es.object.values';
import './es.parse-float';
import './es.parse-int';
import './es.promise';
import './es.promise.all-settled';
import './es.promise.finally';
import './es.reflect.apply';
import './es.reflect.construct';
import './es.reflect.define-property';
import './es.reflect.delete-property';
import './es.reflect.get-own-property-descriptor';
import './es.reflect.get-prototype-of';
import './es.reflect.get';
import './es.reflect.has';
import './es.reflect.is-extensible';
import './es.reflect.own-keys';
import './es.reflect.prevent-extensions';
import './es.reflect.set-prototype-of';
import './es.reflect.set';
import './es.set';
import './es.string.anchor';
import './es.string.big';
import './es.string.blink';
import './es.string.bold';
import './es.string.code-point-at';
import './es.string.ends-with';
import './es.string.fixed';
import './es.string.fontcolor';
import './es.string.fontsize';
import './es.string.from-code-point';
import './es.string.includes';
import './es.string.italics';
import './es.string.iterator';
import './es.string.link';
import './es.string.match-all';
import './es.string.pad-end';
import './es.string.pad-start';
import './es.string.raw';
import './es.string.repeat';
import './es.string.small';
import './es.string.starts-with';
import './es.string.strike';
import './es.string.sub';
import './es.string.sup';
import './es.string.trim';
import './es.string.trim-start';
import './es.string.trim-end';
import './es.symbol';
import './es.symbol.async-iterator';
import './es.weak-map';
import './es.weak-set';
QUnit.module('ESNext');
import './esnext.aggregate-error';
import './esnext.array.is-template-object';
import './esnext.async-iterator.constructor';
import './esnext.async-iterator.as-indexed-pairs';
import './esnext.async-iterator.drop';
import './esnext.async-iterator.every';
import './esnext.async-iterator.filter';
import './esnext.async-iterator.find';
import './esnext.async-iterator.flat-map';
import './esnext.async-iterator.for-each';
import './esnext.async-iterator.from';
import './esnext.async-iterator.map';
import './esnext.async-iterator.reduce';
import './esnext.async-iterator.some';
import './esnext.async-iterator.take';
import './esnext.async-iterator.to-array';
import './esnext.composite-key';
import './esnext.composite-symbol';
import './esnext.iterator.constructor';
import './esnext.iterator.as-indexed-pairs';
import './esnext.iterator.drop';
import './esnext.iterator.every';
import './esnext.iterator.filter';
import './esnext.iterator.find';
import './esnext.iterator.flat-map';
import './esnext.iterator.for-each';
import './esnext.iterator.from';
import './esnext.iterator.map';
import './esnext.iterator.reduce';
import './esnext.iterator.some';
import './esnext.iterator.take';
import './esnext.iterator.to-array';
import './esnext.math.clamp';
import './esnext.math.deg-per-rad';
import './esnext.math.degrees';
import './esnext.math.fscale';
import './esnext.math.iaddh';
import './esnext.math.imulh';
import './esnext.math.isubh';
import './esnext.math.rad-per-deg';
import './esnext.math.radians';
import './esnext.math.scale';
import './esnext.math.signbit';
import './esnext.math.umulh';
import './esnext.math.seeded-prng';
import './esnext.number.from-string';
import './esnext.object.iterate-entries';
import './esnext.object.iterate-keys';
import './esnext.object.iterate-values';
import './esnext.observable';
import './esnext.promise.any';
import './esnext.promise.try';
import './esnext.reflect.define-metadata';
import './esnext.reflect.delete-metadata';
import './esnext.reflect.get-metadata-keys';
import './esnext.reflect.get-metadata';
import './esnext.reflect.get-own-matadata';
import './esnext.reflect.get-own-metadata-keys';
import './esnext.reflect.has-metadata';
import './esnext.reflect.has-own-metadata';
import './esnext.reflect.metadata';
import './esnext.map.delete-all';
import './esnext.map.every';
import './esnext.map.filter';
import './esnext.map.find';
import './esnext.map.find-key';
import './esnext.map.from';
import './esnext.map.group-by';
import './esnext.map.includes';
import './esnext.map.key-by';
import './esnext.map.key-of';
import './esnext.map.map-keys';
import './esnext.map.map-values';
import './esnext.map.merge';
import './esnext.map.of';
import './esnext.map.reduce';
import './esnext.map.some';
import './esnext.map.update';
import './esnext.map.update-or-insert';
import './esnext.map.upsert';
import './esnext.set.add-all';
import './esnext.set.delete-all';
import './esnext.set.difference';
import './esnext.set.every';
import './esnext.set.filter';
import './esnext.set.find';
import './esnext.set.from';
import './esnext.set.intersection';
import './esnext.set.is-disjoint-from';
import './esnext.set.is-subset-of';
import './esnext.set.is-superset-of';
import './esnext.set.join';
import './esnext.set.map';
import './esnext.set.of';
import './esnext.set.reduce';
import './esnext.set.some';
import './esnext.set.symmetric-difference';
import './esnext.set.union';
import './esnext.string.at';
import './esnext.string.code-points';
import './esnext.symbol.async-dispose';
import './esnext.symbol.dispose';
import './esnext.symbol.observable';
import './esnext.symbol.pattern-match';
import './esnext.symbol.replace-all';
import './esnext.weak-map.delete-all';
import './esnext.weak-map.from';
import './esnext.weak-map.of';
import './esnext.weak-map.upsert';
import './esnext.weak-set.add-all';
import './esnext.weak-set.delete-all';
import './esnext.weak-set.from';
import './esnext.weak-set.of';
QUnit.module('Web');
import './web.dom-collections.iterator';
import './web.immediate';
import './web.queue-microtask';
import './web.timers';
import './web.url';
import './web.url-search-params';
QUnit.module('Helpers');
import './helpers.get-iterator-method';
import './helpers.get-iterator';
import './helpers.is-iterable';
import core from 'core-js-pure';
GLOBAL.core = core;
core-js-3.6.1/tests/pure/web.dom-collections.iterator.js 0000664 0000000 0000000 00000003076 13600575677 0023263 0 ustar 00root root 0000000 0000000 import { GLOBAL } from '../helpers/constants';
import Symbol from 'core-js-pure/features/symbol';
import getIteratorMethod from 'core-js-pure/features/get-iterator-method';
QUnit.test('Iterable DOM collections', assert => {
let absent = true;
const collections = [
'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',
];
for (const name of collections) {
const Collection = GLOBAL[name];
if (Collection) {
assert.same(Collection.prototype[Symbol.toStringTag], name, `${ name }::@@toStringTag is '${ name }'`);
assert.isFunction(getIteratorMethod(Collection.prototype), `${ name }::@@iterator is function`);
absent = false;
}
}
if (GLOBAL.NodeList && GLOBAL.document && document.querySelectorAll && document.querySelectorAll('div') instanceof NodeList) {
assert.isFunction(getIteratorMethod(document.querySelectorAll('div')), 'works with document.querySelectorAll');
}
if (absent) {
assert.ok(true, 'DOM collections are absent');
}
});
core-js-3.6.1/tests/pure/web.immediate.js 0000664 0000000 0000000 00000002261 13600575677 0020271 0 ustar 00root root 0000000 0000000 import { timeLimitedPromise } from '../helpers/helpers';
import { setImmediate, clearImmediate } from 'core-js-pure';
QUnit.test('setImmediate / clearImmediate', assert => {
let called = false;
assert.expect(6);
assert.isFunction(setImmediate, 'setImmediate is function');
assert.isFunction(clearImmediate, 'clearImmediate is function');
timeLimitedPromise(1e3, res => {
setImmediate(() => {
called = true;
res();
});
}).then(() => {
assert.ok(true, 'setImmediate works');
}).catch(() => {
assert.ok(false, 'setImmediate works');
}).then(assert.async());
assert.strictEqual(called, false, 'setImmediate is async');
timeLimitedPromise(1e3, res => {
setImmediate((a, b) => {
res(a + b);
}, 'a', 'b');
}).then(it => {
assert.strictEqual(it, 'ab', 'setImmediate works with additional args');
}).catch(() => {
assert.ok(false, 'setImmediate works with additional args');
}).then(assert.async());
timeLimitedPromise(50, res => {
clearImmediate(setImmediate(res));
}).then(() => {
assert.ok(false, 'clearImmediate works');
}).catch(() => {
assert.ok(true, 'clearImmediate works');
}).then(assert.async());
});
core-js-3.6.1/tests/pure/web.queue-microtask.js 0000664 0000000 0000000 00000001032 13600575677 0021444 0 ustar 00root root 0000000 0000000 import queueMicrotask from 'core-js-pure/features/queue-microtask';
QUnit.test('queueMicrotask', assert => {
assert.expect(3);
assert.isFunction(queueMicrotask);
assert.arity(queueMicrotask, 1);
const async = assert.async();
let done = false;
let after = false;
queueMicrotask(() => {
if (!done) {
done = true;
assert.ok(after, 'works');
async();
}
});
setTimeout(() => {
if (!done) {
done = true;
assert.ok(false, 'fails');
async();
}
}, 3e3);
after = true;
});
core-js-3.6.1/tests/pure/web.timers.js 0000664 0000000 0000000 00000002643 13600575677 0017642 0 ustar 00root root 0000000 0000000 import { timeLimitedPromise } from '../helpers/helpers';
import { setTimeout, setInterval } from 'core-js-pure';
QUnit.test('setTimeout / clearTimeout', assert => {
assert.expect(2);
timeLimitedPromise(1e3, resolve => {
setTimeout((a, b) => { resolve(a + b); }, 10, 'a', 'b');
}).then(it => {
assert.strictEqual(it, 'ab', 'setTimeout works with additional args');
}).catch(() => {
assert.ok(false, 'setTimeout works with additional args');
}).then(assert.async());
timeLimitedPromise(50, resolve => {
clearTimeout(setTimeout(resolve, 10));
}).then(() => {
assert.ok(false, 'clearImmediate works with wraped setTimeout');
}).catch(() => {
assert.ok(true, 'clearImmediate works with wraped setTimeout');
}).then(assert.async());
});
QUnit.test('setInterval / clearInterval', assert => {
assert.expect(1);
timeLimitedPromise(1e4, (resolve, reject) => {
let i = 0;
const interval = setInterval((a, b) => {
if (a + b !== 'ab' || i > 2) reject({ a, b, i });
if (i++ === 2) {
clearInterval(interval);
setTimeout(resolve, 30);
}
}, 5, 'a', 'b');
}).then(() => {
assert.ok(true, 'setInterval & clearInterval works with additional args');
}).catch(error => {
if (!error) error = {};
assert.ok(false, `setInterval & clearInterval works with additional args: ${ error.a }, ${ error.b }, times: ${ error.i }`);
}).then(assert.async());
});
core-js-3.6.1/tests/pure/web.url-search-params.js 0000664 0000000 0000000 00000067067 13600575677 0021700 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import { createIterable } from '../helpers/helpers';
import { Symbol, URL, URLSearchParams } from 'core-js-pure';
QUnit.test('URLSearchParams', assert => {
assert.isFunction(URLSearchParams);
assert.arity(URLSearchParams, 0);
assert.same(String(new URLSearchParams()), '');
assert.same(String(new URLSearchParams('')), '');
assert.same(String(new URLSearchParams('a=b')), 'a=b');
assert.same(String(new URLSearchParams(new URLSearchParams('a=b'))), 'a=b');
assert.same(String(new URLSearchParams([])), '');
assert.same(String(new URLSearchParams([[1, 2], ['a', 'b']])), '1=2&a=b');
assert.same(String(new URLSearchParams(createIterable([createIterable(['a', 'b']), createIterable(['c', 'd'])]))), 'a=b&c=d');
assert.same(String(new URLSearchParams({})), '');
assert.same(String(new URLSearchParams({ 1: 2, a: 'b' })), '1=2&a=b');
assert.same(String(new URLSearchParams('?a=b')), 'a=b', 'leading ? should be ignored');
assert.same(String(new URLSearchParams('??a=b')), '%3Fa=b');
assert.same(String(new URLSearchParams('?')), '');
assert.same(String(new URLSearchParams('??')), '%3F=');
assert.same(String(new URLSearchParams('a=b c')), 'a=b+c');
assert.same(String(new URLSearchParams('a=b&b=c&a=d')), 'a=b&b=c&a=d');
assert.same(String(new URLSearchParams('a==')), 'a=%3D');
assert.same(String(new URLSearchParams('a=b=')), 'a=b%3D');
assert.same(String(new URLSearchParams('a=b=c')), 'a=b%3Dc');
assert.same(String(new URLSearchParams('a==b')), 'a=%3Db');
let params = new URLSearchParams('a=b');
assert.same(params.has('a'), true, 'search params object has name "a"');
assert.same(params.has('b'), false, 'search params object has not got name "b"');
params = new URLSearchParams('a=b&c');
assert.same(params.has('a'), true, 'search params object has name "a"');
assert.same(params.has('c'), true, 'search params object has name "c"');
params = new URLSearchParams('&a&&& &&&&&a+b=& c&m%c3%b8%c3%b8');
assert.same(params.has('a'), true, 'search params object has name "a"');
assert.same(params.has('a b'), true, 'search params object has name "a b"');
assert.same(params.has(' '), true, 'search params object has name " "');
assert.same(params.has('c'), false, 'search params object did not have the name "c"');
assert.same(params.has(' c'), true, 'search params object has name " c"');
assert.same(params.has('møø'), true, 'search params object has name "møø"');
params = new URLSearchParams('a=b+c');
assert.same(params.get('a'), 'b c', 'parse +');
params = new URLSearchParams('a+b=c');
assert.same(params.get('a b'), 'c', 'parse +');
params = new URLSearchParams('a=b c');
assert.same(params.get('a'), 'b c', 'parse " "');
params = new URLSearchParams('a b=c');
assert.same(params.get('a b'), 'c', 'parse " "');
params = new URLSearchParams('a=b%20c');
assert.same(params.get('a'), 'b c', 'parse %20');
params = new URLSearchParams('a%20b=c');
assert.same(params.get('a b'), 'c', 'parse %20');
params = new URLSearchParams('a=b\0c');
assert.same(params.get('a'), 'b\0c', 'parse \\0');
params = new URLSearchParams('a\0b=c');
assert.same(params.get('a\0b'), 'c', 'parse \\0');
params = new URLSearchParams('a=b%00c');
assert.same(params.get('a'), 'b\0c', 'parse %00');
params = new URLSearchParams('a%00b=c');
assert.same(params.get('a\0b'), 'c', 'parse %00');
params = new URLSearchParams('a=b\u2384');
assert.same(params.get('a'), 'b\u2384', 'parse \u2384');
params = new URLSearchParams('a\u2384b=c');
assert.same(params.get('a\u2384b'), 'c', 'parse \u2384');
params = new URLSearchParams('a=b%e2%8e%84');
assert.same(params.get('a'), 'b\u2384', 'parse %e2%8e%84');
params = new URLSearchParams('a%e2%8e%84b=c');
assert.same(params.get('a\u2384b'), 'c', 'parse %e2%8e%84');
params = new URLSearchParams('a=b\uD83D\uDCA9c');
assert.same(params.get('a'), 'b\uD83D\uDCA9c', 'parse \uD83D\uDCA9');
params = new URLSearchParams('a\uD83D\uDCA9b=c');
assert.same(params.get('a\uD83D\uDCA9b'), 'c', 'parse \uD83D\uDCA9');
params = new URLSearchParams('a=b%f0%9f%92%a9c');
assert.same(params.get('a'), 'b\uD83D\uDCA9c', 'parse %f0%9f%92%a9');
params = new URLSearchParams('a%f0%9f%92%a9b=c');
assert.same(params.get('a\uD83D\uDCA9b'), 'c', 'parse %f0%9f%92%a9');
params = new URLSearchParams();
params.set('query', '+15555555555');
assert.same(params.toString(), 'query=%2B15555555555');
assert.same(params.get('query'), '+15555555555', 'parse encoded +');
params = new URLSearchParams(params.toString());
assert.same(params.get('query'), '+15555555555', 'parse encoded +');
const testData = [
{ input: '?a=%', output: [['a', '%']], name: 'handling %' },
{ input: { '+': '%C2' }, output: [['+', '%C2']], name: 'object with +' },
{ input: { c: 'x', a: '?' }, output: [['c', 'x'], ['a', '?']], name: 'object with two keys' },
{ input: [['c', 'x'], ['a', '?']], output: [['c', 'x'], ['a', '?']], name: 'array with two keys' },
// eslint-disable-next-line max-len
// !!! { input: { 'a\0b': '42', 'c\uD83D': '23', dሴ: 'foo' }, output: [['a\0b', '42'], ['c\uFFFD', '23'], ['d\u1234', 'foo']], name: 'object with NULL, non-ASCII, and surrogate keys' },
];
for (const { input, output, name } of testData) {
params = new URLSearchParams(input);
let i = 0;
params.forEach((value, key) => {
const [reqKey, reqValue] = output[i++];
assert.same(key, reqKey, `construct with ${ name }`);
assert.same(value, reqValue, `construct with ${ name }`);
});
}
assert.throws(() => {
URLSearchParams('');
}, 'throws w/o `new`');
assert.throws(() => {
new URLSearchParams([[1, 2, 3]]);
}, 'sequence elements must be pairs #1');
assert.throws(() => {
new URLSearchParams([createIterable([createIterable([1, 2, 3])])]);
}, 'sequence elements must be pairs #2');
assert.throws(() => {
new URLSearchParams([[1]]);
}, 'sequence elements must be pairs #3');
assert.throws(() => {
new URLSearchParams([createIterable([createIterable([1])])]);
}, 'sequence elements must be pairs #4');
});
QUnit.test('URLSearchParams#append', assert => {
const { append } = URLSearchParams.prototype;
assert.isFunction(append);
assert.arity(append, 2);
assert.enumerable(URLSearchParams.prototype, 'append');
assert.same(new URLSearchParams().append('a', 'b'), undefined, 'void');
let params = new URLSearchParams();
params.append('a', 'b');
assert.same(String(params), 'a=b');
params.append('a', 'b');
assert.same(String(params), 'a=b&a=b');
params.append('a', 'c');
assert.same(String(params), 'a=b&a=b&a=c');
params = new URLSearchParams();
params.append('', '');
assert.same(String(params), '=');
params.append('', '');
assert.same(String(params), '=&=');
params = new URLSearchParams();
params.append(undefined, undefined);
assert.same(String(params), 'undefined=undefined');
params.append(undefined, undefined);
assert.same(String(params), 'undefined=undefined&undefined=undefined');
params = new URLSearchParams();
params.append(null, null);
assert.same(String(params), 'null=null');
params.append(null, null);
assert.same(String(params), 'null=null&null=null');
params = new URLSearchParams();
params.append('first', 1);
params.append('second', 2);
params.append('third', '');
params.append('first', 10);
assert.ok(params.has('first'), 'search params object has name "first"');
assert.same(params.get('first'), '1', 'search params object has name "first" with value "1"');
assert.same(params.get('second'), '2', 'search params object has name "second" with value "2"');
assert.same(params.get('third'), '', 'search params object has name "third" with value ""');
params.append('first', 10);
assert.same(params.get('first'), '1', 'search params object has name "first" with value "1"');
assert.throws(() => {
return new URLSearchParams('').append();
}, 'throws w/o arguments');
});
QUnit.test('URLSearchParams#delete', assert => {
const $delete = URLSearchParams.prototype.delete;
assert.isFunction($delete);
assert.arity($delete, 1);
assert.enumerable(URLSearchParams.prototype, 'delete');
let params = new URLSearchParams('a=b&c=d');
params.delete('a');
assert.same(String(params), 'c=d');
params = new URLSearchParams('a=a&b=b&a=a&c=c');
params.delete('a');
assert.same(String(params), 'b=b&c=c');
params = new URLSearchParams('a=a&=&b=b&c=c');
params.delete('');
assert.same(String(params), 'a=a&b=b&c=c');
params = new URLSearchParams('a=a&null=null&b=b');
params.delete(null);
assert.same(String(params), 'a=a&b=b');
params = new URLSearchParams('a=a&undefined=undefined&b=b');
params.delete(undefined);
assert.same(String(params), 'a=a&b=b');
params = new URLSearchParams();
params.append('first', 1);
assert.same(params.has('first'), true, 'search params object has name "first"');
assert.same(params.get('first'), '1', 'search params object has name "first" with value "1"');
params.delete('first');
assert.same(params.has('first'), false, 'search params object has no "first" name');
params.append('first', 1);
params.append('first', 10);
params.delete('first');
assert.same(params.has('first'), false, 'search params object has no "first" name');
if (DESCRIPTORS) {
let url = new URL('http://example.com/?param1¶m2');
url.searchParams.delete('param1');
url.searchParams.delete('param2');
assert.same(String(url), 'http://example.com/', 'url.href does not have ?');
assert.same(url.search, '', 'url.search does not have ?');
url = new URL('http://example.com/?');
url.searchParams.delete('param1');
// assert.same(String(url), 'http://example.com/', 'url.href does not have ?'); // Safari bug
assert.same(url.search, '', 'url.search does not have ?');
}
assert.throws(() => {
return new URLSearchParams('').delete();
}, 'throws w/o arguments');
});
QUnit.test('URLSearchParams#get', assert => {
const { get } = URLSearchParams.prototype;
assert.isFunction(get);
assert.arity(get, 1);
assert.enumerable(URLSearchParams.prototype, 'get');
let params = new URLSearchParams('a=b&c=d');
assert.same(params.get('a'), 'b');
assert.same(params.get('c'), 'd');
assert.same(params.get('e'), null);
params = new URLSearchParams('a=b&c=d&a=e');
assert.same(params.get('a'), 'b');
params = new URLSearchParams('=b&c=d');
assert.same(params.get(''), 'b');
params = new URLSearchParams('a=&c=d&a=e');
assert.same(params.get('a'), '');
params = new URLSearchParams('first=second&third&&');
assert.same(params.has('first'), true, 'Search params object has name "first"');
assert.same(params.get('first'), 'second', 'Search params object has name "first" with value "second"');
assert.same(params.get('third'), '', 'Search params object has name "third" with the empty value.');
assert.same(params.get('fourth'), null, 'Search params object has no "fourth" name and value.');
assert.same(new URLSearchParams('a=b c').get('a'), 'b c');
assert.same(new URLSearchParams('a b=c').get('a b'), 'c');
assert.same(new URLSearchParams('a=b%20c').get('a'), 'b c', 'parse %20');
assert.same(new URLSearchParams('a%20b=c').get('a b'), 'c', 'parse %20');
assert.same(new URLSearchParams('a=b\0c').get('a'), 'b\0c', 'parse \\0');
assert.same(new URLSearchParams('a\0b=c').get('a\0b'), 'c', 'parse \\0');
assert.same(new URLSearchParams('a=b%2Bc').get('a'), 'b+c', 'parse %2B');
assert.same(new URLSearchParams('a%2Bb=c').get('a+b'), 'c', 'parse %2B');
assert.same(new URLSearchParams('a=b%00c').get('a'), 'b\0c', 'parse %00');
assert.same(new URLSearchParams('a%00b=c').get('a\0b'), 'c', 'parse %00');
assert.same(new URLSearchParams('a==').get('a'), '=', 'parse =');
assert.same(new URLSearchParams('a=b=').get('a'), 'b=', 'parse =');
assert.same(new URLSearchParams('a=b=c').get('a'), 'b=c', 'parse =');
assert.same(new URLSearchParams('a==b').get('a'), '=b', 'parse =');
assert.same(new URLSearchParams('a=b\u2384').get('a'), 'b\u2384', 'parse \\u2384');
assert.same(new URLSearchParams('a\u2384b=c').get('a\u2384b'), 'c', 'parse \\u2384');
assert.same(new URLSearchParams('a=b%e2%8e%84').get('a'), 'b\u2384', 'parse %e2%8e%84');
assert.same(new URLSearchParams('a%e2%8e%84b=c').get('a\u2384b'), 'c', 'parse %e2%8e%84');
assert.same(new URLSearchParams('a=b\uD83D\uDCA9c').get('a'), 'b\uD83D\uDCA9c', 'parse \\uD83D\\uDCA9');
assert.same(new URLSearchParams('a\uD83D\uDCA9b=c').get('a\uD83D\uDCA9b'), 'c', 'parse \\uD83D\\uDCA9');
assert.same(new URLSearchParams('a=b%f0%9f%92%a9c').get('a'), 'b\uD83D\uDCA9c', 'parse %f0%9f%92%a9');
assert.same(new URLSearchParams('a%f0%9f%92%a9b=c').get('a\uD83D\uDCA9b'), 'c', 'parse %f0%9f%92%a9');
assert.same(new URLSearchParams('=').get(''), '', 'parse =');
assert.throws(() => {
return new URLSearchParams('').get();
}, 'throws w/o arguments');
});
QUnit.test('URLSearchParams#getAll', assert => {
const { getAll } = URLSearchParams.prototype;
assert.isFunction(getAll);
assert.arity(getAll, 1);
assert.enumerable(URLSearchParams.prototype, 'getAll');
let params = new URLSearchParams('a=b&c=d');
assert.arrayEqual(params.getAll('a'), ['b']);
assert.arrayEqual(params.getAll('c'), ['d']);
assert.arrayEqual(params.getAll('e'), []);
params = new URLSearchParams('a=b&c=d&a=e');
assert.arrayEqual(params.getAll('a'), ['b', 'e']);
params = new URLSearchParams('=b&c=d');
assert.arrayEqual(params.getAll(''), ['b']);
params = new URLSearchParams('a=&c=d&a=e');
assert.arrayEqual(params.getAll('a'), ['', 'e']);
params = new URLSearchParams('a=1&a=2&a=3&a');
assert.arrayEqual(params.getAll('a'), ['1', '2', '3', ''], 'search params object has expected name "a" values');
params.set('a', 'one');
assert.arrayEqual(params.getAll('a'), ['one'], 'search params object has expected name "a" values');
assert.throws(() => {
return new URLSearchParams('').getAll();
}, 'throws w/o arguments');
});
QUnit.test('URLSearchParams#has', assert => {
const { has } = URLSearchParams.prototype;
assert.isFunction(has);
assert.arity(has, 1);
assert.enumerable(URLSearchParams.prototype, 'has');
let params = new URLSearchParams('a=b&c=d');
assert.same(params.has('a'), true);
assert.same(params.has('c'), true);
assert.same(params.has('e'), false);
params = new URLSearchParams('a=b&c=d&a=e');
assert.same(params.has('a'), true);
params = new URLSearchParams('=b&c=d');
assert.same(params.has(''), true);
params = new URLSearchParams('null=a');
assert.same(params.has(null), true);
params = new URLSearchParams('a=b&c=d&&');
params.append('first', 1);
params.append('first', 2);
assert.same(params.has('a'), true, 'search params object has name "a"');
assert.same(params.has('c'), true, 'search params object has name "c"');
assert.same(params.has('first'), true, 'search params object has name "first"');
assert.same(params.has('d'), false, 'search params object has no name "d"');
params.delete('first');
assert.same(params.has('first'), false, 'search params object has no name "first"');
assert.throws(() => {
return new URLSearchParams('').has();
}, 'throws w/o arguments');
});
QUnit.test('URLSearchParams#set', assert => {
const { set } = URLSearchParams.prototype;
assert.isFunction(set);
assert.arity(set, 2);
assert.enumerable(URLSearchParams.prototype, 'set');
let params = new URLSearchParams('a=b&c=d');
params.set('a', 'B');
assert.same(String(params), 'a=B&c=d');
params = new URLSearchParams('a=b&c=d&a=e');
params.set('a', 'B');
assert.same(String(params), 'a=B&c=d');
params.set('e', 'f');
assert.same(String(params), 'a=B&c=d&e=f');
params = new URLSearchParams('a=1&a=2&a=3');
assert.same(params.has('a'), true, 'search params object has name "a"');
assert.same(params.get('a'), '1', 'search params object has name "a" with value "1"');
params.set('first', 4);
assert.same(params.has('a'), true, 'search params object has name "a"');
assert.same(params.get('a'), '1', 'search params object has name "a" with value "1"');
assert.same(String(params), 'a=1&a=2&a=3&first=4');
params.set('a', 4);
assert.same(params.has('a'), true, 'search params object has name "a"');
assert.same(params.get('a'), '4', 'search params object has name "a" with value "4"');
assert.same(String(params), 'a=4&first=4');
assert.throws(() => {
return new URLSearchParams('').set();
}, 'throws w/o arguments');
});
QUnit.test('URLSearchParams#sort', assert => {
const { sort } = URLSearchParams.prototype;
assert.isFunction(sort);
assert.arity(sort, 0);
assert.enumerable(URLSearchParams.prototype, 'sort');
let params = new URLSearchParams('a=1&b=4&a=3&b=2');
params.sort();
assert.same(String(params), 'a=1&a=3&b=4&b=2');
params.delete('a');
params.append('a', '0');
params.append('b', '0');
params.sort();
assert.same(String(params), 'a=0&b=4&b=2&b=0');
const testData = [
{
input: 'z=b&a=b&z=a&a=a',
output: [['a', 'b'], ['a', 'a'], ['z', 'b'], ['z', 'a']],
},
{
input: '\uFFFD=x&\uFFFC&\uFFFD=a',
output: [['\uFFFC', ''], ['\uFFFD', 'x'], ['\uFFFD', 'a']],
},
{
input: 'ffi&🌈', // 🌈 > code point, but < code unit because two code units
output: [['🌈', ''], ['ffi', '']],
},
{
input: 'é&e\uFFFD&e\u0301',
output: [['e\u0301', ''], ['e\uFFFD', ''], ['é', '']],
},
{
input: 'z=z&a=a&z=y&a=b&z=x&a=c&z=w&a=d&z=v&a=e&z=u&a=f&z=t&a=g',
// eslint-disable-next-line max-len
output: [['a', 'a'], ['a', 'b'], ['a', 'c'], ['a', 'd'], ['a', 'e'], ['a', 'f'], ['a', 'g'], ['z', 'z'], ['z', 'y'], ['z', 'x'], ['z', 'w'], ['z', 'v'], ['z', 'u'], ['z', 't']],
},
{
input: 'bbb&bb&aaa&aa=x&aa=y',
output: [['aa', 'x'], ['aa', 'y'], ['aaa', ''], ['bb', ''], ['bbb', '']],
},
{
input: 'z=z&=f&=t&=x',
output: [['', 'f'], ['', 't'], ['', 'x'], ['z', 'z']],
},
{
input: 'a🌈&a💩',
output: [['a🌈', ''], ['a💩', '']],
},
];
for (const { input, output } of testData) {
let i = 0;
params = new URLSearchParams(input);
params.sort();
params.forEach((value, key) => {
const [reqKey, reqValue] = output[i++];
assert.same(key, reqKey);
assert.same(value, reqValue);
});
i = 0;
const url = new URL(`?${ input }`, 'https://example/');
params = url.searchParams;
params.sort();
params.forEach((value, key) => {
const [reqKey, reqValue] = output[i++];
assert.same(key, reqKey);
assert.same(value, reqValue);
});
}
if (DESCRIPTORS) {
const url = new URL('http://example.com/?');
url.searchParams.sort();
assert.same(url.href, 'http://example.com/', 'Sorting non-existent params removes ? from URL');
assert.same(url.search, '', 'Sorting non-existent params removes ? from URL');
}
});
QUnit.test('URLSearchParams#toString', assert => {
const { toString } = URLSearchParams.prototype;
assert.isFunction(toString);
assert.arity(toString, 0);
let params = new URLSearchParams();
params.append('a', 'b c');
assert.same(String(params), 'a=b+c');
params.delete('a');
params.append('a b', 'c');
assert.same(String(params), 'a+b=c');
params = new URLSearchParams();
params.append('a', '');
assert.same(String(params), 'a=');
params.append('a', '');
assert.same(String(params), 'a=&a=');
params.append('', 'b');
assert.same(String(params), 'a=&a=&=b');
params.append('', '');
assert.same(String(params), 'a=&a=&=b&=');
params.append('', '');
assert.same(String(params), 'a=&a=&=b&=&=');
params = new URLSearchParams();
params.append('', 'b');
assert.same(String(params), '=b');
params.append('', 'b');
assert.same(String(params), '=b&=b');
params = new URLSearchParams();
params.append('', '');
assert.same(String(params), '=');
params.append('', '');
assert.same(String(params), '=&=');
params = new URLSearchParams();
params.append('a', 'b+c');
assert.same(String(params), 'a=b%2Bc');
params.delete('a');
params.append('a+b', 'c');
assert.same(String(params), 'a%2Bb=c');
params = new URLSearchParams();
params.append('=', 'a');
assert.same(String(params), '%3D=a');
params.append('b', '=');
assert.same(String(params), '%3D=a&b=%3D');
params = new URLSearchParams();
params.append('&', 'a');
assert.same(String(params), '%26=a');
params.append('b', '&');
assert.same(String(params), '%26=a&b=%26');
params = new URLSearchParams();
params.append('a', '\r');
assert.same(String(params), 'a=%0D');
params = new URLSearchParams();
params.append('a', '\n');
assert.same(String(params), 'a=%0A');
params = new URLSearchParams();
params.append('a', '\r\n');
assert.same(String(params), 'a=%0D%0A');
params = new URLSearchParams();
params.append('a', 'b%c');
assert.same(String(params), 'a=b%25c');
params.delete('a');
params.append('a%b', 'c');
assert.same(String(params), 'a%25b=c');
params = new URLSearchParams();
params.append('a', 'b\0c');
assert.same(String(params), 'a=b%00c');
params.delete('a');
params.append('a\0b', 'c');
assert.same(String(params), 'a%00b=c');
params = new URLSearchParams();
params.append('a', 'b\uD83D\uDCA9c');
assert.same(String(params), 'a=b%F0%9F%92%A9c');
params.delete('a');
params.append('a\uD83D\uDCA9b', 'c');
assert.same(String(params), 'a%F0%9F%92%A9b=c');
params = new URLSearchParams('a=b&c=d&&e&&');
assert.same(String(params), 'a=b&c=d&e=');
params = new URLSearchParams('a = b &a=b&c=d%20');
assert.same(String(params), 'a+=+b+&a=b&c=d+');
params = new URLSearchParams('a=&a=b');
assert.same(String(params), 'a=&a=b');
});
QUnit.test('URLSearchParams#forEach', assert => {
const { forEach } = URLSearchParams.prototype;
assert.isFunction(forEach);
assert.arity(forEach, 1);
assert.enumerable(URLSearchParams.prototype, 'forEach');
const expectedValues = { a: '1', b: '2', c: '3' };
let params = new URLSearchParams('a=1&b=2&c=3');
let result = '';
params.forEach((value, key, that) => {
assert.same(params.get(key), expectedValues[key]);
assert.same(value, expectedValues[key]);
assert.same(that, params);
result += key;
});
assert.same(result, 'abc');
new URL('http://a.b/c').searchParams.forEach(() => {
assert.ok(false, 'should not be called');
});
// fails in Chrome 66-
if (DESCRIPTORS) {
const url = new URL('http://a.b/c?a=1&b=2&c=3&d=4');
params = url.searchParams;
result = '';
params.forEach((val, key) => {
url.search = 'x=1&y=2&z=3';
result += key + val;
});
assert.same(result, 'a1y2z3');
}
// fails in Chrome 66-
params = new URLSearchParams('a=1&b=2&c=3');
result = '';
params.forEach((value, key) => {
params.delete('b');
result += key + value;
});
assert.same(result, 'a1c3');
});
QUnit.test('URLSearchParams#entries', assert => {
const { entries } = URLSearchParams.prototype;
assert.isFunction(entries);
assert.arity(entries, 0);
assert.enumerable(URLSearchParams.prototype, 'entries');
const expectedValues = { a: '1', b: '2', c: '3' };
let params = new URLSearchParams('a=1&b=2&c=3');
let iterator = params.entries();
let result = '';
let entry;
while (!(entry = iterator.next()).done) {
const [key, value] = entry.value;
assert.same(params.get(key), expectedValues[key]);
assert.same(value, expectedValues[key]);
result += key;
}
assert.same(result, 'abc');
assert.ok(new URL('http://a.b/c').searchParams.entries().next().done, 'should be finished');
// fails in Chrome 66-
if (DESCRIPTORS) {
const url = new URL('http://a.b/c?a=1&b=2&c=3&d=4');
iterator = url.searchParams.entries();
result = '';
while (!(entry = iterator.next()).done) {
const [key, value] = entry.value;
url.search = 'x=1&y=2&z=3';
result += key + value;
}
assert.same(result, 'a1y2z3');
}
// fails in Chrome 66-
params = new URLSearchParams('a=1&b=2&c=3');
iterator = params.entries();
result = '';
while (!(entry = iterator.next()).done) {
params.delete('b');
const [key, value] = entry.value;
result += key + value;
}
assert.same(result, 'a1c3');
});
QUnit.test('URLSearchParams#keys', assert => {
const { keys } = URLSearchParams.prototype;
assert.isFunction(keys);
assert.arity(keys, 0);
assert.enumerable(URLSearchParams.prototype, 'keys');
let iterator = new URLSearchParams('a=1&b=2&c=3').keys();
let result = '';
let entry;
while (!(entry = iterator.next()).done) {
result += entry.value;
}
assert.same(result, 'abc');
assert.ok(new URL('http://a.b/c').searchParams.keys().next().done, 'should be finished');
// fails in Chrome 66-
if (DESCRIPTORS) {
const url = new URL('http://a.b/c?a=1&b=2&c=3&d=4');
iterator = url.searchParams.keys();
result = '';
while (!(entry = iterator.next()).done) {
const key = entry.value;
url.search = 'x=1&y=2&z=3';
result += key;
}
assert.same(result, 'ayz');
}
// fails in Chrome 66-
const params = new URLSearchParams('a=1&b=2&c=3');
iterator = params.keys();
result = '';
while (!(entry = iterator.next()).done) {
params.delete('b');
const key = entry.value;
result += key;
}
assert.same(result, 'ac');
});
QUnit.test('URLSearchParams#values', assert => {
const { values } = URLSearchParams.prototype;
assert.isFunction(values);
assert.arity(values, 0);
assert.enumerable(URLSearchParams.prototype, 'values');
let iterator = new URLSearchParams('a=1&b=2&c=3').values();
let result = '';
let entry;
while (!(entry = iterator.next()).done) {
result += entry.value;
}
assert.same(result, '123');
assert.ok(new URL('http://a.b/c').searchParams.values().next().done, 'should be finished');
// fails in Chrome 66-
if (DESCRIPTORS) {
const url = new URL('http://a.b/c?a=a&b=b&c=c&d=d');
iterator = url.searchParams.keys();
result = '';
while (!(entry = iterator.next()).done) {
const { value } = entry;
url.search = 'x=x&y=y&z=z';
result += value;
}
assert.same(result, 'ayz');
}
// fails in Chrome 66-
const params = new URLSearchParams('a=1&b=2&c=3');
iterator = params.values();
result = '';
while (!(entry = iterator.next()).done) {
params.delete('b');
const key = entry.value;
result += key;
}
assert.same(result, '13');
});
QUnit.test('URLSearchParams#@@iterator', assert => {
const entries = URLSearchParams.prototype[Symbol.iterator];
assert.isFunction(entries);
assert.arity(entries, 0);
assert.same(entries, URLSearchParams.prototype.entries);
const expectedValues = { a: '1', b: '2', c: '3' };
let params = new URLSearchParams('a=1&b=2&c=3');
let iterator = params[Symbol.iterator]();
let result = '';
let entry;
while (!(entry = iterator.next()).done) {
const [key, value] = entry.value;
assert.same(params.get(key), expectedValues[key]);
assert.same(value, expectedValues[key]);
result += key;
}
assert.same(result, 'abc');
assert.ok(new URL('http://a.b/c').searchParams[Symbol.iterator]().next().done, 'should be finished');
// fails in Chrome 66-
if (DESCRIPTORS) {
const url = new URL('http://a.b/c?a=1&b=2&c=3&d=4');
iterator = url.searchParams[Symbol.iterator]();
result = '';
while (!(entry = iterator.next()).done) {
const [key, value] = entry.value;
url.search = 'x=1&y=2&z=3';
result += key + value;
}
assert.same(result, 'a1y2z3');
}
// fails in Chrome 66-
params = new URLSearchParams('a=1&b=2&c=3');
iterator = params[Symbol.iterator]();
result = '';
while (!(entry = iterator.next()).done) {
params.delete('b');
const [key, value] = entry.value;
result += key + value;
}
assert.same(result, 'a1c3');
});
core-js-3.6.1/tests/pure/web.url.js 0000664 0000000 0000000 00000067056 13600575677 0017152 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import urlTestData from '../wpt-url-resources/urltestdata';
import settersTestData from '../wpt-url-resources/setters';
import toASCIITestData from '../wpt-url-resources/toascii';
import { URL, URLSearchParams } from 'core-js-pure';
const { hasOwnProperty } = Object.prototype;
QUnit.test('URL constructor', assert => {
assert.isFunction(URL);
assert.arity(URL, 1);
assert.same(String(new URL('http://www.domain.com/a/b')), 'http://www.domain.com/a/b');
assert.same(String(new URL('/c/d', 'http://www.domain.com/a/b')), 'http://www.domain.com/c/d');
assert.same(String(new URL('b/c', 'http://www.domain.com/a/b')), 'http://www.domain.com/a/b/c');
assert.same(String(new URL('b/c', new URL('http://www.domain.com/a/b'))), 'http://www.domain.com/a/b/c');
assert.same(String(new URL({ toString: () => 'https://example.org/' })), 'https://example.org/');
assert.same(String(new URL('nonspecial://example.com/')), 'nonspecial://example.com/');
assert.same(String(new URL('https://測試')), 'https://xn--g6w251d/', 'unicode parsing');
assert.same(String(new URL('https://xxпривет.тест')), 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
assert.same(String(new URL('https://xxПРИВЕТ.тест')), 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
assert.same(String(new URL('http://Example.com/', 'https://example.org/')), 'http://example.com/');
assert.same(String(new URL('https://Example.com/', 'https://example.org/')), 'https://example.com/');
assert.same(String(new URL('nonspecial://Example.com/', 'https://example.org/')), 'nonspecial://Example.com/');
assert.same(String(new URL('http:Example.com/', 'https://example.org/')), 'http://example.com/');
assert.same(String(new URL('https:Example.com/', 'https://example.org/')), 'https://example.org/Example.com/');
assert.same(String(new URL('nonspecial:Example.com/', 'https://example.org/')), 'nonspecial:Example.com/');
assert.same(String(new URL('http://0300.168.0xF0')), 'http://192.168.0.240/');
assert.same(String(new URL('http://[20:0:0:1:0:0:0:ff]')), 'http://[20:0:0:1::ff]/');
// assert.same(String(new URL('http://257.168.0xF0')), 'http://257.168.0xf0/', 'incorrect IPv4 parsed as host'); // TypeError in Chrome and Safari
assert.same(String(new URL('http://0300.168.0xG0')), 'http://0300.168.0xg0/', 'incorrect IPv4 parsed as host');
assert.same(String(new URL('file:///var/log/system.log')), 'file:///var/log/system.log', 'file scheme');
// assert.same(String(new URL('file://nnsc.nsf.net/bar/baz')), 'file://nnsc.nsf.net/bar/baz', 'file scheme'); // 'file:///bar/baz' in FF
// assert.same(String(new URL('file://localhost/bar/baz')), 'file:///bar/baz', 'file scheme'); // 'file://localhost/bar/baz' in Chrome
assert.throws(() => new URL(), 'TypeError: Failed to construct \'URL\': 1 argument required, but only 0 present.');
assert.throws(() => new URL(''), 'TypeError: Failed to construct \'URL\': Invalid URL');
assert.throws(() => new URL('', 'about:blank'), 'TypeError: Failed to construct \'URL\': Invalid URL');
assert.throws(() => new URL('abc'), 'TypeError: Failed to construct \'URL\': Invalid URL');
assert.throws(() => new URL('//abc'), 'TypeError: Failed to construct \'URL\': Invalid URL');
assert.throws(() => new URL('http:///www.domain.com/', 'abc'), 'TypeError: Failed to construct \'URL\': Invalid base URL');
assert.throws(() => new URL('http:///www.domain.com/', null), 'TypeError: Failed to construct \'URL\': Invalid base URL');
assert.throws(() => new URL('//abc', null), 'TypeError: Failed to construct \'URL\': Invalid base URL');
assert.throws(() => new URL('http://[20:0:0:1:0:0:0:ff'), 'incorrect IPv6');
assert.throws(() => new URL('http://[20:0:0:1:0:0:0:fg]'), 'incorrect IPv6');
// assert.throws(() => new URL('http://a%b'), 'forbidden host code point'); // no error in FF
assert.throws(() => new URL('1http://zloirock.ru'), 'incorrect scheme');
});
QUnit.test('URL#href', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'href'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'href');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.href, 'http://zloirock.ru/');
if (DESCRIPTORS) {
url.searchParams.append('foo', 'bar');
assert.same(url.href, 'http://zloirock.ru/?foo=bar');
url = new URL('http://zloirock.ru/foo');
url.href = 'https://測試';
assert.same(url.href, 'https://xn--g6w251d/', 'unicode parsing');
assert.same(String(url), 'https://xn--g6w251d/', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.href = 'https://xxпривет.тест';
assert.same(url.href, 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
assert.same(String(url), 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.href = 'https://xxПРИВЕТ.тест';
assert.same(url.href, 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
assert.same(String(url), 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
url = new URL('http://zloirock.ru/');
url.href = 'http://0300.168.0xF0';
assert.same(url.href, 'http://192.168.0.240/');
assert.same(String(url), 'http://192.168.0.240/');
url = new URL('http://zloirock.ru/');
url.href = 'http://[20:0:0:1:0:0:0:ff]';
assert.same(url.href, 'http://[20:0:0:1::ff]/');
assert.same(String(url), 'http://[20:0:0:1::ff]/');
// url = new URL('http://zloirock.ru/');
// url.href = 'http://257.168.0xF0'; // TypeError and Safari
// assert.same(url.href, 'http://257.168.0xf0/', 'incorrect IPv4 parsed as host'); // `F` instead of `f` in Chrome
// assert.same(String(url), 'http://257.168.0xf0/', 'incorrect IPv4 parsed as host'); // `F` instead of `f` in Chrome
url = new URL('http://zloirock.ru/');
url.href = 'http://0300.168.0xG0';
assert.same(url.href, 'http://0300.168.0xg0/', 'incorrect IPv4 parsed as host');
assert.same(String(url), 'http://0300.168.0xg0/', 'incorrect IPv4 parsed as host');
url = new URL('http://192.168.0.240/');
url.href = 'file:///var/log/system.log';
assert.same(url.href, 'file:///var/log/system.log', 'file -> ip');
assert.same(String(url), 'file:///var/log/system.log', 'file -> ip');
url = new URL('file:///var/log/system.log');
url.href = 'http://0300.168.0xF0';
assert.same(url.href, 'http://192.168.0.240/', 'file -> http');
assert.same(String(url), 'http://192.168.0.240/', 'file -> http');
// assert.throws(() => new URL('http://zloirock.ru/').href = undefined, 'incorrect URL'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = '', 'incorrect URL'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = 'abc', 'incorrect URL'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = '//abc', 'incorrect URL'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = 'http://[20:0:0:1:0:0:0:ff', 'incorrect IPv6'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = 'http://[20:0:0:1:0:0:0:fg]', 'incorrect IPv6'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = 'http://a%b', 'forbidden host code point'); // no error in Chrome and FF
// assert.throws(() => new URL('http://zloirock.ru/').href = '1http://zloirock.ru', 'incorrect scheme'); // no error in Chrome
}
});
QUnit.test('URL#origin', assert => {
const url = new URL('http://es6.zloirock.ru/tests.html');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'origin'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'origin');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
}
assert.same(url.origin, 'http://es6.zloirock.ru');
assert.same(new URL('https://測試/tests').origin, 'https://xn--g6w251d');
});
QUnit.test('URL#protocol', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'protocol'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'protocol');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.protocol, 'http:');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.protocol = 'https';
assert.same(url.protocol, 'https:');
assert.same(String(url), 'https://zloirock.ru/');
// https://nodejs.org/api/url.html#url_special_schemes
// url = new URL('http://zloirock.ru/');
// url.protocol = 'fish';
// assert.same(url.protocol, 'http:');
// assert.same(url.href, 'http://zloirock.ru/');
// assert.same(String(url), 'http://zloirock.ru/');
url = new URL('http://zloirock.ru/');
url.protocol = '1http';
assert.same(url.protocol, 'http:');
assert.same(url.href, 'http://zloirock.ru/', 'incorrect scheme');
assert.same(String(url), 'http://zloirock.ru/', 'incorrect scheme');
}
});
QUnit.test('URL#username', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'username'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'username');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.username, '');
url = new URL('http://username@zloirock.ru/');
assert.same(url.username, 'username');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.username = 'username';
assert.same(url.username, 'username');
assert.same(String(url), 'http://username@zloirock.ru/');
}
});
QUnit.test('URL#password', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'password'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'password');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.password, '');
url = new URL('http://username:password@zloirock.ru/');
assert.same(url.password, 'password');
// url = new URL('http://:password@zloirock.ru/'); // TypeError in FF
// assert.same(url.password, 'password');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.username = 'username';
url.password = 'password';
assert.same(url.password, 'password');
assert.same(String(url), 'http://username:password@zloirock.ru/');
// url = new URL('http://zloirock.ru/');
// url.password = 'password';
// assert.same(url.password, 'password'); // '' in FF
// assert.same(String(url), 'http://:password@zloirock.ru/'); // 'http://zloirock.ru/' in FF
}
});
QUnit.test('URL#host', assert => {
let url = new URL('http://zloirock.ru:81/path');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'host'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'host');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.host, 'zloirock.ru:81');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru:81/path');
url.host = 'example.com:82';
assert.same(url.host, 'example.com:82');
assert.same(String(url), 'http://example.com:82/path');
// url = new URL('http://zloirock.ru:81/path');
// url.host = 'other?domain.com';
// assert.same(String(url), 'http://other:81/path'); // 'http://other/?domain.com/path' in Safari
url = new URL('https://www.mydomain.com:8080/path/');
url.host = 'www.otherdomain.com:80';
assert.same(url.href, 'https://www.otherdomain.com:80/path/', 'set default port for another protocol');
// url = new URL('https://www.mydomain.com:8080/path/');
// url.host = 'www.otherdomain.com:443';
// assert.same(url.href, 'https://www.otherdomain.com/path/', 'set default port');
url = new URL('http://zloirock.ru/foo');
url.host = '測試';
assert.same(url.host, 'xn--g6w251d', 'unicode parsing');
assert.same(String(url), 'http://xn--g6w251d/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.host = 'xxпривет.тест';
assert.same(url.host, 'xn--xx-flcmn5bht.xn--e1aybc', 'unicode parsing');
assert.same(String(url), 'http://xn--xx-flcmn5bht.xn--e1aybc/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.host = 'xxПРИВЕТ.тест';
assert.same(url.host, 'xn--xx-flcmn5bht.xn--e1aybc', 'unicode parsing');
assert.same(String(url), 'http://xn--xx-flcmn5bht.xn--e1aybc/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.host = '0300.168.0xF0';
assert.same(url.host, '192.168.0.240');
assert.same(String(url), 'http://192.168.0.240/foo');
// url = new URL('http://zloirock.ru/foo');
// url.host = '[20:0:0:1:0:0:0:ff]';
// assert.same(url.host, '[20:0:0:1::ff]'); // ':0' in Chrome, 'zloirock.ru' in Safari
// assert.same(String(url), 'http://[20:0:0:1::ff]/foo'); // 'http://[20:0/foo' in Chrome, 'http://zloirock.ru/foo' in Safari
// url = new URL('file:///var/log/system.log');
// url.host = 'nnsc.nsf.net'; // does not work in FF
// assert.same(url.hostname, 'nnsc.nsf.net', 'file');
// assert.same(String(url), 'file://nnsc.nsf.net/var/log/system.log', 'file');
// url = new URL('http://zloirock.ru/');
// url.host = '[20:0:0:1:0:0:0:ff';
// assert.same(url.host, 'zloirock.ru', 'incorrect IPv6'); // ':0' in Chrome
// assert.same(String(url), 'http://zloirock.ru/', 'incorrect IPv6'); // 'http://[20:0/' in Chrome
// url = new URL('http://zloirock.ru/');
// url.host = '[20:0:0:1:0:0:0:fg]';
// assert.same(url.host, 'zloirock.ru', 'incorrect IPv6'); // ':0' in Chrome
// assert.same(String(url), 'http://zloirock.ru/', 'incorrect IPv6'); // 'http://[20:0/' in Chrome
// url = new URL('http://zloirock.ru/');
// url.host = 'a%b';
// assert.same(url.host, 'zloirock.ru', 'forbidden host code point'); // '' in Chrome, 'a%b' in FF
// assert.same(String(url), 'http://zloirock.ru/', 'forbidden host code point'); // 'http://a%25b/' in Chrome, 'http://a%b/' in FF
}
});
QUnit.test('URL#hostname', assert => {
let url = new URL('http://zloirock.ru:81/');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'hostname'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'hostname');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.hostname, 'zloirock.ru');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru:81/');
url.hostname = 'example.com';
assert.same(url.hostname, 'example.com');
assert.same(String(url), 'http://example.com:81/');
// url = new URL('http://zloirock.ru:81/');
// url.hostname = 'example.com:82';
// assert.same(url.hostname, 'example.com'); // '' in Chrome
// assert.same(String(url), 'http://example.com:81/'); // 'ttp://example.com:82:81/' in Chrome
url = new URL('http://zloirock.ru/foo');
url.hostname = '測試';
assert.same(url.hostname, 'xn--g6w251d', 'unicode parsing');
assert.same(String(url), 'http://xn--g6w251d/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.hostname = 'xxпривет.тест';
assert.same(url.hostname, 'xn--xx-flcmn5bht.xn--e1aybc', 'unicode parsing');
assert.same(String(url), 'http://xn--xx-flcmn5bht.xn--e1aybc/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.hostname = 'xxПРИВЕТ.тест';
assert.same(url.hostname, 'xn--xx-flcmn5bht.xn--e1aybc', 'unicode parsing');
assert.same(String(url), 'http://xn--xx-flcmn5bht.xn--e1aybc/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.hostname = '0300.168.0xF0';
assert.same(url.hostname, '192.168.0.240');
assert.same(String(url), 'http://192.168.0.240/foo');
// url = new URL('http://zloirock.ru/foo');
// url.hostname = '[20:0:0:1:0:0:0:ff]';
// assert.same(url.hostname, '[20:0:0:1::ff]'); // 'zloirock.ru' in Safari
// assert.same(String(url), 'http://[20:0:0:1::ff]/foo'); // 'http://zloirock.ru/foo' in Safari
// url = new URL('file:///var/log/system.log');
// url.hostname = 'nnsc.nsf.net'; // does not work in FF
// assert.same(url.hostname, 'nnsc.nsf.net', 'file');
// assert.same(String(url), 'file://nnsc.nsf.net/var/log/system.log', 'file');
// url = new URL('http://zloirock.ru/');
// url.hostname = '[20:0:0:1:0:0:0:ff';
// assert.same(url.hostname, 'zloirock.ru', 'incorrect IPv6'); // '' in Chrome
// assert.same(String(url), 'http://zloirock.ru/', 'incorrect IPv6'); // 'http://[20:0:0:1:0:0:0:ff' in Chrome
// url = new URL('http://zloirock.ru/');
// url.hostname = '[20:0:0:1:0:0:0:fg]';
// assert.same(url.hostname, 'zloirock.ru', 'incorrect IPv6'); // '' in Chrome
// assert.same(String(url), 'http://zloirock.ru/', 'incorrect IPv6'); // 'http://[20:0:0:1:0:0:0:ff/' in Chrome
// url = new URL('http://zloirock.ru/');
// url.hostname = 'a%b';
// assert.same(url.hostname, 'zloirock.ru', 'forbidden host code point'); // '' in Chrome, 'a%b' in FF
// assert.same(String(url), 'http://zloirock.ru/', 'forbidden host code point'); // 'http://a%25b/' in Chrome, 'http://a%b/' in FF
}
});
QUnit.test('URL#port', assert => {
let url = new URL('http://zloirock.ru:1337/');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'port'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'port');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.port, '1337');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.port = 80;
assert.same(url.port, '');
assert.same(String(url), 'http://zloirock.ru/');
url.port = 1337;
assert.same(url.port, '1337');
assert.same(String(url), 'http://zloirock.ru:1337/');
// url.port = 'abcd';
// assert.same(url.port, '1337'); // '0' in Chrome
// assert.same(String(url), 'http://zloirock.ru:1337/'); // 'http://zloirock.ru:0/' in Chrome
// url.port = '5678abcd';
// assert.same(url.port, '5678'); // '1337' in FF
// assert.same(String(url), 'http://zloirock.ru:5678/'); // 'http://zloirock.ru:1337/"' in FF
url.port = 1234.5678;
assert.same(url.port, '1234');
assert.same(String(url), 'http://zloirock.ru:1234/');
// url.port = 1e10;
// assert.same(url.port, '1234'); // '0' in Chrome
// assert.same(String(url), 'http://zloirock.ru:1234/'); // 'http://zloirock.ru:0/' in Chrome
}
});
QUnit.test('URL#pathname', assert => {
let url = new URL('http://zloirock.ru/foo/bar');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'pathname'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'pathname');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.pathname, '/foo/bar');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.pathname = 'bar/baz';
assert.same(url.pathname, '/bar/baz');
assert.same(String(url), 'http://zloirock.ru/bar/baz');
}
});
QUnit.test('URL#search', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'search'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'search');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.search, '');
url = new URL('http://zloirock.ru/?foo=bar');
assert.same(url.search, '?foo=bar');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/?');
assert.same(url.search, '');
assert.same(String(url), 'http://zloirock.ru/?');
url.search = 'foo=bar';
assert.same(url.search, '?foo=bar');
assert.same(String(url), 'http://zloirock.ru/?foo=bar');
url.search = '?bar=baz';
assert.same(url.search, '?bar=baz');
assert.same(String(url), 'http://zloirock.ru/?bar=baz');
url.search = '';
assert.same(url.search, '');
assert.same(String(url), 'http://zloirock.ru/');
}
});
QUnit.test('URL#searchParams', assert => {
let url = new URL('http://zloirock.ru/?foo=bar&bar=baz');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'searchParams'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'searchParams');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
}
assert.ok(url.searchParams instanceof URLSearchParams);
assert.same(url.searchParams.get('foo'), 'bar');
assert.same(url.searchParams.get('bar'), 'baz');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.searchParams.append('foo', 'bar');
assert.same(String(url), 'http://zloirock.ru/?foo=bar');
url = new URL('http://zloirock.ru/');
url.search = 'foo=bar';
assert.same(url.searchParams.get('foo'), 'bar');
url = new URL('http://zloirock.ru/?foo=bar&bar=baz');
url.search = '';
assert.same(url.searchParams.has('foo'), false);
}
});
QUnit.test('URL#hash', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'hash'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'hash');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.hash, '');
url = new URL('http://zloirock.ru/#foo');
assert.same(url.hash, '#foo');
url = new URL('http://zloirock.ru/#');
assert.same(url.hash, '');
assert.same(String(url), 'http://zloirock.ru/#');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/#');
url.hash = 'foo';
assert.same(url.hash, '#foo');
assert.same(String(url), 'http://zloirock.ru/#foo');
url.hash = '';
assert.same(url.hash, '');
assert.same(String(url), 'http://zloirock.ru/');
// url.hash = '#';
// assert.same(url.hash, '');
// assert.same(String(url), 'http://zloirock.ru/'); // 'http://zloirock.ru/#' in FF
url.hash = '#foo';
assert.same(url.hash, '#foo');
assert.same(String(url), 'http://zloirock.ru/#foo');
url.hash = '#foo#bar';
assert.same(url.hash, '#foo#bar');
assert.same(String(url), 'http://zloirock.ru/#foo#bar');
url = new URL('http://zloirock.ru/');
url.hash = 'абa';
assert.same(url.hash, '#%D0%B0%D0%B1a');
// url = new URL('http://zloirock.ru/');
// url.hash = '\udc01\ud802a';
// assert.same(url.hash, '#%EF%BF%BD%EF%BF%BDa', 'unmatched surrogates');
}
});
QUnit.test('URL#toJSON', assert => {
const { toJSON } = URL.prototype;
assert.isFunction(toJSON);
assert.arity(toJSON, 0);
assert.enumerable(URL.prototype, 'toJSON');
const url = new URL('http://zloirock.ru/');
assert.same(url.toJSON(), 'http://zloirock.ru/');
if (DESCRIPTORS) {
url.searchParams.append('foo', 'bar');
assert.same(url.toJSON(), 'http://zloirock.ru/?foo=bar');
}
});
QUnit.test('URL#toString', assert => {
const { toString } = URL.prototype;
assert.isFunction(toString);
assert.arity(toString, 0);
assert.enumerable(URL.prototype, 'toString');
const url = new URL('http://zloirock.ru/');
assert.same(url.toString(), 'http://zloirock.ru/');
if (DESCRIPTORS) {
url.searchParams.append('foo', 'bar');
assert.same(url.toString(), 'http://zloirock.ru/?foo=bar');
}
});
QUnit.test('URL.sham', assert => {
assert.same(URL.sham, DESCRIPTORS ? undefined : true);
});
// `core-js` URL implementation pass all (exclude some encoding-ralated) tests
// from the next 3 test cases, but URLs from all of popular browsers fail a serious part of tests.
// Replacing all of them does not looks like a good idea, so next test cases disabled by default.
// see https://github.com/web-platform-tests/wpt/blob/master/url
QUnit.skip('WPT URL constructor tests', assert => {
for (const expected of urlTestData) {
if (typeof expected == 'string') continue;
const name = `Parsing: <${ expected.input }> against <${ expected.base }>`;
if (expected.failure) {
assert.throws(() => new URL(expected.input, expected.base || 'about:blank'), name);
} else {
const url = new URL(expected.input, expected.base || 'about:blank');
assert.same(url.href, expected.href, `${ name }: href`);
assert.same(url.protocol, expected.protocol, `${ name }: protocol`);
assert.same(url.username, expected.username, `${ name }: username`);
assert.same(url.password, expected.password, `${ name }: password`);
assert.same(url.host, expected.host, `${ name }: host`);
assert.same(url.hostname, expected.hostname, `${ name }: hostname`);
assert.same(url.port, expected.port, `${ name }: port`);
assert.same(url.pathname, expected.pathname, `${ name }: pathname`);
assert.same(url.search, expected.search, `${ name }: search`);
if ('searchParams' in expected) {
assert.same(url.searchParams.toString(), expected.searchParams, `${ name }: searchParams`);
}
assert.same(url.hash, expected.hash, `${ name }: hash`);
if ('origin' in expected) {
assert.same(url.origin, expected.origin, `${ name }: origin`);
}
}
}
});
// see https://github.com/web-platform-tests/wpt/blob/master/url
if (DESCRIPTORS) QUnit.skip('WPT URL setters tests', assert => {
for (const setter in settersTestData) {
const testCases = settersTestData[setter];
for (const { href, newValue, comment, expected } of testCases) {
let name = `Setting <${ href }>.${ setter } = '${ newValue }'.`;
if (comment) name += ` ${ comment }`;
const url = new URL(href);
url[setter] = newValue;
for (const attribute in expected) {
assert.same(url[attribute], expected[attribute], name);
}
}
}
});
// see https://github.com/web-platform-tests/wpt/blob/master/url
QUnit.skip('WPT conversion to ASCII tests', assert => {
for (const { comment, input, output } of toASCIITestData) {
let name = `Parsing: <${ input }>`;
if (comment) name += ` ${ comment }`;
if (output === null) {
assert.throws(() => new URL(`https://${ input }/x`), name);
} else {
const url = new URL(`https://${ input }/x`);
assert.same(url.host, output, name);
assert.same(url.hostname, output, name);
assert.same(url.pathname, '/x', name);
assert.same(url.href, `https://${ output }/x`, name);
}
}
});
core-js-3.6.1/tests/targets-parser.js 0000664 0000000 0000000 00000003701 13600575677 0017547 0 ustar 00root root 0000000 0000000 'use strict';
const { deepStrictEqual } = require('assert');
const targetsParser = require('../packages/core-js-compat/targets-parser');
// browserslist
deepStrictEqual(targetsParser('ie 11, chrome 56, ios 12.2'), new Map([
['chrome', '56'],
['ie', '11'],
['ios', '12.2-12.4'],
]));
// targets object
deepStrictEqual(targetsParser({
ie: 11,
chrome: 56,
ios: '12.2',
}), new Map([
['chrome', '56'],
['ie', '11'],
['ios', '12.2'],
]));
// targets.browsers
deepStrictEqual(targetsParser({ browsers: 'ie 11, chrome 56, ios_saf 12.2' }), new Map([
['chrome', '56'],
['ie', '11'],
['ios', '12.2-12.4'],
]));
// targets.esmodules
deepStrictEqual(targetsParser({ esmodules: true }), new Map([
['chrome', '61'],
['edge', '16'],
['firefox', '60'],
['ios', '10.3'],
['opera', '48'],
['opera_mobile', '45'],
['safari', '10.1'],
['samsung', '8.0'],
]));
// targets.node: current
deepStrictEqual(targetsParser({ node: 'current' }), new Map([
['node', String(process.versions.node)],
]));
// targets.node: version
deepStrictEqual(targetsParser({ node: '13.2' }), new Map([
['node', '13.2'],
]));
// normalization
deepStrictEqual(targetsParser({
ie_mob: 11,
chromeandroid: 56,
and_ff: 60,
ios_saf: '12.2',
op_mob: 40,
op_mini: 1,
random: 42,
}), new Map([
['chrome', '56'],
['firefox', '60'],
['ie', '11'],
['ios', '12.2'],
['opera_mobile', '40'],
]));
// mixed
deepStrictEqual(targetsParser({
esmodules: true,
node: 'current',
browsers: 'edge 13, safari 5.1, ios 13',
android: '4.2',
chrome: 77,
electron: 1,
ie: 8,
samsung: 4,
ie_mob: 11,
chromeandroid: 56,
and_ff: 65,
ios_saf: '12.2',
op_mob: 40,
random: 42,
}), new Map([
['android', '4.2'],
['chrome', '56'],
['edge', '13'],
['electron', '1'],
['firefox', '60'],
['ie', '8'],
['ios', '10.3'],
['node', String(process.versions.node)],
['opera', '48'],
['opera_mobile', '40'],
['safari', '5.1'],
['samsung', '4'],
]));
core-js-3.6.1/tests/tests.html 0000664 0000000 0000000 00000000766 13600575677 0016306 0 ustar 00root root 0000000 0000000
Core
core-js-3.6.1/tests/tests/ 0000775 0000000 0000000 00000000000 13600575677 0015407 5 ustar 00root root 0000000 0000000 core-js-3.6.1/tests/tests/es.array-buffer.constructor.js 0000664 0000000 0000000 00000001466 13600575677 0023333 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, NATIVE } from '../helpers/constants';
QUnit.test('ArrayBuffer', assert => {
const Symbol = GLOBAL.Symbol || {};
// in Safari 5 typeof ArrayBuffer is 'object'
assert.same(ArrayBuffer, Object(ArrayBuffer), 'is object');
// 0 in V8 ~ Chromium 27-
assert.arity(ArrayBuffer, 1);
// Safari 5 bug
assert.name(ArrayBuffer, 'ArrayBuffer');
// Safari 5 bug
if (NATIVE) assert.looksNative(ArrayBuffer);
assert.same(new ArrayBuffer(123).byteLength, 123, 'length');
// fails in Safari
assert.throws(() => new ArrayBuffer(-1), RangeError, 'negative length');
assert.notThrows(() => new ArrayBuffer(0.5), 'fractional length');
assert.notThrows(() => new ArrayBuffer(), 'missed length');
if (DESCRIPTORS) assert.same(ArrayBuffer[Symbol.species], ArrayBuffer, '@@species');
});
core-js-3.6.1/tests/tests/es.array-buffer.is-view.js 0000664 0000000 0000000 00000001467 13600575677 0022332 0 ustar 00root root 0000000 0000000 import { GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
QUnit.test('ArrayBuffer.isView', assert => {
const { isView } = ArrayBuffer;
assert.isFunction(isView);
assert.arity(isView, 1);
assert.name(isView, 'isView');
assert.looksNative(isView);
assert.nonEnumerable(ArrayBuffer, 'isView');
for (const name in TYPED_ARRAYS) {
if (GLOBAL[name]) {
assert.same(isView(new GLOBAL[name]([1])), true, `${ name } - true`);
}
}
assert.same(isView(new DataView(new ArrayBuffer(1))), true, 'DataView - true');
assert.same(isView(new ArrayBuffer(1)), false, 'ArrayBuffer - false');
const examples = [undefined, null, false, true, 0, 1, '', 'qwe', {}, [], function () { /* empty */ }];
for (const example of examples) {
assert.same(isView(example), false, `${ example } - false`);
}
});
core-js-3.6.1/tests/tests/es.array-buffer.slice.js 0000664 0000000 0000000 00000002535 13600575677 0022043 0 ustar 00root root 0000000 0000000 QUnit.test('ArrayBuffer#slice', assert => {
const { slice } = ArrayBuffer.prototype;
function arrayToBuffer(it) {
const buffer = new ArrayBuffer(it.length);
const view = new DataView(buffer);
for (let i = 0, { length } = it; i < length; ++i) {
view.setUint8(i, it[i]);
}
return buffer;
}
function bufferToArray(it) {
const results = [];
const view = new DataView(it);
for (let i = 0, { byteLength } = view; i < byteLength; ++i) {
results.push(view.getUint8(i));
}
return results;
}
assert.isFunction(slice);
assert.arity(slice, 2);
assert.name(slice, 'slice');
assert.looksNative(slice);
// assert.nonEnumerable(ArrayBuffer.prototype, 'slice');
const buffer = arrayToBuffer([1, 2, 3, 4, 5]);
assert.ok(buffer instanceof ArrayBuffer, 'correct buffer');
assert.ok(buffer.slice() !== buffer, 'returns new buffer');
assert.ok(buffer.slice() instanceof ArrayBuffer, 'correct instance');
assert.arrayEqual(bufferToArray(buffer.slice()), [1, 2, 3, 4, 5]);
assert.arrayEqual(bufferToArray(buffer.slice(1, 3)), [2, 3]);
assert.arrayEqual(bufferToArray(buffer.slice(1, undefined)), [2, 3, 4, 5]);
assert.arrayEqual(bufferToArray(buffer.slice(1, -1)), [2, 3, 4]);
assert.arrayEqual(bufferToArray(buffer.slice(-2, -1)), [4]);
assert.arrayEqual(bufferToArray(buffer.slice(-2, -3)), []);
});
core-js-3.6.1/tests/tests/es.array.concat.js 0000664 0000000 0000000 00000003056 13600575677 0020743 0 ustar 00root root 0000000 0000000 /* eslint-disable no-sparse-arrays */
QUnit.test('Array#concat', assert => {
const { concat } = Array.prototype;
assert.isFunction(concat);
assert.arity(concat, 1);
assert.name(concat, 'concat');
assert.looksNative(concat);
assert.nonEnumerable(Array.prototype, 'concat');
let array = [1, 2];
const sparseArray = [1, , 2];
const nonSpreadableArray = [1, 2];
nonSpreadableArray[Symbol.isConcatSpreadable] = false;
const arrayLike = { 0: 1, 1: 2, length: 2 };
const spreadableArrayLike = { 0: 1, 1: 2, length: 2, [Symbol.isConcatSpreadable]: true };
assert.deepEqual(array.concat(), [1, 2], '#1');
assert.deepEqual(sparseArray.concat(), [1, , 2], '#2');
assert.deepEqual(nonSpreadableArray.concat(), [[1, 2]], '#3');
assert.deepEqual(concat.call(arrayLike), [{ 0: 1, 1: 2, length: 2 }], '#4');
assert.deepEqual(concat.call(spreadableArrayLike), [1, 2], '#5');
assert.deepEqual([].concat(array), [1, 2], '#6');
assert.deepEqual([].concat(sparseArray), [1, , 2], '#7');
assert.deepEqual([].concat(nonSpreadableArray), [[1, 2]], '#8');
assert.deepEqual([].concat(arrayLike), [{ 0: 1, 1: 2, length: 2 }], '#9');
assert.deepEqual([].concat(spreadableArrayLike), [1, 2], '#10');
assert.deepEqual(array.concat(sparseArray, nonSpreadableArray, arrayLike, spreadableArrayLike), [
1, 2, 1, , 2, [1, 2], { 0: 1, 1: 2, length: 2 }, 1, 2,
], '#11');
array = [];
array.constructor = { [Symbol.species]: function () { // eslint-disable-line object-shorthand
return { foo: 1 };
} };
assert.same(array.concat().foo, 1, '@@species');
});
core-js-3.6.1/tests/tests/es.array.copy-within.js 0000664 0000000 0000000 00000003314 13600575677 0021743 0 ustar 00root root 0000000 0000000 import { NATIVE, STRICT } from '../helpers/constants';
QUnit.test('Array#copyWithin', assert => {
const { copyWithin } = Array.prototype;
assert.isFunction(copyWithin);
assert.arity(copyWithin, 2);
assert.name(copyWithin, 'copyWithin');
assert.looksNative(copyWithin);
const array = [1];
assert.strictEqual(array.copyWithin(0), array);
assert.nonEnumerable(Array.prototype, 'copyWithin');
assert.deepEqual([1, 2, 3, 4, 5].copyWithin(0, 3), [4, 5, 3, 4, 5]);
assert.deepEqual([1, 2, 3, 4, 5].copyWithin(1, 3), [1, 4, 5, 4, 5]);
assert.deepEqual([1, 2, 3, 4, 5].copyWithin(1, 2), [1, 3, 4, 5, 5]);
assert.deepEqual([1, 2, 3, 4, 5].copyWithin(2, 2), [1, 2, 3, 4, 5]);
assert.deepEqual([1, 2, 3, 4, 5].copyWithin(0, 3, 4), [4, 2, 3, 4, 5]);
assert.deepEqual([1, 2, 3, 4, 5].copyWithin(1, 3, 4), [1, 4, 3, 4, 5]);
assert.deepEqual([1, 2, 3, 4, 5].copyWithin(1, 2, 4), [1, 3, 4, 4, 5]);
assert.deepEqual([1, 2, 3, 4, 5].copyWithin(0, -2), [4, 5, 3, 4, 5]);
assert.deepEqual([1, 2, 3, 4, 5].copyWithin(0, -2, -1), [4, 2, 3, 4, 5]);
assert.deepEqual([1, 2, 3, 4, 5].copyWithin(-4, -3, -2), [1, 3, 3, 4, 5]);
assert.deepEqual([1, 2, 3, 4, 5].copyWithin(-4, -3, -1), [1, 3, 4, 4, 5]);
assert.deepEqual([1, 2, 3, 4, 5].copyWithin(-4, -3), [1, 3, 4, 5, 5]);
if (STRICT) {
assert.throws(() => copyWithin.call(null, 0), TypeError);
assert.throws(() => copyWithin.call(undefined, 0), TypeError);
}
if (NATIVE) {
assert.deepEqual(copyWithin.call({
0: 1,
1: 2,
2: 3,
length: -1,
}, 1, 2), {
0: 1,
1: 2,
2: 3,
length: -1,
}, 'uses ToLength');
}
assert.ok('copyWithin' in Array.prototype[Symbol.unscopables], 'In Array#@@unscopables');
});
core-js-3.6.1/tests/tests/es.array.every.js 0000664 0000000 0000000 00000002760 13600575677 0020627 0 ustar 00root root 0000000 0000000 import { NATIVE, STRICT } from '../helpers/constants';
QUnit.test('Array#every', assert => {
const { every } = Array.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.name(every, 'every');
assert.looksNative(every);
assert.nonEnumerable(Array.prototype, 'every');
let array = [1];
const context = {};
array.every(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.ok([1, 2, 3].every(it => typeof it === 'number'));
assert.ok([1, 2, 3].every(it => it < 4));
assert.ok(![1, 2, 3].every(it => it < 3));
assert.ok(![1, 2, 3].every(it => typeof it === 'string'));
assert.ok([1, 2, 3].every(function () {
return +this === 1;
}, 1));
let result = '';
[1, 2, 3].every((value, key) => result += key);
assert.ok(result === '012');
array = [1, 2, 3];
assert.ok(array.every((value, key, that) => that === array));
if (STRICT) {
assert.throws(() => every.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(undefined, () => { /* empty */ }), TypeError);
}
if (NATIVE) {
assert.notThrows(() => every.call({
length: -1,
0: 1,
}, () => {
throw new Error();
}), 'uses ToLength');
}
});
core-js-3.6.1/tests/tests/es.array.fill.js 0000664 0000000 0000000 00000002344 13600575677 0020421 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, NATIVE, STRICT } from '../helpers/constants';
QUnit.test('Array#fill', assert => {
const { fill } = Array.prototype;
assert.isFunction(fill);
assert.arity(fill, 1);
assert.name(fill, 'fill');
assert.looksNative(fill);
assert.nonEnumerable(Array.prototype, 'fill');
const array = new Array(5);
assert.strictEqual(array.fill(5), array);
assert.deepEqual(Array(5).fill(5), [5, 5, 5, 5, 5]);
assert.deepEqual(Array(5).fill(5, 1), [undefined, 5, 5, 5, 5]);
assert.deepEqual(Array(5).fill(5, 1, 4), [undefined, 5, 5, 5, undefined]);
assert.deepEqual(Array(5).fill(5, 6, 1), [undefined, undefined, undefined, undefined, undefined]);
assert.deepEqual(Array(5).fill(5, -3, 4), [undefined, undefined, 5, 5, undefined]);
assert.arrayEqual(fill.call({ length: 5 }, 5), [5, 5, 5, 5, 5]);
if (STRICT) {
assert.throws(() => fill.call(null, 0), TypeError);
assert.throws(() => fill.call(undefined, 0), TypeError);
}
if (NATIVE && DESCRIPTORS) {
assert.notThrows(() => fill.call(Object.defineProperty({
length: -1,
}, 0, {
set() {
throw Error();
},
})), 'uses ToLength');
}
assert.ok('fill' in Array.prototype[Symbol.unscopables], 'In Array#@@unscopables');
});
core-js-3.6.1/tests/tests/es.array.filter.js 0000664 0000000 0000000 00000002455 13600575677 0020763 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
QUnit.test('Array#filter', assert => {
const { filter } = Array.prototype;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.name(filter, 'filter');
assert.looksNative(filter);
assert.nonEnumerable(Array.prototype, 'filter');
let array = [1];
const context = {};
array.filter(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.deepEqual([1, 2, 3, 4, 5], [1, 2, 3, 'q', {}, 4, true, 5].filter(it => typeof it === 'number'));
if (STRICT) {
assert.throws(() => filter.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(undefined, () => { /* empty */ }), TypeError);
}
assert.notThrows(() => filter.call({
length: -1,
0: 1,
}, () => {
throw new Error();
}), 'uses ToLength');
array = [];
array.constructor = { [Symbol.species]: function () { // eslint-disable-line object-shorthand
return { foo: 1 };
} };
assert.same(array.filter(Boolean).foo, 1, '@@species');
});
core-js-3.6.1/tests/tests/es.array.find-index.js 0000664 0000000 0000000 00000002446 13600575677 0021523 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, NATIVE, STRICT } from '../helpers/constants';
QUnit.test('Array#findIndex', assert => {
const { findIndex } = Array.prototype;
assert.isFunction(findIndex);
assert.arity(findIndex, 1);
assert.name(findIndex, 'findIndex');
assert.looksNative(findIndex);
assert.nonEnumerable(Array.prototype, 'findIndex');
const array = [1];
const context = {};
array.findIndex(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same([1, 3, NaN, 42, {}].findIndex(it => it === 42), 3);
assert.same([1, 3, NaN, 42, {}].findIndex(it => it === 43), -1);
if (STRICT) {
assert.throws(() => findIndex.call(null, 0), TypeError);
assert.throws(() => findIndex.call(undefined, 0), TypeError);
}
if (NATIVE && DESCRIPTORS) {
assert.notThrows(() => findIndex.call({
length: -1,
0: 1,
}, () => {
throw new Error();
}) === -1, 'uses ToLength');
}
assert.ok('findIndex' in Array.prototype[Symbol.unscopables], 'In Array#@@unscopables');
});
core-js-3.6.1/tests/tests/es.array.find.js 0000664 0000000 0000000 00000002352 13600575677 0020412 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, NATIVE, STRICT } from '../helpers/constants';
QUnit.test('Array#find', assert => {
const { find } = Array.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.name(find, 'find');
assert.looksNative(find);
assert.nonEnumerable(Array.prototype, 'find');
const array = [1];
const context = {};
array.find(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same([1, 3, NaN, 42, {}].find(it => it === 42), 42);
assert.same([1, 3, NaN, 42, {}].find(it => it === 43), undefined);
if (STRICT) {
assert.throws(() => find.call(null, 0), TypeError);
assert.throws(() => find.call(undefined, 0), TypeError);
}
if (NATIVE && DESCRIPTORS) {
assert.notThrows(() => find.call({
length: -1,
0: 1,
}, () => {
throw new Error();
}) === undefined, 'uses ToLength');
}
assert.ok('find' in Array.prototype[Symbol.unscopables], 'In Array#@@unscopables');
});
core-js-3.6.1/tests/tests/es.array.flat-map.js 0000664 0000000 0000000 00000002331 13600575677 0021170 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
QUnit.test('Array#flatMap', assert => {
const { flatMap } = Array.prototype;
assert.isFunction(flatMap);
assert.name(flatMap, 'flatMap');
assert.arity(flatMap, 1);
assert.looksNative(flatMap);
assert.nonEnumerable(Array.prototype, 'flatMap');
assert.deepEqual([].flatMap(it => it), []);
assert.deepEqual([1, 2, 3].flatMap(it => it), [1, 2, 3]);
assert.deepEqual([1, 2, 3].flatMap(it => [it, it]), [1, 1, 2, 2, 3, 3]);
assert.deepEqual([1, 2, 3].flatMap(it => [[it], [it]]), [[1], [1], [2], [2], [3], [3]]);
assert.deepEqual([1, [2, 3]].flatMap(() => 1), [1, 1]);
const array = [1];
const context = {};
array.flatMap(function (value, key, that) {
assert.same(value, 1);
assert.same(key, 0);
assert.same(that, array);
assert.same(this, context);
return value;
}, context);
if (STRICT) {
assert.throws(() => flatMap.call(null, it => it), TypeError);
assert.throws(() => flatMap.call(undefined, it => it), TypeError);
}
assert.notThrows(() => flatMap.call({ length: -1 }, () => {
throw new Error();
}).length === 0, 'uses ToLength');
assert.ok('flatMap' in Array.prototype[Symbol.unscopables], 'In Array#@@unscopables');
});
core-js-3.6.1/tests/tests/es.array.flat.js 0000664 0000000 0000000 00000002241 13600575677 0020415 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, STRICT } from '../helpers/constants';
QUnit.test('Array#flat', assert => {
const { flat } = Array.prototype;
const { defineProperty } = Object;
assert.isFunction(flat);
assert.name(flat, 'flat');
assert.arity(flat, 0);
assert.looksNative(flat);
assert.nonEnumerable(Array.prototype, 'flat');
assert.deepEqual([].flat(), []);
const array = [1, [2, 3], [4, [5, 6]]];
assert.deepEqual(array.flat(0), array);
assert.deepEqual(array.flat(1), [1, 2, 3, 4, [5, 6]]);
assert.deepEqual(array.flat(), [1, 2, 3, 4, [5, 6]]);
assert.deepEqual(array.flat(2), [1, 2, 3, 4, 5, 6]);
assert.deepEqual(array.flat(3), [1, 2, 3, 4, 5, 6]);
assert.deepEqual(array.flat(-1), array);
assert.deepEqual(array.flat(Infinity), [1, 2, 3, 4, 5, 6]);
if (STRICT) {
assert.throws(() => flat.call(null), TypeError);
assert.throws(() => flat.call(undefined), TypeError);
}
if (DESCRIPTORS) {
assert.notThrows(() => flat.call(defineProperty({ length: -1 }, 0, {
get() {
throw new Error();
},
})).length === 0, 'uses ToLength');
}
assert.ok('flat' in Array.prototype[Symbol.unscopables], 'In Array#@@unscopables');
});
core-js-3.6.1/tests/tests/es.array.for-each.js 0000664 0000000 0000000 00000003251 13600575677 0021155 0 ustar 00root root 0000000 0000000 import { NATIVE, STRICT } from '../helpers/constants';
QUnit.test('Array#forEach', assert => {
const { forEach } = Array.prototype;
assert.isFunction(forEach);
assert.arity(forEach, 1);
assert.name(forEach, 'forEach');
assert.looksNative(forEach);
assert.nonEnumerable(Array.prototype, 'forEach');
let array = [1];
const context = {};
array.forEach(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
let result = '';
[1, 2, 3].forEach(value => {
result += value;
});
assert.ok(result === '123');
result = '';
[1, 2, 3].forEach((value, key) => {
result += key;
});
assert.ok(result === '012');
result = '';
[1, 2, 3].forEach((value, key, that) => {
result += that;
});
assert.ok(result === '1,2,31,2,31,2,3');
result = '';
[1, 2, 3].forEach(function () {
result += this;
}, 1);
assert.ok(result === '111');
result = '';
array = [];
array[5] = '';
array.forEach((value, key) => {
result += key;
});
assert.ok(result === '5');
if (STRICT) {
assert.throws(() => {
forEach.call(null, () => { /* empty */ });
}, TypeError);
assert.throws(() => {
forEach.call(undefined, () => { /* empty */ });
}, TypeError);
}
if (NATIVE) {
assert.notThrows(() => forEach.call({
length: -1,
0: 1,
}, () => {
throw new Error();
}) === undefined, 'uses ToLength');
}
});
core-js-3.6.1/tests/tests/es.array.from.js 0000664 0000000 0000000 00000010275 13600575677 0020440 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL } from '../helpers/constants';
import { createIterable } from '../helpers/helpers';
QUnit.test('Array.from', assert => {
const Symbol = GLOBAL.Symbol || {};
const { from } = Array;
const { defineProperty } = Object;
assert.isFunction(from);
assert.arity(from, 1);
assert.name(from, 'from');
assert.looksNative(from);
assert.nonEnumerable(Array, 'from');
let types = {
'array-like': {
length: '3',
0: '1',
1: '2',
2: '3',
},
arguments: function () {
return arguments;
}('1', '2', '3'),
array: ['1', '2', '3'],
iterable: createIterable(['1', '2', '3']),
string: '123',
};
for (const type in types) {
const data = types[type];
assert.arrayEqual(from(data), ['1', '2', '3'], `Works with ${ type }`);
assert.arrayEqual(from(data, it => it ** 2), [1, 4, 9], `Works with ${ type } + mapFn`);
}
types = {
'array-like': {
length: 1,
0: 1,
},
arguments: function () {
return arguments;
}(1),
array: [1],
iterable: createIterable([1]),
string: '1',
};
for (const type in types) {
const data = types[type];
const context = {};
assert.arrayEqual(from(data, function (value, key) {
assert.same(this, context, `Works with ${ type }, correct callback context`);
assert.same(value, type === 'string' ? '1' : 1, `Works with ${ type }, correct callback key`);
assert.same(key, 0, `Works with ${ type }, correct callback value`);
assert.same(arguments.length, 2, `Works with ${ type }, correct callback arguments number`);
return 42;
}, context), [42], `Works with ${ type }, correct result`);
}
const primitives = [false, true, 0];
for (const primitive of primitives) {
assert.arrayEqual(from(primitive), [], `Works with ${ primitive }`);
}
assert.throws(() => from(null), TypeError, 'Throws on null');
assert.throws(() => from(undefined), TypeError, 'Throws on undefined');
assert.arrayEqual(from('𠮷𠮷𠮷'), ['𠮷', '𠮷', '𠮷'], 'Uses correct string iterator');
let done = true;
from(createIterable([1, 2, 3], {
return() {
return done = false;
},
}), () => false);
assert.ok(done, '.return #default');
done = false;
try {
from(createIterable([1, 2, 3], {
return() {
return done = true;
},
}), () => {
throw new Error();
});
} catch { /* empty */ }
assert.ok(done, '.return #throw');
class C { /* empty */ }
let instance = from.call(C, createIterable([1, 2]));
assert.ok(instance instanceof C, 'generic, iterable case, instanceof');
assert.arrayEqual(instance, [1, 2], 'generic, iterable case, elements');
instance = from.call(C, {
0: 1,
1: 2,
length: 2,
});
assert.ok(instance instanceof C, 'generic, array-like case, instanceof');
assert.arrayEqual(instance, [1, 2], 'generic, array-like case, elements');
let array = [1, 2, 3];
done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return [][Symbol.iterator].call(this);
};
assert.arrayEqual(from(array), [1, 2, 3], 'Array with custom iterator, elements');
assert.ok(done, 'call @@iterator in Array with custom iterator');
array = [1, 2, 3];
delete array[1];
assert.arrayEqual(from(array, String), ['1', 'undefined', '3'], 'Ignores holes');
assert.notThrows(() => from({
length: -1,
0: 1,
}, () => {
throw new Error();
}).length === 0, 'Uses ToLength');
assert.arrayEqual(from([], undefined), [], 'Works with undefined as asecond argument');
assert.throws(() => from([], null), TypeError, 'Throws with null as second argument');
assert.throws(() => from([], 0), TypeError, 'Throws with 0 as second argument');
assert.throws(() => from([], ''), TypeError, 'Throws with "" as second argument');
assert.throws(() => from([], false), TypeError, 'Throws with false as second argument');
assert.throws(() => from([], {}), TypeError, 'Throws with {} as second argument');
if (DESCRIPTORS) {
let called = false;
defineProperty(C.prototype, 0, {
set() {
called = true;
},
});
from.call(C, [1, 2, 3]);
assert.ok(!called, 'Should not call prototype accessors');
}
});
core-js-3.6.1/tests/tests/es.array.includes.js 0000664 0000000 0000000 00000002215 13600575677 0021276 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, NATIVE, STRICT } from '../helpers/constants';
QUnit.test('Array#includes', assert => {
const { includes } = Array.prototype;
assert.isFunction(includes);
assert.name(includes, 'includes');
assert.arity(includes, 1);
assert.looksNative(includes);
assert.nonEnumerable(Array.prototype, 'includes');
const object = {};
const array = [1, 2, 3, -0, object];
assert.ok(array.includes(1));
assert.ok(array.includes(-0));
assert.ok(array.includes(0));
assert.ok(array.includes(object));
assert.ok(!array.includes(4));
assert.ok(!array.includes(-0.5));
assert.ok(!array.includes({}));
assert.ok(Array(1).includes(undefined));
assert.ok([NaN].includes(NaN));
if (STRICT) {
assert.throws(() => includes.call(null, 0), TypeError);
assert.throws(() => includes.call(undefined, 0), TypeError);
}
if (NATIVE && DESCRIPTORS) {
assert.notThrows(() => includes.call(Object.defineProperty({
length: -1,
}, 0, {
get() {
throw new Error();
},
}), 1) === false, 'uses ToLength');
}
assert.ok('includes' in Array.prototype[Symbol.unscopables], 'In Array#@@unscopables');
});
core-js-3.6.1/tests/tests/es.array.index-of.js 0000664 0000000 0000000 00000002137 13600575677 0021204 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, NATIVE, STRICT } from '../helpers/constants';
QUnit.test('Array#indexOf', assert => {
const { indexOf } = Array.prototype;
assert.isFunction(indexOf);
assert.arity(indexOf, 1);
assert.name(indexOf, 'indexOf');
assert.looksNative(indexOf);
assert.nonEnumerable(Array.prototype, 'indexOf');
assert.same(0, [1, 1, 1].indexOf(1));
assert.same(-1, [1, 2, 3].indexOf(1, 1));
assert.same(1, [1, 2, 3].indexOf(2, 1));
assert.same(-1, [1, 2, 3].indexOf(2, -1));
assert.same(1, [1, 2, 3].indexOf(2, -2));
assert.same(-1, [NaN].indexOf(NaN));
assert.same(3, Array(2).concat([1, 2, 3]).indexOf(2));
assert.same(-1, Array(1).indexOf(undefined));
assert.same(0, [1].indexOf(1, -0), "shouldn't return negative zero");
if (STRICT) {
assert.throws(() => indexOf.call(null, 0), TypeError);
assert.throws(() => indexOf.call(undefined, 0), TypeError);
}
if (NATIVE && DESCRIPTORS) {
assert.notThrows(() => indexOf.call(Object.defineProperty({
length: -1,
}, 0, {
get() {
throw new Error();
},
}), 1) === -1, 'uses ToLength');
}
});
core-js-3.6.1/tests/tests/es.array.is-array.js 0000664 0000000 0000000 00000000546 13600575677 0021224 0 ustar 00root root 0000000 0000000 QUnit.test('Array.isArray', assert => {
const { isArray } = Array;
assert.isFunction(isArray);
assert.arity(isArray, 1);
assert.name(isArray, 'isArray');
assert.looksNative(isArray);
assert.nonEnumerable(Array, 'isArray');
assert.ok(!isArray({}));
assert.ok(!isArray(function () {
return arguments;
}()));
assert.ok(isArray([]));
});
core-js-3.6.1/tests/tests/es.array.iterator.js 0000664 0000000 0000000 00000010141 13600575677 0021316 0 ustar 00root root 0000000 0000000 import { GLOBAL, NATIVE } from '../helpers/constants';
const Symbol = GLOBAL.Symbol || {};
QUnit.test('Array#keys', assert => {
const { keys } = Array.prototype;
assert.isFunction(keys);
assert.arity(keys, 0);
assert.name(keys, 'keys');
assert.looksNative(keys);
assert.nonEnumerable(Array.prototype, 'keys');
const iterator = ['q', 'w', 'e'].keys();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Array Iterator');
assert.strictEqual(String(iterator), '[object Array Iterator]');
assert.deepEqual(iterator.next(), {
value: 0,
done: false,
});
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
});
assert.deepEqual(iterator.next(), {
value: 2,
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
if (NATIVE) {
assert.deepEqual(keys.call({
length: -1,
}).next(), {
value: undefined,
done: true,
}, 'uses ToLength');
}
assert.ok('keys' in Array.prototype[Symbol.unscopables], 'In Array#@@unscopables');
});
QUnit.test('Array#values', assert => {
const { values } = Array.prototype;
assert.isFunction(values);
assert.arity(values, 0);
assert.name(values, 'values');
assert.looksNative(values);
assert.nonEnumerable(Array.prototype, 'values');
const iterator = ['q', 'w', 'e'].values();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Array Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
if (NATIVE) {
assert.deepEqual(values.call({
length: -1,
}).next(), {
value: undefined,
done: true,
}, 'uses ToLength');
}
assert.ok('values' in Array.prototype[Symbol.unscopables], 'In Array#@@unscopables');
});
QUnit.test('Array#entries', assert => {
const { entries } = Array.prototype;
assert.isFunction(entries);
assert.arity(entries, 0);
assert.name(entries, 'entries');
assert.looksNative(entries);
assert.nonEnumerable(Array.prototype, 'entries');
const iterator = ['q', 'w', 'e'].entries();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Array Iterator');
assert.deepEqual(iterator.next(), {
value: [0, 'q'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: [1, 'w'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: [2, 'e'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
if (NATIVE) {
assert.deepEqual(entries.call({
length: -1,
}).next(), {
value: undefined,
done: true,
}, 'uses ToLength');
}
assert.ok('entries' in Array.prototype[Symbol.unscopables], 'In Array#@@unscopables');
});
QUnit.test('Array#@@iterator', assert => {
assert.isIterable(Array.prototype);
assert.arity(Array.prototype[Symbol.iterator], 0);
assert.name(Array.prototype[Symbol.iterator], 'values');
assert.looksNative(Array.prototype[Symbol.iterator]);
assert.nonEnumerable(Array.prototype, Symbol.iterator);
assert.strictEqual(Array.prototype[Symbol.iterator], Array.prototype.values);
const iterator = ['q', 'w', 'e'][Symbol.iterator]();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Array Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
if (NATIVE) {
assert.deepEqual(Array.prototype[Symbol.iterator].call({
length: -1,
}).next(), {
value: undefined,
done: true,
}, 'uses ToLength');
}
});
core-js-3.6.1/tests/tests/es.array.join.js 0000664 0000000 0000000 00000001113 13600575677 0020423 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
QUnit.test('Array#join', assert => {
const { join } = Array.prototype;
assert.isFunction(join);
assert.arity(join, 1);
assert.name(join, 'join');
assert.looksNative(join);
assert.nonEnumerable(Array.prototype, 'join');
assert.strictEqual(join.call([1, 2, 3], undefined), '1,2,3');
assert.strictEqual(join.call('123'), '1,2,3');
assert.strictEqual(join.call('123', '|'), '1|2|3');
if (STRICT) {
assert.throws(() => join.call(null, 0), TypeError);
assert.throws(() => join.call(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/tests/es.array.last-index-of.js 0000664 0000000 0000000 00000002443 13600575677 0022145 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, NATIVE, STRICT } from '../helpers/constants';
QUnit.test('Array#lastIndexOf', assert => {
const { lastIndexOf } = Array.prototype;
assert.isFunction(lastIndexOf);
assert.arity(lastIndexOf, 1);
assert.name(lastIndexOf, 'lastIndexOf');
assert.looksNative(lastIndexOf);
assert.nonEnumerable(Array.prototype, 'lastIndexOf');
assert.same(2, [1, 1, 1].lastIndexOf(1));
assert.same(-1, [1, 2, 3].lastIndexOf(3, 1));
assert.same(1, [1, 2, 3].lastIndexOf(2, 1));
assert.same(-1, [1, 2, 3].lastIndexOf(2, -3));
assert.same(-1, [1, 2, 3].lastIndexOf(1, -4));
assert.same(1, [1, 2, 3].lastIndexOf(2, -2));
assert.same(-1, [NaN].lastIndexOf(NaN));
assert.same(1, [1, 2, 3].concat(Array(2)).lastIndexOf(2));
assert.same(0, [1].lastIndexOf(1, -0), "shouldn't return negative zero");
if (STRICT) {
assert.throws(() => lastIndexOf.call(null, 0), TypeError);
assert.throws(() => lastIndexOf.call(undefined, 0), TypeError);
}
if (NATIVE && DESCRIPTORS) {
assert.notThrows(() => lastIndexOf.call(Object.defineProperties({
length: -1,
}, {
2147483646: {
get() {
throw new Error();
},
},
4294967294: {
get() {
throw new Error();
},
},
}), 1) === -1, 'uses ToLength');
}
});
core-js-3.6.1/tests/tests/es.array.map.js 0000664 0000000 0000000 00000002614 13600575677 0020250 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
QUnit.test('Array#map', assert => {
const { map } = Array.prototype;
assert.isFunction(map);
assert.arity(map, 1);
assert.name(map, 'map');
assert.looksNative(map);
assert.nonEnumerable(Array.prototype, 'map');
let array = [1];
const context = {};
array.map(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.deepEqual([2, 3, 4], [1, 2, 3].map(value => value + 1));
assert.deepEqual([1, 3, 5], [1, 2, 3].map((value, key) => value + key));
assert.deepEqual([2, 2, 2], [1, 2, 3].map(function () {
return +this;
}, 2));
if (STRICT) {
assert.throws(() => map.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => map.call(undefined, () => { /* empty */ }), TypeError);
}
assert.notThrows(() => map.call({
length: -1,
0: 1,
}, () => {
throw new Error();
}).length === 0, 'uses ToLength');
array = [];
array.constructor = { [Symbol.species]: function () { // eslint-disable-line object-shorthand
return { foo: 1 };
} };
assert.same(array.map(Boolean).foo, 1, '@@species');
});
core-js-3.6.1/tests/tests/es.array.of.js 0000664 0000000 0000000 00000001502 13600575677 0020072 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Array.of', assert => {
const { defineProperty } = Object;
assert.isFunction(Array.of);
assert.arity(Array.of, 0);
assert.name(Array.of, 'of');
assert.looksNative(Array.of);
assert.nonEnumerable(Array, 'of');
assert.deepEqual(Array.of(1), [1]);
assert.deepEqual(Array.of(1, 2, 3), [1, 2, 3]);
class C { /* empty */ }
const instance = Array.of.call(C, 1, 2);
assert.ok(instance instanceof C);
assert.strictEqual(instance[0], 1);
assert.strictEqual(instance[1], 2);
assert.strictEqual(instance.length, 2);
if (DESCRIPTORS) {
let called = false;
defineProperty(C.prototype, 0, {
set() {
called = true;
},
});
Array.of.call(C, 1, 2, 3);
assert.ok(!called, 'Should not call prototype accessors');
}
});
core-js-3.6.1/tests/tests/es.array.reduce-right.js 0000664 0000000 0000000 00000003703 13600575677 0022055 0 ustar 00root root 0000000 0000000 import { NATIVE, STRICT } from '../helpers/constants';
QUnit.test('Array#reduceRight', assert => {
const { reduceRight } = Array.prototype;
assert.isFunction(reduceRight);
assert.arity(reduceRight, 1);
assert.name(reduceRight, 'reduceRight');
assert.looksNative(reduceRight);
assert.nonEnumerable(Array.prototype, 'reduceRight');
const array = [1];
const accumulator = {};
array.reduceRight(function (memo, value, key, that) {
assert.same(arguments.length, 4, 'correct number of callback arguments');
assert.same(memo, accumulator, 'correct callback accumulator');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
}, accumulator);
assert.same([1, 2, 3].reduceRight(((a, b) => a + b), 1), 7, 'works with initial accumulator');
[1, 2].reduceRight((memo, value, key) => {
assert.same(memo, 2, 'correct default accumulator');
assert.same(value, 1, 'correct start value without initial accumulator');
assert.same(key, 0, 'correct start index without initial accumulator');
});
assert.same([1, 2, 3].reduceRight((a, b) => a + b), 6, 'works without initial accumulator');
let values = '';
let keys = '';
[1, 2, 3].reduceRight((memo, value, key) => {
values += value;
keys += key;
}, 0);
assert.same(values, '321', 'correct order #1');
assert.same(keys, '210', 'correct order #2');
assert.same(reduceRight.call({
0: 1,
1: 2,
length: 2,
}, (a, b) => a + b), 3, 'generic');
if (STRICT) {
assert.throws(() => reduceRight.call(null, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduceRight.call(undefined, () => { /* empty */ }, 1), TypeError);
}
if (NATIVE) {
assert.notThrows(() => reduceRight.call({
length: -1,
2147483646: 0,
4294967294: 0,
}, () => {
throw new Error();
}, 1) === undefined, 'uses ToLength');
}
});
core-js-3.6.1/tests/tests/es.array.reduce.js 0000664 0000000 0000000 00000003520 13600575677 0020737 0 ustar 00root root 0000000 0000000 import { NATIVE, STRICT } from '../helpers/constants';
QUnit.test('Array#reduce', assert => {
const { reduce } = Array.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.name(reduce, 'reduce');
assert.looksNative(reduce);
assert.nonEnumerable(Array.prototype, 'reduce');
const array = [1];
const accumulator = {};
array.reduce(function (memo, value, key, that) {
assert.same(arguments.length, 4, 'correct number of callback arguments');
assert.same(memo, accumulator, 'correct callback accumulator');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
}, accumulator);
assert.same([1, 2, 3].reduce(((a, b) => a + b), 1), 7, 'works with initial accumulator');
[1, 2].reduce((memo, value, key) => {
assert.same(memo, 1, 'correct default accumulator');
assert.same(value, 2, 'correct start value without initial accumulator');
assert.same(key, 1, 'correct start index without initial accumulator');
});
assert.same([1, 2, 3].reduce((a, b) => a + b), 6, 'works without initial accumulator');
let values = '';
let keys = '';
[1, 2, 3].reduce((memo, value, key) => {
values += value;
keys += key;
}, 0);
assert.same(values, '123', 'correct order #1');
assert.same(keys, '012', 'correct order #2');
assert.same(reduce.call({
0: 1,
1: 2,
length: 2,
}, (a, b) => a + b), 3, 'generic');
if (STRICT) {
assert.throws(() => reduce.call(null, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(undefined, () => { /* empty */ }, 1), TypeError);
}
if (NATIVE) {
assert.notThrows(() => reduce.call({
length: -1,
0: 1,
}, () => {
throw new Error();
}, 1) === undefined, 'uses ToLength');
}
});
core-js-3.6.1/tests/tests/es.array.reverse.js 0000664 0000000 0000000 00000001151 13600575677 0021141 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
QUnit.test('Array#reverse', assert => {
const { reverse } = Array.prototype;
assert.isFunction(reverse);
assert.arity(reverse, 0);
assert.name(reverse, 'reverse');
assert.looksNative(reverse);
assert.nonEnumerable(Array.prototype, 'reverse');
const a = [1, 2.2, 3.3];
function fn() {
+a;
a.reverse();
}
fn();
assert.arrayEqual(a, [3.3, 2.2, 1]);
if (STRICT) {
assert.throws(() => reverse.call(null, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reverse.call(undefined, () => { /* empty */ }, 1), TypeError);
}
});
core-js-3.6.1/tests/tests/es.array.slice.js 0000664 0000000 0000000 00000003231 13600575677 0020566 0 ustar 00root root 0000000 0000000 import { GLOBAL, NATIVE, STRICT } from '../helpers/constants';
QUnit.test('Array#slice', assert => {
const { slice } = Array.prototype;
const { isArray } = Array;
assert.isFunction(slice);
assert.arity(slice, 2);
assert.name(slice, 'slice');
assert.looksNative(slice);
assert.nonEnumerable(Array.prototype, 'slice');
let array = ['1', '2', '3', '4', '5'];
assert.deepEqual(array.slice(), array);
assert.deepEqual(array.slice(1, 3), ['2', '3']);
assert.deepEqual(array.slice(1, undefined), ['2', '3', '4', '5']);
assert.deepEqual(array.slice(1, -1), ['2', '3', '4']);
assert.deepEqual(array.slice(-2, -1), ['4']);
assert.deepEqual(array.slice(-2, -3), []);
const string = '12345';
assert.deepEqual(slice.call(string), array);
assert.deepEqual(slice.call(string, 1, 3), ['2', '3']);
assert.deepEqual(slice.call(string, 1, undefined), ['2', '3', '4', '5']);
assert.deepEqual(slice.call(string, 1, -1), ['2', '3', '4']);
assert.deepEqual(slice.call(string, -2, -1), ['4']);
assert.deepEqual(slice.call(string, -2, -3), []);
const list = GLOBAL.document && document.body && document.body.childNodes;
if (list) {
assert.notThrows(() => isArray(slice.call(list)), 'works on NodeList');
}
if (NATIVE) {
if (STRICT) {
assert.throws(() => slice.call(null), TypeError);
assert.throws(() => slice.call(undefined), TypeError);
}
assert.deepEqual(slice.call({
length: -1,
0: 1,
}, 0, 1), [], 'uses ToLength');
}
array = [];
array.constructor = { [Symbol.species]: function () { // eslint-disable-line object-shorthand
return { foo: 1 };
} };
assert.same(array.slice().foo, 1, '@@species');
});
core-js-3.6.1/tests/tests/es.array.some.js 0000664 0000000 0000000 00000003040 13600575677 0020430 0 ustar 00root root 0000000 0000000 import { NATIVE, STRICT } from '../helpers/constants';
QUnit.test('Array#some', assert => {
const { some } = Array.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.name(some, 'some');
assert.looksNative(some);
assert.nonEnumerable(Array.prototype, 'some');
let array = [1];
const context = {};
array.some(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.ok([1, '2', 3].some(value => typeof value === 'number'));
assert.ok([1, 2, 3].some(value => value < 3));
assert.ok(![1, 2, 3].some(value => value < 0));
assert.ok(![1, 2, 3].some(value => typeof value === 'string'));
assert.ok(![1, 2, 3].some(function () {
return +this !== 1;
}, 1));
let result = '';
[1, 2, 3].some((value, key) => {
result += key;
return false;
});
assert.ok(result === '012');
array = [1, 2, 3];
assert.ok(!array.some((value, key, that) => that !== array));
if (STRICT) {
assert.throws(() => some.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(undefined, () => { /* empty */ }), TypeError);
}
if (NATIVE) {
assert.notThrows(() => some.call({
length: -1,
0: 1,
}, () => {
throw new Error();
}) === false, 'uses ToLength');
}
});
core-js-3.6.1/tests/tests/es.array.sort.js 0000664 0000000 0000000 00000001226 13600575677 0020460 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
QUnit.test('Array#sort', assert => {
const { sort } = Array.prototype;
assert.isFunction(sort);
assert.arity(sort, 1);
assert.name(sort, 'sort');
assert.looksNative(sort);
assert.nonEnumerable(Array.prototype, 'sort');
assert.notThrows(() => [1, 2, 3].sort(undefined).length === 3, 'works with undefined');
assert.throws(() => [1, 2, 3].sort(null), 'throws on null');
assert.throws(() => [1, 2, 3].sort({}), 'throws on {}');
if (STRICT) {
assert.throws(() => sort.call(null), TypeError, 'ToObject(this)');
assert.throws(() => sort.call(undefined), TypeError, 'ToObject(this)');
}
});
core-js-3.6.1/tests/tests/es.array.splice.js 0000664 0000000 0000000 00000002413 13600575677 0020747 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
QUnit.test('Array#splice', assert => {
const { splice } = Array.prototype;
assert.isFunction(splice);
assert.arity(splice, 2);
assert.name(splice, 'splice');
assert.looksNative(splice);
assert.nonEnumerable(Array.prototype, 'splice');
let array = [1, 2, 3, 4, 5];
assert.deepEqual(array.splice(2), [3, 4, 5]);
assert.deepEqual(array, [1, 2]);
array = [1, 2, 3, 4, 5];
assert.deepEqual(array.splice(-2), [4, 5]);
assert.deepEqual(array, [1, 2, 3]);
array = [1, 2, 3, 4, 5];
assert.deepEqual(array.splice(2, 2), [3, 4]);
assert.deepEqual(array, [1, 2, 5]);
array = [1, 2, 3, 4, 5];
assert.deepEqual(array.splice(2, -2), []);
assert.deepEqual(array, [1, 2, 3, 4, 5]);
array = [1, 2, 3, 4, 5];
assert.deepEqual(array.splice(2, 2, 6, 7), [3, 4]);
assert.deepEqual(array, [1, 2, 6, 7, 5]);
if (STRICT) {
assert.throws(() => splice.call(null), TypeError);
assert.throws(() => splice.call(undefined), TypeError);
}
assert.deepEqual(splice.call({
length: -1,
0: 1,
}), [], 'uses ToLength');
array = [];
array.constructor = { [Symbol.species]: function () { // eslint-disable-line object-shorthand
return { foo: 1 };
} };
assert.same(array.splice().foo, 1, '@@species');
});
core-js-3.6.1/tests/tests/es.data-view.js 0000664 0000000 0000000 00000017652 13600575677 0020247 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, NATIVE } from '../helpers/constants';
QUnit.test('DataView', assert => {
assert.same(DataView, Object(DataView), 'is object'); // in Safari 5 typeof DataView is 'object'
if (NATIVE) assert.arity(DataView, 3); // 1 in IE11
if (NATIVE) assert.name(DataView, 'DataView'); // Safari 5 bug
if (NATIVE) assert.looksNative(DataView); // Safari 5 bug
let dataview = new DataView(new ArrayBuffer(8));
assert.same(dataview.byteOffset, 0, '#byteOffset, passed buffer');
assert.same(dataview.byteLength, 8, '#byteLength, passed buffer');
dataview = new DataView(new ArrayBuffer(16), 8);
assert.same(dataview.byteOffset, 8, '#byteOffset, passed buffer and byteOffset');
assert.same(dataview.byteLength, 8, '#byteLength, passed buffer and byteOffset');
dataview = new DataView(new ArrayBuffer(24), 8, 8);
assert.same(dataview.byteOffset, 8, '#byteOffset, passed buffer, byteOffset and length');
assert.same(dataview.byteLength, 8, '#byteLength, passed buffer, byteOffset and length');
if (NATIVE) {
// fails in IE / MS Edge
dataview = new DataView(new ArrayBuffer(8), undefined);
assert.same(dataview.byteOffset, 0, '#byteOffset, passed buffer and undefined');
assert.same(dataview.byteLength, 8, '#byteLength, passed buffer and undefined');
// fails in IE / MS Edge
dataview = new DataView(new ArrayBuffer(16), 8, undefined);
assert.same(dataview.byteOffset, 8, '#byteOffset, passed buffer, byteOffset and undefined');
assert.same(dataview.byteLength, 8, '#byteLength, passed buffer, byteOffset and undefined');
// fails in IE10
dataview = new DataView(new ArrayBuffer(8), 8);
assert.same(dataview.byteOffset, 8, '#byteOffset, passed buffer and byteOffset with buffer length');
assert.same(dataview.byteLength, 0, '#byteLength, passed buffer and byteOffset with buffer length');
// TypeError in IE + FF bug - TypeError instead of RangeError
assert.throws(() => new DataView(new ArrayBuffer(8), -1), RangeError, 'If offset < 0, throw a RangeError exception');
assert.throws(() => new DataView(new ArrayBuffer(8), 16), RangeError, 'If newByteLength < 0, throw a RangeError exception');
assert.throws(() => new DataView(new ArrayBuffer(24), 8, 24), RangeError, 'If offset+newByteLength > bufferByteLength, throw a RangeError exception');
// Android ~ 4.0
assert.throws(() => DataView(1), TypeError, 'throws without `new`');
assert.throws(() => DataView(1), 'throws without `new`');
} else {
// FF bug - TypeError instead of RangeError
assert.throws(() => new DataView(new ArrayBuffer(8), -1), 'If offset < 0, throw a RangeError exception');
assert.throws(() => new DataView(new ArrayBuffer(8), 16), 'If newByteLength < 0, throw a RangeError exception');
assert.throws(() => new DataView(new ArrayBuffer(24), 8, 24), 'If offset+newByteLength > bufferByteLength, throw a RangeError exception');
}
dataview = new DataView(new ArrayBuffer(8));
dataview.setUint32(0, 0x12345678);
assert.same(dataview.getUint32(0), 0x12345678, 'big endian/big endian');
dataview.setUint32(0, 0x12345678, true);
assert.same(dataview.getUint32(0, true), 0x12345678, 'little endian/little endian');
dataview.setUint32(0, 0x12345678, true);
assert.same(dataview.getUint32(0), 0x78563412, 'little endian/big endian');
dataview.setUint32(0, 0x12345678);
assert.same(dataview.getUint32(0, true), 0x78563412, 'big endian/little endian');
assert.throws(() => new DataView({}), 'non-ArrayBuffer argument, object');
assert.throws(() => new DataView('foo'), 'non-ArrayBuffer argument, string');
});
if (DESCRIPTORS) {
QUnit.test('DataView accessors', assert => {
const uint8array = new Uint8Array(8);
const dataview = new DataView(uint8array.buffer);
assert.arrayEqual(uint8array, [0, 0, 0, 0, 0, 0, 0, 0]);
dataview.setUint8(0, 255);
assert.arrayEqual(uint8array, [0xFF, 0, 0, 0, 0, 0, 0, 0]);
dataview.setInt8(1, -1);
assert.arrayEqual(uint8array, [0xFF, 0xFF, 0, 0, 0, 0, 0, 0]);
dataview.setUint16(2, 0x1234);
assert.arrayEqual(uint8array, [0xFF, 0xFF, 0x12, 0x34, 0, 0, 0, 0]);
dataview.setInt16(4, -1);
assert.arrayEqual(uint8array, [0xFF, 0xFF, 0x12, 0x34, 0xFF, 0xFF, 0, 0]);
dataview.setUint32(1, 0x12345678);
assert.arrayEqual(uint8array, [0xFF, 0x12, 0x34, 0x56, 0x78, 0xFF, 0, 0]);
dataview.setInt32(4, -2023406815);
assert.arrayEqual(uint8array, [0xFF, 0x12, 0x34, 0x56, 0x87, 0x65, 0x43, 0x21]);
dataview.setFloat32(2, 1.2e+38);
assert.arrayEqual(uint8array, [0xFF, 0x12, 0x7E, 0xB4, 0x8E, 0x52, 0x43, 0x21]);
dataview.setFloat64(0, -1.2345678e+301);
assert.arrayEqual(uint8array, [0xFE, 0x72, 0x6F, 0x51, 0x5F, 0x61, 0x77, 0xE5]);
const data = [0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87];
for (let i = 0, { length } = data; i < length; ++i) {
uint8array[i] = data[i];
}
assert.same(dataview.getUint8(0), 128);
assert.same(dataview.getInt8(1), -127);
assert.same(dataview.getUint16(2), 33411);
assert.same(dataview.getInt16(3), -31868);
assert.same(dataview.getUint32(4), 2223343239);
assert.same(dataview.getInt32(2), -2105310075);
assert.same(dataview.getFloat32(2), -1.932478247535851e-37);
assert.same(dataview.getFloat64(0), -3.116851295377095e-306);
});
QUnit.test('DataView endian', assert => {
const { buffer } = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7]);
let dataview = new DataView(buffer);
assert.same(dataview.byteLength, 8, 'buffer');
assert.same(dataview.byteOffset, 0, 'buffer');
assert.throws(() => dataview.getUint8(-2));
assert.throws(() => dataview.getUint8(8), 'bounds for buffer');
assert.throws(() => dataview.setUint8(-2, 0), 'bounds for buffer');
assert.throws(() => dataview.setUint8(8, 0), 'bounds for buffer');
dataview = new DataView(buffer, 2);
assert.same(dataview.byteLength, 6, 'buffer, byteOffset');
assert.same(dataview.byteOffset, 2, 'buffer, byteOffset');
assert.same(dataview.getUint8(5), 7, 'buffer, byteOffset');
assert.throws(() => dataview.getUint8(-2), 'bounds for buffer, byteOffset');
assert.throws(() => dataview.getUint8(6), 'bounds for buffer, byteOffset');
assert.throws(() => dataview.setUint8(-2, 0), 'bounds for buffer, byteOffset');
assert.throws(() => dataview.setUint8(6, 0), 'bounds for buffer, byteOffset');
assert.throws(() => new DataView(buffer, -1), 'invalid byteOffset');
assert.throws(() => new DataView(buffer, 9), 'invalid byteOffset');
dataview = new DataView(buffer, 2, 4);
assert.same(dataview.byteLength, 4, 'buffer, byteOffset, length');
assert.same(dataview.byteOffset, 2, 'buffer, byteOffset, length');
assert.same(dataview.getUint8(3), 5, 'buffer, byteOffset, length');
assert.throws(() => dataview.getUint8(-2), 'bounds for buffer, byteOffset, length');
assert.throws(() => dataview.getUint8(4), 'bounds for buffer, byteOffset, length');
assert.throws(() => dataview.setUint8(-2, 0), 'bounds for buffer, byteOffset, length');
assert.throws(() => dataview.setUint8(4, 0), 'bounds for buffer, byteOffset, length');
assert.throws(() => new DataView(buffer, 0, 9), 'invalid byteOffset+length');
assert.throws(() => new DataView(buffer, 8, 1), 'invalid byteOffset+length');
assert.throws(() => new DataView(buffer, 9, -1), 'invalid byteOffset+length');
});
}
const types = ['Uint8', 'Int8', 'Uint16', 'Int16', 'Uint32', 'Int32', 'Float32', 'Float64'];
for (const type of types) {
const GETTER = `get${ type }`;
const SETTER = `set${ type }`;
QUnit.test(`DataView#${ GETTER }`, assert => {
assert.isFunction(DataView.prototype[GETTER]);
NATIVE && assert.arity(DataView.prototype[GETTER], 1);
assert.same(new DataView(new ArrayBuffer(8))[GETTER](0), 0, 'returns element');
});
QUnit.test(`DataView#${ SETTER }`, assert => {
assert.isFunction(DataView.prototype[SETTER]);
NATIVE && assert.arity(DataView.prototype[SETTER], 2);
assert.same(new DataView(new ArrayBuffer(8))[SETTER](0, 0), undefined, 'void');
});
}
core-js-3.6.1/tests/tests/es.date.now.js 0000664 0000000 0000000 00000000415 13600575677 0020072 0 ustar 00root root 0000000 0000000 QUnit.test('Date.now', assert => {
const { now } = Date;
assert.isFunction(now);
assert.arity(now, 0);
assert.name(now, 'now');
assert.looksNative(now);
assert.nonEnumerable(Date, 'now');
assert.ok(+new Date() - now() < 10, 'Date.now() ~ +new Date');
});
core-js-3.6.1/tests/tests/es.date.to-iso-string.js 0000664 0000000 0000000 00000001617 13600575677 0022012 0 ustar 00root root 0000000 0000000 QUnit.test('Date#toISOString', assert => {
const { toISOString } = Date.prototype;
assert.isFunction(toISOString);
assert.arity(toISOString, 0);
assert.name(toISOString, 'toISOString');
assert.looksNative(toISOString);
assert.nonEnumerable(Date.prototype, 'toISOString');
assert.strictEqual(new Date(0).toISOString(), '1970-01-01T00:00:00.000Z');
assert.strictEqual(new Date(1e12 + 1).toISOString(), '2001-09-09T01:46:40.001Z');
assert.strictEqual(new Date(-5e13 - 1).toISOString(), '0385-07-25T07:06:39.999Z');
const future = new Date(1e15 + 1).toISOString();
assert.ok(future === '+033658-09-27T01:46:40.001Z' || future === '33658-09-27T01:46:40.001Z');
const prehistoric = new Date(-1e15 + 1).toISOString();
assert.ok(prehistoric === '-029719-04-05T22:13:20.001Z' || prehistoric === '-29719-04-05T22:13:20.001Z');
assert.throws(() => new Date(NaN).toISOString(), RangeError);
});
core-js-3.6.1/tests/tests/es.date.to-json.js 0000664 0000000 0000000 00000000746 13600575677 0020667 0 ustar 00root root 0000000 0000000 QUnit.test('Date#toJSON', assert => {
const { toJSON } = Date.prototype;
assert.isFunction(toJSON);
assert.arity(toJSON, 1);
assert.name(toJSON, 'toJSON');
assert.looksNative(toJSON);
assert.nonEnumerable(Date.prototype, 'toJSON');
const date = new Date();
assert.same(date.toJSON(), date.toISOString(), 'base');
assert.same(new Date(NaN).toJSON(), null, 'not finite');
assert.same(toJSON.call({
toISOString() {
return 42;
},
}), 42, 'generic');
});
core-js-3.6.1/tests/tests/es.date.to-primitive.js 0000664 0000000 0000000 00000002367 13600575677 0021727 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
QUnit.test('Date#@@toPrimitive', assert => {
const toPrimitive = Date.prototype[Symbol.toPrimitive];
assert.isFunction(toPrimitive);
assert.arity(toPrimitive, 1);
assert.nonEnumerable(Date.prototype, Symbol.toPrimitive);
const date = new Date();
assert.same(date[Symbol.toPrimitive]('string'), date.toString(), 'generic, hint "string"');
assert.same(date[Symbol.toPrimitive]('number'), +date, 'generic, hint "number"');
assert.same(date[Symbol.toPrimitive]('default'), date.toString(), 'generic, hint "default"');
assert.same(toPrimitive.call(Object(2), 'string'), '2', 'generic, hint "string"');
assert.same(toPrimitive.call(Object(2), 'number'), 2, 'generic, hint "number"');
assert.same(toPrimitive.call(Object(2), 'default'), '2', 'generic, hint "default"');
let data = [undefined, '', 'foo', { toString() { return 'string'; } }];
for (const value of data) {
assert.throws(() => new Date()[Symbol.toPrimitive](value), TypeError, `throws on ${ value } as a hint`);
}
if (STRICT) {
data = [1, false, 'string', null, undefined];
for (const value of data) {
assert.throws(() => toPrimitive.call(value, 'string'), TypeError, `throws on ${ value } as \`this\``);
}
}
});
core-js-3.6.1/tests/tests/es.date.to-string.js 0000664 0000000 0000000 00000000476 13600575677 0021224 0 ustar 00root root 0000000 0000000 QUnit.test('Date#toString', assert => {
const { toString } = Date.prototype;
assert.isFunction(toString);
assert.arity(toString, 0);
assert.name(toString, 'toString');
assert.looksNative(toString);
assert.nonEnumerable(Date.prototype, 'toString');
assert.same(String(new Date(NaN)), 'Invalid Date');
});
core-js-3.6.1/tests/tests/es.function.bind.js 0000664 0000000 0000000 00000001641 13600575677 0021115 0 ustar 00root root 0000000 0000000 QUnit.test('Function#bind', assert => {
const { bind } = Function.prototype;
assert.isFunction(bind);
assert.arity(bind, 1);
assert.name(bind, 'bind');
assert.looksNative(bind);
assert.nonEnumerable(Function.prototype, 'bind');
assert.same(function () {
return this.a;
}.bind({ a: 42 })(), 42);
assert.same(new (function () { /* empty */ })().a, undefined);
function A(a, b) {
this.a = a;
this.b = b;
}
const instance = new (A.bind(null, 1))(2);
assert.ok(instance instanceof A);
assert.strictEqual(instance.a, 1);
assert.strictEqual(instance.b, 2);
assert.same((it => it).bind(null, 42)(), 42);
const regExpTest = RegExp.prototype.test.bind(/a/);
assert.ok(regExpTest('a'));
const Date2017 = Date.bind(null, 2017);
const date = new Date2017(11);
assert.ok(date instanceof Date);
assert.strictEqual(date.getFullYear(), 2017);
assert.strictEqual(date.getMonth(), 11);
});
core-js-3.6.1/tests/tests/es.function.has-instance.js 0000664 0000000 0000000 00000000436 13600575677 0022557 0 ustar 00root root 0000000 0000000 QUnit.test('Function#@@hasInstance', assert => {
assert.ok(Symbol.hasInstance in Function.prototype);
assert.nonEnumerable(Function.prototype, Symbol.hasInstance);
assert.ok(Function[Symbol.hasInstance](() => { /* empty */ }));
assert.ok(!Function[Symbol.hasInstance]({}));
});
core-js-3.6.1/tests/tests/es.function.name.js 0000664 0000000 0000000 00000001371 13600575677 0021121 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
if (DESCRIPTORS) {
QUnit.test('Function#name', assert => {
assert.ok('name' in Function.prototype);
assert.nonEnumerable(Function.prototype, 'name');
function foo() { /* empty */ }
assert.same(foo.name, 'foo');
assert.same(function () { /* empty */ }.name, '');
if (Object.freeze) {
assert.same(Object.freeze(() => { /* empty */ }).name, '');
}
function bar() { /* empty */ }
bar.toString = function () {
throw new Error();
};
assert.notThrows(() => bar.name === 'bar', 'works with redefined `.toString`');
const baz = Object(() => { /* empty */ });
baz.toString = function () {
return '';
};
assert.same(baz.name, '');
});
}
core-js-3.6.1/tests/tests/es.global-this.js 0000664 0000000 0000000 00000000237 13600575677 0020562 0 ustar 00root root 0000000 0000000 QUnit.test('globalThis', assert => {
assert.same(globalThis, Object(globalThis), 'is object');
assert.same(globalThis.Math, Math, 'contains globals');
});
core-js-3.6.1/tests/tests/es.json.stringify.js 0000664 0000000 0000000 00000001643 13600575677 0021345 0 ustar 00root root 0000000 0000000 import { GLOBAL } from '../helpers/constants';
if (GLOBAL.JSON) {
QUnit.test('Well‑formed JSON.stringify', assert => {
const { stringify } = JSON;
assert.isFunction(stringify);
assert.arity(stringify, 3);
assert.name(stringify, 'stringify');
assert.looksNative(stringify);
assert.same(stringify({ foo: 'bar' }), '{"foo":"bar"}', 'basic');
assert.same(stringify('\uDEAD'), '"\\udead"', 'r1');
assert.same(stringify('\uDF06\uD834'), '"\\udf06\\ud834"', 'r2');
assert.same(stringify('\uDF06ab\uD834'), '"\\udf06ab\\ud834"', 'r3');
assert.same(stringify('𠮷'), '"𠮷"', 'r4');
assert.same(stringify('\uD834\uDF06'), '"𝌆"', 'r5');
assert.same(stringify('\uD834\uD834\uDF06'), '"\\ud834𝌆"', 'r6');
assert.same(stringify('\uD834\uDF06\uDF06'), '"𝌆\\udf06"', 'r7');
assert.same(stringify({ '𠮷': ['\uDF06\uD834'] }), '{"𠮷":["\\udf06\\ud834"]}', 'r8');
});
}
core-js-3.6.1/tests/tests/es.map.js 0000664 0000000 0000000 00000031671 13600575677 0017140 0 ustar 00root root 0000000 0000000 /* eslint-disable sonarjs/no-element-overwrite */
import { DESCRIPTORS, GLOBAL, NATIVE } from '../helpers/constants';
import { createIterable, is, nativeSubclass } from '../helpers/helpers';
const Symbol = GLOBAL.Symbol || {};
const { getOwnPropertyDescriptor, keys, getOwnPropertyNames, getOwnPropertySymbols, freeze } = Object;
const { ownKeys } = GLOBAL.Reflect || {};
QUnit.test('Map', assert => {
assert.isFunction(Map);
assert.arity(Map, 0);
assert.name(Map, 'Map');
assert.looksNative(Map);
assert.ok('clear' in Map.prototype, 'clear in Map.prototype');
assert.ok('delete' in Map.prototype, 'delete in Map.prototype');
assert.ok('forEach' in Map.prototype, 'forEach in Map.prototype');
assert.ok('get' in Map.prototype, 'get in Map.prototype');
assert.ok('has' in Map.prototype, 'has in Map.prototype');
assert.ok('set' in Map.prototype, 'set in Map.prototype');
assert.ok(new Map() instanceof Map, 'new Map instanceof Map');
assert.strictEqual(new Map(createIterable([[1, 1], [2, 2], [3, 3]])).size, 3, 'Init from iterable');
assert.strictEqual(new Map([[freeze({}), 1], [2, 3]]).size, 2, 'Support frozen objects');
let done = false;
try {
new Map(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
assert.ok(done, '.return #throw');
const array = [];
done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return [][Symbol.iterator].call(this);
};
new Map(array);
assert.ok(done);
const object = {};
new Map().set(object, 1);
if (DESCRIPTORS) {
const results = [];
for (const key in object) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(Map);
assert.ok(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.ok(new Subclass() instanceof Map, 'correct subclassing with native classes #2');
assert.strictEqual(new Subclass().set(1, 2).get(1), 2, 'correct subclassing with native classes #3');
}
});
QUnit.test('Map#clear', assert => {
assert.isFunction(Map.prototype.clear);
assert.arity(Map.prototype.clear, 0);
assert.name(Map.prototype.clear, 'clear');
assert.looksNative(Map.prototype.clear);
assert.nonEnumerable(Map.prototype, 'clear');
let map = new Map();
map.clear();
assert.strictEqual(map.size, 0);
map = new Map();
map.set(1, 2);
map.set(2, 3);
map.set(1, 4);
map.clear();
assert.strictEqual(map.size, 0);
assert.ok(!map.has(1));
assert.ok(!map.has(2));
const frozen = freeze({});
map = new Map();
map.set(1, 2);
map.set(frozen, 3);
map.clear();
assert.strictEqual(map.size, 0, 'Support frozen objects');
assert.ok(!map.has(1));
assert.ok(!map.has(frozen));
});
QUnit.test('Map#delete', assert => {
assert.isFunction(Map.prototype.delete);
assert.arity(Map.prototype.delete, 1);
if (NATIVE) assert.name(Map.prototype.delete, 'delete');
assert.looksNative(Map.prototype.delete);
assert.nonEnumerable(Map.prototype, 'delete');
const object = {};
const map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 7);
map.set(2, 5);
map.set(1, 4);
map.set(object, 9);
assert.strictEqual(map.size, 5);
assert.ok(map.delete(NaN));
assert.strictEqual(map.size, 4);
assert.ok(!map.delete(4));
assert.strictEqual(map.size, 4);
map.delete([]);
assert.strictEqual(map.size, 4);
map.delete(object);
assert.strictEqual(map.size, 3);
const frozen = freeze({});
map.set(frozen, 42);
assert.strictEqual(map.size, 4);
map.delete(frozen);
assert.strictEqual(map.size, 3);
});
QUnit.test('Map#forEach', assert => {
assert.isFunction(Map.prototype.forEach);
assert.arity(Map.prototype.forEach, 1);
assert.name(Map.prototype.forEach, 'forEach');
assert.looksNative(Map.prototype.forEach);
assert.nonEnumerable(Map.prototype, 'forEach');
let result = {};
let count = 0;
const object = {};
let map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 7);
map.set(2, 5);
map.set(1, 4);
map.set(object, 9);
map.forEach((value, key) => {
count++;
result[value] = key;
});
assert.strictEqual(count, 5);
assert.deepEqual(result, {
1: NaN,
7: 3,
5: 2,
4: 1,
9: object,
});
map = new Map();
map.set('0', 9);
map.set('1', 9);
map.set('2', 9);
map.set('3', 9);
result = '';
map.forEach((value, key) => {
result += key;
if (key === '2') {
map.delete('2');
map.delete('3');
map.delete('1');
map.set('4', 9);
}
});
assert.strictEqual(result, '0124');
map = new Map([['0', 1]]);
result = '';
map.forEach(it => {
map.delete('0');
if (result !== '') throw new Error();
result += it;
});
assert.strictEqual(result, '1');
assert.throws(() => {
Map.prototype.forEach.call(new Set(), () => { /* empty */ });
}, 'non-generic');
});
QUnit.test('Map#get', assert => {
assert.isFunction(Map.prototype.get);
assert.name(Map.prototype.get, 'get');
assert.arity(Map.prototype.get, 1);
assert.looksNative(Map.prototype.get);
assert.nonEnumerable(Map.prototype, 'get');
const object = {};
const frozen = freeze({});
const map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 1);
map.set(2, 5);
map.set(1, 4);
map.set(frozen, 42);
map.set(object, object);
assert.strictEqual(map.get(NaN), 1);
assert.strictEqual(map.get(4), undefined);
assert.strictEqual(map.get({}), undefined);
assert.strictEqual(map.get(object), object);
assert.strictEqual(map.get(frozen), 42);
assert.strictEqual(map.get(2), 5);
});
QUnit.test('Map#has', assert => {
assert.isFunction(Map.prototype.has);
assert.name(Map.prototype.has, 'has');
assert.arity(Map.prototype.has, 1);
assert.looksNative(Map.prototype.has);
assert.nonEnumerable(Map.prototype, 'has');
const object = {};
const frozen = freeze({});
const map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 1);
map.set(2, 5);
map.set(1, 4);
map.set(frozen, 42);
map.set(object, object);
assert.ok(map.has(NaN));
assert.ok(map.has(object));
assert.ok(map.has(2));
assert.ok(map.has(frozen));
assert.ok(!map.has(4));
assert.ok(!map.has({}));
});
QUnit.test('Map#set', assert => {
assert.isFunction(Map.prototype.set);
assert.name(Map.prototype.set, 'set');
assert.arity(Map.prototype.set, 2);
assert.looksNative(Map.prototype.set);
assert.nonEnumerable(Map.prototype, 'set');
const object = {};
let map = new Map();
map.set(NaN, 1);
map.set(2, 1);
map.set(3, 1);
map.set(2, 5);
map.set(1, 4);
map.set(object, object);
assert.ok(map.size === 5);
const chain = map.set(7, 2);
assert.strictEqual(chain, map);
map.set(7, 2);
assert.strictEqual(map.size, 6);
assert.strictEqual(map.get(7), 2);
assert.strictEqual(map.get(NaN), 1);
map.set(NaN, 42);
assert.strictEqual(map.size, 6);
assert.strictEqual(map.get(NaN), 42);
map.set({}, 11);
assert.strictEqual(map.size, 7);
assert.strictEqual(map.get(object), object);
map.set(object, 27);
assert.strictEqual(map.size, 7);
assert.strictEqual(map.get(object), 27);
map = new Map();
map.set(NaN, 2);
map.set(NaN, 3);
map.set(NaN, 4);
assert.strictEqual(map.size, 1);
const frozen = freeze({});
map = new Map().set(frozen, 42);
assert.strictEqual(map.get(frozen), 42);
});
QUnit.test('Map#size', assert => {
assert.nonEnumerable(Map.prototype, 'size');
const map = new Map();
map.set(2, 1);
const { size } = map;
assert.strictEqual(typeof size, 'number', 'size is number');
assert.strictEqual(size, 1, 'size is correct');
if (DESCRIPTORS) {
const sizeDescriptor = getOwnPropertyDescriptor(Map.prototype, 'size');
assert.ok(sizeDescriptor && sizeDescriptor.get, 'size is getter');
assert.ok(sizeDescriptor && !sizeDescriptor.set, 'size isnt setter');
assert.throws(() => Map.prototype.size, TypeError);
}
});
QUnit.test('Map & -0', assert => {
let map = new Map();
map.set(-0, 1);
assert.strictEqual(map.size, 1);
assert.ok(map.has(0));
assert.ok(map.has(-0));
assert.strictEqual(map.get(0), 1);
assert.strictEqual(map.get(-0), 1);
map.forEach((val, key) => {
assert.ok(!is(key, -0));
});
map.delete(-0);
assert.strictEqual(map.size, 0);
map = new Map([[-0, 1]]);
map.forEach((val, key) => {
assert.ok(!is(key, -0));
});
map = new Map();
map.set(4, 4);
map.set(3, 3);
map.set(2, 2);
map.set(1, 1);
map.set(0, 0);
assert.ok(map.has(-0));
});
QUnit.test('Map#@@toStringTag', assert => {
assert.strictEqual(Map.prototype[Symbol.toStringTag], 'Map', 'Map::@@toStringTag is `Map`');
assert.strictEqual(String(new Map()), '[object Map]', 'correct stringification');
});
QUnit.test('Map Iterator', assert => {
const map = new Map();
map.set('a', 1);
map.set('b', 2);
map.set('c', 3);
map.set('d', 4);
const results = [];
const iterator = map.keys();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.nonEnumerable(iterator, 'next');
assert.nonEnumerable(iterator, Symbol.iterator);
results.push(iterator.next().value);
assert.ok(map.delete('a'));
assert.ok(map.delete('b'));
assert.ok(map.delete('c'));
map.set('e');
results.push(iterator.next().value);
results.push(iterator.next().value);
assert.ok(iterator.next().done);
map.set('f');
assert.ok(iterator.next().done);
assert.deepEqual(results, ['a', 'd', 'e']);
});
QUnit.test('Map#keys', assert => {
assert.isFunction(Map.prototype.keys);
assert.name(Map.prototype.keys, 'keys');
assert.arity(Map.prototype.keys, 0);
assert.looksNative(Map.prototype.keys);
assert.nonEnumerable(Map.prototype, 'keys');
const map = new Map();
map.set('a', 'q');
map.set('s', 'w');
map.set('d', 'e');
const iterator = map.keys();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Map Iterator');
assert.deepEqual(iterator.next(), {
value: 'a',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 's',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'd',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Map#values', assert => {
assert.isFunction(Map.prototype.values);
assert.name(Map.prototype.values, 'values');
assert.arity(Map.prototype.values, 0);
assert.looksNative(Map.prototype.values);
assert.nonEnumerable(Map.prototype, 'values');
const map = new Map();
map.set('a', 'q');
map.set('s', 'w');
map.set('d', 'e');
const iterator = map.values();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Map Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Map#entries', assert => {
assert.isFunction(Map.prototype.entries);
assert.name(Map.prototype.entries, 'entries');
assert.arity(Map.prototype.entries, 0);
assert.looksNative(Map.prototype.entries);
assert.nonEnumerable(Map.prototype, 'entries');
const map = new Map();
map.set('a', 'q');
map.set('s', 'w');
map.set('d', 'e');
const iterator = map.entries();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Map Iterator');
assert.deepEqual(iterator.next(), {
value: ['a', 'q'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['s', 'w'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['d', 'e'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Map#@@iterator', assert => {
assert.isIterable(Map.prototype);
assert.name(Map.prototype.entries, 'entries');
assert.arity(Map.prototype.entries, 0);
assert.looksNative(Map.prototype[Symbol.iterator]);
assert.strictEqual(Map.prototype[Symbol.iterator], Map.prototype.entries);
const map = new Map();
map.set('a', 'q');
map.set('s', 'w');
map.set('d', 'e');
const iterator = map[Symbol.iterator]();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Map Iterator');
assert.strictEqual(String(iterator), '[object Map Iterator]');
assert.deepEqual(iterator.next(), {
value: ['a', 'q'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['s', 'w'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['d', 'e'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
core-js-3.6.1/tests/tests/es.math.acosh.js 0000664 0000000 0000000 00000001306 13600575677 0020400 0 ustar 00root root 0000000 0000000 QUnit.test('Math.acosh', assert => {
const { acosh } = Math;
assert.isFunction(acosh);
assert.name(acosh, 'acosh');
assert.arity(acosh, 1);
assert.looksNative(acosh);
assert.nonEnumerable(Math, 'acosh');
assert.same(acosh(NaN), NaN);
assert.same(acosh(0.5), NaN);
assert.same(acosh(-1), NaN);
assert.same(acosh(-1e300), NaN);
assert.same(acosh(1), 0);
assert.strictEqual(acosh(Infinity), Infinity);
assert.epsilon(acosh(1234), 7.811163220849231);
assert.epsilon(acosh(8.88), 2.8737631531629235);
assert.epsilon(acosh(1e+160), 369.10676205960726);
assert.epsilon(acosh(Number.MAX_VALUE), 710.475860073944);
assert.epsilon(acosh(1 + Number.EPSILON), 2.1073424255447017e-8);
});
core-js-3.6.1/tests/tests/es.math.asinh.js 0000664 0000000 0000000 00000001227 13600575677 0020407 0 ustar 00root root 0000000 0000000 QUnit.test('Math.asinh', assert => {
const { asinh } = Math;
assert.isFunction(asinh);
assert.name(asinh, 'asinh');
assert.arity(asinh, 1);
assert.looksNative(asinh);
assert.nonEnumerable(Math, 'asinh');
assert.same(asinh(NaN), NaN);
assert.same(asinh(0), 0);
assert.same(asinh(-0), -0);
assert.strictEqual(asinh(Infinity), Infinity);
assert.strictEqual(asinh(-Infinity), -Infinity);
assert.epsilon(asinh(1234), 7.811163549201245);
assert.epsilon(asinh(9.99), 2.997227420191335);
assert.epsilon(asinh(1e150), 346.0809111296668);
assert.epsilon(asinh(1e7), 16.811242831518268);
assert.epsilon(asinh(-1e7), -16.811242831518268);
});
core-js-3.6.1/tests/tests/es.math.atanh.js 0000664 0000000 0000000 00000001352 13600575677 0020377 0 ustar 00root root 0000000 0000000 QUnit.test('Math.atanh', assert => {
const { atanh } = Math;
assert.isFunction(atanh);
assert.name(atanh, 'atanh');
assert.arity(atanh, 1);
assert.looksNative(atanh);
assert.nonEnumerable(Math, 'atanh');
assert.same(atanh(NaN), NaN);
assert.same(atanh(-2), NaN);
assert.same(atanh(-1.5), NaN);
assert.same(atanh(2), NaN);
assert.same(atanh(1.5), NaN);
assert.strictEqual(atanh(-1), -Infinity);
assert.strictEqual(atanh(1), Infinity);
assert.same(atanh(0), 0);
assert.same(atanh(-0), -0);
assert.same(atanh(-1e300), NaN);
assert.same(atanh(1e300), NaN);
assert.epsilon(atanh(0.5), 0.5493061443340549);
assert.epsilon(atanh(-0.5), -0.5493061443340549);
assert.epsilon(atanh(0.444), 0.47720201260109457);
});
core-js-3.6.1/tests/tests/es.math.cbrt.js 0000664 0000000 0000000 00000001031 13600575677 0020230 0 ustar 00root root 0000000 0000000 QUnit.test('Math.cbrt', assert => {
const { cbrt } = Math;
assert.isFunction(cbrt);
assert.name(cbrt, 'cbrt');
assert.arity(cbrt, 1);
assert.looksNative(cbrt);
assert.nonEnumerable(Math, 'cbrt');
assert.same(cbrt(NaN), NaN);
assert.same(cbrt(0), 0);
assert.same(cbrt(-0), -0);
assert.strictEqual(cbrt(Infinity), Infinity);
assert.strictEqual(cbrt(-Infinity), -Infinity);
assert.strictEqual(cbrt(-8), -2);
assert.strictEqual(cbrt(8), 2);
assert.epsilon(cbrt(-1000), -10);
assert.epsilon(cbrt(1000), 10);
});
core-js-3.6.1/tests/tests/es.math.clz32.js 0000664 0000000 0000000 00000000667 13600575677 0020251 0 ustar 00root root 0000000 0000000 QUnit.test('Math.clz32', assert => {
const { clz32 } = Math;
assert.isFunction(clz32);
assert.name(clz32, 'clz32');
assert.arity(clz32, 1);
assert.looksNative(clz32);
assert.nonEnumerable(Math, 'clz32');
assert.strictEqual(clz32(0), 32);
assert.strictEqual(clz32(1), 31);
assert.same(clz32(-1), 0);
assert.strictEqual(clz32(0.6), 32);
assert.same(clz32(2 ** 32 - 1), 0);
assert.strictEqual(clz32(2 ** 32), 32);
});
core-js-3.6.1/tests/tests/es.math.cosh.js 0000664 0000000 0000000 00000001276 13600575677 0020245 0 ustar 00root root 0000000 0000000 QUnit.test('Math.cosh', assert => {
const { cosh } = Math;
assert.isFunction(cosh);
assert.name(cosh, 'cosh');
assert.arity(cosh, 1);
assert.looksNative(cosh);
assert.nonEnumerable(Math, 'cosh');
assert.same(cosh(NaN), NaN);
assert.strictEqual(cosh(0), 1);
assert.strictEqual(cosh(-0), 1);
assert.strictEqual(cosh(Infinity), Infinity);
assert.strictEqual(cosh(-Infinity), Infinity);
assert.epsilon(cosh(12), 81377.395712574, 1e-9);
assert.epsilon(cosh(22), 1792456423.065795780980053377, 1e-5);
assert.epsilon(cosh(-10), 11013.23292010332313972137);
assert.epsilon(cosh(-23), 4872401723.1244513000, 1e-5);
assert.epsilon(cosh(710), 1.1169973830808557e+308, 1e+295);
});
core-js-3.6.1/tests/tests/es.math.expm1.js 0000664 0000000 0000000 00000000767 13600575677 0020347 0 ustar 00root root 0000000 0000000 QUnit.test('Math.expm1', assert => {
const { expm1 } = Math;
assert.isFunction(expm1);
assert.name(expm1, 'expm1');
assert.arity(expm1, 1);
assert.looksNative(expm1);
assert.nonEnumerable(Math, 'expm1');
assert.same(expm1(NaN), NaN);
assert.same(expm1(0), 0);
assert.same(expm1(-0), -0);
assert.strictEqual(expm1(Infinity), Infinity);
assert.strictEqual(expm1(-Infinity), -1);
assert.epsilon(expm1(10), 22025.465794806718);
assert.epsilon(expm1(-10), -0.9999546000702375);
});
core-js-3.6.1/tests/tests/es.math.fround.js 0000664 0000000 0000000 00000002620 13600575677 0020600 0 ustar 00root root 0000000 0000000 QUnit.test('Math.fround', assert => {
const { fround } = Math;
assert.isFunction(fround);
assert.name(fround, 'fround');
assert.arity(fround, 1);
assert.looksNative(fround);
assert.nonEnumerable(Math, 'fround');
assert.same(fround(undefined), NaN);
assert.same(fround(NaN), NaN);
assert.same(fround(0), 0);
assert.same(fround(-0), -0);
assert.same(fround(Number.MIN_VALUE), 0);
assert.same(fround(-Number.MIN_VALUE), -0);
assert.strictEqual(fround(Infinity), Infinity);
assert.strictEqual(fround(-Infinity), -Infinity);
assert.strictEqual(fround(1.7976931348623157e+308), Infinity);
assert.strictEqual(fround(-1.7976931348623157e+308), -Infinity);
assert.strictEqual(fround(3.4028235677973366e+38), Infinity);
assert.strictEqual(fround(3), 3);
assert.strictEqual(fround(-3), -3);
const maxFloat32 = 3.4028234663852886e+38;
const minFloat32 = 1.401298464324817e-45;
assert.strictEqual(fround(maxFloat32), maxFloat32);
assert.strictEqual(fround(-maxFloat32), -maxFloat32);
assert.strictEqual(fround(maxFloat32 + 2 ** 102), maxFloat32);
assert.strictEqual(fround(minFloat32), minFloat32);
assert.strictEqual(fround(-minFloat32), -minFloat32);
assert.same(fround(minFloat32 / 2), 0);
assert.same(fround(-minFloat32 / 2), -0);
assert.strictEqual(fround(minFloat32 / 2 + 2 ** -202), minFloat32);
assert.strictEqual(fround(-minFloat32 / 2 - 2 ** -202), -minFloat32);
});
core-js-3.6.1/tests/tests/es.math.hypot.js 0000664 0000000 0000000 00000003601 13600575677 0020446 0 ustar 00root root 0000000 0000000 QUnit.test('Math.hypot', assert => {
const { hypot, sqrt } = Math;
assert.isFunction(hypot);
assert.name(hypot, 'hypot');
assert.arity(hypot, 2);
assert.looksNative(hypot);
assert.nonEnumerable(Math, 'hypot');
assert.strictEqual(hypot(), 0);
assert.strictEqual(hypot(1), 1);
assert.same(hypot('', 0), 0);
assert.same(hypot(0, ''), 0);
assert.strictEqual(hypot(Infinity, 0), Infinity, 'Infinity, 0');
assert.strictEqual(hypot(-Infinity, 0), Infinity, '-Infinity, 0');
assert.strictEqual(hypot(0, Infinity), Infinity, '0, Infinity');
assert.strictEqual(hypot(0, -Infinity), Infinity, '0, -Infinity');
assert.strictEqual(hypot(Infinity, NaN), Infinity, 'Infinity, NaN');
assert.strictEqual(hypot(NaN, -Infinity), Infinity, 'NaN, -Infinity');
assert.same(hypot(NaN, 0), NaN, 'NaN, 0');
assert.same(hypot(0, NaN), NaN, '0, NaN');
assert.same(hypot(0, -0), 0);
assert.same(hypot(0, 0), 0);
assert.same(hypot(-0, -0), 0);
assert.same(hypot(-0, 0), 0);
assert.strictEqual(hypot(0, 1), 1);
assert.strictEqual(hypot(0, -1), 1);
assert.strictEqual(hypot(-0, 1), 1);
assert.strictEqual(hypot(-0, -1), 1);
assert.same(hypot(0), 0);
assert.strictEqual(hypot(1), 1);
assert.strictEqual(hypot(2), 2);
assert.strictEqual(hypot(0, 0, 1), 1);
assert.strictEqual(hypot(0, 1, 0), 1);
assert.strictEqual(hypot(1, 0, 0), 1);
assert.strictEqual(hypot(2, 3, 4), sqrt(2 * 2 + 3 * 3 + 4 * 4));
assert.strictEqual(hypot(2, 3, 4, 5), sqrt(2 * 2 + 3 * 3 + 4 * 4 + 5 * 5));
assert.epsilon(hypot(66, 66), 93.33809511662427);
assert.epsilon(hypot(0.1, 100), 100.0000499999875);
assert.strictEqual(hypot(1e+300, 1e+300), 1.4142135623730952e+300);
assert.strictEqual(Math.floor(hypot(1e-300, 1e-300) * 1e308), 141421356);
assert.strictEqual(hypot(1e+300, 1e+300, 2, 3), 1.4142135623730952e+300);
assert.strictEqual(hypot(-3, 4), 5);
assert.strictEqual(hypot(3, -4), 5);
});
core-js-3.6.1/tests/tests/es.math.imul.js 0000664 0000000 0000000 00000003005 13600575677 0020247 0 ustar 00root root 0000000 0000000 QUnit.test('Math.imul', assert => {
const { imul } = Math;
assert.isFunction(imul);
assert.name(imul, 'imul');
assert.arity(imul, 2);
assert.looksNative(imul);
assert.nonEnumerable(Math, 'imul');
assert.same(imul(0, 0), 0);
assert.strictEqual(imul(123, 456), 56088);
assert.strictEqual(imul(-123, 456), -56088);
assert.strictEqual(imul(123, -456), -56088);
assert.strictEqual(imul(19088743, 4275878552), 602016552);
assert.same(imul(false, 7), 0);
assert.same(imul(7, false), 0);
assert.same(imul(false, false), 0);
assert.strictEqual(imul(true, 7), 7);
assert.strictEqual(imul(7, true), 7);
assert.strictEqual(imul(true, true), 1);
assert.same(imul(undefined, 7), 0);
assert.same(imul(7, undefined), 0);
assert.same(imul(undefined, undefined), 0);
assert.same(imul('str', 7), 0);
assert.same(imul(7, 'str'), 0);
assert.same(imul({}, 7), 0);
assert.same(imul(7, {}), 0);
assert.same(imul([], 7), 0);
assert.same(imul(7, []), 0);
assert.strictEqual(imul(0xFFFFFFFF, 5), -5);
assert.strictEqual(imul(0xFFFFFFFE, 5), -10);
assert.strictEqual(imul(2, 4), 8);
assert.strictEqual(imul(-1, 8), -8);
assert.strictEqual(imul(-2, -2), 4);
assert.same(imul(-0, 7), 0);
assert.same(imul(7, -0), 0);
assert.same(imul(0.1, 7), 0);
assert.same(imul(7, 0.1), 0);
assert.same(imul(0.9, 7), 0);
assert.same(imul(7, 0.9), 0);
assert.strictEqual(imul(1.1, 7), 7);
assert.strictEqual(imul(7, 1.1), 7);
assert.strictEqual(imul(1.9, 7), 7);
assert.strictEqual(imul(7, 1.9), 7);
});
core-js-3.6.1/tests/tests/es.math.log10.js 0000664 0000000 0000000 00000001331 13600575677 0020223 0 ustar 00root root 0000000 0000000 QUnit.test('Math.log10', assert => {
const { log10 } = Math;
assert.isFunction(log10);
assert.name(log10, 'log10');
assert.arity(log10, 1);
assert.looksNative(log10);
assert.nonEnumerable(Math, 'log10');
assert.same(log10(''), log10(0));
assert.same(log10(NaN), NaN);
assert.same(log10(-1), NaN);
assert.same(log10(0), -Infinity);
assert.same(log10(-0), -Infinity);
assert.same(log10(1), 0);
assert.same(log10(Infinity), Infinity);
assert.epsilon(log10(0.1), -1);
assert.epsilon(log10(0.5), -0.3010299956639812);
assert.epsilon(log10(1.5), 0.17609125905568124);
assert.epsilon(log10(5), 0.6989700043360189);
assert.epsilon(log10(50), 1.6989700043360187);
assert.epsilon(log10(1000), 3);
});
core-js-3.6.1/tests/tests/es.math.log1p.js 0000664 0000000 0000000 00000001050 13600575677 0020321 0 ustar 00root root 0000000 0000000 QUnit.test('Math.log1p', assert => {
const { log1p } = Math;
assert.isFunction(log1p);
assert.name(log1p, 'log1p');
assert.arity(log1p, 1);
assert.looksNative(log1p);
assert.nonEnumerable(Math, 'log1p');
assert.same(log1p(''), log1p(0));
assert.same(log1p(NaN), NaN);
assert.same(log1p(-2), NaN);
assert.same(log1p(-1), -Infinity);
assert.same(log1p(0), 0);
assert.same(log1p(-0), -0);
assert.same(log1p(Infinity), Infinity);
assert.epsilon(log1p(5), 1.791759469228055);
assert.epsilon(log1p(50), 3.9318256327243257);
});
core-js-3.6.1/tests/tests/es.math.log2.js 0000664 0000000 0000000 00000001046 13600575677 0020147 0 ustar 00root root 0000000 0000000 QUnit.test('Math.log2', assert => {
const { log2 } = Math;
assert.isFunction(log2);
assert.name(log2, 'log2');
assert.arity(log2, 1);
assert.looksNative(log2);
assert.nonEnumerable(Math, 'log2');
assert.same(log2(''), log2(0));
assert.same(log2(NaN), NaN);
assert.same(log2(-1), NaN);
assert.same(log2(0), -Infinity);
assert.same(log2(-0), -Infinity);
assert.same(log2(1), 0);
assert.same(log2(Infinity), Infinity);
assert.same(log2(0.5), -1);
assert.same(log2(32), 5);
assert.epsilon(log2(5), 2.321928094887362);
});
core-js-3.6.1/tests/tests/es.math.sign.js 0000664 0000000 0000000 00000001115 13600575677 0020241 0 ustar 00root root 0000000 0000000 QUnit.test('Math.sign', assert => {
const { sign } = Math;
assert.isFunction(sign);
assert.name(sign, 'sign');
assert.arity(sign, 1);
assert.looksNative(sign);
assert.nonEnumerable(Math, 'sign');
assert.same(sign(NaN), NaN);
assert.same(sign(), NaN);
assert.same(sign(-0), -0);
assert.same(sign(0), 0);
assert.strictEqual(sign(Infinity), 1);
assert.strictEqual(sign(-Infinity), -1);
assert.strictEqual(sign(13510798882111488), 1);
assert.strictEqual(sign(-13510798882111488), -1);
assert.strictEqual(sign(42.5), 1);
assert.strictEqual(sign(-42.5), -1);
});
core-js-3.6.1/tests/tests/es.math.sinh.js 0000664 0000000 0000000 00000001030 13600575677 0020236 0 ustar 00root root 0000000 0000000 QUnit.test('Math.sinh', assert => {
const { sinh } = Math;
assert.isFunction(sinh);
assert.name(sinh, 'sinh');
assert.arity(sinh, 1);
assert.looksNative(sinh);
assert.nonEnumerable(Math, 'sinh');
assert.same(sinh(NaN), NaN);
assert.same(sinh(0), 0);
assert.same(sinh(-0), -0);
assert.strictEqual(sinh(Infinity), Infinity);
assert.strictEqual(sinh(-Infinity), -Infinity);
assert.epsilon(sinh(-5), -74.20321057778875);
assert.epsilon(sinh(2), 3.6268604078470186);
assert.strictEqual(sinh(-2e-17), -2e-17);
});
core-js-3.6.1/tests/tests/es.math.tanh.js 0000664 0000000 0000000 00000001007 13600575677 0020233 0 ustar 00root root 0000000 0000000 import { NATIVE } from '../helpers/constants';
QUnit.test('Math.tanh', assert => {
const { tanh } = Math;
assert.isFunction(tanh);
assert.name(tanh, 'tanh');
assert.arity(tanh, 1);
assert.looksNative(tanh);
assert.nonEnumerable(Math, 'tanh');
assert.same(tanh(NaN), NaN);
assert.same(tanh(0), 0);
assert.same(tanh(-0), -0);
assert.strictEqual(tanh(Infinity), 1);
assert.strictEqual(tanh(90), 1);
assert.epsilon(tanh(10), 0.9999999958776927);
if (NATIVE) assert.strictEqual(tanh(710), 1);
});
core-js-3.6.1/tests/tests/es.math.trunc.js 0000664 0000000 0000000 00000002116 13600575677 0020436 0 ustar 00root root 0000000 0000000 QUnit.test('Math.trunc', assert => {
const { trunc } = Math;
assert.isFunction(trunc);
assert.name(trunc, 'trunc');
assert.arity(trunc, 1);
assert.looksNative(trunc);
assert.nonEnumerable(Math, 'trunc');
assert.same(trunc(NaN), NaN, 'NaN -> NaN');
assert.same(trunc(-0), -0, '-0 -> -0');
assert.same(trunc(0), 0, '0 -> 0');
assert.same(trunc(Infinity), Infinity, 'Infinity -> Infinity');
assert.same(trunc(-Infinity), -Infinity, '-Infinity -> -Infinity');
assert.same(trunc(null), 0, 'null -> 0');
assert.same(trunc({}), NaN, '{} -> NaN');
assert.strictEqual(trunc([]), 0, '[] -> 0');
assert.strictEqual(trunc(1.01), 1, '1.01 -> 0');
assert.strictEqual(trunc(1.99), 1, '1.99 -> 0');
assert.strictEqual(trunc(-1), -1, '-1 -> -1');
assert.strictEqual(trunc(-1.99), -1, '-1.99 -> -1');
assert.strictEqual(trunc(-555.555), -555, '-555.555 -> -555');
assert.strictEqual(trunc(0x20000000000001), 0x20000000000001, '0x20000000000001 -> 0x20000000000001');
assert.strictEqual(trunc(-0x20000000000001), -0x20000000000001, '-0x20000000000001 -> -0x20000000000001');
});
core-js-3.6.1/tests/tests/es.number.constructor.js 0000664 0000000 0000000 00000015274 13600575677 0022240 0 ustar 00root root 0000000 0000000 import { nativeSubclass } from '../helpers/helpers';
const whitespaces = ' \t\u000B\f\u00A0\uFEFF\n\r\u2028\u2029\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000';
function getCheck(assert) {
return function (a, b) {
assert.same(Number(a), b, `Number ${ typeof a } ${ a } -> ${ b }`);
const x = new Number(a);
assert.ok(x === Object(x), `new Number ${ typeof a } ${ a } is object`);
assert.strictEqual({}.toString.call(x).slice(8, -1), 'Number', `classof new Number ${ typeof a } ${ a } is Number`);
assert.same(x.valueOf(), b, `new Number(${ typeof a } ${ a }).valueOf() -> ${ b }`);
};
}
QUnit.test('Number constructor: regression', assert => {
const check = getCheck(assert);
assert.isFunction(Number);
assert.arity(Number, 1);
assert.name(Number, 'Number');
assert.looksNative(Number);
assert.same(Number.prototype.constructor, Number);
assert.same(1.0.constructor, Number);
const constants = ['MAX_VALUE', 'MIN_VALUE', 'NaN', 'NEGATIVE_INFINITY', 'POSITIVE_INFINITY'];
for (const constant of constants) {
assert.ok(constant in Number, `Number.${ constant }`);
assert.nonEnumerable(Number, constant);
}
assert.same(Number(), 0);
assert.same(new Number().valueOf(), 0);
check(42, 42);
check(42.42, 42.42);
check(new Number(42), 42);
check(new Number(42.42), 42.42);
check('42', 42);
check('42.42', 42.42);
check('0x42', 66);
check('0X42', 66);
check('0xzzz', NaN);
check('0x1g', NaN);
check('+0x1', NaN);
check('-0x1', NaN);
check('+0X1', NaN);
check('-0X1', NaN);
check(new String('42'), 42);
check(new String('42.42'), 42.42);
check(new String('0x42'), 66);
check(null, 0);
check(undefined, NaN);
check(false, 0);
check(true, 1);
check(new Boolean(false), 0);
check(new Boolean(true), 1);
check({}, NaN);
check({
valueOf: '1.1',
}, NaN);
check({
valueOf: '1.1',
toString() {
return '2.2';
},
}, 2.2);
check({
valueOf() {
return '1.1';
},
}, 1.1);
check({
valueOf() {
return '1.1';
},
toString() {
return '2.2';
},
}, 1.1);
check({
valueOf() {
return '-0x1a2b3c';
},
}, NaN);
check({
toString() {
return '-0x1a2b3c';
},
}, NaN);
check({
valueOf() {
return 42;
},
}, 42);
check({
valueOf() {
return '42';
},
}, 42);
check({
valueOf() {
return null;
},
}, 0);
check({
toString() {
return 42;
},
}, 42);
check({
toString() {
return '42';
},
}, 42);
check({
valueOf() {
return 1;
},
toString() {
return 2;
},
}, 1);
check({
valueOf: 1,
toString() {
return 2;
},
}, 2);
let number = 1;
assert.strictEqual(Number({
valueOf() {
return ++number;
},
}), 2, 'Number call valueOf only once #1');
assert.strictEqual(number, 2, 'Number call valueOf only once #2');
number = 1;
assert.strictEqual(Number({
toString() {
return ++number;
},
}), 2, 'Number call toString only once #1');
assert.strictEqual(number, 2, 'Number call toString only once #2');
number = 1;
assert.strictEqual(new Number({
valueOf() {
return ++number;
},
}).valueOf(), 2, 'new Number call valueOf only once #1');
assert.strictEqual(number, 2, 'new Number call valueOf only once #2');
number = 1;
assert.strictEqual(new Number({
toString() {
return ++number;
},
}).valueOf(), 2, 'new Number call toString only once #1');
assert.strictEqual(number, 2, 'new Number call toString only once #2');
assert.throws(() => Number(Object.create(null)), TypeError, 'Number assert.throws on object w/o valueOf and toString');
assert.throws(() => Number({
valueOf: 1,
toString: 2,
}), TypeError, 'Number assert.throws on object then valueOf and toString are not functions');
assert.throws(() => new Number(Object.create(null)), TypeError, 'new Number assert.throws on object w/o valueOf and toString');
assert.throws(() => new Number({
valueOf: 1,
toString: 2,
}), TypeError, 'new Number assert.throws on object then valueOf and toString are not functions');
number = new Number(42);
assert.strictEqual(typeof number.constructor(number), 'number');
check(`${ whitespaces }42`, 42);
check(`42${ whitespaces }`, 42);
check(`${ whitespaces }42${ whitespaces }`, 42);
check(`${ whitespaces }0x42`, 66);
check(`0x42${ whitespaces }`, 66);
check(`${ whitespaces }0x42${ whitespaces }`, 66);
check(`${ whitespaces }0X42`, 66);
check(`0X42${ whitespaces }`, 66);
check(`${ whitespaces }0X42${ whitespaces }`, 66);
if (nativeSubclass) {
const Subclass = nativeSubclass(Number);
assert.ok(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.ok(new Subclass() instanceof Number, 'correct subclassing with native classes #2');
assert.same(new Subclass(1).toFixed(2), '1.00', 'correct subclassing with native classes #3');
}
});
QUnit.test('Number constructor: binary', assert => {
const check = getCheck(assert);
check('0b1', 1);
check('0B1', 1);
check('0b12', NaN);
check('0b234', NaN);
check('0b1!', NaN);
check('+0b1', NaN);
check('-0b1', NaN);
check(' 0b1', 1);
check('0b1\n', 1);
check('\n 0b1\n ', 1);
check(' 0B1', 1);
check('0B1\n', 1);
check('\n 0B1\n ', 1);
check({
valueOf() {
return '0b11';
},
}, 3);
check({
toString() {
return '0b111';
},
}, 7);
check({
valueOf() {
return '0b101010';
},
}, 42);
check({
toString() {
return '0b101010';
},
}, 42);
check(`${ whitespaces }0b11`, 3);
check(`0b11${ whitespaces }`, 3);
check(`${ whitespaces }0b11${ whitespaces }`, 3);
check(`${ whitespaces }0B11`, 3);
check(`0B11${ whitespaces }`, 3);
check(`${ whitespaces }0B11${ whitespaces }`, 3);
});
QUnit.test('Number constructor: octal', assert => {
const check = getCheck(assert);
check('0o7', 7);
check('0O7', 7);
check('0o18', NaN);
check('0o89a', NaN);
check('0o1!', NaN);
check('+0o1', NaN);
check('-0o1', NaN);
check(' 0o1', 1);
check('0o1\n', 1);
check('\n 0o1\n ', 1);
check(' 0O1', 1);
check('0O1\n', 1);
check('\n 0O1\n ', 1);
check({
valueOf() {
return '0o77';
},
}, 63);
check({
toString() {
return '0o777';
},
}, 511);
check({
valueOf() {
return '0o12345';
},
}, 5349);
check({
toString() {
return '0o12345';
},
}, 5349);
check(`${ whitespaces }0o11`, 9);
check(`0o11${ whitespaces }`, 9);
check(`${ whitespaces }0o11${ whitespaces }`, 9);
check(`${ whitespaces }0O11`, 9);
check(`0O11${ whitespaces }`, 9);
check(`${ whitespaces }0O11${ whitespaces }`, 9);
});
core-js-3.6.1/tests/tests/es.number.epsilon.js 0000664 0000000 0000000 00000000532 13600575677 0021313 0 ustar 00root root 0000000 0000000 QUnit.test('Number.EPSILON', assert => {
const { EPSILON } = Number;
assert.ok('EPSILON' in Number, 'EPSILON in Number');
assert.nonEnumerable(Number, 'EPSILON');
assert.strictEqual(EPSILON, 2 ** -52, 'Is 2^-52');
assert.ok(1 !== 1 + EPSILON, '1 isnt 1 + EPSILON');
assert.strictEqual(1, 1 + EPSILON / 2, '1 is 1 + EPSILON / 2');
});
core-js-3.6.1/tests/tests/es.number.is-finite.js 0000664 0000000 0000000 00000001714 13600575677 0021534 0 ustar 00root root 0000000 0000000 QUnit.test('Number.isFinite', assert => {
const { isFinite } = Number;
const { create } = Object;
assert.isFunction(isFinite);
assert.name(isFinite, 'isFinite');
assert.arity(isFinite, 1);
assert.looksNative(isFinite);
assert.nonEnumerable(Number, 'isFinite');
const finite = [
1,
0.1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
];
for (const value of finite) {
assert.ok(isFinite(value), `isFinite ${ typeof value } ${ value }`);
}
const notFinite = [
NaN,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notFinite) {
assert.ok(!isFinite(value), `not isFinite ${ typeof value } ${ value }`);
}
assert.ok(!isFinite(create(null)), 'Number.isFinite(Object.create(null)) -> false');
});
core-js-3.6.1/tests/tests/es.number.is-integer.js 0000664 0000000 0000000 00000001742 13600575677 0021714 0 ustar 00root root 0000000 0000000 QUnit.test('Number.isInteger', assert => {
const { isInteger } = Number;
const { create } = Object;
assert.isFunction(isInteger);
assert.name(isInteger, 'isInteger');
assert.arity(isInteger, 1);
assert.looksNative(isInteger);
assert.nonEnumerable(Number, 'isInteger');
const integers = [
1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
];
for (const value of integers) {
assert.ok(isInteger(value), `isInteger ${ typeof value } ${ value }`);
}
const notIntegers = [
NaN,
0.1,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notIntegers) {
assert.ok(!isInteger(value), `not isInteger ${ typeof value } ${ value }`);
}
assert.ok(!isInteger(create(null)), 'Number.isInteger(Object.create(null)) -> false');
});
core-js-3.6.1/tests/tests/es.number.is-nan.js 0000664 0000000 0000000 00000001512 13600575677 0021026 0 ustar 00root root 0000000 0000000 QUnit.test('Number.isNaN', assert => {
const { isNaN } = Number;
const { create } = Object;
assert.isFunction(isNaN);
assert.name(isNaN, 'isNaN');
assert.arity(isNaN, 1);
assert.looksNative(isNaN);
assert.nonEnumerable(Number, 'isNaN');
assert.ok(isNaN(NaN), 'Number.isNaN NaN');
const notNaNs = [
1,
0.1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notNaNs) {
assert.ok(!isNaN(value), `not Number.isNaN ${ typeof value } ${ value }`);
}
assert.ok(!isNaN(create(null)), 'Number.isNaN(Object.create(null)) -> false');
});
core-js-3.6.1/tests/tests/es.number.is-safe-integer.js 0000664 0000000 0000000 00000002204 13600575677 0022622 0 ustar 00root root 0000000 0000000 QUnit.test('Number.isSafeInteger', assert => {
const { isSafeInteger } = Number;
const { create } = Object;
assert.isFunction(isSafeInteger);
assert.name(isSafeInteger, 'isSafeInteger');
assert.arity(isSafeInteger, 1);
assert.looksNative(isSafeInteger);
assert.nonEnumerable(Number, 'isSafeInteger');
const safeIntegers = [
1,
-1,
2 ** 16,
2 ** 16 - 1,
2 ** 31,
2 ** 31 - 1,
2 ** 32,
2 ** 32 - 1,
-0,
9007199254740991,
-9007199254740991,
];
for (const value of safeIntegers) {
assert.ok(isSafeInteger(value), `isSafeInteger ${ typeof value } ${ value }`);
}
const notSafeIntegers = [
9007199254740992,
-9007199254740992,
NaN,
0.1,
Infinity,
'NaN',
'5',
false,
new Number(NaN),
new Number(Infinity),
new Number(5),
new Number(0.1),
undefined,
null,
{},
function () { /* empty */ },
];
for (const value of notSafeIntegers) {
assert.ok(!isSafeInteger(value), `not isSafeInteger ${ typeof value } ${ value }`);
}
assert.ok(!isSafeInteger(create(null)), 'Number.isSafeInteger(Object.create(null)) -> false');
});
core-js-3.6.1/tests/tests/es.number.max-safe-integer.js 0000664 0000000 0000000 00000000340 13600575677 0022773 0 ustar 00root root 0000000 0000000 QUnit.test('Number.MAX_SAFE_INTEGER', assert => {
assert.ok('MAX_SAFE_INTEGER' in Number);
assert.nonEnumerable(Number, 'MAX_SAFE_INTEGER');
assert.strictEqual(Number.MAX_SAFE_INTEGER, 2 ** 53 - 1, 'Is 2^53 - 1');
});
core-js-3.6.1/tests/tests/es.number.min-safe-integer.js 0000664 0000000 0000000 00000000344 13600575677 0022775 0 ustar 00root root 0000000 0000000 QUnit.test('Number.MIN_SAFE_INTEGER', assert => {
assert.ok('MIN_SAFE_INTEGER' in Number);
assert.nonEnumerable(Number, 'MIN_SAFE_INTEGER');
assert.strictEqual(Number.MIN_SAFE_INTEGER, -(2 ** 53) + 1, 'Is -2^53 + 1');
});
core-js-3.6.1/tests/tests/es.number.parse-float.js 0000664 0000000 0000000 00000001412 13600575677 0022055 0 ustar 00root root 0000000 0000000 import { GLOBAL, WHITESPACES } from '../helpers/constants';
QUnit.test('Number.parseFloat', assert => {
const { parseFloat } = Number;
assert.isFunction(parseFloat);
assert.name(parseFloat, 'parseFloat');
assert.arity(parseFloat, 1);
assert.looksNative(parseFloat);
assert.nonEnumerable(Number, 'parseFloat');
assert.same(parseFloat, GLOBAL.parseFloat);
assert.same(parseFloat('0'), 0);
assert.same(parseFloat(' 0'), 0);
assert.same(parseFloat('+0'), 0);
assert.same(parseFloat(' +0'), 0);
assert.same(parseFloat('-0'), -0);
assert.same(parseFloat(' -0'), -0);
assert.same(parseFloat(`${ WHITESPACES }+0`), 0);
assert.same(parseFloat(`${ WHITESPACES }-0`), -0);
assert.same(parseFloat(null), NaN);
assert.same(parseFloat(undefined), NaN);
});
core-js-3.6.1/tests/tests/es.number.parse-int.js 0000664 0000000 0000000 00000003373 13600575677 0021552 0 ustar 00root root 0000000 0000000 import { GLOBAL, WHITESPACES } from '../helpers/constants';
QUnit.test('Number.parseInt', assert => {
const { parseInt } = Number;
assert.isFunction(parseInt);
assert.name(parseInt, 'parseInt');
assert.arity(parseInt, 2);
assert.looksNative(parseInt);
assert.nonEnumerable(Number, 'parseInt');
assert.same(parseInt, GLOBAL.parseInt);
for (let radix = 2; radix <= 36; ++radix) {
assert.same(parseInt('10', radix), radix, `radix ${ radix }`);
}
const strings = ['01', '08', '10', '42'];
for (const string of strings) {
assert.same(parseInt(string), parseInt(string, 10), `default radix is 10: ${ string }`);
}
assert.same(parseInt('0x16'), parseInt('0x16', 16), 'default radix is 16: 0x16');
assert.same(parseInt(' 0x16'), parseInt('0x16', 16), 'ignores leading whitespace #1');
assert.same(parseInt(' 42'), parseInt('42', 10), 'ignores leading whitespace #2');
assert.same(parseInt(' 08'), parseInt('08', 10), 'ignores leading whitespace #3');
assert.same(parseInt(`${ WHITESPACES }08`), parseInt('08', 10), 'ignores leading whitespace #4');
assert.same(parseInt(`${ WHITESPACES }0x16`), parseInt('0x16', 16), 'ignores leading whitespace #5');
const fakeZero = {
valueOf() {
return 0;
},
};
assert.same(parseInt('08', fakeZero), parseInt('08', 10), 'valueOf #1');
assert.same(parseInt('0x16', fakeZero), parseInt('0x16', 16), 'valueOf #2');
assert.same(parseInt('-0xF'), -15, 'signed hex #1');
assert.same(parseInt('-0xF', 16), -15, 'signed hex #2');
assert.same(parseInt('+0xF'), 15, 'signed hex #3');
assert.same(parseInt('+0xF', 16), 15, 'signed hex #4');
assert.same(parseInt('10', -4294967294), 2, 'radix uses ToUint32');
assert.same(parseInt(null), NaN);
assert.same(parseInt(undefined), NaN);
});
core-js-3.6.1/tests/tests/es.number.to-fixed.js 0000664 0000000 0000000 00000007142 13600575677 0021365 0 ustar 00root root 0000000 0000000 QUnit.test('Number#toFixed', assert => {
const { toFixed } = Number.prototype;
assert.isFunction(toFixed);
assert.name(toFixed, 'toFixed');
assert.arity(toFixed, 1);
assert.looksNative(toFixed);
assert.nonEnumerable(Number.prototype, 'toFixed');
assert.same(0.00008.toFixed(3), '0.000');
assert.same(0.9.toFixed(0), '1');
assert.same(1.255.toFixed(2), '1.25');
assert.same(1843654265.0774949.toFixed(5), '1843654265.07749');
assert.same(1000000000000000128.0.toFixed(0), '1000000000000000128');
assert.same(toFixed.call(1), '1');
assert.same(toFixed.call(1, 0), '1');
assert.same(toFixed.call(1, 1), '1.0');
assert.same(toFixed.call(1, 1.1), '1.0');
assert.same(toFixed.call(1, 0.9), '1');
assert.same(toFixed.call(1, '0'), '1');
assert.same(toFixed.call(1, '1'), '1.0');
assert.same(toFixed.call(1, '1.1'), '1.0');
assert.same(toFixed.call(1, '0.9'), '1');
assert.same(toFixed.call(1, NaN), '1');
assert.same(toFixed.call(1, 'some string'), '1');
assert.notThrows(() => toFixed.call(1, -0.1) === '1');
assert.same(new Number(1).toFixed(), '1');
assert.same(new Number(1).toFixed(0), '1');
assert.same(new Number(1).toFixed(1), '1.0');
assert.same(new Number(1).toFixed(1.1), '1.0');
assert.same(new Number(1).toFixed(0.9), '1');
assert.same(new Number(1).toFixed('0'), '1');
assert.same(new Number(1).toFixed('1'), '1.0');
assert.same(new Number(1).toFixed('1.1'), '1.0');
assert.same(new Number(1).toFixed('0.9'), '1');
assert.same(new Number(1).toFixed(NaN), '1');
assert.same(new Number(1).toFixed('some string'), '1');
assert.notThrows(() => new Number(1).toFixed(-0.1) === '1');
assert.same(NaN.toFixed(), 'NaN');
assert.same(NaN.toFixed(0), 'NaN');
assert.same(NaN.toFixed(1), 'NaN');
assert.same(NaN.toFixed(1.1), 'NaN');
assert.same(NaN.toFixed(0.9), 'NaN');
assert.same(NaN.toFixed('0'), 'NaN');
assert.same(NaN.toFixed('1'), 'NaN');
assert.same(NaN.toFixed('1.1'), 'NaN');
assert.same(NaN.toFixed('0.9'), 'NaN');
assert.same(NaN.toFixed(NaN), 'NaN');
assert.same(NaN.toFixed('some string'), 'NaN');
assert.notThrows(() => NaN.toFixed(-0.1) === 'NaN');
assert.same(new Number(1e21).toFixed(), String(1e21));
assert.same(new Number(1e21).toFixed(0), String(1e21));
assert.same(new Number(1e21).toFixed(1), String(1e21));
assert.same(new Number(1e21).toFixed(1.1), String(1e21));
assert.same(new Number(1e21).toFixed(0.9), String(1e21));
assert.same(new Number(1e21).toFixed('0'), String(1e21));
assert.same(new Number(1e21).toFixed('1'), String(1e21));
assert.same(new Number(1e21).toFixed('1.1'), String(1e21));
assert.same(new Number(1e21).toFixed('0.9'), String(1e21));
assert.same(new Number(1e21).toFixed(NaN), String(1e21));
assert.same(new Number(1e21).toFixed('some string'), String(1e21));
assert.notThrows(() => new Number(1e21).toFixed(-0.1) === String(1e21));
assert.throws(() => 1.0.toFixed(-101), RangeError, 'If f < 0 or f > 20, throw a RangeError exception.');
assert.throws(() => 1.0.toFixed(101), RangeError, 'If f < 0 or f > 20, throw a RangeError exception.');
assert.throws(() => NaN.toFixed(Infinity), RangeError, 'If f < 0 or f > 20, throw a RangeError exception.');
assert.throws(() => toFixed.call({}, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toFixed.call('123', 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toFixed.call(false, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toFixed.call(null, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toFixed.call(undefined, 1), TypeError, '? thisNumberValue(this value)');
});
core-js-3.6.1/tests/tests/es.number.to-precision.js 0000664 0000000 0000000 00000002776 13600575677 0022271 0 ustar 00root root 0000000 0000000 QUnit.test('Number#toPrecision', assert => {
const { toPrecision } = Number.prototype;
assert.isFunction(toPrecision);
assert.name(toPrecision, 'toPrecision');
assert.arity(toPrecision, 1);
assert.looksNative(toPrecision);
assert.nonEnumerable(Number.prototype, 'toPrecision');
assert.same(0.00008.toPrecision(3), '0.0000800', '0.00008.toPrecision(3)');
assert.same(1.255.toPrecision(2), '1.3', '1.255.toPrecision(2)');
assert.same(1843654265.0774949.toPrecision(13), '1843654265.077', '1843654265.0774949.toPrecision(13)');
assert.same(NaN.toPrecision(1), 'NaN', 'If x is NaN, return the String "NaN".');
assert.same(123.456.toPrecision(), '123.456', 'If precision is undefined, return ! ToString(x).');
assert.same(123.456.toPrecision(undefined), '123.456', 'If precision is undefined, return ! ToString(x).');
assert.throws(() => 0.9.toPrecision(0), RangeError, 'If p < 1 or p > 21, throw a RangeError exception.');
assert.throws(() => 0.9.toPrecision(101), RangeError, 'If p < 1 or p > 21, throw a RangeError exception.');
assert.throws(() => toPrecision.call({}, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toPrecision.call('123', 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toPrecision.call(false, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toPrecision.call(null, 1), TypeError, '? thisNumberValue(this value)');
assert.throws(() => toPrecision.call(undefined, 1), TypeError, '? thisNumberValue(this value)');
});
core-js-3.6.1/tests/tests/es.object.assign.js 0000664 0000000 0000000 00000004476 13600575677 0021117 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Object.assign', assert => {
const { assign, keys, defineProperty } = Object;
assert.isFunction(assign);
assert.arity(assign, 2);
assert.name(assign, 'assign');
assert.looksNative(assign);
assert.nonEnumerable(Object, 'assign');
let object = { q: 1 };
assert.strictEqual(object, assign(object, { bar: 2 }), 'assign return target');
assert.strictEqual(object.bar, 2, 'assign define properties');
assert.deepEqual(assign({}, { q: 1 }, { w: 2 }), { q: 1, w: 2 });
assert.deepEqual(assign({}, 'qwe'), { 0: 'q', 1: 'w', 2: 'e' });
assert.throws(() => assign(null, { q: 1 }), TypeError);
assert.throws(() => assign(undefined, { q: 1 }), TypeError);
let string = assign('qwe', { q: 1 });
assert.strictEqual(typeof string, 'object');
assert.strictEqual(String(string), 'qwe');
assert.strictEqual(string.q, 1);
assert.same(assign({}, { valueOf: 42 }).valueOf, 42, 'IE enum keys bug');
if (DESCRIPTORS) {
object = { baz: 1 };
assign(object, defineProperty({}, 'bar', {
get() {
return this.baz + 1;
},
}));
assert.ok(object.bar === undefined, "assign don't copy descriptors");
object = { a: 'a' };
const c = Symbol('c');
const d = Symbol('d');
object[c] = 'c';
defineProperty(object, 'b', { value: 'b' });
defineProperty(object, d, { value: 'd' });
const object2 = assign({}, object);
assert.strictEqual(object2.a, 'a', 'a');
assert.strictEqual(object2.b, undefined, 'b');
assert.strictEqual(object2[c], 'c', 'c');
assert.strictEqual(object2[d], undefined, 'd');
try {
assert.strictEqual(Function('assign', `
return assign({ b: 1 }, { get a() {
delete this.b;
}, b: 2 });
`)(assign).b, 1);
} catch { /* empty */ }
try {
assert.strictEqual(Function('assign', `
return assign({ b: 1 }, { get a() {
Object.defineProperty(this, "b", {
value: 3,
enumerable: false
});
}, b: 2 });
`)(assign).b, 1);
} catch { /* empty */ }
}
string = 'abcdefghijklmnopqrst';
const result = {};
for (let i = 0, { length } = string; i < length; ++i) {
const char = string.charAt(i);
result[char] = char;
}
assert.strictEqual(keys(assign({}, result)).join(''), string);
});
core-js-3.6.1/tests/tests/es.object.create.js 0000664 0000000 0000000 00000002320 13600575677 0021060 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Object.create', assert => {
const { create, getPrototypeOf, getOwnPropertyNames } = Object;
function getPropertyNames(object) {
let result = [];
do {
result = result.concat(getOwnPropertyNames(object));
} while (object = getPrototypeOf(object));
return result;
}
assert.isFunction(create);
assert.arity(create, 2);
assert.name(create, 'create');
assert.looksNative(create);
assert.nonEnumerable(Object, 'create');
let object = { q: 1 };
assert.ok({}.isPrototypeOf.call(object, create(object)));
assert.ok(create(object).q === 1);
function F() {
return this.a = 1;
}
assert.ok(create(new F()) instanceof F);
assert.ok(F.prototype === getPrototypeOf(getPrototypeOf(create(new F()))));
assert.ok(create(new F()).a === 1);
assert.ok(create({}, { a: { value: 42 } }).a === 42);
object = create(null, { w: { value: 2 } });
assert.same(object, Object(object));
assert.ok(!('toString' in object));
assert.ok(object.w === 2);
assert.deepEqual(getPropertyNames(create(null)), []);
});
QUnit.test('Object.create.sham flag', assert => {
assert.same(Object.create.sham, DESCRIPTORS ? undefined : true);
});
core-js-3.6.1/tests/tests/es.object.define-getter.js 0000664 0000000 0000000 00000002002 13600575677 0022334 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, STRICT } from '../helpers/constants';
if (DESCRIPTORS) {
QUnit.test('Object#__defineGetter__', assert => {
const { __defineGetter__ } = Object.prototype;
assert.isFunction(__defineGetter__);
assert.arity(__defineGetter__, 2);
assert.name(__defineGetter__, '__defineGetter__');
assert.looksNative(__defineGetter__);
assert.nonEnumerable(Object.prototype, '__defineGetter__');
const object = {};
assert.same(object.__defineGetter__('key', () => 42), undefined, 'void');
assert.same(object.key, 42, 'works');
object.__defineSetter__('key', function () {
this.foo = 43;
});
object.key = 44;
assert.ok(object.key === 42 && object.foo === 43, 'works with setter');
if (STRICT) {
assert.throws(() => __defineGetter__.call(null, 1, () => { /* empty */ }), TypeError, 'Throws on null as `this`');
assert.throws(() => __defineGetter__.call(undefined, 1, () => { /* empty */ }), TypeError, 'Throws on undefined as `this`');
}
});
}
core-js-3.6.1/tests/tests/es.object.define-properties.js 0000664 0000000 0000000 00000001276 13600575677 0023252 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Object.defineProperties', assert => {
const { defineProperties } = Object;
assert.isFunction(defineProperties);
assert.arity(defineProperties, 2);
assert.name(defineProperties, 'defineProperties');
assert.looksNative(defineProperties);
assert.nonEnumerable(Object, 'defineProperties');
const source = {};
const result = defineProperties(source, { q: { value: 42 }, w: { value: 33 } });
assert.same(result, source);
assert.same(result.q, 42);
assert.same(result.w, 33);
});
QUnit.test('Object.defineProperties.sham flag', assert => {
assert.same(Object.defineProperties.sham, DESCRIPTORS ? undefined : true);
});
core-js-3.6.1/tests/tests/es.object.define-property.js 0000664 0000000 0000000 00000001446 13600575677 0022741 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Object.defineProperty', assert => {
const { defineProperty, create } = Object;
assert.isFunction(defineProperty);
assert.arity(defineProperty, 3);
assert.name(defineProperty, 'defineProperty');
assert.looksNative(defineProperty);
assert.nonEnumerable(Object, 'defineProperty');
const source = {};
const result = defineProperty(source, 'q', {
value: 42,
});
assert.same(result, source);
assert.same(result.q, 42);
assert.throws(() => defineProperty(42, 1, {}));
assert.throws(() => defineProperty({}, create(null), {}));
assert.throws(() => defineProperty({}, 1, 1));
});
QUnit.test('Object.defineProperty.sham flag', assert => {
assert.same(Object.defineProperty.sham, DESCRIPTORS ? undefined : true);
});
core-js-3.6.1/tests/tests/es.object.define-setter.js 0000664 0000000 0000000 00000002164 13600575677 0022361 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, STRICT } from '../helpers/constants';
if (DESCRIPTORS) {
QUnit.test('Object#__defineSetter__', assert => {
const { __defineSetter__ } = Object.prototype;
assert.isFunction(__defineSetter__);
assert.arity(__defineSetter__, 2);
assert.name(__defineSetter__, '__defineSetter__');
assert.looksNative(__defineSetter__);
assert.nonEnumerable(Object.prototype, '__defineSetter__');
let object = {};
assert.same(object.__defineSetter__('key', function () {
this.foo = 43;
}), undefined, 'void');
object.key = 44;
assert.same(object.foo, 43, 'works');
object = {};
object.__defineSetter__('key', function () {
this.foo = 43;
});
object.__defineGetter__('key', () => 42);
object.key = 44;
assert.ok(object.key === 42 && object.foo === 43, 'works with getter');
if (STRICT) {
assert.throws(() => __defineSetter__.call(null, 1, () => { /* empty */ }), TypeError, 'Throws on null as `this`');
assert.throws(() => __defineSetter__.call(undefined, 1, () => { /* empty */ }), TypeError, 'Throws on undefined as `this`');
}
});
}
core-js-3.6.1/tests/tests/es.object.entries.js 0000664 0000000 0000000 00000002305 13600575677 0021271 0 ustar 00root root 0000000 0000000 QUnit.test('Object.entries', assert => {
const { entries, create, assign } = Object;
assert.isFunction(entries);
assert.arity(entries, 1);
assert.name(entries, 'entries');
assert.looksNative(entries);
assert.nonEnumerable(Object, 'entries');
assert.deepEqual(entries({ q: 1, w: 2, e: 3 }), [['q', 1], ['w', 2], ['e', 3]]);
assert.deepEqual(entries(new String('qwe')), [['0', 'q'], ['1', 'w'], ['2', 'e']]);
assert.deepEqual(entries(assign(create({ q: 1, w: 2, e: 3 }), { a: 4, s: 5, d: 6 })), [['a', 4], ['s', 5], ['d', 6]]);
assert.deepEqual(entries({ valueOf: 42 }), [['valueOf', 42]], 'IE enum keys bug');
try {
assert.deepEqual(Function('entries', `
return entries({
a: 1,
get b() {
delete this.c;
return 2;
},
c: 3
});
`)(entries), [['a', 1], ['b', 2]]);
} catch { /* empty */ }
try {
assert.deepEqual(Function('entries', `
return entries({
a: 1,
get b() {
Object.defineProperty(this, "c", {
value: 4,
enumerable: false
});
return 2;
},
c: 3
});
`)(entries), [['a', 1], ['b', 2]]);
} catch { /* empty */ }
});
core-js-3.6.1/tests/tests/es.object.freeze.js 0000664 0000000 0000000 00000002102 13600575677 0021073 0 ustar 00root root 0000000 0000000 import { GLOBAL, NATIVE } from '../helpers/constants';
QUnit.test('Object.freeze', assert => {
const { freeze, isFrozen, keys, getOwnPropertyNames, getOwnPropertySymbols } = Object;
const { ownKeys } = GLOBAL.Reflect || {};
assert.isFunction(freeze);
assert.arity(freeze, 1);
assert.name(freeze, 'freeze');
assert.looksNative(freeze);
assert.nonEnumerable(Object, 'freeze');
const data = [42, 'foo', false, null, undefined, {}];
for (const value of data) {
assert.notThrows(() => freeze(value) || true, `accept ${ {}.toString.call(value).slice(8, -1) }`);
assert.same(freeze(value), value, `returns target on ${ {}.toString.call(value).slice(8, -1) }`);
}
if (NATIVE) assert.ok(isFrozen(freeze({})));
const results = [];
for (const key in freeze({})) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(freeze({})), []);
assert.arrayEqual(getOwnPropertyNames(freeze({})), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(freeze({})), []);
if (ownKeys) assert.arrayEqual(ownKeys(freeze({})), []);
});
core-js-3.6.1/tests/tests/es.object.from-entries.js 0000664 0000000 0000000 00000001523 13600575677 0022233 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
QUnit.test('Object.fromEntries', assert => {
const { fromEntries } = Object;
assert.isFunction(fromEntries);
assert.arity(fromEntries, 1);
assert.name(fromEntries, 'fromEntries');
assert.looksNative(fromEntries);
assert.nonEnumerable(Object, 'fromEntries');
assert.ok(fromEntries([]) instanceof Object);
assert.same(fromEntries([['foo', 1]]).foo, 1);
assert.same(fromEntries(createIterable([['bar', 2]])).bar, 2);
class Unit {
constructor(id) {
this.id = id;
}
toString() {
return `unit${ this.id }`;
}
}
const units = new Set([new Unit(101), new Unit(102), new Unit(103)]);
const object = fromEntries(units.entries());
assert.same(object.unit101.id, 101);
assert.same(object.unit102.id, 102);
assert.same(object.unit103.id, 103);
});
core-js-3.6.1/tests/tests/es.object.get-own-property-descriptor.js 0000664 0000000 0000000 00000002214 13600575677 0025235 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Object.getOwnPropertyDescriptor', assert => {
const { getOwnPropertyDescriptor } = Object;
assert.isFunction(getOwnPropertyDescriptor);
assert.arity(getOwnPropertyDescriptor, 2);
assert.name(getOwnPropertyDescriptor, 'getOwnPropertyDescriptor');
assert.looksNative(getOwnPropertyDescriptor);
assert.nonEnumerable(Object, 'getOwnPropertyDescriptor');
assert.deepEqual(getOwnPropertyDescriptor({ q: 42 }, 'q'), {
writable: true,
enumerable: true,
configurable: true,
value: 42,
});
assert.ok(getOwnPropertyDescriptor({}, 'toString') === undefined);
const primitives = [42, 'foo', false];
for (const value of primitives) {
assert.notThrows(() => getOwnPropertyDescriptor(value) || true, `accept ${ typeof value }`);
}
assert.throws(() => getOwnPropertyDescriptor(null), TypeError, 'throws on null');
assert.throws(() => getOwnPropertyDescriptor(undefined), TypeError, 'throws on undefined');
});
QUnit.test('Object.getOwnPropertyDescriptor.sham flag', assert => {
assert.same(Object.getOwnPropertyDescriptor.sham, DESCRIPTORS ? undefined : true);
});
core-js-3.6.1/tests/tests/es.object.get-own-property-descriptors.js 0000664 0000000 0000000 00000002445 13600575677 0025426 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Object.getOwnPropertyDescriptors', assert => {
const { create, getOwnPropertyDescriptors } = Object;
assert.isFunction(getOwnPropertyDescriptors);
assert.arity(getOwnPropertyDescriptors, 1);
assert.name(getOwnPropertyDescriptors, 'getOwnPropertyDescriptors');
assert.looksNative(getOwnPropertyDescriptors);
assert.nonEnumerable(Object, 'getOwnPropertyDescriptors');
const object = create({ q: 1 }, { e: { value: 3 } });
object.w = 2;
const symbol = Symbol('4');
object[symbol] = 4;
const descriptors = getOwnPropertyDescriptors(object);
assert.strictEqual(descriptors.q, undefined);
assert.deepEqual(descriptors.w, {
enumerable: true,
configurable: true,
writable: true,
value: 2,
});
if (DESCRIPTORS) {
assert.deepEqual(descriptors.e, {
enumerable: false,
configurable: false,
writable: false,
value: 3,
});
} else {
assert.deepEqual(descriptors.e, {
enumerable: true,
configurable: true,
writable: true,
value: 3,
});
}
assert.strictEqual(descriptors[symbol].value, 4);
});
QUnit.test('Object.getOwnPropertyDescriptors.sham flag', assert => {
assert.same(Object.getOwnPropertyDescriptors.sham, DESCRIPTORS ? undefined : true);
});
core-js-3.6.1/tests/tests/es.object.get-own-property-names.js 0000664 0000000 0000000 00000003524 13600575677 0024167 0 ustar 00root root 0000000 0000000 import { GLOBAL } from '../helpers/constants';
import { includes } from '../helpers/helpers';
QUnit.test('Object.getOwnPropertyNames', assert => {
const { getOwnPropertyNames } = Object;
assert.isFunction(getOwnPropertyNames);
assert.arity(getOwnPropertyNames, 1);
assert.name(getOwnPropertyNames, 'getOwnPropertyNames');
assert.looksNative(getOwnPropertyNames);
assert.nonEnumerable(Object, 'getOwnPropertyNames');
function F1() {
this.w = 1;
}
function F2() {
this.toString = 1;
}
F1.prototype.q = F2.prototype.q = 1;
const names = getOwnPropertyNames([1, 2, 3]);
assert.strictEqual(names.length, 4);
assert.ok(includes(names, '0'));
assert.ok(includes(names, '1'));
assert.ok(includes(names, '2'));
assert.ok(includes(names, 'length'));
assert.deepEqual(getOwnPropertyNames(new F1()), ['w']);
assert.deepEqual(getOwnPropertyNames(new F2()), ['toString']);
assert.ok(includes(getOwnPropertyNames(Array.prototype), 'toString'));
assert.ok(includes(getOwnPropertyNames(Object.prototype), 'toString'));
assert.ok(includes(getOwnPropertyNames(Object.prototype), 'constructor'));
const primitives = [42, 'foo', false];
for (const value of primitives) {
assert.notThrows(() => getOwnPropertyNames(value), `accept ${ typeof value }`);
}
assert.throws(() => {
getOwnPropertyNames(null);
}, TypeError, 'throws on null');
assert.throws(() => {
getOwnPropertyNames(undefined);
}, TypeError, 'throws on undefined');
if (GLOBAL.document) {
assert.notThrows(() => {
const iframe = document.createElement('iframe');
iframe.src = 'http://example.com';
document.documentElement.appendChild(iframe);
const window = iframe.contentWindow;
document.documentElement.removeChild(iframe);
return getOwnPropertyNames(window);
}, 'IE11 bug with iframe and window');
}
});
core-js-3.6.1/tests/tests/es.object.get-prototype-of.js 0000664 0000000 0000000 00000002764 13600575677 0023055 0 ustar 00root root 0000000 0000000 import { CORRECT_PROTOTYPE_GETTER } from '../helpers/constants';
QUnit.test('Object.getPrototypeOf', assert => {
const { create, getPrototypeOf } = Object;
assert.isFunction(getPrototypeOf);
assert.arity(getPrototypeOf, 1);
assert.name(getPrototypeOf, 'getPrototypeOf');
assert.looksNative(getPrototypeOf);
assert.nonEnumerable(Object, 'getPrototypeOf');
assert.ok(getPrototypeOf({}) === Object.prototype);
assert.ok(getPrototypeOf([]) === Array.prototype);
function F() { /* empty */ }
assert.ok(getPrototypeOf(new F()) === F.prototype);
const object = { q: 1 };
assert.ok(getPrototypeOf(create(object)) === object);
assert.ok(getPrototypeOf(create(null)) === null);
assert.ok(getPrototypeOf(getPrototypeOf({})) === null);
function Foo() { /* empty */ }
Foo.prototype.foo = 'foo';
function Bar() { /* empty */ }
Bar.prototype = create(Foo.prototype);
Bar.prototype.constructor = Bar;
assert.strictEqual(getPrototypeOf(Bar.prototype).foo, 'foo');
const primitives = [42, 'foo', false];
for (const value of primitives) {
assert.notThrows(() => getPrototypeOf(value), `accept ${ typeof value }`);
}
assert.throws(() => getPrototypeOf(null), TypeError, 'throws on null');
assert.throws(() => getPrototypeOf(undefined), TypeError, 'throws on undefined');
assert.strictEqual(getPrototypeOf('foo'), String.prototype);
});
QUnit.test('Object.getPrototypeOf.sham flag', assert => {
assert.same(Object.getPrototypeOf.sham, CORRECT_PROTOTYPE_GETTER ? undefined : true);
});
core-js-3.6.1/tests/tests/es.object.is-extensible.js 0000664 0000000 0000000 00000001302 13600575677 0022367 0 ustar 00root root 0000000 0000000 import { NATIVE } from '../helpers/constants';
QUnit.test('Object.isExtensible', assert => {
const { preventExtensions, isExtensible } = Object;
assert.isFunction(isExtensible);
assert.arity(isExtensible, 1);
assert.name(isExtensible, 'isExtensible');
assert.nonEnumerable(Object, 'isExtensible');
assert.looksNative(isExtensible);
const primitives = [42, 'string', false, null, undefined];
for (const value of primitives) {
assert.notThrows(() => isExtensible(value) || true, `accept ${ value }`);
assert.same(isExtensible(value), false, `returns true on ${ value }`);
}
assert.same(isExtensible({}), true);
if (NATIVE) assert.ok(!isExtensible(preventExtensions({})));
});
core-js-3.6.1/tests/tests/es.object.is-frozen.js 0000664 0000000 0000000 00000001172 13600575677 0021535 0 ustar 00root root 0000000 0000000 import { NATIVE } from '../helpers/constants';
QUnit.test('Object.isFrozen', assert => {
const { freeze, isFrozen } = Object;
assert.isFunction(isFrozen);
assert.arity(isFrozen, 1);
assert.name(isFrozen, 'isFrozen');
assert.looksNative(isFrozen);
assert.nonEnumerable(Object, 'isFrozen');
const primitives = [42, 'string', false, null, undefined];
for (const value of primitives) {
assert.notThrows(() => isFrozen(value) || true, `accept ${ value }`);
assert.same(isFrozen(value), true, `returns true on ${ value }`);
}
assert.same(isFrozen({}), false);
if (NATIVE) assert.ok(isFrozen(freeze({})));
});
core-js-3.6.1/tests/tests/es.object.is-sealed.js 0000664 0000000 0000000 00000001166 13600575677 0021472 0 ustar 00root root 0000000 0000000 import { NATIVE } from '../helpers/constants';
QUnit.test('Object.isSealed', assert => {
const { seal, isSealed } = Object;
assert.isFunction(isSealed);
assert.arity(isSealed, 1);
assert.name(isSealed, 'isSealed');
assert.looksNative(isSealed);
assert.nonEnumerable(Object, 'isSealed');
const primitives = [42, 'string', false, null, undefined];
for (const value of primitives) {
assert.notThrows(() => isSealed(value) || true, `accept ${ value }`);
assert.same(isSealed(value), true, `returns true on ${ value }`);
}
assert.same(isSealed({}), false);
if (NATIVE) assert.ok(isSealed(seal({})));
});
core-js-3.6.1/tests/tests/es.object.is.js 0000664 0000000 0000000 00000000536 13600575677 0020237 0 ustar 00root root 0000000 0000000 QUnit.test('Object.is', assert => {
const { is } = Object;
assert.isFunction(is);
assert.arity(is, 2);
assert.name(is, 'is');
assert.looksNative(is);
assert.nonEnumerable(Object, 'is');
assert.ok(is(1, 1), '1 is 1');
assert.ok(is(NaN, NaN), '1 is 1');
assert.ok(!is(0, -0), '0 isnt -0');
assert.ok(!is({}, {}), '{} isnt {}');
});
core-js-3.6.1/tests/tests/es.object.keys.js 0000664 0000000 0000000 00000001557 13600575677 0020603 0 ustar 00root root 0000000 0000000 import { includes } from '../helpers/helpers';
QUnit.test('Object.keys', assert => {
const { keys } = Object;
assert.isFunction(keys);
assert.arity(keys, 1);
assert.name(keys, 'keys');
assert.looksNative(keys);
assert.nonEnumerable(Object, 'keys');
function F1() {
this.w = 1;
}
function F2() {
this.toString = 1;
}
F1.prototype.q = F2.prototype.q = 1;
assert.deepEqual(keys([1, 2, 3]), ['0', '1', '2']);
assert.deepEqual(keys(new F1()), ['w']);
assert.deepEqual(keys(new F2()), ['toString']);
assert.ok(!includes(keys(Array.prototype), 'push'));
const primitives = [42, 'foo', false];
for (const value of primitives) {
assert.notThrows(() => keys(value), `accept ${ typeof value }`);
}
assert.throws(() => keys(null), TypeError, 'throws on null');
assert.throws(() => keys(undefined), TypeError, 'throws on undefined');
});
core-js-3.6.1/tests/tests/es.object.lookup-getter.js 0000664 0000000 0000000 00000002323 13600575677 0022421 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, STRICT } from '../helpers/constants';
if (DESCRIPTORS) {
QUnit.test('Object#__lookupGetter__', assert => {
const { __lookupGetter__ } = Object.prototype;
const { create } = Object;
assert.isFunction(__lookupGetter__);
assert.arity(__lookupGetter__, 1);
assert.name(__lookupGetter__, '__lookupGetter__');
assert.looksNative(__lookupGetter__);
assert.nonEnumerable(Object.prototype, '__lookupGetter__');
assert.same({}.__lookupGetter__('key'), undefined, 'empty object');
assert.same({ key: 42 }.__lookupGetter__('key'), undefined, 'data descriptor');
const object = {};
function setter() { /* empty */ }
object.__defineGetter__('key', setter);
assert.same(object.__lookupGetter__('key'), setter, 'own getter');
assert.same(create(object).__lookupGetter__('key'), setter, 'proto getter');
assert.same(create(object).__lookupGetter__('foo'), undefined, 'empty proto');
if (STRICT) {
assert.throws(() => __lookupGetter__.call(null, 1, () => { /* empty */ }), TypeError, 'Throws on null as `this`');
assert.throws(() => __lookupGetter__.call(undefined, 1, () => { /* empty */ }), TypeError, 'Throws on undefined as `this`');
}
});
}
core-js-3.6.1/tests/tests/es.object.lookup-setter.js 0000664 0000000 0000000 00000002323 13600575677 0022435 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, STRICT } from '../helpers/constants';
if (DESCRIPTORS) {
QUnit.test('Object#__lookupSetter__', assert => {
const { __lookupSetter__ } = Object.prototype;
const { create } = Object;
assert.isFunction(__lookupSetter__);
assert.arity(__lookupSetter__, 1);
assert.name(__lookupSetter__, '__lookupSetter__');
assert.looksNative(__lookupSetter__);
assert.nonEnumerable(Object.prototype, '__lookupSetter__');
assert.same({}.__lookupSetter__('key'), undefined, 'empty object');
assert.same({ key: 42 }.__lookupSetter__('key'), undefined, 'data descriptor');
const object = {};
function setter() { /* empty */ }
object.__defineSetter__('key', setter);
assert.same(object.__lookupSetter__('key'), setter, 'own getter');
assert.same(create(object).__lookupSetter__('key'), setter, 'proto getter');
assert.same(create(object).__lookupSetter__('foo'), undefined, 'empty proto');
if (STRICT) {
assert.throws(() => __lookupSetter__.call(null, 1, () => { /* empty */ }), TypeError, 'Throws on null as `this`');
assert.throws(() => __lookupSetter__.call(undefined, 1, () => { /* empty */ }), TypeError, 'Throws on undefined as `this`');
}
});
}
core-js-3.6.1/tests/tests/es.object.prevent-extensions.js 0000664 0000000 0000000 00000002373 13600575677 0023505 0 ustar 00root root 0000000 0000000 import { GLOBAL, NATIVE } from '../helpers/constants';
QUnit.test('Object.preventExtensions', assert => {
const { preventExtensions, keys, isExtensible, getOwnPropertyNames, getOwnPropertySymbols } = Object;
const { ownKeys } = GLOBAL.Reflect || {};
assert.isFunction(preventExtensions);
assert.arity(preventExtensions, 1);
assert.name(preventExtensions, 'preventExtensions');
assert.looksNative(preventExtensions);
assert.nonEnumerable(Object, 'preventExtensions');
const data = [42, 'foo', false, null, undefined, {}];
for (const value of data) {
assert.notThrows(() => preventExtensions(value) || true, `accept ${ {}.toString.call(value).slice(8, -1) }`);
assert.same(preventExtensions(value), value, `returns target on ${ {}.toString.call(value).slice(8, -1) }`);
}
if (NATIVE) assert.ok(!isExtensible(preventExtensions({})));
const results = [];
for (const key in preventExtensions({})) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(preventExtensions({})), []);
assert.arrayEqual(getOwnPropertyNames(preventExtensions({})), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(preventExtensions({})), []);
if (ownKeys) assert.arrayEqual(ownKeys(preventExtensions({})), []);
});
core-js-3.6.1/tests/tests/es.object.seal.js 0000664 0000000 0000000 00000002042 13600575677 0020542 0 ustar 00root root 0000000 0000000 import { GLOBAL, NATIVE } from '../helpers/constants';
QUnit.test('Object.seal', assert => {
const { seal, isSealed, keys, getOwnPropertyNames, getOwnPropertySymbols } = Object;
const { ownKeys } = GLOBAL.Reflect || {};
assert.isFunction(seal);
assert.arity(seal, 1);
assert.name(seal, 'seal');
assert.looksNative(seal);
assert.nonEnumerable(Object, 'seal');
const data = [42, 'foo', false, null, undefined, {}];
for (const value of data) {
assert.notThrows(() => seal(value) || true, `accept ${ {}.toString.call(value).slice(8, -1) }`);
assert.same(seal(value), value, `returns target on ${ {}.toString.call(value).slice(8, -1) }`);
}
if (NATIVE) assert.ok(isSealed(seal({})));
const results = [];
for (const key in seal({})) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(seal({})), []);
assert.arrayEqual(getOwnPropertyNames(seal({})), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(seal({})), []);
if (ownKeys) assert.arrayEqual(ownKeys(seal({})), []);
});
core-js-3.6.1/tests/tests/es.object.set-prototype-of.js 0000664 0000000 0000000 00000001437 13600575677 0023065 0 ustar 00root root 0000000 0000000 import { PROTO } from '../helpers/constants';
if (PROTO) QUnit.test('Object.setPrototypeOf', assert => {
const { setPrototypeOf } = Object;
assert.isFunction(setPrototypeOf);
assert.arity(setPrototypeOf, 2);
assert.name(setPrototypeOf, 'setPrototypeOf');
assert.looksNative(setPrototypeOf);
assert.nonEnumerable(Object, 'setPrototypeOf');
assert.ok('apply' in setPrototypeOf({}, Function.prototype), 'Parent properties in target');
assert.strictEqual(setPrototypeOf({ a: 2 }, {
b() {
return this.a ** 2;
},
}).b(), 4, 'Child and parent properties in target');
const object = {};
assert.strictEqual(setPrototypeOf(object, { a: 1 }), object, 'setPrototypeOf return target');
assert.ok(!('toString' in setPrototypeOf({}, null)), 'Can set null as prototype');
});
core-js-3.6.1/tests/tests/es.object.to-string.js 0000664 0000000 0000000 00000006734 13600575677 0021560 0 ustar 00root root 0000000 0000000 import { GLOBAL, STRICT } from '../helpers/constants';
QUnit.test('Object#toString', assert => {
const { toString } = Object.prototype;
const Symbol = GLOBAL.Symbol || {};
assert.arity(toString, 0);
assert.name(toString, 'toString');
assert.looksNative(toString);
assert.nonEnumerable(Object.prototype, 'toString');
if (STRICT) {
assert.strictEqual(toString.call(null), '[object Null]', 'null -> `Null`');
assert.strictEqual(toString.call(undefined), '[object Undefined]', 'undefined -> `Undefined`');
}
assert.strictEqual(toString.call(true), '[object Boolean]', 'bool -> `Boolean`');
assert.strictEqual(toString.call('string'), '[object String]', 'string -> `String`');
assert.strictEqual(toString.call(7), '[object Number]', 'number -> `Number`');
assert.strictEqual(`${ {} }`, '[object Object]', '{} -> `Object`');
assert.strictEqual(toString.call([]), '[object Array]', ' [] -> `Array`');
assert.strictEqual(toString.call(() => { /* empty */ }), '[object Function]', 'function -> `Function`');
assert.strictEqual(toString.call(/./), '[object RegExp]', 'regexp -> `RegExp`');
assert.strictEqual(toString.call(new TypeError()), '[object Error]', 'new TypeError -> `Error`');
assert.strictEqual(toString.call(function () {
return arguments;
}()), '[object Arguments]', 'arguments -> `Arguments`');
const constructors = [
'Array',
'RegExp',
'Boolean',
'String',
'Number',
'Error',
'Int8Array',
'Uint8Array',
'Uint8ClampedArray',
'Int16Array',
'Uint16Array',
'Int32Array',
'Uint32Array',
'Float32Array',
'Float64Array',
'ArrayBuffer',
];
for (const name of constructors) {
const Constructor = GLOBAL[name];
if (Constructor) {
assert.strictEqual(toString.call(new Constructor(1)), `[object ${ name }]`, `new ${ name }(1) -> \`${ name }\``);
}
}
if (GLOBAL.DataView) {
assert.strictEqual(`${ new DataView(new ArrayBuffer(1)) }`, '[object DataView]', 'dataview -> `DataView`');
}
if (GLOBAL.Set) {
assert.strictEqual(`${ new Set() }`, '[object Set]', 'set -> `Set`');
}
if (GLOBAL.Map) {
assert.strictEqual(`${ new Map() }`, '[object Map]', 'map -> `Map`');
}
if (GLOBAL.WeakSet) {
assert.strictEqual(`${ new WeakSet() }`, '[object WeakSet]', 'weakset -> `WeakSet`');
}
if (GLOBAL.WeakMap) {
assert.strictEqual(`${ new WeakMap() }`, '[object WeakMap]', 'weakmap -> `WeakMap`');
}
if (GLOBAL.Promise) {
assert.strictEqual(`${ new Promise((() => { /* empty */ })) }`, '[object Promise]', 'promise -> `Promise`');
}
if (''[Symbol.iterator]) {
assert.strictEqual(`${ ''[Symbol.iterator]() }`, '[object String Iterator]', 'String Iterator -> `String Iterator`');
}
if ([].entries) {
assert.strictEqual(`${ [].entries() }`, '[object Array Iterator]', 'Array Iterator -> `Array Iterator`');
}
if (GLOBAL.Set && Set.entries) {
assert.strictEqual(`${ new Set().entries() }`, '[object Set Iterator]', 'Set Iterator -> `Set Iterator`');
}
if (GLOBAL.Map && Map.entries) {
assert.strictEqual(`${ new Map().entries() }`, '[object Map Iterator]', 'Map Iterator -> `Map Iterator`');
}
assert.strictEqual(`${ Math }`, '[object Math]', 'Math -> `Math`');
if (GLOBAL.JSON) {
assert.strictEqual(`${ JSON }`, '[object JSON]', 'JSON -> `JSON`');
}
function Class() { /* empty */ }
Class.prototype[Symbol.toStringTag] = 'Class';
assert.strictEqual(`${ new Class() }`, '[object Class]', 'user class instance -> [Symbol.toStringTag]');
});
core-js-3.6.1/tests/tests/es.object.values.js 0000664 0000000 0000000 00000001775 13600575677 0021131 0 ustar 00root root 0000000 0000000 QUnit.test('Object.values', assert => {
const { values, create, assign } = Object;
assert.isFunction(values);
assert.arity(values, 1);
assert.name(values, 'values');
assert.looksNative(values);
assert.nonEnumerable(Object, 'values');
assert.deepEqual(values({ q: 1, w: 2, e: 3 }), [1, 2, 3]);
assert.deepEqual(values(new String('qwe')), ['q', 'w', 'e']);
assert.deepEqual(values(assign(create({ q: 1, w: 2, e: 3 }), { a: 4, s: 5, d: 6 })), [4, 5, 6]);
assert.deepEqual(values({ valueOf: 42 }), [42], 'IE enum keys bug');
try {
assert.deepEqual(Function('values', `
return values({ a: 1, get b() {
delete this.c;
return 2;
}, c: 3 });
`)(values), [1, 2]);
} catch { /* empty */ }
try {
assert.deepEqual(Function('values', `
return values({ a: 1, get b() {
Object.defineProperty(this, "c", {
value: 4,
enumerable: false
});
return 2;
}, c: 3 });
`)(values), [1, 2]);
} catch { /* empty */ }
});
core-js-3.6.1/tests/tests/es.parse-float.js 0000664 0000000 0000000 00000001176 13600575677 0020575 0 ustar 00root root 0000000 0000000 import { WHITESPACES } from '../helpers/constants';
QUnit.test('parseFloat', assert => {
assert.isFunction(parseFloat);
assert.name(parseFloat, 'parseFloat');
assert.arity(parseFloat, 1);
assert.looksNative(parseFloat);
assert.same(parseFloat('0'), 0);
assert.same(parseFloat(' 0'), 0);
assert.same(parseFloat('+0'), 0);
assert.same(parseFloat(' +0'), 0);
assert.same(parseFloat('-0'), -0);
assert.same(parseFloat(' -0'), -0);
assert.same(parseFloat(`${ WHITESPACES }+0`), 0);
assert.same(parseFloat(`${ WHITESPACES }-0`), -0);
assert.same(parseFloat(null), NaN);
assert.same(parseFloat(undefined), NaN);
});
core-js-3.6.1/tests/tests/es.parse-int.js 0000664 0000000 0000000 00000003223 13600575677 0020255 0 ustar 00root root 0000000 0000000 import { WHITESPACES } from '../helpers/constants';
/* eslint-disable radix */
QUnit.test('parseInt', assert => {
assert.isFunction(parseInt);
assert.name(parseInt, 'parseInt');
assert.arity(parseInt, 2);
assert.looksNative(parseInt);
for (let radix = 2; radix <= 36; ++radix) {
assert.same(parseInt('10', radix), radix, `radix ${ radix }`);
}
const strings = ['01', '08', '10', '42'];
for (const string of strings) {
assert.same(parseInt(string), parseInt(string, 10), `default radix is 10: ${ string }`);
}
assert.same(parseInt('0x16'), parseInt('0x16', 16), 'default radix is 16: 0x16');
assert.same(parseInt(' 0x16'), parseInt('0x16', 16), 'ignores leading whitespace #1');
assert.same(parseInt(' 42'), parseInt('42', 10), 'ignores leading whitespace #2');
assert.same(parseInt(' 08'), parseInt('08', 10), 'ignores leading whitespace #3');
assert.same(parseInt(`${ WHITESPACES }08`), parseInt('08', 10), 'ignores leading whitespace #4');
assert.same(parseInt(`${ WHITESPACES }0x16`), parseInt('0x16', 16), 'ignores leading whitespace #5');
const fakeZero = {
valueOf() {
return 0;
},
};
assert.same(parseInt('08', fakeZero), parseInt('08', 10), 'valueOf #1');
assert.same(parseInt('0x16', fakeZero), parseInt('0x16', 16), 'valueOf #2');
assert.same(parseInt('-0xF'), -15, 'signed hex #1');
assert.same(parseInt('-0xF', 16), -15, 'signed hex #2');
assert.same(parseInt('+0xF'), 15, 'signed hex #3');
assert.same(parseInt('+0xF', 16), 15, 'signed hex #4');
assert.same(parseInt('10', -4294967294), 2, 'radix uses ToUint32');
assert.same(parseInt(null), NaN);
assert.same(parseInt(undefined), NaN);
});
core-js-3.6.1/tests/tests/es.promise.all-settled.js 0000664 0000000 0000000 00000001665 13600575677 0022252 0 ustar 00root root 0000000 0000000 QUnit.test('Promise.allSettled', assert => {
assert.isFunction(Promise.allSettled);
assert.arity(Promise.allSettled, 1);
assert.looksNative(Promise.allSettled);
assert.nonEnumerable(Promise, 'allSettled');
assert.ok(Promise.allSettled([1, 2, 3]) instanceof Promise, 'returns a promise');
});
QUnit.test('Promise.allSettled, resolved', assert => {
assert.expect(1);
const async = assert.async();
Promise.allSettled([
Promise.resolve(1),
Promise.reject(2),
Promise.resolve(3),
]).then(it => {
assert.deepEqual(it, [
{ value: 1, status: 'fulfilled' },
{ reason: 2, status: 'rejected' },
{ value: 3, status: 'fulfilled' },
], 'resolved with a correct value');
async();
});
});
QUnit.test('Promise.allSettled, rejected', assert => {
assert.expect(1);
const async = assert.async();
Promise.allSettled().catch(() => {
assert.ok(true, 'rejected as expected');
async();
});
});
core-js-3.6.1/tests/tests/es.promise.finally.js 0000664 0000000 0000000 00000003572 13600575677 0021475 0 ustar 00root root 0000000 0000000 QUnit.test('Promise#finally', assert => {
assert.isFunction(Promise.prototype.finally);
assert.arity(Promise.prototype.finally, 1);
assert.looksNative(Promise.prototype.finally);
assert.nonEnumerable(Promise.prototype, 'finally');
assert.ok(Promise.resolve(42).finally(() => { /* empty */ }) instanceof Promise, 'returns a promise');
});
QUnit.test('Promise#finally, resolved', assert => {
assert.expect(3);
const async = assert.async();
let called = 0;
let argument = null;
Promise.resolve(42).finally(it => {
called++;
argument = it;
}).then(it => {
assert.same(it, 42, 'resolved with a correct value');
assert.same(called, 1, 'onFinally function called one time');
assert.same(argument, undefined, 'onFinally function called with a correct argument');
async();
});
});
QUnit.test('Promise#finally, rejected', assert => {
assert.expect(2);
const async = assert.async();
let called = 0;
let argument = null;
Promise.reject(42).finally(it => {
called++;
argument = it;
}).catch(() => {
assert.same(called, 1, 'onFinally function called one time');
assert.same(argument, undefined, 'onFinally function called with a correct argument');
async();
});
});
const promise = (() => {
try {
return Function('return (async function () { /* empty */ })()')();
} catch { /* empty */ }
})();
if (promise && promise.constructor !== Promise) QUnit.test('Native Promise, patched', assert => {
assert.isFunction(promise.finally);
assert.arity(promise.finally, 1);
assert.looksNative(promise.finally);
assert.nonEnumerable(promise.constructor.prototype, 'finally');
function empty() { /* empty */ }
assert.ok(promise.finally(empty) instanceof Promise, '`.finally` returns `Promise` instance #1');
assert.ok(new promise.constructor(empty).finally(empty) instanceof Promise, '`.finally` returns `Promise` instance #2');
});
core-js-3.6.1/tests/tests/es.promise.js 0000664 0000000 0000000 00000041244 13600575677 0020036 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, NATIVE, PROTO, STRICT } from '../helpers/constants';
import { createIterable } from '../helpers/helpers';
const Symbol = GLOBAL.Symbol || {};
const { setPrototypeOf, create } = Object;
QUnit.test('Promise', assert => {
assert.isFunction(Promise);
assert.arity(Promise, 1);
assert.name(Promise, 'Promise');
assert.looksNative(Promise);
assert.throws(() => {
Promise();
}, 'throws w/o `new`');
new Promise(function (resolve, reject) {
assert.isFunction(resolve, 'resolver is function');
assert.isFunction(reject, 'rejector is function');
if (STRICT) assert.same(this, undefined, 'correct executor context');
});
});
if (DESCRIPTORS) QUnit.test('Promise operations order', assert => {
let resolve, resolve2;
assert.expect(1);
const EXPECTED_ORDER = 'DEHAFGBC';
const async = assert.async();
let result = '';
const promise1 = new Promise(r => {
resolve = r;
});
resolve({
then() {
result += 'A';
throw Error();
},
});
promise1.catch(() => {
result += 'B';
});
promise1.catch(() => {
result += 'C';
assert.same(result, EXPECTED_ORDER);
async();
});
const promise2 = new Promise(r => {
resolve2 = r;
});
resolve2(Object.defineProperty({}, 'then', {
get() {
result += 'D';
throw Error();
},
}));
result += 'E';
promise2.catch(() => {
result += 'F';
});
promise2.catch(() => {
result += 'G';
});
result += 'H';
setTimeout(() => {
if (!~result.indexOf('C')) {
assert.same(result, EXPECTED_ORDER);
async();
}
}, 1e3);
});
QUnit.test('Promise#then', assert => {
assert.isFunction(Promise.prototype.then);
if (NATIVE) assert.arity(Promise.prototype.then, 2);
assert.name(Promise.prototype.then, 'then');
assert.looksNative(Promise.prototype.then);
assert.nonEnumerable(Promise.prototype, 'then');
let promise = new Promise(resolve => {
resolve(42);
});
let FakePromise1 = promise.constructor = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
const FakePromise2 = FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
assert.ok(promise.then(() => { /* empty */ }) instanceof FakePromise2, 'subclassing, @@species pattern');
promise = new Promise(resolve => {
resolve(42);
});
promise.constructor = FakePromise1 = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
assert.ok(promise.then(() => { /* empty */ }) instanceof Promise, 'subclassing, incorrect `this` pattern');
promise = new Promise(resolve => {
resolve(42);
});
promise.constructor = FakePromise1 = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
FakePromise1[Symbol.species] = function () { /* empty */ };
assert.throws(() => {
promise.then(() => { /* empty */ });
}, 'NewPromiseCapability validations, #1');
FakePromise1[Symbol.species] = function (executor) {
executor(null, () => { /* empty */ });
};
assert.throws(() => {
promise.then(() => { /* empty */ });
}, 'NewPromiseCapability validations, #2');
FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, null);
};
assert.throws(() => {
promise.then(() => { /* empty */ });
}, 'NewPromiseCapability validations, #3');
});
QUnit.test('Promise#catch', assert => {
assert.isFunction(Promise.prototype.catch);
if (NATIVE) assert.arity(Promise.prototype.catch, 1);
if (NATIVE) assert.name(Promise.prototype.catch, 'catch');
assert.looksNative(Promise.prototype.catch);
assert.nonEnumerable(Promise.prototype, 'catch');
let promise = new Promise(resolve => {
resolve(42);
});
let FakePromise1 = promise.constructor = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
const FakePromise2 = FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
assert.ok(promise.catch(() => { /* empty */ }) instanceof FakePromise2, 'subclassing, @@species pattern');
promise = new Promise(resolve => {
resolve(42);
});
promise.constructor = FakePromise1 = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
assert.ok(promise.catch(() => { /* empty */ }) instanceof Promise, 'subclassing, incorrect `this` pattern');
promise = new Promise(resolve => {
resolve(42);
});
promise.constructor = FakePromise1 = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
FakePromise1[Symbol.species] = function () { /* empty */ };
assert.throws(() => {
promise.catch(() => { /* empty */ });
}, 'NewPromiseCapability validations, #1');
FakePromise1[Symbol.species] = function (executor) {
executor(null, () => { /* empty */ });
};
assert.throws(() => {
promise.catch(() => { /* empty */ });
}, 'NewPromiseCapability validations, #2');
FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, null);
};
assert.throws(() => {
promise.catch(() => { /* empty */ });
}, 'NewPromiseCapability validations, #3');
assert.same(Promise.prototype.catch.call({
then(x, y) {
return y;
},
}, 42), 42, 'calling `.then`');
});
QUnit.test('Promise#@@toStringTag', assert => {
assert.ok(Promise.prototype[Symbol.toStringTag] === 'Promise', 'Promise::@@toStringTag is `Promise`');
assert.strictEqual(String(new Promise(() => { /* empty */ })), '[object Promise]', 'correct stringification');
});
QUnit.test('Promise.all', assert => {
let FakePromise1, FakePromise2;
const { all, resolve } = Promise;
assert.isFunction(all);
assert.arity(all, 1);
assert.name(all, 'all');
assert.looksNative(all);
assert.nonEnumerable(Promise, 'all');
const iterable = createIterable([1, 2, 3]);
Promise.all(iterable).catch(() => { /* empty */ });
assert.ok(iterable.received, 'works with iterables: iterator received');
assert.ok(iterable.called, 'works with iterables: next called');
const array = [];
let done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return [][Symbol.iterator].call(this);
};
Promise.all(array);
assert.ok(done);
assert.throws(() => {
all.call(null, []).catch(() => { /* empty */ });
}, TypeError, 'throws without context');
done = false;
try {
Promise.resolve = function () {
throw new Error();
};
Promise.all(createIterable([1, 2, 3], {
return() {
done = true;
},
})).catch(() => { /* empty */ });
} catch (error) { /* empty */ }
Promise.resolve = resolve;
assert.ok(done, 'iteration closing');
FakePromise1 = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
FakePromise2 = FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
FakePromise1.resolve = FakePromise2.resolve = Promise.resolve.bind(Promise);
assert.ok(all.call(FakePromise1, [1, 2, 3]) instanceof FakePromise1, 'subclassing, `this` pattern');
FakePromise1 = function () { /* empty */ };
FakePromise2 = function (executor) {
executor(null, () => { /* empty */ });
};
const FakePromise3 = function (executor) {
executor(() => { /* empty */ }, null);
};
FakePromise1.resolve = FakePromise2.resolve = FakePromise3.resolve = Promise.resolve.bind(Promise);
assert.throws(() => {
all.call(FakePromise1, [1, 2, 3]);
}, 'NewPromiseCapability validations, #1');
assert.throws(() => {
all.call(FakePromise2, [1, 2, 3]);
}, 'NewPromiseCapability validations, #2');
assert.throws(() => {
all.call(FakePromise3, [1, 2, 3]);
}, 'NewPromiseCapability validations, #3');
});
QUnit.test('Promise.race', assert => {
let FakePromise1, FakePromise2;
const { race, resolve } = Promise;
assert.isFunction(race);
assert.arity(race, 1);
assert.name(race, 'race');
assert.looksNative(race);
assert.nonEnumerable(Promise, 'race');
const iterable = createIterable([1, 2, 3]);
Promise.race(iterable).catch(() => { /* empty */ });
assert.ok(iterable.received, 'works with iterables: iterator received');
assert.ok(iterable.called, 'works with iterables: next called');
const array = [];
let done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return [][Symbol.iterator].call(this);
};
Promise.race(array);
assert.ok(done);
assert.throws(() => {
race.call(null, []).catch(() => { /* empty */ });
}, TypeError, 'throws without context');
done = false;
try {
Promise.resolve = function () {
throw new Error();
};
Promise.race(createIterable([1, 2, 3], {
return() {
done = true;
},
})).catch(() => { /* empty */ });
} catch (error) { /* empty */ }
Promise.resolve = resolve;
assert.ok(done, 'iteration closing');
FakePromise1 = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
FakePromise2 = FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
FakePromise1.resolve = FakePromise2.resolve = Promise.resolve.bind(Promise);
assert.ok(race.call(FakePromise1, [1, 2, 3]) instanceof FakePromise1, 'subclassing, `this` pattern');
FakePromise1 = function () { /* empty */ };
FakePromise2 = function (executor) {
executor(null, () => { /* empty */ });
};
const FakePromise3 = function (executor) {
executor(() => { /* empty */ }, null);
};
FakePromise1.resolve = FakePromise2.resolve = FakePromise3.resolve = Promise.resolve.bind(Promise);
assert.throws(() => {
race.call(FakePromise1, [1, 2, 3]);
}, 'NewPromiseCapability validations, #1');
assert.throws(() => {
race.call(FakePromise2, [1, 2, 3]);
}, 'NewPromiseCapability validations, #2');
assert.throws(() => {
race.call(FakePromise3, [1, 2, 3]);
}, 'NewPromiseCapability validations, #3');
});
QUnit.test('Promise.resolve', assert => {
const { resolve } = Promise;
assert.isFunction(resolve);
if (NATIVE) assert.arity(resolve, 1);
assert.name(resolve, 'resolve');
assert.looksNative(resolve);
assert.nonEnumerable(Promise, 'resolve');
assert.throws(() => {
resolve.call(null, 1).catch(() => { /* empty */ });
}, TypeError, 'throws without context');
function FakePromise1(executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
}
FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
assert.ok(resolve.call(FakePromise1, 42) instanceof FakePromise1, 'subclassing, `this` pattern');
assert.throws(() => {
resolve.call(() => { /* empty */ }, 42);
}, 'NewPromiseCapability validations, #1');
assert.throws(() => {
resolve.call(executor => {
executor(null, () => { /* empty */ });
}, 42);
}, 'NewPromiseCapability validations, #2');
assert.throws(() => {
resolve.call(executor => {
executor(() => { /* empty */ }, null);
}, 42);
}, 'NewPromiseCapability validations, #3');
});
QUnit.test('Promise.reject', assert => {
const { reject } = Promise;
assert.isFunction(reject);
if (NATIVE) assert.arity(reject, 1);
assert.name(reject, 'reject');
assert.looksNative(reject);
assert.nonEnumerable(Promise, 'reject');
assert.throws(() => {
reject.call(null, 1).catch(() => { /* empty */ });
}, TypeError, 'throws without context');
function FakePromise1(executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
}
FakePromise1[Symbol.species] = function (executor) {
executor(() => { /* empty */ }, () => { /* empty */ });
};
assert.ok(reject.call(FakePromise1, 42) instanceof FakePromise1, 'subclassing, `this` pattern');
assert.throws(() => {
reject.call(() => { /* empty */ }, 42);
}, 'NewPromiseCapability validations, #1');
assert.throws(() => {
reject.call(executor => {
executor(null, () => { /* empty */ });
}, 42);
}, 'NewPromiseCapability validations, #2');
assert.throws(() => {
reject.call(executor => {
executor(() => { /* empty */ }, null);
}, 42);
}, 'NewPromiseCapability validations, #3');
});
if (PROTO) QUnit.test('Promise subclassing', assert => {
function SubPromise(executor) {
const self = new Promise(executor);
setPrototypeOf(self, SubPromise.prototype);
self.mine = 'subclass';
return self;
}
setPrototypeOf(SubPromise, Promise);
SubPromise.prototype = create(Promise.prototype);
SubPromise.prototype.constructor = SubPromise;
let promise1 = SubPromise.resolve(5);
assert.strictEqual(promise1.mine, 'subclass');
promise1 = promise1.then(it => {
assert.strictEqual(it, 5);
});
assert.strictEqual(promise1.mine, 'subclass');
let promise2 = new SubPromise(resolve => {
resolve(6);
});
assert.strictEqual(promise2.mine, 'subclass');
promise2 = promise2.then(it => {
assert.strictEqual(it, 6);
});
assert.strictEqual(promise2.mine, 'subclass');
const promise3 = SubPromise.all([promise1, promise2]);
assert.strictEqual(promise3.mine, 'subclass');
assert.ok(promise3 instanceof Promise);
assert.ok(promise3 instanceof SubPromise);
promise3.then(assert.async(), it => {
assert.ok(it, false);
});
});
// qunit@2.5 strange bug
QUnit.skip('Unhandled rejection tracking', assert => {
let done = false;
const resume = assert.async();
if (GLOBAL.process) {
assert.expect(3);
function onunhandledrejection(reason, promise) {
process.removeListener('unhandledRejection', onunhandledrejection);
assert.same(promise, $promise, 'unhandledRejection, promise');
assert.same(reason, 42, 'unhandledRejection, reason');
$promise.catch(() => {
// empty
});
}
function onrejectionhandled(promise) {
process.removeListener('rejectionHandled', onrejectionhandled);
assert.same(promise, $promise, 'rejectionHandled, promise');
done || resume();
done = true;
}
process.on('unhandledRejection', onunhandledrejection);
process.on('rejectionHandled', onrejectionhandled);
} else {
if (GLOBAL.addEventListener) {
assert.expect(8);
function onunhandledrejection(it) {
assert.same(it.promise, $promise, 'addEventListener(unhandledrejection), promise');
assert.same(it.reason, 42, 'addEventListener(unhandledrejection), reason');
GLOBAL.removeEventListener('unhandledrejection', onunhandledrejection);
}
GLOBAL.addEventListener('rejectionhandled', onunhandledrejection);
function onrejectionhandled(it) {
assert.same(it.promise, $promise, 'addEventListener(rejectionhandled), promise');
assert.same(it.reason, 42, 'addEventListener(rejectionhandled), reason');
GLOBAL.removeEventListener('rejectionhandled', onrejectionhandled);
}
GLOBAL.addEventListener('rejectionhandled', onrejectionhandled);
} else assert.expect(4);
GLOBAL.onunhandledrejection = function (it) {
assert.same(it.promise, $promise, 'onunhandledrejection, promise');
assert.same(it.reason, 42, 'onunhandledrejection, reason');
setTimeout(() => {
$promise.catch(() => {
// empty
});
}, 1);
GLOBAL.onunhandledrejection = null;
};
GLOBAL.onrejectionhandled = function (it) {
assert.same(it.promise, $promise, 'onrejectionhandled, promise');
assert.same(it.reason, 42, 'onrejectionhandled, reason');
GLOBAL.onrejectionhandled = null;
done || resume();
done = true;
};
}
Promise.reject(43).catch(() => {
// empty
});
const $promise = Promise.reject(42);
setTimeout(() => {
done || resume();
done = true;
}, 3e3);
});
const promise = (() => {
try {
return Function('return (async function () { /* empty */ })()')();
} catch { /* empty */ }
})();
if (promise && promise.constructor !== Promise) QUnit.test('Native Promise, patched', assert => {
assert.isFunction(promise.then);
assert.arity(promise.then, 2);
assert.looksNative(promise.then);
assert.nonEnumerable(promise.constructor.prototype, 'then');
function empty() { /* empty */ }
assert.ok(promise.then(empty) instanceof Promise, '`.then` returns `Promise` instance #1');
assert.ok(new promise.constructor(empty).then(empty) instanceof Promise, '`.then` returns `Promise` instance #2');
assert.ok(promise.catch(empty) instanceof Promise, '`.catch` returns `Promise` instance #1');
assert.ok(new promise.constructor(empty).catch(empty) instanceof Promise, '`.catch` returns `Promise` instance #2');
assert.ok(promise.finally(empty) instanceof Promise, '`.finally` returns `Promise` instance #1');
assert.ok(new promise.constructor(empty).finally(empty) instanceof Promise, '`.finally` returns `Promise` instance #2');
});
core-js-3.6.1/tests/tests/es.reflect.apply.js 0000664 0000000 0000000 00000001403 13600575677 0021121 0 ustar 00root root 0000000 0000000 QUnit.test('Reflect.apply', assert => {
const { apply } = Reflect;
assert.isFunction(apply);
assert.arity(apply, 3);
assert.name(apply, 'apply');
assert.looksNative(apply);
assert.nonEnumerable(Reflect, 'apply');
assert.strictEqual(apply(Array.prototype.push, [1, 2], [3, 4, 5]), 5);
function f(a, b, c) {
return a + b + c;
}
f.apply = 42;
assert.strictEqual(apply(f, null, ['foo', 'bar', 'baz']), 'foobarbaz', 'works with redefined apply');
assert.throws(() => apply(42, null, []), TypeError, 'throws on primitive');
assert.throws(() => apply(() => { /* empty */ }, null), TypeError, 'throws without third argument');
assert.throws(() => apply(() => { /* empty */ }, null, '123'), TypeError, 'throws on primitive as third argument');
});
core-js-3.6.1/tests/tests/es.reflect.construct.js 0000664 0000000 0000000 00000002301 13600575677 0022016 0 ustar 00root root 0000000 0000000 QUnit.test('Reflect.construct', assert => {
const { construct } = Reflect;
const { getPrototypeOf } = Object;
assert.isFunction(construct);
assert.arity(construct, 2);
assert.name(construct, 'construct');
assert.looksNative(construct);
assert.nonEnumerable(Reflect, 'construct');
function A(a, b, c) {
this.qux = a + b + c;
}
assert.strictEqual(construct(A, ['foo', 'bar', 'baz']).qux, 'foobarbaz', 'basic');
A.apply = 42;
assert.strictEqual(construct(A, ['foo', 'bar', 'baz']).qux, 'foobarbaz', 'works with redefined apply');
const instance = construct(function () {
this.x = 42;
}, [], Array);
assert.strictEqual(instance.x, 42, 'constructor with newTarget');
assert.ok(instance instanceof Array, 'prototype with newTarget');
assert.throws(() => construct(42, []), TypeError, 'throws on primitive');
function B() { /* empty */ }
B.prototype = 42;
assert.notThrows(() => getPrototypeOf(construct(B, [])) === Object.prototype);
assert.notThrows(() => typeof construct(Date, []).getTime() == 'number', 'works with native constructors with 2 arguments');
assert.throws(() => construct(() => { /* empty */ }), 'throws when the second argument is not an object');
});
core-js-3.6.1/tests/tests/es.reflect.define-property.js 0000664 0000000 0000000 00000002460 13600575677 0023114 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Reflect.defineProperty', assert => {
const { defineProperty } = Reflect;
const { getOwnPropertyDescriptor, create } = Object;
assert.isFunction(defineProperty);
assert.arity(defineProperty, 3);
assert.name(defineProperty, 'defineProperty');
assert.looksNative(defineProperty);
assert.nonEnumerable(Reflect, 'defineProperty');
let object = {};
assert.strictEqual(defineProperty(object, 'foo', { value: 123 }), true);
assert.strictEqual(object.foo, 123);
if (DESCRIPTORS) {
object = {};
defineProperty(object, 'foo', {
value: 123,
enumerable: true,
});
assert.deepEqual(getOwnPropertyDescriptor(object, 'foo'), {
value: 123,
enumerable: true,
configurable: false,
writable: false,
});
assert.strictEqual(defineProperty(object, 'foo', {
value: 42,
}), false);
}
assert.throws(() => defineProperty(42, 'foo', {
value: 42,
}), TypeError, 'throws on primitive');
assert.throws(() => defineProperty(42, 1, {}));
assert.throws(() => defineProperty({}, create(null), {}));
assert.throws(() => defineProperty({}, 1, 1));
});
QUnit.test('Reflect.defineProperty.sham flag', assert => {
assert.same(Reflect.defineProperty.sham, DESCRIPTORS ? undefined : true);
});
core-js-3.6.1/tests/tests/es.reflect.delete-property.js 0000664 0000000 0000000 00000001347 13600575677 0023127 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Reflect.deleteProperty', assert => {
const { deleteProperty } = Reflect;
const { defineProperty, keys } = Object;
assert.isFunction(deleteProperty);
assert.arity(deleteProperty, 2);
assert.name(deleteProperty, 'deleteProperty');
assert.looksNative(deleteProperty);
assert.nonEnumerable(Reflect, 'deleteProperty');
const object = { bar: 456 };
assert.strictEqual(deleteProperty(object, 'bar'), true);
assert.ok(keys(object).length === 0);
if (DESCRIPTORS) {
assert.strictEqual(deleteProperty(defineProperty({}, 'foo', {
value: 42,
}), 'foo'), false);
}
assert.throws(() => deleteProperty(42, 'foo'), TypeError, 'throws on primitive');
});
core-js-3.6.1/tests/tests/es.reflect.get-own-property-descriptor.js 0000664 0000000 0000000 00000001502 13600575677 0025412 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Reflect.getOwnPropertyDescriptor', assert => {
const { getOwnPropertyDescriptor } = Reflect;
assert.isFunction(getOwnPropertyDescriptor);
assert.arity(getOwnPropertyDescriptor, 2);
assert.name(getOwnPropertyDescriptor, 'getOwnPropertyDescriptor');
assert.looksNative(getOwnPropertyDescriptor);
assert.nonEnumerable(Reflect, 'getOwnPropertyDescriptor');
const object = { baz: 789 };
const descriptor = getOwnPropertyDescriptor(object, 'baz');
assert.strictEqual(descriptor.value, 789);
assert.throws(() => getOwnPropertyDescriptor(42, 'constructor'), TypeError, 'throws on primitive');
});
QUnit.test('Reflect.getOwnPropertyDescriptor.sham flag', assert => {
assert.same(Reflect.getOwnPropertyDescriptor.sham, DESCRIPTORS ? undefined : true);
});
core-js-3.6.1/tests/tests/es.reflect.get-prototype-of.js 0000664 0000000 0000000 00000001220 13600575677 0023215 0 ustar 00root root 0000000 0000000 import { CORRECT_PROTOTYPE_GETTER } from '../helpers/constants';
QUnit.test('Reflect.getPrototypeOf', assert => {
const { getPrototypeOf } = Reflect;
assert.isFunction(getPrototypeOf);
assert.arity(getPrototypeOf, 1);
assert.name(getPrototypeOf, 'getPrototypeOf');
assert.looksNative(getPrototypeOf);
assert.nonEnumerable(Reflect, 'getPrototypeOf');
assert.strictEqual(getPrototypeOf([]), Array.prototype);
assert.throws(() => getPrototypeOf(42), TypeError, 'throws on primitive');
});
QUnit.test('Reflect.getPrototypeOf.sham flag', assert => {
assert.same(Reflect.getPrototypeOf.sham, CORRECT_PROTOTYPE_GETTER ? undefined : true);
});
core-js-3.6.1/tests/tests/es.reflect.get.js 0000664 0000000 0000000 00000002076 13600575677 0020562 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, NATIVE } from '../helpers/constants';
QUnit.test('Reflect.get', assert => {
const { defineProperty, create } = Object;
const { get } = Reflect;
assert.isFunction(get);
if (NATIVE) assert.arity(get, 2);
assert.name(get, 'get');
assert.looksNative(get);
assert.nonEnumerable(Reflect, 'get');
assert.strictEqual(get({ qux: 987 }, 'qux'), 987);
if (DESCRIPTORS) {
const target = create(defineProperty({ z: 3 }, 'w', {
get() {
return this;
},
}), {
x: {
value: 1,
},
y: {
get() {
return this;
},
},
});
const receiver = {};
assert.strictEqual(get(target, 'x', receiver), 1, 'get x');
assert.strictEqual(get(target, 'y', receiver), receiver, 'get y');
assert.strictEqual(get(target, 'z', receiver), 3, 'get z');
assert.strictEqual(get(target, 'w', receiver), receiver, 'get w');
assert.strictEqual(get(target, 'u', receiver), undefined, 'get u');
}
assert.throws(() => get(42, 'constructor'), TypeError, 'throws on primitive');
});
core-js-3.6.1/tests/tests/es.reflect.has.js 0000664 0000000 0000000 00000000733 13600575677 0020554 0 ustar 00root root 0000000 0000000 QUnit.test('Reflect.has', assert => {
const { has } = Reflect;
assert.isFunction(has);
assert.arity(has, 2);
assert.name(has, 'has');
assert.looksNative(has);
assert.nonEnumerable(Reflect, 'has');
const object = { qux: 987 };
assert.strictEqual(has(object, 'qux'), true);
assert.strictEqual(has(object, 'qwe'), false);
assert.strictEqual(has(object, 'toString'), true);
assert.throws(() => has(42, 'constructor'), TypeError, 'throws on primitive');
});
core-js-3.6.1/tests/tests/es.reflect.is-extensible.js 0000664 0000000 0000000 00000001063 13600575677 0022551 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Reflect.isExtensible', assert => {
const { isExtensible } = Reflect;
const { preventExtensions } = Object;
assert.isFunction(isExtensible);
assert.arity(isExtensible, 1);
assert.name(isExtensible, 'isExtensible');
assert.looksNative(isExtensible);
assert.nonEnumerable(Reflect, 'isExtensible');
assert.ok(isExtensible({}));
if (DESCRIPTORS) {
assert.ok(!isExtensible(preventExtensions({})));
}
assert.throws(() => isExtensible(42), TypeError, 'throws on primitive');
});
core-js-3.6.1/tests/tests/es.reflect.own-keys.js 0000664 0000000 0000000 00000001711 13600575677 0021552 0 ustar 00root root 0000000 0000000 import { includes } from '../helpers/helpers';
QUnit.test('Reflect.ownKeys', assert => {
const { ownKeys } = Reflect;
const { defineProperty, create } = Object;
const symbol = Symbol('c');
assert.isFunction(ownKeys);
assert.arity(ownKeys, 1);
assert.name(ownKeys, 'ownKeys');
assert.looksNative(ownKeys);
assert.nonEnumerable(Reflect, 'ownKeys');
const object = { a: 1 };
defineProperty(object, 'b', {
value: 2,
});
object[symbol] = 3;
let keys = ownKeys(object);
assert.strictEqual(keys.length, 3, 'ownKeys return all own keys');
assert.ok(includes(keys, 'a'), 'ownKeys return all own keys: simple');
assert.ok(includes(keys, 'b'), 'ownKeys return all own keys: hidden');
assert.strictEqual(object[keys[2]], 3, 'ownKeys return all own keys: symbol');
keys = ownKeys(create(object));
assert.strictEqual(keys.length, 0, 'ownKeys return only own keys');
assert.throws(() => ownKeys(42), TypeError, 'throws on primitive');
});
core-js-3.6.1/tests/tests/es.reflect.prevent-extensions.js 0000664 0000000 0000000 00000001410 13600575677 0023652 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, FREEZING } from '../helpers/constants';
QUnit.test('Reflect.preventExtensions', assert => {
const { preventExtensions } = Reflect;
const { isExtensible } = Object;
assert.isFunction(preventExtensions);
assert.arity(preventExtensions, 1);
assert.name(preventExtensions, 'preventExtensions');
assert.looksNative(preventExtensions);
assert.nonEnumerable(Reflect, 'preventExtensions');
const object = {};
assert.ok(preventExtensions(object), true);
if (DESCRIPTORS) {
assert.ok(!isExtensible(object));
}
assert.throws(() => preventExtensions(42), TypeError, 'throws on primitive');
});
QUnit.test('Reflect.preventExtensions.sham flag', assert => {
assert.same(Reflect.preventExtensions.sham, FREEZING ? undefined : true);
});
core-js-3.6.1/tests/tests/es.reflect.set-prototype-of.js 0000664 0000000 0000000 00000001341 13600575677 0023235 0 ustar 00root root 0000000 0000000 import { NATIVE, PROTO } from '../helpers/constants';
if (PROTO) QUnit.test('Reflect.setPrototypeOf', assert => {
const { setPrototypeOf } = Reflect;
assert.isFunction(setPrototypeOf);
if (NATIVE) assert.arity(setPrototypeOf, 2);
assert.name(setPrototypeOf, 'setPrototypeOf');
assert.looksNative(setPrototypeOf);
assert.nonEnumerable(Reflect, 'setPrototypeOf');
let object = {};
assert.ok(setPrototypeOf(object, Array.prototype), true);
assert.ok(object instanceof Array);
assert.throws(() => setPrototypeOf({}, 42), TypeError);
assert.throws(() => setPrototypeOf(42, {}), TypeError, 'throws on primitive');
object = {};
assert.ok(setPrototypeOf(object, object) === false, 'false on recursive __proto__');
});
core-js-3.6.1/tests/tests/es.reflect.set.js 0000664 0000000 0000000 00000005433 13600575677 0020576 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, NATIVE } from '../helpers/constants';
QUnit.test('Reflect.set', assert => {
const { set } = Reflect;
const { defineProperty, getOwnPropertyDescriptor, create, getPrototypeOf } = Object;
assert.isFunction(set);
if (NATIVE) assert.arity(set, 3);
assert.name(set, 'set');
assert.looksNative(set);
assert.nonEnumerable(Reflect, 'set');
const object = {};
assert.ok(set(object, 'quux', 654), true);
assert.strictEqual(object.quux, 654);
let target = {};
const receiver = {};
set(target, 'foo', 1, receiver);
assert.strictEqual(target.foo, undefined, 'target.foo === undefined');
assert.strictEqual(receiver.foo, 1, 'receiver.foo === 1');
if (DESCRIPTORS) {
defineProperty(receiver, 'bar', {
value: 0,
writable: true,
enumerable: false,
configurable: true,
});
set(target, 'bar', 1, receiver);
assert.strictEqual(receiver.bar, 1, 'receiver.bar === 1');
assert.strictEqual(getOwnPropertyDescriptor(receiver, 'bar').enumerable, false, 'enumerability not overridden');
let out = null;
target = create(defineProperty({ z: 3 }, 'w', {
set() {
out = this;
},
}), {
x: {
value: 1,
writable: true,
configurable: true,
},
y: {
set() {
out = this;
},
},
c: {
value: 1,
writable: false,
configurable: false,
},
});
assert.strictEqual(set(target, 'x', 2, target), true, 'set x');
assert.strictEqual(target.x, 2, 'set x');
out = null;
assert.strictEqual(set(target, 'y', 2, target), true, 'set y');
assert.strictEqual(out, target, 'set y');
assert.strictEqual(set(target, 'z', 4, target), true);
assert.strictEqual(target.z, 4, 'set z');
out = null;
assert.strictEqual(set(target, 'w', 1, target), true, 'set w');
assert.strictEqual(out, target, 'set w');
assert.strictEqual(set(target, 'u', 0, target), true, 'set u');
assert.strictEqual(target.u, 0, 'set u');
assert.strictEqual(set(target, 'c', 2, target), false, 'set c');
assert.strictEqual(target.c, 1, 'set c');
// https://github.com/zloirock/core-js/issues/392
let o = defineProperty({}, 'test', {
writable: false,
configurable: true,
});
assert.strictEqual(set(getPrototypeOf(o), 'test', 1, o), false);
// https://github.com/zloirock/core-js/issues/393
o = defineProperty({}, 'test', {
get() { /* empty */ },
});
assert.notThrows(() => !set(getPrototypeOf(o), 'test', 1, o));
o = defineProperty({}, 'test', {
// eslint-disable-next-line no-unused-vars
set(v) { /* empty */ },
});
assert.notThrows(() => !set(getPrototypeOf(o), 'test', 1, o));
}
assert.throws(() => set(42, 'q', 42), TypeError, 'throws on primitive');
});
core-js-3.6.1/tests/tests/es.regexp.constructor.js 0000664 0000000 0000000 00000004132 13600575677 0022231 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL } from '../helpers/constants';
import { nativeSubclass } from '../helpers/helpers';
if (DESCRIPTORS) {
QUnit.test('RegExp constructor', assert => {
const Symbol = GLOBAL.Symbol || {};
assert.isFunction(RegExp);
assert.arity(RegExp, 2);
assert.name(RegExp, 'RegExp');
assert.looksNative(RegExp);
assert.ok({}.toString.call(RegExp()).slice(8, -1), 'RegExp');
assert.ok({}.toString.call(new RegExp()).slice(8, -1), 'RegExp');
const regexp = /a/g;
assert.notStrictEqual(regexp, new RegExp(regexp), 'new RegExp(regexp) isnt regexp');
assert.strictEqual(regexp, RegExp(regexp), 'RegExp(regexp) is regexp');
regexp[Symbol.match] = false;
assert.notStrictEqual(regexp, RegExp(regexp), 'RegExp(regexp) isnt regexp, changed Symbol.match');
const object = {};
assert.notStrictEqual(object, RegExp(object), 'RegExp(O) isnt O');
object[Symbol.match] = true;
object.constructor = RegExp;
assert.strictEqual(object, RegExp(object), 'RegExp(O) is O, changed Symbol.match');
assert.strictEqual(String(regexp), '/a/g', 'b is /a/g');
assert.strictEqual(String(new RegExp(/a/g, 'mi')), '/a/im', 'Allows a regex with flags');
assert.ok(new RegExp(/a/g, 'im') instanceof RegExp, 'Works with instanceof');
assert.strictEqual(new RegExp(/a/g, 'im').constructor, RegExp, 'Has the right constructor');
/(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)(o)(p)/.exec('abcdefghijklmnopq');
let result = true;
const characters = 'bcdefghij';
for (let i = 0, { length } = characters; i < length; ++i) {
const chr = characters[i];
if (RegExp[`$${ i + 1 }`] !== chr) {
result = false;
}
}
assert.ok(result, 'Updates RegExp globals');
if (nativeSubclass) {
const Subclass = nativeSubclass(RegExp);
assert.ok(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.ok(new Subclass() instanceof RegExp, 'correct subclassing with native classes #2');
assert.ok(new Subclass('^abc$').test('abc'), 'correct subclassing with native classes #3');
}
});
}
core-js-3.6.1/tests/tests/es.regexp.exec.js 0000664 0000000 0000000 00000005544 13600575677 0020600 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('RegExp#exec lastIndex updating', assert => {
let re = /b/;
assert.strictEqual(re.lastIndex, 0, '.lastIndex starts at 0 for non-global regexps');
re.exec('abc');
assert.strictEqual(re.lastIndex, 0, '.lastIndex isn\'t updated for non-global regexps');
re = /b/g;
assert.strictEqual(re.lastIndex, 0, '.lastIndex starts at 0 for global regexps');
re.exec('abc');
assert.strictEqual(re.lastIndex, 2, '.lastIndex is updated for global regexps');
re = /b*/;
re.exec('a');
assert.strictEqual(re.lastIndex, 0, '.lastIndex isn\'t updated for non-global regexps if the match is empty');
re = /b*/g;
re.exec('a');
assert.strictEqual(re.lastIndex, 0, '.lastIndex isn\'t updated for global regexps if the match is empty');
});
QUnit.test('RegExp#exec capturing groups', assert => {
assert.deepEqual(/(a?)/.exec('x'), ['', ''], '/(a?)/.exec("x") returns ["", ""]');
assert.deepEqual(/(a)?/.exec('x'), ['', undefined], '/(a)?/.exec("x") returns ["", undefined]');
// @nicolo-ribaudo: I don't know how to fix this in IE8. For the `/(a)?/` case it is fixed using
// #replace, but here also #replace is buggy :(
// assert.deepEqual(/(a?)?/.exec('x'), ['', undefined], '/(a?)?/.exec("x") returns ["", undefined]');
});
if (DESCRIPTORS) {
QUnit.test('RegExp#exec sticky', assert => {
const re = new RegExp('a', 'y');
const str = 'bbabaab';
assert.strictEqual(re.lastIndex, 0, '#1');
assert.strictEqual(re.exec(str), null, '#2');
assert.strictEqual(re.lastIndex, 0, '#3');
re.lastIndex = 1;
assert.strictEqual(re.exec(str), null, '#4');
assert.strictEqual(re.lastIndex, 0, '#5');
re.lastIndex = 2;
const result = re.exec(str);
assert.deepEqual(result, ['a'], '#6');
assert.strictEqual(result.index, 2, '#7');
assert.strictEqual(re.lastIndex, 3, '#8');
assert.strictEqual(re.exec(str), null, '#9');
assert.strictEqual(re.lastIndex, 0, '#10');
re.lastIndex = 4;
assert.deepEqual(re.exec(str), ['a'], '#11');
assert.strictEqual(re.lastIndex, 5, '#12');
assert.deepEqual(re.exec(str), ['a'], '#13');
assert.strictEqual(re.lastIndex, 6, '#14');
assert.strictEqual(re.exec(str), null, '#15');
assert.strictEqual(re.lastIndex, 0, '#16');
});
QUnit.test('RegExp#exec sticky anchored', assert => {
const regex = new RegExp('^foo', 'y');
assert.deepEqual(regex.exec('foo'), ['foo'], '#1');
regex.lastIndex = 2;
assert.strictEqual(regex.exec('..foo'), null, '#2');
regex.lastIndex = 2;
assert.strictEqual(regex.exec('.\nfoo'), null, '#3');
const regex2 = new RegExp('^foo', 'my');
regex2.lastIndex = 2;
assert.strictEqual(regex2.exec('..foo'), null, '#4');
regex2.lastIndex = 2;
assert.deepEqual(regex2.exec('.\nfoo'), ['foo'], '#5');
assert.strictEqual(regex2.lastIndex, 5, '#6');
});
}
core-js-3.6.1/tests/tests/es.regexp.flags.js 0000664 0000000 0000000 00000001423 13600575677 0020740 0 ustar 00root root 0000000 0000000 /* eslint-disable unicorn/regex-shorthand */
import { DESCRIPTORS } from '../helpers/constants';
if (DESCRIPTORS) {
QUnit.test('RegExp#flags', assert => {
assert.nonEnumerable(RegExp.prototype, 'flags');
assert.strictEqual(/./g.flags, 'g', '/./g.flags is "g"');
assert.strictEqual(/./.flags, '', '/./.flags is ""');
assert.strictEqual(RegExp('.', 'gim').flags, 'gim', 'RegExp(".", "gim").flags is "gim"');
assert.strictEqual(RegExp('.').flags, '', 'RegExp(".").flags is ""');
assert.strictEqual(/./gim.flags, 'gim', '/./gim.flags is "gim"');
assert.strictEqual(/./gmi.flags, 'gim', '/./gmi.flags is "gim"');
assert.strictEqual(/./mig.flags, 'gim', '/./mig.flags is "gim"');
assert.strictEqual(/./mgi.flags, 'gim', '/./mgi.flags is "gim"');
});
}
core-js-3.6.1/tests/tests/es.regexp.sticky.js 0000664 0000000 0000000 00000002616 13600575677 0021157 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
if (DESCRIPTORS) {
QUnit.test('RegExp#sticky', assert => {
const re = new RegExp('a', 'y');
assert.strictEqual(re.sticky, true, '.sticky is true');
assert.strictEqual(re.flags, 'y', '.flags contains y');
assert.strictEqual(/a/.sticky, false);
const stickyGetter = Object.getOwnPropertyDescriptor(RegExp.prototype, 'sticky').get;
if (typeof stickyGetter === 'function') {
// Old firefox versions set a non-configurable non-writable .sticky property
// It works correctly, but it isn't a getter and it can't be polyfilled.
// We need to skip these tests.
assert.throws(() => {
stickyGetter.call({});
}, undefined, '.sticky getter can only be called on RegExp instances');
try {
stickyGetter.call(/a/);
assert.ok(true, '.sticky getter works on literals');
} catch (error) {
assert.ok(false, '.sticky getter works on literals');
}
try {
stickyGetter.call(new RegExp('a'));
assert.ok(true, '.sticky getter works on instances');
} catch (error) {
assert.ok(false, '.sticky getter works on instances');
}
assert.ok(Object.hasOwnProperty.call(RegExp.prototype, 'sticky'), 'prototype has .sticky property');
assert.strictEqual(RegExp.prototype.sticky, undefined, '.sticky is undefined on prototype');
}
});
}
core-js-3.6.1/tests/tests/es.regexp.test.js 0000664 0000000 0000000 00000001044 13600575677 0020622 0 ustar 00root root 0000000 0000000
QUnit.test('RegExp#test delegates to exec', assert => {
const exec = function () {
execCalled = true;
return /./.exec.apply(this, arguments);
};
let execCalled = false;
let re = /[ac]/;
re.exec = exec;
assert.strictEqual(re.test('abc'), true, '#1');
assert.ok(execCalled, '#2');
re = /a/;
// Not a function, should be ignored
re.exec = 3;
assert.strictEqual(re.test('abc'), true, '#3');
re = /a/;
// Does not return an object, should throw
re.exec = () => 3;
assert.throws(() => re.test('abc', '#4'));
});
core-js-3.6.1/tests/tests/es.regexp.to-string.js 0000664 0000000 0000000 00000002471 13600575677 0021576 0 ustar 00root root 0000000 0000000 /* eslint-disable unicorn/regex-shorthand */
import { STRICT } from '../helpers/constants';
QUnit.test('RegExp#toString', assert => {
const { toString } = RegExp.prototype;
assert.isFunction(toString);
assert.arity(toString, 0);
assert.name(toString, 'toString');
assert.looksNative(toString);
assert.nonEnumerable(RegExp.prototype, 'toString');
assert.same(String(/pattern/), '/pattern/');
assert.same(String(/pattern/i), '/pattern/i');
assert.same(String(/pattern/mi), '/pattern/im');
assert.same(String(/pattern/im), '/pattern/im');
assert.same(String(/pattern/mgi), '/pattern/gim');
assert.same(String(new RegExp('pattern')), '/pattern/');
assert.same(String(new RegExp('pattern', 'i')), '/pattern/i');
assert.same(String(new RegExp('pattern', 'mi')), '/pattern/im');
assert.same(String(new RegExp('pattern', 'im')), '/pattern/im');
assert.same(String(new RegExp('pattern', 'mgi')), '/pattern/gim');
assert.same(toString.call({
source: 'foo',
flags: 'bar',
}), '/foo/bar');
assert.same(toString.call({}), '/undefined/undefined');
if (STRICT) {
assert.throws(() => toString.call(7));
assert.throws(() => toString.call('a'));
assert.throws(() => toString.call(false));
assert.throws(() => toString.call(null));
assert.throws(() => toString.call(undefined));
}
});
core-js-3.6.1/tests/tests/es.set.js 0000664 0000000 0000000 00000030054 13600575677 0017150 0 ustar 00root root 0000000 0000000 /* eslint-disable sonarjs/no-element-overwrite */
import { DESCRIPTORS, GLOBAL, NATIVE } from '../helpers/constants';
import { createIterable, is, nativeSubclass } from '../helpers/helpers';
const Symbol = GLOBAL.Symbol || {};
const { getOwnPropertyDescriptor, keys, getOwnPropertyNames, getOwnPropertySymbols, freeze } = Object;
const { ownKeys } = Reflect || {};
const { from } = Array;
QUnit.test('Set', assert => {
assert.isFunction(Set);
assert.name(Set, 'Set');
assert.arity(Set, 0);
assert.looksNative(Set);
assert.ok('add' in Set.prototype, 'add in Set.prototype');
assert.ok('clear' in Set.prototype, 'clear in Set.prototype');
assert.ok('delete' in Set.prototype, 'delete in Set.prototype');
assert.ok('forEach' in Set.prototype, 'forEach in Set.prototype');
assert.ok('has' in Set.prototype, 'has in Set.prototype');
assert.ok(new Set() instanceof Set, 'new Set instanceof Set');
const set = new Set();
set.add(1);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
assert.strictEqual(set.size, 3);
const result = [];
set.forEach(val => {
result.push(val);
});
assert.deepEqual(result, [1, 2, 3]);
assert.strictEqual(new Set(createIterable([1, 2, 3])).size, 3, 'Init from iterable');
assert.strictEqual(new Set([freeze({}), 1]).size, 2, 'Support frozen objects');
assert.strictEqual(new Set([NaN, NaN, NaN]).size, 1);
assert.deepEqual(from(new Set([3, 4]).add(2).add(1)), [3, 4, 2, 1]);
let done = false;
const { add } = Set.prototype;
// eslint-disable-next-line no-extend-native
Set.prototype.add = function () {
throw new Error();
};
try {
new Set(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
// eslint-disable-next-line no-extend-native
Set.prototype.add = add;
assert.ok(done, '.return #throw');
const array = [];
done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return [][Symbol.iterator].call(this);
};
new Set(array);
assert.ok(done);
const object = {};
new Set().add(object);
if (DESCRIPTORS) {
const results = [];
for (const key in results) keys.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(Set);
assert.ok(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.ok(new Subclass() instanceof Set, 'correct subclassing with native classes #2');
assert.ok(new Subclass().add(2).has(2), 'correct subclassing with native classes #3');
}
});
QUnit.test('Set#add', assert => {
assert.isFunction(Set.prototype.add);
assert.name(Set.prototype.add, 'add');
assert.arity(Set.prototype.add, 1);
assert.looksNative(Set.prototype.add);
assert.nonEnumerable(Set.prototype, 'add');
const array = [];
let set = new Set();
set.add(NaN);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.add(array);
assert.strictEqual(set.size, 5);
const chain = set.add(NaN);
assert.strictEqual(chain, set);
assert.strictEqual(set.size, 5);
set.add(2);
assert.strictEqual(set.size, 5);
set.add(array);
assert.strictEqual(set.size, 5);
set.add([]);
assert.strictEqual(set.size, 6);
set.add(4);
assert.strictEqual(set.size, 7);
const frozen = freeze({});
set = new Set();
set.add(frozen);
assert.ok(set.has(frozen));
});
QUnit.test('Set#clear', assert => {
assert.isFunction(Set.prototype.clear);
assert.name(Set.prototype.clear, 'clear');
assert.arity(Set.prototype.clear, 0);
assert.looksNative(Set.prototype.clear);
assert.nonEnumerable(Set.prototype, 'clear');
let set = new Set();
set.clear();
assert.strictEqual(set.size, 0);
set = new Set();
set.add(1);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.clear();
assert.strictEqual(set.size, 0);
assert.ok(!set.has(1));
assert.ok(!set.has(2));
assert.ok(!set.has(3));
const frozen = freeze({});
set = new Set();
set.add(1);
set.add(frozen);
set.clear();
assert.strictEqual(set.size, 0, 'Support frozen objects');
assert.ok(!set.has(1));
assert.ok(!set.has(frozen));
});
QUnit.test('Set#delete', assert => {
assert.isFunction(Set.prototype.delete);
if (NATIVE) assert.name(Set.prototype.delete, 'delete');
assert.arity(Set.prototype.delete, 1);
assert.looksNative(Set.prototype.delete);
assert.nonEnumerable(Set.prototype, 'delete');
const array = [];
const set = new Set();
set.add(NaN);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.add(array);
assert.strictEqual(set.size, 5);
assert.strictEqual(set.delete(NaN), true);
assert.strictEqual(set.size, 4);
assert.strictEqual(set.delete(4), false);
assert.strictEqual(set.size, 4);
set.delete([]);
assert.strictEqual(set.size, 4);
set.delete(array);
assert.strictEqual(set.size, 3);
const frozen = freeze({});
set.add(frozen);
assert.strictEqual(set.size, 4);
set.delete(frozen);
assert.strictEqual(set.size, 3);
});
QUnit.test('Set#forEach', assert => {
assert.isFunction(Set.prototype.forEach);
assert.name(Set.prototype.forEach, 'forEach');
assert.arity(Set.prototype.forEach, 1);
assert.looksNative(Set.prototype.forEach);
assert.nonEnumerable(Set.prototype, 'forEach');
let result = [];
let count = 0;
let set = new Set();
set.add(1);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.forEach(value => {
count++;
result.push(value);
});
assert.strictEqual(count, 3);
assert.deepEqual(result, [1, 2, 3]);
set = new Set();
set.add('0');
set.add('1');
set.add('2');
set.add('3');
result = '';
set.forEach(it => {
result += it;
if (it === '2') {
set.delete('2');
set.delete('3');
set.delete('1');
set.add('4');
}
});
assert.strictEqual(result, '0124');
set = new Set();
set.add('0');
result = '';
set.forEach(it => {
set.delete('0');
if (result !== '') throw new Error();
result += it;
});
assert.strictEqual(result, '0');
assert.throws(() => {
Set.prototype.forEach.call(new Map(), () => { /* empty */ });
}, 'non-generic');
});
QUnit.test('Set#has', assert => {
assert.isFunction(Set.prototype.has);
assert.name(Set.prototype.has, 'has');
assert.arity(Set.prototype.has, 1);
assert.looksNative(Set.prototype.has);
assert.nonEnumerable(Set.prototype, 'has');
const array = [];
const frozen = freeze({});
const set = new Set();
set.add(NaN);
set.add(2);
set.add(3);
set.add(2);
set.add(1);
set.add(frozen);
set.add(array);
assert.ok(set.has(NaN));
assert.ok(set.has(array));
assert.ok(set.has(frozen));
assert.ok(set.has(2));
assert.ok(!set.has(4));
assert.ok(!set.has([]));
});
QUnit.test('Set#size', assert => {
assert.nonEnumerable(Set.prototype, 'size');
const set = new Set();
set.add(1);
const { size } = set;
assert.strictEqual(typeof size, 'number', 'size is number');
assert.strictEqual(size, 1, 'size is correct');
if (DESCRIPTORS) {
const sizeDescriptor = getOwnPropertyDescriptor(Set.prototype, 'size');
assert.ok(sizeDescriptor && sizeDescriptor.get, 'size is getter');
assert.ok(sizeDescriptor && !sizeDescriptor.set, 'size isnt setter');
assert.throws(() => Set.prototype.size, TypeError);
}
});
QUnit.test('Set & -0', assert => {
let set = new Set();
set.add(-0);
assert.strictEqual(set.size, 1);
assert.ok(set.has(0));
assert.ok(set.has(-0));
set.forEach(it => {
assert.ok(!is(it, -0));
});
set.delete(-0);
assert.strictEqual(set.size, 0);
set = new Set([-0]);
set.forEach(key => {
assert.ok(!is(key, -0));
});
set = new Set();
set.add(4);
set.add(3);
set.add(2);
set.add(1);
set.add(0);
assert.ok(set.has(-0));
});
QUnit.test('Set#@@toStringTag', assert => {
assert.strictEqual(Set.prototype[Symbol.toStringTag], 'Set', 'Set::@@toStringTag is `Set`');
assert.strictEqual(String(new Set()), '[object Set]', 'correct stringification');
});
QUnit.test('Set Iterator', assert => {
const set = new Set();
set.add('a');
set.add('b');
set.add('c');
set.add('d');
const results = [];
const iterator = set.keys();
results.push(iterator.next().value);
assert.ok(set.delete('a'));
assert.ok(set.delete('b'));
assert.ok(set.delete('c'));
set.add('e');
results.push(iterator.next().value);
results.push(iterator.next().value);
assert.ok(iterator.next().done);
set.add('f');
assert.ok(iterator.next().done);
assert.deepEqual(results, ['a', 'd', 'e']);
});
QUnit.test('Set#keys', assert => {
assert.isFunction(Set.prototype.keys);
assert.name(Set.prototype.keys, 'values');
assert.arity(Set.prototype.keys, 0);
assert.looksNative(Set.prototype.keys);
assert.strictEqual(Set.prototype.keys, Set.prototype.values);
assert.nonEnumerable(Set.prototype, 'keys');
const set = new Set();
set.add('q');
set.add('w');
set.add('e');
const iterator = set.keys();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Set Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Set#values', assert => {
assert.isFunction(Set.prototype.values);
assert.name(Set.prototype.values, 'values');
assert.arity(Set.prototype.values, 0);
assert.looksNative(Set.prototype.values);
assert.nonEnumerable(Set.prototype, 'values');
const set = new Set();
set.add('q');
set.add('w');
set.add('e');
const iterator = set.values();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Set Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Set#entries', assert => {
assert.isFunction(Set.prototype.entries);
assert.name(Set.prototype.entries, 'entries');
assert.arity(Set.prototype.entries, 0);
assert.looksNative(Set.prototype.entries);
assert.nonEnumerable(Set.prototype, 'entries');
const set = new Set();
set.add('q');
set.add('w');
set.add('e');
const iterator = set.entries();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Set Iterator');
assert.deepEqual(iterator.next(), {
value: ['q', 'q'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['w', 'w'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: ['e', 'e'],
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
QUnit.test('Set#@@iterator', assert => {
assert.isIterable(Set.prototype);
assert.name(Set.prototype[Symbol.iterator], 'values');
assert.arity(Set.prototype[Symbol.iterator], 0);
assert.looksNative(Set.prototype[Symbol.iterator]);
assert.strictEqual(Set.prototype[Symbol.iterator], Set.prototype.values);
assert.nonEnumerable(Set.prototype, 'values');
const set = new Set();
set.add('q');
set.add('w');
set.add('e');
const iterator = set[Symbol.iterator]();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Set Iterator');
assert.strictEqual(String(iterator), '[object Set Iterator]');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
core-js-3.6.1/tests/tests/es.string.anchor.js 0000664 0000000 0000000 00000000614 13600575677 0021133 0 ustar 00root root 0000000 0000000 QUnit.test('String#anchor', assert => {
const { anchor } = String.prototype;
assert.isFunction(anchor);
assert.arity(anchor, 1);
assert.name(anchor, 'anchor');
assert.looksNative(anchor);
assert.nonEnumerable(String.prototype, 'anchor');
assert.same('a'.anchor('b'), 'a ', 'lower case');
assert.same('a'.anchor('"'), 'a ', 'escape quotes');
});
core-js-3.6.1/tests/tests/es.string.big.js 0000664 0000000 0000000 00000000436 13600575677 0020424 0 ustar 00root root 0000000 0000000 QUnit.test('String#big', assert => {
const { big } = String.prototype;
assert.isFunction(big);
assert.arity(big, 0);
assert.name(big, 'big');
assert.looksNative(big);
assert.nonEnumerable(String.prototype, 'big');
assert.same('a'.big(), 'a ', 'lower case');
});
core-js-3.6.1/tests/tests/es.string.blink.js 0000664 0000000 0000000 00000000464 13600575677 0020763 0 ustar 00root root 0000000 0000000 QUnit.test('String#blink', assert => {
const { blink } = String.prototype;
assert.isFunction(blink);
assert.arity(blink, 0);
assert.name(blink, 'blink');
assert.looksNative(blink);
assert.nonEnumerable(String.prototype, 'blink');
assert.same('a'.blink(), 'a ', 'lower case');
});
core-js-3.6.1/tests/tests/es.string.bold.js 0000664 0000000 0000000 00000000443 13600575677 0020601 0 ustar 00root root 0000000 0000000 QUnit.test('String#bold', assert => {
const { bold } = String.prototype;
assert.isFunction(bold);
assert.arity(bold, 0);
assert.name(bold, 'bold');
assert.looksNative(bold);
assert.nonEnumerable(String.prototype, 'bold');
assert.same('a'.bold(), 'a ', 'lower case');
});
core-js-3.6.1/tests/tests/es.string.code-point-at.js 0000664 0000000 0000000 00000007144 13600575677 0022331 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
QUnit.test('String#codePointAt', assert => {
const { codePointAt } = String.prototype;
assert.isFunction(codePointAt);
assert.arity(codePointAt, 1);
assert.name(codePointAt, 'codePointAt');
assert.looksNative(codePointAt);
assert.nonEnumerable(String.prototype, 'codePointAt');
assert.strictEqual('abc\uD834\uDF06def'.codePointAt(''), 0x61);
assert.strictEqual('abc\uD834\uDF06def'.codePointAt('_'), 0x61);
assert.strictEqual('abc\uD834\uDF06def'.codePointAt(), 0x61);
assert.strictEqual('abc\uD834\uDF06def'.codePointAt(-Infinity), undefined);
assert.strictEqual('abc\uD834\uDF06def'.codePointAt(-1), undefined);
assert.strictEqual('abc\uD834\uDF06def'.codePointAt(-0), 0x61);
assert.strictEqual('abc\uD834\uDF06def'.codePointAt(0), 0x61);
assert.strictEqual('abc\uD834\uDF06def'.codePointAt(3), 0x1D306);
assert.strictEqual('abc\uD834\uDF06def'.codePointAt(4), 0xDF06);
assert.strictEqual('abc\uD834\uDF06def'.codePointAt(5), 0x64);
assert.strictEqual('abc\uD834\uDF06def'.codePointAt(42), undefined);
assert.strictEqual('abc\uD834\uDF06def'.codePointAt(Infinity), undefined);
assert.strictEqual('abc\uD834\uDF06def'.codePointAt(Infinity), undefined);
assert.strictEqual('abc\uD834\uDF06def'.codePointAt(NaN), 0x61);
assert.strictEqual('abc\uD834\uDF06def'.codePointAt(false), 0x61);
assert.strictEqual('abc\uD834\uDF06def'.codePointAt(null), 0x61);
assert.strictEqual('abc\uD834\uDF06def'.codePointAt(undefined), 0x61);
assert.strictEqual('\uD834\uDF06def'.codePointAt(''), 0x1D306);
assert.strictEqual('\uD834\uDF06def'.codePointAt('1'), 0xDF06);
assert.strictEqual('\uD834\uDF06def'.codePointAt('_'), 0x1D306);
assert.strictEqual('\uD834\uDF06def'.codePointAt(), 0x1D306);
assert.strictEqual('\uD834\uDF06def'.codePointAt(-1), undefined);
assert.strictEqual('\uD834\uDF06def'.codePointAt(-0), 0x1D306);
assert.strictEqual('\uD834\uDF06def'.codePointAt(0), 0x1D306);
assert.strictEqual('\uD834\uDF06def'.codePointAt(1), 0xDF06);
assert.strictEqual('\uD834\uDF06def'.codePointAt(42), undefined);
assert.strictEqual('\uD834\uDF06def'.codePointAt(false), 0x1D306);
assert.strictEqual('\uD834\uDF06def'.codePointAt(null), 0x1D306);
assert.strictEqual('\uD834\uDF06def'.codePointAt(undefined), 0x1D306);
assert.strictEqual('\uD834abc'.codePointAt(''), 0xD834);
assert.strictEqual('\uD834abc'.codePointAt('_'), 0xD834);
assert.strictEqual('\uD834abc'.codePointAt(), 0xD834);
assert.strictEqual('\uD834abc'.codePointAt(-1), undefined);
assert.strictEqual('\uD834abc'.codePointAt(-0), 0xD834);
assert.strictEqual('\uD834abc'.codePointAt(0), 0xD834);
assert.strictEqual('\uD834abc'.codePointAt(false), 0xD834);
assert.strictEqual('\uD834abc'.codePointAt(NaN), 0xD834);
assert.strictEqual('\uD834abc'.codePointAt(null), 0xD834);
assert.strictEqual('\uD834abc'.codePointAt(undefined), 0xD834);
assert.strictEqual('\uDF06abc'.codePointAt(''), 0xDF06);
assert.strictEqual('\uDF06abc'.codePointAt('_'), 0xDF06);
assert.strictEqual('\uDF06abc'.codePointAt(), 0xDF06);
assert.strictEqual('\uDF06abc'.codePointAt(-1), undefined);
assert.strictEqual('\uDF06abc'.codePointAt(-0), 0xDF06);
assert.strictEqual('\uDF06abc'.codePointAt(0), 0xDF06);
assert.strictEqual('\uDF06abc'.codePointAt(false), 0xDF06);
assert.strictEqual('\uDF06abc'.codePointAt(NaN), 0xDF06);
assert.strictEqual('\uDF06abc'.codePointAt(null), 0xDF06);
assert.strictEqual('\uDF06abc'.codePointAt(undefined), 0xDF06);
if (STRICT) {
assert.throws(() => codePointAt.call(null, 0), TypeError);
assert.throws(() => codePointAt.call(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/tests/es.string.ends-with.js 0000664 0000000 0000000 00000002511 13600575677 0021561 0 ustar 00root root 0000000 0000000 import { GLOBAL, STRICT } from '../helpers/constants';
const Symbol = GLOBAL.Symbol || {};
QUnit.test('String#endsWith', assert => {
const { endsWith } = String.prototype;
assert.isFunction(endsWith);
assert.arity(endsWith, 1);
assert.name(endsWith, 'endsWith');
assert.looksNative(endsWith);
assert.nonEnumerable(String.prototype, 'endsWith');
assert.ok('undefined'.endsWith());
assert.ok(!'undefined'.endsWith(null));
assert.ok('abc'.endsWith(''));
assert.ok('abc'.endsWith('c'));
assert.ok('abc'.endsWith('bc'));
assert.ok(!'abc'.endsWith('ab'));
assert.ok('abc'.endsWith('', NaN));
assert.ok(!'abc'.endsWith('c', -1));
assert.ok('abc'.endsWith('a', 1));
assert.ok('abc'.endsWith('c', Infinity));
assert.ok('abc'.endsWith('a', true));
assert.ok(!'abc'.endsWith('c', 'x'));
assert.ok(!'abc'.endsWith('a', 'x'));
if (STRICT) {
assert.throws(() => endsWith.call(null, '.'), TypeError);
assert.throws(() => endsWith.call(undefined, '.'), TypeError);
}
const regexp = /./;
assert.throws(() => '/./'.endsWith(regexp), TypeError);
regexp[Symbol.match] = false;
assert.notThrows(() => '/./'.endsWith(regexp));
const object = {};
assert.notThrows(() => '[object Object]'.endsWith(object));
object[Symbol.match] = true;
assert.throws(() => '[object Object]'.endsWith(object), TypeError);
});
core-js-3.6.1/tests/tests/es.string.fixed.js 0000664 0000000 0000000 00000000456 13600575677 0020764 0 ustar 00root root 0000000 0000000 QUnit.test('String#fixed', assert => {
const { fixed } = String.prototype;
assert.isFunction(fixed);
assert.arity(fixed, 0);
assert.name(fixed, 'fixed');
assert.looksNative(fixed);
assert.nonEnumerable(String.prototype, 'fixed');
assert.same('a'.fixed(), 'a ', 'lower case');
});
core-js-3.6.1/tests/tests/es.string.fontcolor.js 0000664 0000000 0000000 00000000670 13600575677 0021670 0 ustar 00root root 0000000 0000000 QUnit.test('String#fontcolor', assert => {
const { fontcolor } = String.prototype;
assert.isFunction(fontcolor);
assert.arity(fontcolor, 1);
assert.name(fontcolor, 'fontcolor');
assert.looksNative(fontcolor);
assert.nonEnumerable(String.prototype, 'fontcolor');
assert.same('a'.fontcolor('b'), 'a ', 'lower case');
assert.same('a'.fontcolor('"'), 'a ', 'escape quotes');
});
core-js-3.6.1/tests/tests/es.string.fontsize.js 0000664 0000000 0000000 00000000654 13600575677 0021526 0 ustar 00root root 0000000 0000000 QUnit.test('String#fontsize', assert => {
const { fontsize } = String.prototype;
assert.isFunction(fontsize);
assert.arity(fontsize, 1);
assert.name(fontsize, 'fontsize');
assert.looksNative(fontsize);
assert.nonEnumerable(String.prototype, 'fontsize');
assert.same('a'.fontsize('b'), 'a ', 'lower case');
assert.same('a'.fontsize('"'), 'a ', 'escape quotes');
});
core-js-3.6.1/tests/tests/es.string.from-code-point.js 0000664 0000000 0000000 00000003774 13600575677 0022675 0 ustar 00root root 0000000 0000000 QUnit.test('String.fromCodePoint', assert => {
const { fromCodePoint } = String;
assert.isFunction(fromCodePoint);
assert.arity(fromCodePoint, 1);
assert.name(fromCodePoint, 'fromCodePoint');
assert.looksNative(fromCodePoint);
assert.nonEnumerable(String, 'fromCodePoint');
assert.strictEqual(fromCodePoint(''), '\0');
assert.strictEqual(fromCodePoint(), '');
assert.strictEqual(fromCodePoint(-0), '\0');
assert.strictEqual(fromCodePoint(0), '\0');
assert.strictEqual(fromCodePoint(0x1D306), '\uD834\uDF06');
assert.strictEqual(fromCodePoint(0x1D306, 0x61, 0x1D307), '\uD834\uDF06a\uD834\uDF07');
assert.strictEqual(fromCodePoint(0x61, 0x62, 0x1D307), 'ab\uD834\uDF07');
assert.strictEqual(fromCodePoint(false), '\0');
assert.strictEqual(fromCodePoint(null), '\0');
assert.throws(() => fromCodePoint('_'), RangeError);
assert.throws(() => fromCodePoint('+Infinity'), RangeError);
assert.throws(() => fromCodePoint('-Infinity'), RangeError);
assert.throws(() => fromCodePoint(-1), RangeError);
assert.throws(() => fromCodePoint(0x10FFFF + 1), RangeError);
assert.throws(() => fromCodePoint(3.14), RangeError);
assert.throws(() => fromCodePoint(3e-2), RangeError);
assert.throws(() => fromCodePoint(-Infinity), RangeError);
assert.throws(() => fromCodePoint(Infinity), RangeError);
assert.throws(() => fromCodePoint(NaN), RangeError);
assert.throws(() => fromCodePoint(undefined), RangeError);
assert.throws(() => fromCodePoint({}), RangeError);
assert.throws(() => fromCodePoint(/./), RangeError);
let number = 0x60;
assert.strictEqual(fromCodePoint({
valueOf() {
return ++number;
},
}), 'a');
assert.strictEqual(number, 0x61);
// one code unit per symbol
let counter = 2 ** 15 * 3 / 2;
let result = [];
while (--counter >= 0) result.push(0);
// should not throw
fromCodePoint.apply(null, result);
counter = 2 ** 15 * 3 / 2;
result = [];
while (--counter >= 0) result.push(0xFFFF + 1);
// should not throw
fromCodePoint.apply(null, result);
});
core-js-3.6.1/tests/tests/es.string.includes.js 0000664 0000000 0000000 00000001756 13600575677 0021477 0 ustar 00root root 0000000 0000000 import { GLOBAL, STRICT } from '../helpers/constants';
const Symbol = GLOBAL.Symbol || {};
QUnit.test('String#includes', assert => {
const { includes } = String.prototype;
assert.isFunction(includes);
assert.arity(includes, 1);
assert.name(includes, 'includes');
assert.looksNative(includes);
assert.nonEnumerable(String.prototype, 'includes');
assert.ok(!'abc'.includes());
assert.ok('aundefinedb'.includes());
assert.ok('abcd'.includes('b', 1));
assert.ok(!'abcd'.includes('b', 2));
if (STRICT) {
assert.throws(() => includes.call(null, '.'), TypeError);
assert.throws(() => includes.call(undefined, '.'), TypeError);
}
const regexp = /./;
assert.throws(() => '/./'.includes(regexp), TypeError);
regexp[Symbol.match] = false;
assert.notThrows(() => '/./'.includes(regexp));
const object = {};
assert.notThrows(() => '[object Object]'.includes(object));
object[Symbol.match] = true;
assert.throws(() => '[object Object]'.includes(object), TypeError);
});
core-js-3.6.1/tests/tests/es.string.italics.js 0000664 0000000 0000000 00000000476 13600575677 0021317 0 ustar 00root root 0000000 0000000 QUnit.test('String#italics', assert => {
const { italics } = String.prototype;
assert.isFunction(italics);
assert.arity(italics, 0);
assert.name(italics, 'italics');
assert.looksNative(italics);
assert.nonEnumerable(String.prototype, 'italics');
assert.same('a'.italics(), 'a ', 'lower case');
});
core-js-3.6.1/tests/tests/es.string.iterator.js 0000664 0000000 0000000 00000002207 13600575677 0021512 0 ustar 00root root 0000000 0000000 import { GLOBAL } from '../helpers/constants';
const Symbol = GLOBAL.Symbol || {};
QUnit.test('String#@@iterator', assert => {
assert.isIterable(String.prototype);
let iterator = 'qwe'[Symbol.iterator]();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'String Iterator');
assert.strictEqual(String(iterator), '[object String Iterator]');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'w',
done: false,
});
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.strictEqual(Array.from('𠮷𠮷𠮷').length, 3);
iterator = '𠮷𠮷𠮷'[Symbol.iterator]();
assert.deepEqual(iterator.next(), {
value: '𠮷',
done: false,
});
assert.deepEqual(iterator.next(), {
value: '𠮷',
done: false,
});
assert.deepEqual(iterator.next(), {
value: '𠮷',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
core-js-3.6.1/tests/tests/es.string.link.js 0000664 0000000 0000000 00000000570 13600575677 0020617 0 ustar 00root root 0000000 0000000 QUnit.test('String#link', assert => {
const { link } = String.prototype;
assert.isFunction(link);
assert.arity(link, 1);
assert.name(link, 'link');
assert.looksNative(link);
assert.nonEnumerable(String.prototype, 'link');
assert.same('a'.link('b'), 'a ', 'lower case');
assert.same('a'.link('"'), 'a ', 'escape quotes');
});
core-js-3.6.1/tests/tests/es.string.match-all.js 0000664 0000000 0000000 00000006624 13600575677 0021532 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
QUnit.test('String#matchAll', assert => {
const { matchAll } = String.prototype;
const { assign } = Object;
assert.isFunction(matchAll);
assert.arity(matchAll, 1);
assert.name(matchAll, 'matchAll');
assert.looksNative(matchAll);
assert.nonEnumerable(String.prototype, 'matchAll');
let data = ['aabc', { toString() { return 'aabc'; } }];
for (const target of data) {
const iterator = matchAll.call(target, /[ac]/g);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: assign(['a'], {
input: 'aabc',
index: 0,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['a'], {
input: 'aabc',
index: 1,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['c'], {
input: 'aabc',
index: 3,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
}
let iterator = '1111a2b3cccc'.matchAll(/(\d)(\D)/g);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'RegExp String Iterator');
assert.strictEqual(String(iterator), '[object RegExp String Iterator]');
assert.deepEqual(iterator.next(), {
value: assign(['1a', '1', 'a'], {
input: '1111a2b3cccc',
index: 3,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['2b', '2', 'b'], {
input: '1111a2b3cccc',
index: 5,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['3c', '3', 'c'], {
input: '1111a2b3cccc',
index: 7,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
assert.throws(() => '1111a2b3cccc'.matchAll(/(\d)(\D)/), TypeError);
iterator = '1111a2b3cccc'.matchAll('(\\d)(\\D)');
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: assign(['1a', '1', 'a'], {
input: '1111a2b3cccc',
index: 3,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['2b', '2', 'b'], {
input: '1111a2b3cccc',
index: 5,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign(['3c', '3', 'c'], {
input: '1111a2b3cccc',
index: 7,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
/* IE8- issue
iterator = 'abc'.matchAll(/\B/g);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.deepEqual(iterator.next(), {
value: assign([''], {
input: 'abc',
index: 1,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: assign([''], {
input: 'abc',
index: 2,
}),
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
*/
data = [null, undefined, NaN, 42, {}, []];
for (const target of data) {
assert.notThrows(() => ''.matchAll(target), `Not throws on ${ target } as the first argument`);
}
if (STRICT) {
assert.throws(() => matchAll.call(null, /./g), TypeError, 'Throws on null as `this`');
assert.throws(() => matchAll.call(undefined, /./g), TypeError, 'Throws on undefined as `this`');
}
});
core-js-3.6.1/tests/tests/es.string.match.js 0000664 0000000 0000000 00000026371 13600575677 0020765 0 ustar 00root root 0000000 0000000 // TODO: fix escaping in regexps
/* eslint-disable unicorn/no-unsafe-regex */
import { GLOBAL, NATIVE, STRICT } from '../helpers/constants';
import { patchRegExp$exec } from '../helpers/helpers';
const Symbol = GLOBAL.Symbol || {};
const run = assert => {
assert.isFunction(''.match);
assert.arity(''.match, 1);
assert.name(''.match, 'match');
assert.looksNative(''.match);
assert.nonEnumerable(String.prototype, 'match');
let instance = Object(true);
instance.match = String.prototype.match;
assert.strictEqual(instance.match(true)[0], 'true', 'S15.5.4.10_A1_T1');
instance = Object(false);
instance.match = String.prototype.match;
assert.strictEqual(instance.match(false)[0], 'false', 'S15.5.4.10_A1_T2');
let matched = ''.match();
let expected = RegExp().exec('');
assert.strictEqual(matched.length, expected.length, 'S15.5.4.10_A1_T4 #1');
assert.strictEqual(matched.index, expected.index, 'S15.5.4.10_A1_T4 #2');
assert.strictEqual(matched.input, expected.input, 'S15.5.4.10_A1_T4 #3');
assert.strictEqual('gnulluna'.match(null)[0], 'null', 'S15.5.4.10_A1_T5');
matched = Object('undefined').match(undefined);
expected = RegExp(undefined).exec('undefined');
assert.strictEqual(matched.length, expected.length, 'S15.5.4.10_A1_T6 #1');
assert.strictEqual(matched.index, expected.index, 'S15.5.4.10_A1_T6 #2');
assert.strictEqual(matched.input, expected.input, 'S15.5.4.10_A1_T6 #3');
let object = { toString() { /* empty */ } };
matched = String(object).match(undefined);
expected = RegExp(undefined).exec('undefined');
assert.strictEqual(matched.length, expected.length, 'S15.5.4.10_A1_T8 #1');
assert.strictEqual(matched.index, expected.index, 'S15.5.4.10_A1_T8 #2');
assert.strictEqual(matched.input, expected.input, 'S15.5.4.10_A1_T8 #3');
object = { toString() { return '\u0041B'; } };
let string = 'ABB\u0041BABAB';
assert.strictEqual(string.match(object)[0], 'AB', 'S15.5.4.10_A1_T10');
object = { toString() { throw new Error('intostr'); } };
string = 'ABB\u0041BABAB';
try {
string.match(object);
assert.ok(false, 'S15.5.4.10_A1_T11 #1 lead to throwing exception');
} catch (error) {
assert.strictEqual(error.message, 'intostr', `S15.5.4.10_A1_T11 #1.1: Exception === "intostr". Actual: ${ error }`);
}
object = {
toString() {
return {};
},
valueOf() {
throw new Error('intostr');
},
};
string = 'ABB\u0041BABAB';
try {
string.match(object);
assert.ok(false, 'S15.5.4.10_A1_T12 #1 lead to throwing exception');
} catch (error) {
assert.strictEqual(error.message, 'intostr', `S15.5.4.10_A1_T12 #1.1: Exception === "intostr". Actual: ${ error }`);
}
object = {
toString() {
return {};
},
valueOf() {
return 1;
},
};
assert.strictEqual('ABB\u0041B\u0031ABAB\u0031BBAA'.match(object)[0], '1', 'S15.5.4.10_A1_T13 #1');
assert.strictEqual('ABB\u0041B\u0031ABAB\u0031BBAA'.match(object).length, 1, 'S15.5.4.10_A1_T13 #2');
let regexp = RegExp('77');
assert.strictEqual('ABB\u0041BABAB\u0037\u0037BBAA'.match(regexp)[0], '77', 'S15.5.4.10_A1_T14');
string = '1234567890';
assert.strictEqual(string.match(3)[0], '3', 'S15.5.4.10_A2_T1 #1');
assert.strictEqual(string.match(3).length, 1, 'S15.5.4.10_A2_T1 #2');
assert.strictEqual(string.match(3).index, 2, 'S15.5.4.10_A2_T1 #3');
assert.strictEqual(string.match(3).input, string, 'S15.5.4.10_A2_T1 #4');
let matches = ['34', '34', '34'];
string = '343443444';
assert.strictEqual(string.match(/34/g).length, 3, 'S15.5.4.10_A2_T2 #1');
for (let i = 0, { length } = matches; i < length; ++i) {
assert.strictEqual(string.match(/34/g)[i], matches[i], 'S15.5.4.10_A2_T2 #2');
}
matches = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'];
string = '123456abcde7890';
assert.strictEqual(string.match(/\d/g).length, 10, 'S15.5.4.10_A2_T3 #1');
for (let i = 0, { length } = matches; i < length; ++i) {
assert.strictEqual(string.match(/\d/g)[i], matches[i], 'S15.5.4.10_A2_T3 #2');
}
matches = ['12', '34', '56', '78', '90'];
string = '123456abcde7890';
assert.strictEqual(string.match(/\d{2}/g).length, 5, 'S15.5.4.10_A2_T4 #1');
for (let i = 0, { length } = matches; i < length; ++i) {
assert.strictEqual(string.match(/\d{2}/g)[i], matches[i], 'S15.5.4.10_A2_T4 #2');
}
matches = ['ab', 'cd'];
string = '123456abcde7890';
assert.strictEqual(string.match(/\D{2}/g).length, 2, 'S15.5.4.10_A2_T5 #1');
for (let i = 0, { length } = matches; i < length; ++i) {
assert.strictEqual(string.match(/\D{2}/g)[i], matches[i], 'S15.5.4.10_A2_T5 #2');
}
string = 'Boston, Mass. 02134';
assert.strictEqual(string.match(/(\d{5})([ -]?\d{4})?$/)[0], '02134', 'S15.5.4.10_A2_T6 #1');
assert.strictEqual(string.match(/(\d{5})([ -]?\d{4})?$/)[1], '02134', 'S15.5.4.10_A2_T6 #2');
if (NATIVE) assert.strictEqual(string.match(/(\d{5})([ -]?\d{4})?$/)[2], undefined, 'S15.5.4.10_A2_T6 #3');
assert.strictEqual(string.match(/(\d{5})([ -]?\d{4})?$/).length, 3, 'S15.5.4.10_A2_T6 #4');
assert.strictEqual(string.match(/(\d{5})([ -]?\d{4})?$/).index, 14, 'S15.5.4.10_A2_T6 #5');
assert.strictEqual(string.match(/(\d{5})([ -]?\d{4})?$/).input, string, 'S15.5.4.10_A2_T6 #6');
string = 'Boston, Mass. 02134';
assert.strictEqual(string.match(/(\d{5})([ -]?\d{4})?$/g).length, 1, 'S15.5.4.10_A2_T7 #1');
assert.strictEqual(string.match(/(\d{5})([ -]?\d{4})?$/g)[0], '02134', 'S15.5.4.10_A2_T7 #2');
/* IE8- buggy here (empty string instead of `undefined`), but we don't polyfill base `.match` logic
matches = ['02134', '02134', undefined];
string = 'Boston, MA 02134';
regexp = /([\d]{5})([-\ ]?[\d]{4})?$/;
regexp.lastIndex = 0;
assert.strictEqual(string.match(regexp).length, 3, 'S15.5.4.10_A2_T8 #1');
assert.strictEqual(string.match(regexp).index, string.lastIndexOf('0'), 'S15.5.4.10_A2_T8 #2');
for (let i = 0, { length } = matches; i < length; ++i) {
assert.strictEqual(string.match(regexp)[i], matches[i], 'S15.5.4.10_A2_T8 #3');
}
string = 'Boston, MA 02134';
matches = ['02134', '02134', undefined];
regexp = /([\d]{5})([-\ ]?[\d]{4})?$/;
regexp.lastIndex = string.length;
assert.strictEqual(string.match(regexp).length, 3, 'S15.5.4.10_A2_T9 #1');
assert.strictEqual(string.match(regexp).index, string.lastIndexOf('0'), 'S15.5.4.10_A2_T9 #2');
for (let i = 0, { length } = matches; i < length; ++i) {
assert.strictEqual(string.match(regexp)[i], matches[i], 'S15.5.4.10_A2_T9 #3');
}
string = 'Boston, MA 02134';
matches = ['02134', '02134', undefined];
regexp = /([\d]{5})([-\ ]?[\d]{4})?$/;
regexp.lastIndex = string.lastIndexOf('0');
assert.strictEqual(string.match(regexp).length, 3, 'S15.5.4.10_A2_T10 #1');
assert.strictEqual(string.match(regexp).index, string.lastIndexOf('0'), 'S15.5.4.10_A2_T10 #2');
for (let i = 0, { length } = matches; i < length; ++i) {
assert.strictEqual(string.match(regexp)[i], matches[i], 'S15.5.4.10_A2_T10 #3');
}
string = 'Boston, MA 02134';
matches = ['02134', '02134', undefined];
regexp = /([\d]{5})([-\ ]?[\d]{4})?$/;
regexp.lastIndex = string.lastIndexOf('0') + 1;
assert.strictEqual(string.match(regexp).length, 3, 'S15.5.4.10_A2_T11 #1');
assert.strictEqual(string.match(regexp).index, string.lastIndexOf('0'), 'S15.5.4.10_A2_T11 #2');
for (let i = 0, { length } = matches; i < length; ++i) {
assert.strictEqual(string.match(regexp)[i], matches[i], 'S15.5.4.10_A2_T11 #3');
}
*/
string = 'Boston, MA 02134';
regexp = /(\d{5})([ -]?\d{4})?$/g;
assert.strictEqual(string.match(regexp).length, 1, 'S15.5.4.10_A2_T12 #1');
assert.strictEqual(string.match(regexp)[0], '02134', 'S15.5.4.10_A2_T12 #2');
regexp = /(\d{5})([ -]?\d{4})?$/g;
regexp.lastIndex = 0;
string = 'Boston, MA 02134';
assert.strictEqual(string.match(regexp).length, 1, 'S15.5.4.10_A2_T13 #1');
assert.strictEqual(string.match(regexp)[0], '02134', 'S15.5.4.10_A2_T13 #2');
string = 'Boston, MA 02134';
regexp = /(\d{5})([ -]?\d{4})?$/g;
regexp.lastIndex = string.length;
assert.strictEqual(string.match(regexp).length, 1, 'S15.5.4.10_A2_T14 #1');
assert.strictEqual(string.match(regexp)[0], '02134', 'S15.5.4.10_A2_T14 #2');
string = 'Boston, MA 02134';
regexp = /(\d{5})([ -]?\d{4})?$/g;
regexp.lastIndex = string.lastIndexOf('0');
assert.strictEqual(string.match(regexp).length, 1, 'S15.5.4.10_A2_T15 #1');
assert.strictEqual(string.match(regexp)[0], '02134', 'S15.5.4.10_A2_T15 #2');
string = 'Boston, MA 02134';
regexp = /(\d{5})([ -]?\d{4})?$/g;
regexp.lastIndex = string.lastIndexOf('0') + 1;
assert.strictEqual(string.match(regexp).length, 1, 'S15.5.4.10_A2_T16 #1');
assert.strictEqual(string.match(regexp)[0], '02134', 'S15.5.4.10_A2_T16 #2');
regexp = /0./;
let number = 10203040506070809000;
assert.strictEqual(''.match.call(number, regexp)[0], '02', 'S15.5.4.10_A2_T17 #1');
assert.strictEqual(''.match.call(number, regexp).length, 1, 'S15.5.4.10_A2_T17 #2');
assert.strictEqual(''.match.call(number, regexp).index, 1, 'S15.5.4.10_A2_T17 #3');
assert.strictEqual(''.match.call(number, regexp).input, String(number), 'S15.5.4.10_A2_T17 #4');
regexp = /0./;
regexp.lastIndex = 0;
number = 10203040506070809000;
assert.strictEqual(''.match.call(number, regexp)[0], '02', 'S15.5.4.10_A2_T18 #1');
assert.strictEqual(''.match.call(number, regexp).length, 1, 'S15.5.4.10_A2_T18 #2');
assert.strictEqual(''.match.call(number, regexp).index, 1, 'S15.5.4.10_A2_T18 #3');
assert.strictEqual(''.match.call(number, regexp).input, String(number), 'S15.5.4.10_A2_T18 #4');
};
QUnit.test('String#match regression', run);
QUnit.test('RegExp#@@match appearance', assert => {
const match = /./[Symbol.match];
assert.isFunction(match);
// assert.name(match, '[Symbol.match]');
assert.arity(match, 1);
assert.looksNative(match);
assert.nonEnumerable(RegExp.prototype, Symbol.match);
});
QUnit.test('RegExp#@@match basic behavior', assert => {
const string = '123456abcde7890';
const matches = ['12', '34', '56', '78', '90'];
assert.strictEqual(/\d{2}/g[Symbol.match](string).length, 5);
for (let i = 0, { length } = matches; i < length; ++i) {
assert.strictEqual(/\d{2}/g[Symbol.match](string)[i], matches[i]);
}
});
QUnit.test('String#match delegates to @@match', assert => {
const string = STRICT ? 'string' : Object('string');
const number = STRICT ? 42 : Object(42);
const object = {};
object[Symbol.match] = function (it) {
return { value: it };
};
assert.strictEqual(string.match(object).value, string);
assert.strictEqual(''.match.call(number, object).value, number);
const regexp = /./;
regexp[Symbol.match] = function (it) {
return { value: it };
};
assert.strictEqual(string.match(regexp).value, string);
assert.strictEqual(''.match.call(number, regexp).value, number);
});
QUnit.test('RegExp#@@match delegates to exec', assert => {
const exec = function () {
execCalled = true;
return /./.exec.apply(this, arguments);
};
let execCalled = false;
let re = /[ac]/;
re.exec = exec;
assert.deepEqual(re[Symbol.match]('abc'), ['a']);
assert.ok(execCalled);
re = /a/;
// Not a function, should be ignored
re.exec = 3;
assert.deepEqual(re[Symbol.match]('abc'), ['a']);
re = /a/;
// Does not return an object, should throw
re.exec = () => 3;
assert.throws(() => re[Symbol.match]('abc'));
});
QUnit.test('RegExp#@@match implementation', patchRegExp$exec(run));
core-js-3.6.1/tests/tests/es.string.pad-end.js 0000664 0000000 0000000 00000001412 13600575677 0021166 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
QUnit.test('String#padEnd', assert => {
const { padEnd } = String.prototype;
assert.isFunction(padEnd);
assert.arity(padEnd, 1);
assert.name(padEnd, 'padEnd');
assert.looksNative(padEnd);
assert.nonEnumerable(String.prototype, 'padEnd');
assert.strictEqual('abc'.padEnd(5), 'abc ');
assert.strictEqual('abc'.padEnd(4, 'de'), 'abcd');
assert.strictEqual('abc'.padEnd(), 'abc');
assert.strictEqual('abc'.padEnd(5, '_'), 'abc__');
assert.strictEqual(''.padEnd(0), '');
assert.strictEqual('foo'.padEnd(1), 'foo');
assert.strictEqual('foo'.padEnd(5, ''), 'foo');
if (STRICT) {
assert.throws(() => padEnd.call(null, 0), TypeError);
assert.throws(() => padEnd.call(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/tests/es.string.pad-start.js 0000664 0000000 0000000 00000001454 13600575677 0021563 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
QUnit.test('String#padStart', assert => {
const { padStart } = String.prototype;
assert.isFunction(padStart);
assert.arity(padStart, 1);
assert.name(padStart, 'padStart');
assert.looksNative(padStart);
assert.nonEnumerable(String.prototype, 'padStart');
assert.strictEqual('abc'.padStart(5), ' abc');
assert.strictEqual('abc'.padStart(4, 'de'), 'dabc');
assert.strictEqual('abc'.padStart(), 'abc');
assert.strictEqual('abc'.padStart(5, '_'), '__abc');
assert.strictEqual(''.padStart(0), '');
assert.strictEqual('foo'.padStart(1), 'foo');
assert.strictEqual('foo'.padStart(5, ''), 'foo');
if (STRICT) {
assert.throws(() => padStart.call(null, 0), TypeError);
assert.throws(() => padStart.call(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/tests/es.string.raw.js 0000664 0000000 0000000 00000001052 13600575677 0020447 0 ustar 00root root 0000000 0000000 QUnit.test('String.raw', assert => {
const { raw } = String;
assert.isFunction(raw);
assert.arity(raw, 1);
assert.name(raw, 'raw');
assert.looksNative(raw);
assert.nonEnumerable(String, 'raw');
assert.strictEqual(raw({ raw: ['Hi\\n', '!'] }, 'Bob'), 'Hi\\nBob!', 'raw is array');
assert.strictEqual(raw({ raw: 'test' }, 0, 1, 2), 't0e1s2t', 'raw is string');
assert.strictEqual(raw({ raw: 'test' }, 0), 't0est', 'lacks substituting');
assert.throws(() => raw({}), TypeError);
assert.throws(() => raw({ raw: null }), TypeError);
});
core-js-3.6.1/tests/tests/es.string.repeat.js 0000664 0000000 0000000 00000001222 13600575677 0021135 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
QUnit.test('String#repeat', assert => {
const { repeat } = String.prototype;
assert.isFunction(repeat);
assert.arity(repeat, 1);
assert.name(repeat, 'repeat');
assert.looksNative(repeat);
assert.nonEnumerable(String.prototype, 'repeat');
assert.strictEqual('qwe'.repeat(3), 'qweqweqwe');
assert.strictEqual('qwe'.repeat(2.5), 'qweqwe');
assert.throws(() => 'qwe'.repeat(-1), RangeError);
assert.throws(() => 'qwe'.repeat(Infinity), RangeError);
if (STRICT) {
assert.throws(() => repeat.call(null, 1), TypeError);
assert.throws(() => repeat.call(undefined, 1), TypeError);
}
});
core-js-3.6.1/tests/tests/es.string.replace.js 0000664 0000000 0000000 00000021605 13600575677 0021277 0 ustar 00root root 0000000 0000000 import { GLOBAL, NATIVE, STRICT } from '../helpers/constants';
import { patchRegExp$exec } from '../helpers/helpers';
const Symbol = GLOBAL.Symbol || {};
const run = assert => {
assert.isFunction(''.replace);
assert.arity(''.replace, 2);
assert.name(''.replace, 'replace');
assert.looksNative(''.replace);
assert.nonEnumerable(String.prototype, 'replace');
let instance = Object(true);
instance.replace = String.prototype.replace;
assert.strictEqual(instance.replace(true, 1), '1', 'S15.5.4.11_A1_T1');
instance = Object(false);
instance.replace = String.prototype.replace;
assert.strictEqual(instance.replace(false, undefined), 'undefined', 'S15.5.4.11_A1_T2');
assert.strictEqual('gnulluna'.replace(null, (a1, a2) => `${ a2 }`), 'g1una', 'S15.5.4.11_A1_T4');
assert.strictEqual('gnulluna'.replace(null, () => { /* empty */ }), 'gundefineduna', 'S15.5.4.11_A1_T5');
assert.strictEqual(Object('undefined').replace(undefined, (a1, a2) => a2 + 42), '42', 'S15.5.4.11_A1_T6');
assert.strictEqual('undefined'.replace('e', undefined), 'undundefinedfined', 'S15.5.4.11_A1_T7');
assert.strictEqual(String({
toString() { /* empty */ },
}).replace(/e/g, undefined), 'undundefinedfinundefinedd', 'S15.5.4.11_A1_T8');
assert.strictEqual(new String({
valueOf() { /* empty */ },
toString: undefined,
}).replace(function () { /* empty */ }(), (a1, a2, a3) => a1 + a2 + a3), 'undefined0undefined', 'S15.5.4.11_A1_T9');
assert.strictEqual('ABB\u0041BABAB'.replace({
toString() {
return '\u0041B';
},
}, () => { /* empty */ }), 'undefinedBABABAB', 'S15.5.4.11_A1_T10');
if (NATIVE) {
try {
'ABB\u0041BABAB'.replace({
toString() {
throw new Error('insearchValue');
},
}, {
toString() {
throw new Error('inreplaceValue');
},
});
assert.ok(false, 'S15.5.4.11_A1_T11 #1 lead to throwing exception');
} catch (error) {
assert.strictEqual(error.message, 'insearchValue', 'S15.5.4.11_A1_T11 #2');
}
try {
Object('ABB\u0041BABAB').replace({
toString() {
return {};
},
valueOf() {
throw new Error('insearchValue');
},
}, {
toString() {
throw new Error('inreplaceValue');
},
});
assert.ok(false, 'S15.5.4.11_A1_T12 #1 lead to throwing exception');
} catch (error) {
assert.strictEqual(error.message, 'insearchValue', 'S15.5.4.11_A1_T12 #2');
}
}
try {
'ABB\u0041BABAB\u0031BBAA'.replace({
toString() {
return {};
},
valueOf() {
throw new Error('insearchValue');
},
}, {
toString() {
return 1;
},
});
assert.ok(false, 'S15.5.4.11_A1_T13 #1 lead to throwing exception');
} catch (error) {
assert.strictEqual(error.message, 'insearchValue', 'S15.5.4.11_A1_T13 #2');
}
assert.strictEqual('ABB\u0041BABAB\u0037\u0037BBAA'.replace(new RegExp('77'), 1), 'ABBABABAB\u0031BBAA', 'S15.5.4.11_A1_T14');
instance = Object(1100.00777001);
instance.replace = String.prototype.replace;
try {
instance.replace({
toString() {
return /77/;
},
}, 1);
assert.ok(false, 'S15.5.4.11_A1_T15 #1 lead to throwing exception');
} catch (error) {
assert.ok(error instanceof TypeError, 'S15.5.4.11_A1_T15 #2');
}
instance = Object(1100.00777001);
instance.replace = String.prototype.replace;
try {
instance.replace(/77/, {
toString() {
return (a1, a2) => `${ a2 }z`;
},
});
assert.ok(false, 'S15.5.4.11_A1_T16 #1 lead to throwing exception');
} catch (error) {
assert.ok(error instanceof TypeError, 'S15.5.4.11_A1_T16 #2');
}
assert.strictEqual('asdf'.replace(RegExp('', 'g'), '1'), '1a1s1d1f1', 'S15.5.4.11_A1_T17');
assert.strictEqual('She sells seashells by the seashore.'.replace(/sh/g, 'sch'), 'She sells seaschells by the seaschore.', 'S15.5.4.11_A2_T1');
assert.strictEqual('She sells seashells by the seashore.'.replace(/sh/g, '$$sch'), 'She sells sea$schells by the sea$schore.', 'S15.5.4.11_A2_T2');
assert.strictEqual('She sells seashells by the seashore.'.replace(/sh/g, '$&sch'), 'She sells seashschells by the seashschore.', 'S15.5.4.11_A2_T3');
// eslint-disable-next-line max-len
assert.strictEqual('She sells seashells by the seashore.'.replace(/sh/g, '$`sch'), 'She sells seaShe sells seaschells by the seaShe sells seashells by the seaschore.', 'S15.5.4.11_A2_T4');
assert.strictEqual('She sells seashells by the seashore.'.replace(/sh/g, "$'sch"), 'She sells seaells by the seashore.schells by the seaore.schore.', 'S15.5.4.11_A2_T5');
assert.strictEqual('She sells seashells by the seashore.'.replace(/sh/, 'sch'), 'She sells seaschells by the seashore.', 'S15.5.4.11_A2_T6');
assert.strictEqual('She sells seashells by the seashore.'.replace(/sh/, '$$sch'), 'She sells sea$schells by the seashore.', 'S15.5.4.11_A2_T7');
assert.strictEqual('She sells seashells by the seashore.'.replace(/sh/, '$&sch'), 'She sells seashschells by the seashore.', 'S15.5.4.11_A2_T8');
assert.strictEqual('She sells seashells by the seashore.'.replace(/sh/, '$`sch'), 'She sells seaShe sells seaschells by the seashore.', 'S15.5.4.11_A2_T9');
assert.strictEqual('She sells seashells by the seashore.'.replace(/sh/, "$'sch"), 'She sells seaells by the seashore.schells by the seashore.', 'S15.5.4.11_A2_T10');
assert.strictEqual('uid=31'.replace(/(uid=)(\d+)/, '$1115'), 'uid=115', 'S15.5.4.11_A3_T1');
assert.strictEqual('uid=31'.replace(/(uid=)(\d+)/, '$11A15'), 'uid=1A15', 'S15.5.4.11_A3_T3');
assert.strictEqual('abc12 def34'.replace(/([a-z]+)(\d+)/, (a, b, c) => c + b), '12abc def34', 'S15.5.4.11_A4_T1');
assert.strictEqual('aaaaaaaaaa,aaaaaaaaaaaaaaa'.replace(/^(a+)\1*,\1+$/, '$1'), 'aaaaa', 'S15.5.4.11_A5_T1');
// https://github.com/zloirock/core-js/issues/471
assert.strictEqual('{price} Retail'.replace(/{price}/g, '$25.00'), '$25.00 Retail');
assert.strictEqual('a'.replace(/(.)/, '$0'), '$0');
};
QUnit.test('String#replace regression', run);
QUnit.test('RegExp#@@replace appearance', assert => {
const replace = /./[Symbol.replace];
assert.isFunction(replace);
// assert.name(replace, '[Symbol.replace]');
assert.arity(replace, 2);
assert.looksNative(replace);
assert.nonEnumerable(RegExp.prototype, Symbol.replace);
});
QUnit.test('RegExp#@@replace basic behavior', assert => {
assert.strictEqual(/([a-z]+)(\d+)/[Symbol.replace]('abc12 def34', (a, b, c) => c + b), '12abc def34');
});
QUnit.test('String.replace delegates to @@replace', assert => {
const string = STRICT ? 'string' : Object('string');
const number = STRICT ? 42 : Object(42);
const object = {};
object[Symbol.replace] = function (a, b) {
return { a, b };
};
assert.strictEqual(string.replace(object, 42).a, string);
assert.strictEqual(string.replace(object, 42).b, 42);
assert.strictEqual(''.replace.call(number, object, 42).a, number);
assert.strictEqual(''.replace.call(number, object, 42).b, 42);
const regexp = /./;
regexp[Symbol.replace] = function (a, b) {
return { a, b };
};
assert.strictEqual(string.replace(regexp, 42).a, string);
assert.strictEqual(string.replace(regexp, 42).b, 42);
assert.strictEqual(''.replace.call(number, regexp, 42).a, number);
assert.strictEqual(''.replace.call(number, regexp, 42).b, 42);
});
QUnit.test('RegExp#@@replace delegates to exec', assert => {
const exec = function () {
execCalled = true;
return /./.exec.apply(this, arguments);
};
let execCalled = false;
let re = /[ac]/;
re.exec = exec;
assert.deepEqual(re[Symbol.replace]('abc', 'f'), 'fbc');
assert.ok(execCalled);
assert.strictEqual(re.lastIndex, 0);
execCalled = false;
re = /[ac]/g;
re.exec = exec;
assert.deepEqual(re[Symbol.replace]('abc', 'f'), 'fbf');
assert.ok(execCalled);
assert.strictEqual(re.lastIndex, 0);
re = /a/;
// Not a function, should be ignored
re.exec = 3;
assert.deepEqual(re[Symbol.replace]('abc', 'f'), 'fbc');
re = /a/;
// Does not return an object, should throw
re.exec = () => 3;
assert.throws(() => re[Symbol.replace]('abc', 'f'));
});
QUnit.test('RegExp#@@replace correctly handles substitutions', assert => {
const re = /./;
re.exec = function () {
const result = ['23', '7'];
result.groups = { '!!!': '7' };
result.index = 1;
return result;
};
assert.strictEqual('1234'.replace(re, '$1'), '174');
assert.strictEqual('1234'.replace(re, '$'), '174');
assert.strictEqual('1234'.replace(re, '$`'), '114');
assert.strictEqual('1234'.replace(re, '$\''), '144');
assert.strictEqual('1234'.replace(re, '$$'), '1$4');
assert.strictEqual('1234'.replace(re, '$&'), '1234');
assert.strictEqual('1234'.replace(re, '$x'), '1$x4');
let args;
assert.strictEqual('1234'.replace(re, (..._args) => { args = _args; return 'x'; }), '1x4');
assert.deepEqual(args, ['23', '7', 1, '1234', { '!!!': '7' }]);
});
QUnit.test('RegExp#@@replace implementation', patchRegExp$exec(run));
core-js-3.6.1/tests/tests/es.string.search.js 0000664 0000000 0000000 00000011577 13600575677 0021140 0 ustar 00root root 0000000 0000000 import { GLOBAL, STRICT } from '../helpers/constants';
import { patchRegExp$exec } from '../helpers/helpers';
const Symbol = GLOBAL.Symbol || {};
const run = assert => {
assert.isFunction(''.search);
assert.arity(''.search, 1);
assert.name(''.search, 'search');
assert.looksNative(''.search);
assert.nonEnumerable(String.prototype, 'search');
let instance = Object(true);
instance.search = String.prototype.search;
assert.strictEqual(instance.search(true), 0, 'S15.5.4.12_A1_T1');
instance = Object(false);
instance.search = String.prototype.search;
assert.strictEqual(instance.search(false), 0, 'S15.5.4.12_A1_T2');
assert.strictEqual(''.search(), 0, 'S15.5.4.12_A1_T4 #1');
assert.strictEqual('--undefined--'.search(), 0, 'S15.5.4.12_A1_T4 #2');
assert.strictEqual('gnulluna'.search(null), 1, 'S15.5.4.12_A1_T5');
assert.strictEqual(Object('undefined').search(undefined), 0, 'S15.5.4.12_A1_T6');
assert.strictEqual('undefined'.search(undefined), 0, 'S15.5.4.12_A1_T7');
assert.strictEqual(String({
toString() { /* empty */ },
}).search(undefined), 0, 'S15.5.4.12_A1_T8');
assert.strictEqual('ssABB\u0041BABAB'.search({
toString() {
return '\u0041B';
},
}), 2, 'S15.5.4.12_A1_T10');
try {
'ABB\u0041BABAB'.search({
toString() {
throw new Error('intostr');
},
});
assert.ok(false, 'S15.5.4.12_A1_T11 #1 lead to throwing exception');
} catch (error) {
assert.strictEqual(error.message, 'intostr', 'S15.5.4.12_A1_T11 #2');
}
try {
Object('ABB\u0041BABAB').search({
toString() {
return {};
},
valueOf() {
throw new Error('intostr');
},
});
assert.ok(false, 'S15.5.4.12_A1_T12 #1 lead to throwing exception');
} catch (error) {
assert.strictEqual(error.message, 'intostr', 'S15.5.4.12_A1_T12 #2');
}
assert.strictEqual('ABB\u0041B\u0031ABAB\u0031BBAA'.search({
toString() {
return {};
},
valueOf() {
return 1;
},
}), 5, 'S15.5.4.12_A1_T13');
assert.strictEqual('ABB\u0041BABAB\u0037\u0037BBAA'.search(RegExp('77')), 9, 'S15.5.4.12_A1_T14');
assert.strictEqual(Object('test string').search('string'), 5, 'S15.5.4.12_A2_T1');
assert.strictEqual(Object('test string').search('String'), -1, 'S15.5.4.12_A2_T2');
assert.strictEqual(Object('test string').search(/string/i), 5, 'S15.5.4.12_A2_T3');
assert.strictEqual(Object('test string').search(/Four/), -1, 'S15.5.4.12_A2_T4');
assert.strictEqual(Object('one two three four five').search(/four/), 14, 'S15.5.4.12_A2_T5');
assert.strictEqual(Object('test string').search('notexist'), -1, 'S15.5.4.12_A2_T6');
assert.strictEqual(Object('test string probe').search('string pro'), 5, 'S15.5.4.12_A2_T7');
let string = Object('power of the power of the power of the power of the power of the power of the great sword');
assert.strictEqual(string.search(/the/), string.search(/the/g), 'S15.5.4.12_A3_T1');
string = Object('power \u006F\u0066 the power of the power \u006F\u0066 the power of the power \u006F\u0066 the power of the great sword');
assert.strictEqual(string.search(/of/), string.search(/of/g), 'S15.5.4.12_A3_T2');
};
QUnit.test('String#search regression', run);
QUnit.test('RegExp#@@search appearance', assert => {
const search = /./[Symbol.search];
assert.isFunction(search);
// assert.name(search, '[Symbol.search]');
assert.arity(search, 1);
assert.looksNative(search);
assert.nonEnumerable(RegExp.prototype, Symbol.search);
});
QUnit.test('RegExp#@@search basic behavior', assert => {
assert.strictEqual(/four/[Symbol.search]('one two three four five'), 14);
assert.strictEqual(/Four/[Symbol.search]('one two three four five'), -1);
});
QUnit.test('String#search delegates to @@search', assert => {
const string = STRICT ? 'string' : Object('string');
const number = STRICT ? 42 : Object(42);
const object = {};
object[Symbol.search] = function (it) {
return { value: it };
};
assert.strictEqual(string.search(object).value, string);
assert.strictEqual(''.search.call(number, object).value, number);
const regexp = /./;
regexp[Symbol.search] = function (it) {
return { value: it };
};
assert.strictEqual(string.search(regexp).value, string);
assert.strictEqual(''.search.call(number, regexp).value, number);
});
QUnit.test('RegExp#@@search delegates to exec', assert => {
let execCalled = false;
let re = /b/;
re.lastIndex = 7;
re.exec = function () {
execCalled = true;
return /./.exec.apply(this, arguments);
};
assert.deepEqual(re[Symbol.search]('abc'), 1);
assert.ok(execCalled);
assert.strictEqual(re.lastIndex, 7);
re = /b/;
// Not a function, should be ignored
re.exec = 3;
assert.deepEqual(re[Symbol.search]('abc'), 1);
re = /b/;
// Does not return an object, should throw
re.exec = () => 3;
assert.throws(() => re[Symbol.search]('abc'));
});
QUnit.test('RegExp#@@search implementation', patchRegExp$exec(run));
core-js-3.6.1/tests/tests/es.string.small.js 0000664 0000000 0000000 00000000464 13600575677 0020774 0 ustar 00root root 0000000 0000000 QUnit.test('String#small', assert => {
const { small } = String.prototype;
assert.isFunction(small);
assert.arity(small, 0);
assert.name(small, 'small');
assert.looksNative(small);
assert.nonEnumerable(String.prototype, 'small');
assert.same('a'.small(), 'a ', 'lower case');
});
core-js-3.6.1/tests/tests/es.string.split.js 0000664 0000000 0000000 00000120212 13600575677 0021011 0 ustar 00root root 0000000 0000000 import { GLOBAL, NATIVE, STRICT } from '../helpers/constants';
import { patchRegExp$exec } from '../helpers/helpers';
const Symbol = GLOBAL.Symbol || {};
const run = assert => {
assert.isFunction(''.split);
assert.arity(''.split, 2);
assert.name(''.split, 'split');
assert.looksNative(''.split);
assert.nonEnumerable(String.prototype, 'split');
assert.arrayEqual('ab'.split(), ['ab'], 'If "separator" is undefined must return Array with one String - "this" string');
assert.arrayEqual('ab'.split(undefined), ['ab'], 'If "separator" is undefined must return Array with one String - "this" string');
assert.arrayEqual('ab'.split(undefined, 0), [], 'If "separator" is undefined and "limit" set to 0 must return Array[]');
assert.arrayEqual(''.split(), [''], "''.split() results in ['']");
assert.arrayEqual(''.split(/./), [''], "''.split(/./) results in ['']");
assert.arrayEqual(''.split(/.?/), [], "''.split(/.?/) results in []");
assert.arrayEqual(''.split(/.??/), [], "''.split(/.??/) results in []");
assert.arrayEqual('ab'.split(/a*/), ['', 'b'], "'ab'.split(/a*/) results in ['', 'b']");
assert.arrayEqual('ab'.split(/a*?/), ['a', 'b'], "'ab'.split(/a*?/) results in ['a', 'b']");
assert.arrayEqual('ab'.split(/(?:ab)/), ['', ''], "'ab'.split(/(?:ab)/) results in ['', '']");
assert.arrayEqual('ab'.split(/(?:ab)*/), ['', ''], "'ab'.split(/(?:ab)*/) results in ['', '']");
assert.arrayEqual('ab'.split(/(?:ab)*?/), ['a', 'b'], "'ab'.split(/(?:ab)*?/) results in ['a', 'b']");
assert.arrayEqual('test'.split(''), ['t', 'e', 's', 't'], "'test'.split('') results in ['t', 'e', 's', 't']");
assert.arrayEqual('test'.split(), ['test'], "'test'.split() results in ['test']");
assert.arrayEqual('111'.split(1), ['', '', '', ''], "'111'.split(1) results in ['', '', '', '']");
assert.arrayEqual('test'.split(/(?:)/, 2), ['t', 'e'], "'test'.split(/(?:)/, 2) results in ['t', 'e']");
assert.arrayEqual('test'.split(/(?:)/, -1), ['t', 'e', 's', 't'], "'test'.split(/(?:)/, -1) results in ['t', 'e', 's', 't']");
assert.arrayEqual('test'.split(/(?:)/, undefined), ['t', 'e', 's', 't'], "'test'.split(/(?:)/, undefined) results in ['t', 'e', 's', 't']");
assert.arrayEqual('test'.split(/(?:)/, null), [], "'test'.split(/(?:)/, null) results in []");
assert.arrayEqual('test'.split(/(?:)/, NaN), [], "'test'.split(/(?:)/, NaN) results in []");
assert.arrayEqual('test'.split(/(?:)/, true), ['t'], "'test'.split(/(?:)/, true) results in ['t']");
assert.arrayEqual('test'.split(/(?:)/, '2'), ['t', 'e'], "'test'.split(/(?:)/, '2') results in ['t', 'e']");
assert.arrayEqual('test'.split(/(?:)/, 'two'), [], "'test'.split(/(?:)/, 'two') results in []");
assert.arrayEqual('a'.split(/-/), ['a'], "'a'.split(/-/) results in ['a']");
assert.arrayEqual('a'.split(/-?/), ['a'], "'a'.split(/-?/) results in ['a']");
assert.arrayEqual('a'.split(/-??/), ['a'], "'a'.split(/-??/) results in ['a']");
assert.arrayEqual('a'.split(/a/), ['', ''], "'a'.split(/a/) results in ['', '']");
assert.arrayEqual('a'.split(/a?/), ['', ''], "'a'.split(/a?/) results in ['', '']");
assert.arrayEqual('a'.split(/a??/), ['a'], "'a'.split(/a??/) results in ['a']");
assert.arrayEqual('ab'.split(/-/), ['ab'], "'ab'.split(/-/) results in ['ab']");
assert.arrayEqual('ab'.split(/-?/), ['a', 'b'], "'ab'.split(/-?/) results in ['a', 'b']");
assert.arrayEqual('ab'.split(/-??/), ['a', 'b'], "'ab'.split(/-??/) results in ['a', 'b']");
assert.arrayEqual('a-b'.split(/-/), ['a', 'b'], "'a-b'.split(/-/) results in ['a', 'b']");
assert.arrayEqual('a-b'.split(/-?/), ['a', 'b'], "'a-b'.split(/-?/) results in ['a', 'b']");
assert.arrayEqual('a-b'.split(/-??/), ['a', '-', 'b'], "'a-b'.split(/-??/) results in ['a', '-', 'b']");
assert.arrayEqual('a--b'.split(/-/), ['a', '', 'b'], "'a--b'.split(/-/) results in ['a', '', 'b']");
assert.arrayEqual('a--b'.split(/-?/), ['a', '', 'b'], "'a--b'.split(/-?/) results in ['a', '', 'b']");
assert.arrayEqual('a--b'.split(/-??/), ['a', '-', '-', 'b'], "'a--b'.split(/-??/) results in ['a', '-', '-', 'b']");
assert.arrayEqual(''.split(/()()/), [], "''.split(/()()/) results in []");
assert.arrayEqual('.'.split(/()()/), ['.'], "'.'.split(/()()/) results in ['.']");
assert.arrayEqual('.'.split(/(.?)(.?)/), ['', '.', '', ''], "'.'.split(/(.?)(.?)/) results in ['', '.', '', '']");
assert.arrayEqual('.'.split(/(.??)(.??)/), ['.'], "'.'.split(/(.??)(.??)/) results in ['.']");
assert.arrayEqual('.'.split(/(.)?(.)?/), ['', '.', undefined, ''], "'.'.split(/(.)?(.)?/) results in ['', '.', undefined, '']");
// eslint-disable-next-line max-len
assert.arrayEqual('Abold andcoded'.split(/<(\/)?([^<>]+)>/), ['A', undefined, 'B', 'bold', '/', 'B', 'and', undefined, 'CODE', 'coded', '/', 'CODE', ''], "'Abold andcoded'.split(/<(\\/)?([^<>]+)>/) results in ['A', undefined, 'B', 'bold', '/', 'B', 'and', undefined, 'CODE', 'coded', '/', 'CODE', '']");
assert.arrayEqual('tesst'.split(/(s)*/), ['t', undefined, 'e', 's', 't'], "'tesst'.split(/(s)*/) results in ['t', undefined, 'e', 's', 't']");
// eslint-disable-next-line max-len
assert.arrayEqual('tesst'.split(/(s)*?/), ['t', undefined, 'e', undefined, 's', undefined, 's', undefined, 't'], "'tesst'.split(/(s)*?/) results in ['t', undefined, 'e', undefined, 's', undefined, 's', undefined, 't']");
assert.arrayEqual('tesst'.split(/(s*)/), ['t', '', 'e', 'ss', 't'], "'tesst'.split(/(s*)/) results in ['t', '', 'e', 'ss', 't']");
assert.arrayEqual('tesst'.split(/(s*?)/), ['t', '', 'e', '', 's', '', 's', '', 't'], "'tesst'.split(/(s*?)/) results in ['t', '', 'e', '', 's', '', 's', '', 't']");
assert.arrayEqual('tesst'.split(/s*/), ['t', 'e', 't'], "'tesst'.split(/(?:s)*/) results in ['t', 'e', 't']");
assert.arrayEqual('tesst'.split(/(?=s+)/), ['te', 's', 'st'], "'tesst'.split(/(?=s+)/) results in ['te', 's', 'st']");
assert.arrayEqual('test'.split('t'), ['', 'es', ''], "'test'.split('t') results in ['', 'es', '']");
assert.arrayEqual('test'.split('es'), ['t', 't'], "'test'.split('es') results in ['t', 't']");
assert.arrayEqual('test'.split(/t/), ['', 'es', ''], "'test'.split(/t/) results in ['', 'es', '']");
assert.arrayEqual('test'.split(/es/), ['t', 't'], "'test'.split(/es/) results in ['t', 't']");
assert.arrayEqual('test'.split(/(t)/), ['', 't', 'es', 't', ''], "'test'.split(/(t)/) results in ['', 't', 'es', 't', '']");
assert.arrayEqual('test'.split(/(es)/), ['t', 'es', 't'], "'test'.split(/(es)/) results in ['t', 'es', 't']");
assert.arrayEqual('test'.split(/(t)(e)(s)(t)/), ['', 't', 'e', 's', 't', ''], "'test'.split(/(t)(e)(s)(t)/) results in ['', 't', 'e', 's', 't', '']");
assert.arrayEqual('.'.split(/(((.((.??)))))/), ['', '.', '.', '.', '', '', ''], "'.'.split(/(((.((.??)))))/) results in ['', '.', '.', '.', '', '', '']");
assert.arrayEqual('.'.split(/(((((.??)))))/), ['.'], "'.'.split(/(((((.??)))))/) results in ['.']");
assert.arrayEqual('a b c d'.split(/ /, -(2 ** 32) + 1), ['a'], "'a b c d'.split(/ /, -(2 ** 32) + 1) results in ['a']");
assert.arrayEqual('a b c d'.split(/ /, 2 ** 32 + 1), ['a'], "'a b c d'.split(/ /, 2 ** 32 + 1) results in ['a']");
assert.arrayEqual('a b c d'.split(/ /, Infinity), [], "'a b c d'.split(/ /, Infinity) results in []");
let instance = Object(true);
instance.split = String.prototype.split;
let split = instance.split(true, false);
assert.strictEqual(typeof split, 'object', 'S15.5.4.14_A1_T1 #1');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A1_T1 #2');
assert.strictEqual(split.length, 0, 'S15.5.4.14_A1_T1 #3');
instance = Object(false);
instance.split = String.prototype.split;
split = instance.split(false, 0, null);
assert.strictEqual(typeof split, 'object', 'S15.5.4.14_A1_T2 #1');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A1_T2 #2');
assert.strictEqual(split.length, 0, 'S15.5.4.14_A1_T2 #3');
split = ''.split();
assert.strictEqual(typeof split, 'object', 'S15.5.4.14_A1_T4 #1');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A1_T4 #2');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A1_T4 #3');
assert.strictEqual(split[0], '', 'S15.5.4.14_A1_T4 #4');
split = 'gnulluna'.split(null);
assert.strictEqual(typeof split, 'object', 'S15.5.4.14_A1_T5 #1');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A1_T5 #2');
assert.strictEqual(split.length, 2, 'S15.5.4.14_A1_T5 #3');
assert.strictEqual(split[0], 'g', 'S15.5.4.14_A1_T5 #4');
assert.strictEqual(split[1], 'una', 'S15.5.4.14_A1_T5 #5');
if (NATIVE) {
split = Object('1undefined').split(undefined);
assert.strictEqual(typeof split, 'object', 'S15.5.4.14_A1_T6 #1');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A1_T6 #2');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A1_T6 #3');
assert.strictEqual(split[0], '1undefined', 'S15.5.4.14_A1_T6 #4');
split = 'undefinedd'.split(undefined);
assert.strictEqual(typeof split, 'object', 'S15.5.4.14_A1_T7 #1');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A1_T7 #2');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A1_T7 #3');
assert.strictEqual(split[0], 'undefinedd', 'S15.5.4.14_A1_T7 #4');
split = String({
toString() { /* empty */ },
}).split(undefined);
assert.strictEqual(typeof split, 'object', 'S15.5.4.14_A1_T8 #1');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A1_T8 #2');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A1_T8 #3');
assert.strictEqual(split[0], 'undefined', 'S15.5.4.14_A1_T8 #4');
}
split = new String({
valueOf() { /* empty */ },
toString: undefined,
}).split(() => { /* empty */ });
assert.strictEqual(typeof split, 'object', 'S15.5.4.14_A1_T9 #1');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A1_T9 #2');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A1_T9 #3');
assert.strictEqual(split[0], 'undefined', 'S15.5.4.14_A1_T9 #4');
split = 'ABB\u0041BABAB'.split({
toString() {
return '\u0042B';
},
}, {
valueOf() {
return true;
},
});
assert.strictEqual(typeof split, 'object', 'S15.5.4.14_A1_T10 #1');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A1_T10 #2');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A1_T10 #3');
assert.strictEqual(split[0], 'A', 'S15.5.4.14_A1_T10 #4');
try {
'ABB\u0041BABAB'.split({
toString() {
return '\u0041B';
},
}, {
valueOf() {
throw new Error('intointeger');
},
});
assert.ok(false, 'S15.5.4.14_A1_T11 #1 lead to throwing exception');
} catch (error) {
assert.strictEqual(error.message, 'intointeger', 'S15.5.4.14_A1_T11 #2');
}
if (NATIVE) {
try {
new String('ABB\u0041BABAB').split({
toString() {
return '\u0041B';
},
}, {
valueOf() {
return {};
},
toString() {
throw new Error('intointeger');
},
});
assert.ok(false, 'S15.5.4.14_A1_T12 #1 lead to throwing exception');
} catch (error) {
assert.strictEqual(error.message, 'intointeger', 'S15.5.4.14_A1_T12 #2');
}
}
split = 'ABB\u0041BABAB\u0042cc^^\u0042Bvv%%B\u0042xxx'.split({
toString() {
return '\u0042\u0042';
},
}, {
valueOf() {
return {};
},
toString() {
return '2';
},
});
assert.strictEqual(typeof split, 'object', 'S15.5.4.14_A1_T13 #1');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A1_T13 #2');
assert.strictEqual(split.length, 2, 'S15.5.4.14_A1_T13 #3');
assert.strictEqual(split[0], 'A', 'S15.5.4.14_A1_T13 #4');
assert.strictEqual(split[1], 'ABABA', 'S15.5.4.14_A1_T13 #5');
if (NATIVE) {
try {
instance = Object(10001.10001);
instance.split = String.prototype.split;
instance.split({
toString() {
throw new Error('intostr');
},
}, {
valueOf() {
throw new Error('intoint');
},
});
assert.ok(false, 'S15.5.4.14_A1_T14 #1 lead to throwing exception');
} catch (error) {
assert.strictEqual(error.message, 'intoint', 'S15.5.4.14_A1_T14 #2');
}
try {
class F {
costructor(value) {
this.value = value;
}
valueOf() {
return `${ this.value }`;
}
toString() {
return new Number();
}
}
F.prototype.split = String.prototype.split;
new F().split({
toString() {
return {};
},
valueOf() {
throw new Error('intostr');
},
}, {
valueOf() {
throw new Error('intoint');
},
});
assert.ok(false, 'S15.5.4.14_A1_T15 #1 lead to throwing exception');
} catch (error) {
assert.strictEqual(error.message, 'intoint', 'S15.5.4.14_A1_T15 #2');
}
}
try {
String.prototype.split.call(6776767677.006771122677555, {
toString() {
return /77/g;
},
});
assert.ok(false, 'S15.5.4.14_A1_T16 #1 lead to throwing exception');
} catch (error) {
assert.ok(error instanceof TypeError, 'S15.5.4.14_A1_T16 #2');
}
split = String.prototype.split.call(6776767677.006771122677555, /77/g);
assert.strictEqual(typeof split, 'object', 'S15.5.4.14_A1_T17 #1');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A1_T17 #2');
assert.strictEqual(split.length, 4, 'S15.5.4.14_A1_T17 #3');
assert.strictEqual(split[0], '6', 'S15.5.4.14_A1_T17 #4');
assert.strictEqual(split[1], '67676', 'S15.5.4.14_A1_T17 #5');
assert.strictEqual(split[2], '.006', 'S15.5.4.14_A1_T17 #6');
assert.strictEqual(split[3], '1', 'S15.5.4.14_A1_T17 #7');
split = String.prototype.split.call(6776767677.006771122677555, /00/, 1);
assert.strictEqual(typeof split, 'object', 'S15.5.4.14_A1_T18 #1');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A1_T18 #2');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A1_T18 #3');
assert.strictEqual(split[0], '6776767677.', 'S15.5.4.14_A1_T18 #4');
split = Object('one,two,three,four,five').split(',');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T1 #1');
assert.strictEqual(split.length, 5, 'S15.5.4.14_A2_T1 #2');
assert.strictEqual(split[0], 'one', 'S15.5.4.14_A2_T1 #3');
assert.strictEqual(split[1], 'two', 'S15.5.4.14_A2_T1 #4');
assert.strictEqual(split[2], 'three', 'S15.5.4.14_A2_T1 #5');
assert.strictEqual(split[3], 'four', 'S15.5.4.14_A2_T1 #6');
assert.strictEqual(split[4], 'five', 'S15.5.4.14_A2_T1 #7');
split = Object('one two three four five').split(' ');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T2 #1');
assert.strictEqual(split.length, 5, 'S15.5.4.14_A2_T2 #2');
assert.strictEqual(split[0], 'one', 'S15.5.4.14_A2_T2 #3');
assert.strictEqual(split[1], 'two', 'S15.5.4.14_A2_T2 #4');
assert.strictEqual(split[2], 'three', 'S15.5.4.14_A2_T2 #5');
assert.strictEqual(split[3], 'four', 'S15.5.4.14_A2_T2 #6');
assert.strictEqual(split[4], 'five', 'S15.5.4.14_A2_T2 #7');
split = Object('one two three four five').split(RegExp(' '), 2);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T3 #1');
assert.strictEqual(split.length, 2, 'S15.5.4.14_A2_T3 #2');
assert.strictEqual(split[0], 'one', 'S15.5.4.14_A2_T3 #3');
assert.strictEqual(split[1], 'two', 'S15.5.4.14_A2_T3 #4');
split = Object('one two three').split('');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T4 #1');
assert.strictEqual(split.length, 'one two three'.length, 'S15.5.4.14_A2_T4 #2');
assert.strictEqual(split[0], 'o', 'S15.5.4.14_A2_T4 #3');
assert.strictEqual(split[1], 'n', 'S15.5.4.14_A2_T4 #4');
assert.strictEqual(split[11], 'e', 'S15.5.4.14_A2_T4 #5');
assert.strictEqual(split[12], 'e', 'S15.5.4.14_A2_T4 #6');
split = Object('one-1,two-2,four-4').split(/,/);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T5 #1');
assert.strictEqual(split.length, 3, 'S15.5.4.14_A2_T5 #2');
assert.strictEqual(split[0], 'one-1', 'S15.5.4.14_A2_T5 #3');
assert.strictEqual(split[1], 'two-2', 'S15.5.4.14_A2_T5 #4');
assert.strictEqual(split[2], 'four-4', 'S15.5.4.14_A2_T5 #5');
let string = Object('one-1 two-2 three-3');
split = string.split('');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T6 #1');
assert.strictEqual(split.length, string.length, 'S15.5.4.14_A2_T6 #2');
for (let i = 0, { length } = split; i < length; ++i) {
assert.strictEqual(split[i], string.charAt(i), `S15.5.4.14_A2_T6 #${ i + 3 }`);
}
if (NATIVE) {
string = 'thisundefinedisundefinedaundefinedstringundefinedobject';
split = string.split(undefined);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T7 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A2_T7 #2');
assert.strictEqual(split[0], string, 'S15.5.4.14_A2_T7 #3');
}
string = 'thisnullisnullanullstringnullobject';
let expected = ['this', 'is', 'a', 'string', 'object'];
split = string.split(null);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T8 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A2_T8 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A2_T8 #${ i + 3 }`);
}
string = 'thistrueistrueatruestringtrueobject';
expected = ['this', 'is', 'a', 'string', 'object'];
split = string.split(true);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T9 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A2_T9 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A2_T9 #${ i + 3 }`);
}
string = 'this123is123a123string123object';
expected = ['this', 'is', 'a', 'string', 'object'];
split = string.split(123);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T10 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A2_T10 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A2_T10 #${ i + 3 }`);
}
split = Object('one-1,two-2,four-4').split(':');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T11 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A2_T11 #2');
assert.strictEqual(split[0], 'one-1,two-2,four-4', 'S15.5.4.14_A2_T11 #3');
split = Object('one-1 two-2 four-4').split('r-42');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T12 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A2_T12 #2');
assert.strictEqual(split[0], 'one-1 two-2 four-4', 'S15.5.4.14_A2_T12 #3');
split = Object('one-1 two-2 four-4').split('-4');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T13 #1');
assert.strictEqual(split.length, 2, 'S15.5.4.14_A2_T13 #2');
assert.strictEqual(split[0], 'one-1 two-2 four', 'S15.5.4.14_A2_T13 #3');
assert.strictEqual(split[1], '', 'S15.5.4.14_A2_T13 #4');
split = Object('one-1 two-2 four-4').split('on');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T14 #1');
assert.strictEqual(split.length, 2, 'S15.5.4.14_A2_T14 #2');
assert.strictEqual(split[0], '', 'S15.5.4.14_A2_T14 #3');
assert.strictEqual(split[1], 'e-1 two-2 four-4', 'S15.5.4.14_A2_T14 #4');
split = new String().split('');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T15 #1');
assert.strictEqual(split.length, 0, 'S15.5.4.14_A2_T15 #2');
assert.strictEqual(split[0], undefined, 'S15.5.4.14_A2_T15 #3');
split = new String().split(' ');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T16 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A2_T16 #2');
assert.strictEqual(split[0], '', 'S15.5.4.14_A2_T16 #3');
split = Object(' ').split('');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T18 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A2_T18 #2');
assert.strictEqual(split[0], ' ', 'S15.5.4.14_A2_T18 #3');
split = Object(' ').split(' ');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T19 #1');
assert.strictEqual(split.length, 2, 'S15.5.4.14_A2_T19 #2');
assert.strictEqual(split[0], '', 'S15.5.4.14_A2_T19 #3');
assert.strictEqual(split[1], '', 'S15.5.4.14_A2_T19 #4');
split = ''.split('x');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T19 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A2_T19 #2');
assert.strictEqual(split[0], '', 'S15.5.4.14_A2_T19 #3');
string = Object('one-1 two-2 three-3');
split = string.split(new RegExp());
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T20 #1');
assert.strictEqual(split.length, string.length, 'S15.5.4.14_A2_T20 #2');
for (let i = 0, { length } = split; i < length; ++i) {
assert.strictEqual(split[i], string.charAt(i), `S15.5.4.14_A2_T20 #${ i + 3 }`);
}
split = Object('hello').split('ll');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T21 #1');
assert.strictEqual(split.length, 2, 'S15.5.4.14_A2_T21 #2');
assert.strictEqual(split[0], 'he', 'S15.5.4.14_A2_T21 #3');
assert.strictEqual(split[1], 'o', 'S15.5.4.14_A2_T21 #4');
split = Object('hello').split('l');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T22 #1');
assert.strictEqual(split.length, 3, 'S15.5.4.14_A2_T22 #2');
assert.strictEqual(split[0], 'he', 'S15.5.4.14_A2_T22 #3');
assert.strictEqual(split[1], '', 'S15.5.4.14_A2_T22 #4');
assert.strictEqual(split[2], 'o', 'S15.5.4.14_A2_T22 #5');
split = Object('hello').split('x');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T23 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A2_T23 #2');
assert.strictEqual(split[0], 'hello', 'S15.5.4.14_A2_T23 #3');
split = Object('hello').split('h');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T24 #1');
assert.strictEqual(split.length, 2, 'S15.5.4.14_A2_T24 #2');
assert.strictEqual(split[0], '', 'S15.5.4.14_A2_T24 #3');
assert.strictEqual(split[1], 'ello', 'S15.5.4.14_A2_T24 #4');
split = Object('hello').split('o');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T25 #1');
assert.strictEqual(split.length, 2, 'S15.5.4.14_A2_T25 #2');
assert.strictEqual(split[0], 'hell', 'S15.5.4.14_A2_T25 #3');
assert.strictEqual(split[1], '', 'S15.5.4.14_A2_T25 #4');
split = Object('hello').split('hello');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T26 #1');
assert.strictEqual(split.length, 2, 'S15.5.4.14_A2_T26 #2');
assert.strictEqual(split[0], '', 'S15.5.4.14_A2_T26 #3');
assert.strictEqual(split[1], '', 'S15.5.4.14_A2_T26 #4');
split = Object('hello').split(undefined);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T27 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A2_T27 #2');
assert.strictEqual(split[0], 'hello', 'S15.5.4.14_A2_T27 #3');
split = Object('hello').split('hellothere');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T28 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A2_T28 #2');
assert.strictEqual(split[0], 'hello', 'S15.5.4.14_A2_T28 #3');
instance = Object(100111122133144155);
instance.split = String.prototype.split;
split = instance.split(1);
expected = ['', '00', '', '', '', '22', '33', '44', '60'];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T29 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A2_T29 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A2_T29 #${ i + 3 }`);
}
instance = Object(100111122133144155);
instance.split = String.prototype.split;
split = instance.split(1, 1);
expected = [''];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T30 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A2_T30 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A2_T30 #${ i + 3 }`);
}
instance = Object(100111122133144155);
instance.split = String.prototype.split;
split = instance.split(1, 2);
expected = ['', '00'];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T31 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A2_T31 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A2_T31 #${ i + 3 }`);
}
instance = Object(100111122133144155);
instance.split = String.prototype.split;
split = instance.split(1, 0);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T32 #1');
assert.strictEqual(split.length, 0, 'S15.5.4.14_A2_T32 #2');
instance = Object(100111122133144155);
instance.split = String.prototype.split;
split = instance.split(1, 100);
expected = ['', '00', '', '', '', '22', '33', '44', '60'];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T33 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A2_T33 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A2_T33 #${ i + 3 }`);
}
instance = Object(100111122133144155);
instance.split = String.prototype.split;
split = instance.split(1, undefined);
expected = ['', '00', '', '', '', '22', '33', '44', '60'];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T34 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A2_T34 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A2_T34 #${ i + 3 }`);
}
instance = Object(100111122133144155);
instance.split = String.prototype.split;
split = instance.split(1, 2 ** 32 - 1);
expected = ['', '00', '', '', '', '22', '33', '44', '60'];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T35 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A2_T35 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A2_T35 #${ i + 3 }`);
}
instance = Object(100111122133144155);
instance.split = String.prototype.split;
split = instance.split(1, 'boo');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T36 #1');
assert.strictEqual(split.length, 0, 'S15.5.4.14_A2_T36 #2');
instance = Object(100111122133144155);
instance.split = String.prototype.split;
split = instance.split(1, -(2 ** 32) + 1);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T37 #1');
assert.arrayEqual(split, [''], 'S15.5.4.14_A2_T37 #2');
instance = Object(100111122133144155);
instance.split = String.prototype.split;
split = instance.split(1, NaN);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T38 #1');
assert.strictEqual(split.length, 0, 'S15.5.4.14_A2_T38 #2');
instance = Object('hello').split('l', 0);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T39 #1');
assert.strictEqual(split.length, 0, 'S15.5.4.14_A2_T39 #2');
split = Object('hello').split('l', 1);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T40 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A2_T40 #2');
assert.strictEqual(split[0], 'he', 'S15.5.4.14_A2_T40 #3');
split = Object('hello').split('l', 2);
expected = ['he', ''];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T41 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A2_T41 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A2_T41 #${ i + 3 }`);
}
split = Object('hello').split('l', 3);
expected = ['he', '', 'o'];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T42 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A2_T42 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A2_T42 #${ i + 3 }`);
}
split = Object('hello').split('l', 4);
expected = ['he', '', 'o'];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A2_T43 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A2_T43 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A2_T43 #${ i + 3 }`);
}
split = Object('one,two,three,four,five').split();
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A3_T1 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A3_T1 #2');
assert.strictEqual(split[0], 'one,two,three,four,five', 'S15.5.4.14_A3_T1 #3');
split = String.prototype.split.call({});
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A3_T2 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A3_T2 #2');
assert.strictEqual(split[0], '[object Object]', 'S15.5.4.14_A3_T2 #3');
split = String.prototype.split.call({
toString() {
return 'function(){}';
},
});
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A3_T3 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A3_T3 #2');
assert.strictEqual(split[0], 'function(){}', 'S15.5.4.14_A3_T3 #3');
split = String.prototype.split.call(Object(NaN));
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A3_T4 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A3_T4 #2');
assert.strictEqual(split[0], 'NaN', 'S15.5.4.14_A3_T4 #3');
split = String.prototype.split.call(Object(-1234567890));
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A3_T5 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A3_T5 #2');
assert.strictEqual(split[0], '-1234567890', 'S15.5.4.14_A3_T5 #3');
instance = Object(-1e21);
split = String.prototype.split.call(instance);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A3_T6 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A3_T6 #2');
assert.strictEqual(split[0], instance.toString(), 'S15.5.4.14_A3_T6 #3');
split = String.prototype.split.call(Math);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A3_T7 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A3_T7 #2');
assert.strictEqual(split[0], '[object Math]', 'S15.5.4.14_A3_T7 #3');
split = String.prototype.split.call([1, 2, 3, 4, 5]);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A3_T8 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A3_T8 #2');
assert.strictEqual(split[0], '1,2,3,4,5', 'S15.5.4.14_A3_T8 #3');
split = String.prototype.split.call(Object(false));
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A3_T9 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A3_T9 #2');
assert.strictEqual(split[0], 'false', 'S15.5.4.14_A3_T9 #3');
split = String.prototype.split.call(new String());
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A3_T10 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A3_T10 #2');
assert.strictEqual(split[0], '', 'S15.5.4.14_A3_T10 #3');
split = String.prototype.split.call(Object(' '));
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A3_T11 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A3_T11 #2');
assert.strictEqual(split[0], ' ', 'S15.5.4.14_A3_T11 #3');
if (NATIVE) {
split = Object('hello').split(/l/);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T1 #1');
assert.strictEqual(split.length, 3, 'S15.5.4.14_A4_T1 #2');
assert.strictEqual(split[0], 'he', 'S15.5.4.14_A4_T1 #3');
assert.strictEqual(split[1], '', 'S15.5.4.14_A4_T1 #4');
assert.strictEqual(split[2], 'o', 'S15.5.4.14_A4_T1 #5');
}
split = Object('hello').split(/l/, 0);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T2 #1');
assert.strictEqual(split.length, 0, 'S15.5.4.14_A4_T2 #2');
split = Object('hello').split(/l/, 1);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T3 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A4_T3 #2');
assert.strictEqual(split[0], 'he', 'S15.5.4.14_A4_T3 #3');
if (NATIVE) {
split = Object('hello').split(/l/, 2);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T4 #1');
assert.strictEqual(split.length, 2, 'S15.5.4.14_A4_T4 #2');
assert.strictEqual(split[0], 'he', 'S15.5.4.14_A4_T4 #3');
assert.strictEqual(split[1], '', 'S15.5.4.14_A4_T4 #4');
split = Object('hello').split(/l/, 3);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T5 #1');
assert.strictEqual(split.length, 3, 'S15.5.4.14_A4_T5 #2');
assert.strictEqual(split[0], 'he', 'S15.5.4.14_A4_T5 #3');
assert.strictEqual(split[1], '', 'S15.5.4.14_A4_T5 #4');
assert.strictEqual(split[2], 'o', 'S15.5.4.14_A4_T5 #5');
split = Object('hello').split(/l/, 4);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T6 #1');
assert.strictEqual(split.length, 3, 'S15.5.4.14_A4_T6 #2');
assert.strictEqual(split[0], 'he', 'S15.5.4.14_A4_T6 #3');
assert.strictEqual(split[1], '', 'S15.5.4.14_A4_T6 #4');
assert.strictEqual(split[2], 'o', 'S15.5.4.14_A4_T6 #5');
split = Object('hello').split(/l/, undefined);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T7 #1');
assert.strictEqual(split.length, 3, 'S15.5.4.14_A4_T7 #2');
assert.strictEqual(split[0], 'he', 'S15.5.4.14_A4_T7 #3');
assert.strictEqual(split[1], '', 'S15.5.4.14_A4_T7 #4');
assert.strictEqual(split[2], 'o', 'S15.5.4.14_A4_T7 #5');
}
split = Object('hello').split(/l/, 'hi');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T8 #1');
assert.strictEqual(split.length, 0, 'S15.5.4.14_A4_T8 #2');
split = Object('hello').split(new RegExp());
expected = ['h', 'e', 'l', 'l', 'o'];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T10 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A4_T10 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A4_T10 #${ i + 3 }`);
}
split = Object('hello').split(new RegExp(), 0);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T11 #1');
assert.strictEqual(split.length, 0, 'S15.5.4.14_A4_T11 #2');
split = Object('hello').split(new RegExp(), 1);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T12 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A4_T12 #2');
assert.strictEqual(split[0], 'h', 'S15.5.4.14_A4_T12 #3');
split = Object('hello').split(new RegExp(), 2);
expected = ['h', 'e'];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T13 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A4_T13 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A4_T13 #${ i + 3 }`);
}
split = Object('hello').split(new RegExp(), 3);
expected = ['h', 'e', 'l'];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T14 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A4_T14 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A4_T14 #${ i + 3 }`);
}
split = Object('hello').split(new RegExp(), 4);
expected = ['h', 'e', 'l', 'l'];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T15 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A4_T15 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A4_T15 #${ i + 3 }`);
}
split = Object('hello').split(new RegExp(), undefined);
expected = ['h', 'e', 'l', 'l', 'o'];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T16 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A4_T16 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A4_T16 #${ i + 3 }`);
}
split = Object('hello').split(new RegExp(), 'hi');
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T18 #1');
assert.strictEqual(split.length, 0, 'S15.5.4.14_A4_T18 #2');
split = Object('a b c de f').split(/\s/);
expected = ['a', 'b', 'c', 'de', 'f'];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T19 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A4_T19 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A4_T19 #${ i + 3 }`);
}
split = Object('a b c de f').split(/\s/, 3);
expected = ['a', 'b', 'c'];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T20 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A4_T20 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A4_T20 #${ i + 3 }`);
}
split = Object('a b c de f').split(/X/);
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T21 #1');
assert.strictEqual(split.length, 1, 'S15.5.4.14_A4_T21 #2');
assert.strictEqual(split[0], 'a b c de f', 'S15.5.4.14_A4_T21 #3');
split = Object('dfe23iu 34 =+65--').split(/\d+/);
expected = ['dfe', 'iu ', ' =+', '--'];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T22 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A4_T22 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A4_T22 #${ i + 3 }`);
}
if (NATIVE) {
split = Object('abc').split(/[a-z]/);
expected = ['', '', '', ''];
assert.strictEqual(split.constructor, Array, 'S15.5.4.14_A4_T24 #1');
assert.strictEqual(split.length, expected.length, 'S15.5.4.14_A4_T24 #2');
for (let i = 0, { length } = expected; i < length; ++i) {
assert.strictEqual(expected[i], split[i], `S15.5.4.14_A4_T24 #${ i + 3 }`);
}
}
};
QUnit.test('String#split regression', run);
QUnit.test('RegExp#@@split appearance', assert => {
const split = /./[Symbol.split];
assert.isFunction(split);
// assert.name(split, '[Symbol.split]');
assert.arity(split, 2);
assert.looksNative(split);
assert.nonEnumerable(RegExp.prototype, Symbol.split);
});
QUnit.test('RegExp#@@split basic behavior', assert => {
assert.strictEqual(/\s/[Symbol.split]('a b c de f').length, 5);
assert.strictEqual(/\s/[Symbol.split]('a b c de f', undefined).length, 5);
assert.strictEqual(/\s/[Symbol.split]('a b c de f', 1).length, 1);
assert.strictEqual(/\s/[Symbol.split]('a b c de f', 10).length, 5);
});
QUnit.test('String#split delegates to @@split', assert => {
const string = STRICT ? 'string' : Object('string');
const number = STRICT ? 42 : Object(42);
const object = {};
object[Symbol.split] = function (a, b) {
return { a, b };
};
assert.strictEqual(string.split(object, 42).a, string);
assert.strictEqual(string.split(object, 42).b, 42);
assert.strictEqual(''.split.call(number, object, 42).a, number);
assert.strictEqual(''.split.call(number, object, 42).b, 42);
const regexp = /./;
regexp[Symbol.split] = function (a, b) {
return { a, b };
};
assert.strictEqual(string.split(regexp, 42).a, string);
assert.strictEqual(string.split(regexp, 42).b, 42);
assert.strictEqual(''.split.call(number, regexp, 42).a, number);
assert.strictEqual(''.split.call(number, regexp, 42).b, 42);
});
QUnit.test('RegExp#@@split delegates to exec', assert => {
let execCalled = false;
let speciesCalled = false;
let execSpeciesCalled = false;
const re = /[24]/;
re.exec = function () {
execCalled = true;
return /./.exec.apply(this, arguments);
};
re.constructor = {
// eslint-disable-next-line object-shorthand
[Symbol.species]: function (source, flags) {
const re2 = new RegExp(source, flags);
speciesCalled = true;
re2.exec = function () {
execSpeciesCalled = true;
return /./.exec.apply(this, arguments);
};
return re2;
},
};
assert.deepEqual(re[Symbol.split]('123451234'), ['1', '3', '51', '3', '']);
assert.ok(!execCalled);
assert.ok(speciesCalled);
assert.ok(execSpeciesCalled);
re.constructor = {
// eslint-disable-next-line object-shorthand
[Symbol.species]: function (source, flags) {
const re2 = new RegExp(source, flags);
// Not a function, should be ignored
re2.exec = 3;
return re2;
},
};
assert.deepEqual(re[Symbol.split]('123451234'), ['1', '3', '51', '3', '']);
re.constructor = {
// eslint-disable-next-line object-shorthand
[Symbol.species]: function (source, flags) {
const re2 = new RegExp(source, flags);
// Does not return an object, should throw
re2.exec = () => 3;
return re2;
},
};
assert.throws(() => re[Symbol.split]('123451234'));
});
QUnit.test('RegExp#@@split implementation', patchRegExp$exec(run));
core-js-3.6.1/tests/tests/es.string.starts-with.js 0000664 0000000 0000000 00000002525 13600575677 0022155 0 ustar 00root root 0000000 0000000 import { GLOBAL, STRICT } from '../helpers/constants';
const Symbol = GLOBAL.Symbol || {};
QUnit.test('String#startsWith', assert => {
const { startsWith } = String.prototype;
assert.isFunction(startsWith);
assert.arity(startsWith, 1);
assert.name(startsWith, 'startsWith');
assert.looksNative(startsWith);
assert.nonEnumerable(String.prototype, 'startsWith');
assert.ok('undefined'.startsWith());
assert.ok(!'undefined'.startsWith(null));
assert.ok('abc'.startsWith(''));
assert.ok('abc'.startsWith('a'));
assert.ok('abc'.startsWith('ab'));
assert.ok(!'abc'.startsWith('bc'));
assert.ok('abc'.startsWith('', NaN));
assert.ok('abc'.startsWith('a', -1));
assert.ok(!'abc'.startsWith('a', 1));
assert.ok(!'abc'.startsWith('a', Infinity));
assert.ok('abc'.startsWith('b', true));
assert.ok('abc'.startsWith('a', 'x'));
if (STRICT) {
assert.throws(() => startsWith.call(null, '.'), TypeError);
assert.throws(() => startsWith.call(undefined, '.'), TypeError);
}
const regexp = /./;
assert.throws(() => '/./'.startsWith(regexp), TypeError);
regexp[Symbol.match] = false;
assert.notThrows(() => '/./'.startsWith(regexp));
const object = {};
assert.notThrows(() => '[object Object]'.startsWith(object));
object[Symbol.match] = true;
assert.throws(() => '[object Object]'.startsWith(object), TypeError);
});
core-js-3.6.1/tests/tests/es.string.strike.js 0000664 0000000 0000000 00000000477 13600575677 0021171 0 ustar 00root root 0000000 0000000 QUnit.test('String#strike', assert => {
const { strike } = String.prototype;
assert.isFunction(strike);
assert.arity(strike, 0);
assert.name(strike, 'strike');
assert.looksNative(strike);
assert.nonEnumerable(String.prototype, 'strike');
assert.same('a'.strike(), 'a ', 'lower case');
});
core-js-3.6.1/tests/tests/es.string.sub.js 0000664 0000000 0000000 00000000436 13600575677 0020454 0 ustar 00root root 0000000 0000000 QUnit.test('String#sub', assert => {
const { sub } = String.prototype;
assert.isFunction(sub);
assert.arity(sub, 0);
assert.name(sub, 'sub');
assert.looksNative(sub);
assert.nonEnumerable(String.prototype, 'sub');
assert.same('a'.sub(), 'a ', 'lower case');
});
core-js-3.6.1/tests/tests/es.string.sup.js 0000664 0000000 0000000 00000000436 13600575677 0020472 0 ustar 00root root 0000000 0000000 QUnit.test('String#sup', assert => {
const { sup } = String.prototype;
assert.isFunction(sup);
assert.arity(sup, 0);
assert.name(sup, 'sup');
assert.looksNative(sup);
assert.nonEnumerable(String.prototype, 'sup');
assert.same('a'.sup(), 'a ', 'lower case');
});
core-js-3.6.1/tests/tests/es.string.trim-end.js 0000664 0000000 0000000 00000003001 13600575677 0021371 0 ustar 00root root 0000000 0000000 import { STRICT, WHITESPACES } from '../helpers/constants';
QUnit.test('String#trimRight', assert => {
const { trimRight } = String.prototype;
assert.isFunction(trimRight);
assert.arity(trimRight, 0);
assert.name(trimRight, 'trimEnd');
assert.looksNative(trimRight);
assert.nonEnumerable(String.prototype, 'trimRight');
assert.strictEqual(' \n q w e \n '.trimRight(), ' \n q w e', 'removes whitespaces at right side of string');
assert.strictEqual(WHITESPACES.trimRight(), '', 'removes all whitespaces');
assert.strictEqual('\u200B\u0085'.trimRight(), '\u200B\u0085', "shouldn't remove this symbols");
if (STRICT) {
assert.throws(() => trimRight.call(null, 0), TypeError);
assert.throws(() => trimRight.call(undefined, 0), TypeError);
}
});
QUnit.test('String#trimEnd', assert => {
const { trimEnd } = String.prototype;
assert.isFunction(trimEnd);
assert.arity(trimEnd, 0);
assert.name(trimEnd, 'trimEnd');
assert.looksNative(trimEnd);
assert.nonEnumerable(String.prototype, 'trimEnd');
assert.same(trimEnd, String.prototype.trimRight, 'same #trimRight');
assert.strictEqual(' \n q w e \n '.trimEnd(), ' \n q w e', 'removes whitespaces at right side of string');
assert.strictEqual(WHITESPACES.trimEnd(), '', 'removes all whitespaces');
assert.strictEqual('\u200B\u0085'.trimEnd(), '\u200B\u0085', "shouldn't remove this symbols");
if (STRICT) {
assert.throws(() => trimEnd.call(null, 0), TypeError);
assert.throws(() => trimEnd.call(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/tests/es.string.trim-start.js 0000664 0000000 0000000 00000003017 13600575677 0021767 0 ustar 00root root 0000000 0000000 import { STRICT, WHITESPACES } from '../helpers/constants';
QUnit.test('String#trimLeft', assert => {
const { trimLeft } = String.prototype;
assert.isFunction(trimLeft);
assert.arity(trimLeft, 0);
assert.name(trimLeft, 'trimStart');
assert.looksNative(trimLeft);
assert.nonEnumerable(String.prototype, 'trimLeft');
assert.strictEqual(' \n q w e \n '.trimLeft(), 'q w e \n ', 'removes whitespaces at left side of string');
assert.strictEqual(WHITESPACES.trimLeft(), '', 'removes all whitespaces');
assert.strictEqual('\u200B\u0085'.trimLeft(), '\u200B\u0085', "shouldn't remove this symbols");
if (STRICT) {
assert.throws(() => trimLeft.call(null, 0), TypeError);
assert.throws(() => trimLeft.call(undefined, 0), TypeError);
}
});
QUnit.test('String#trimStart', assert => {
const { trimStart } = String.prototype;
assert.isFunction(trimStart);
assert.arity(trimStart, 0);
assert.name(trimStart, 'trimStart');
assert.looksNative(trimStart);
assert.nonEnumerable(String.prototype, 'trimStart');
assert.same(trimStart, String.prototype.trimLeft, 'same #trimLeft');
assert.strictEqual(' \n q w e \n '.trimStart(), 'q w e \n ', 'removes whitespaces at left side of string');
assert.strictEqual(WHITESPACES.trimStart(), '', 'removes all whitespaces');
assert.strictEqual('\u200B\u0085'.trimStart(), '\u200B\u0085', "shouldn't remove this symbols");
if (STRICT) {
assert.throws(() => trimStart.call(null, 0), TypeError);
assert.throws(() => trimStart.call(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/tests/es.string.trim.js 0000664 0000000 0000000 00000001315 13600575677 0020633 0 ustar 00root root 0000000 0000000 import { STRICT, WHITESPACES } from '../helpers/constants';
QUnit.test('String#trim', assert => {
const { trim } = String.prototype;
assert.isFunction(''.trim);
assert.arity(trim, 0);
assert.name(trim, 'trim');
assert.looksNative(trim);
assert.nonEnumerable(String.prototype, 'trim');
assert.strictEqual(' \n q w e \n '.trim(), 'q w e', 'removes whitespaces at left & right side of string');
assert.strictEqual(WHITESPACES.trim(), '', 'removes all whitespaces');
assert.strictEqual('\u200B\u0085'.trim(), '\u200B\u0085', "shouldn't remove this symbols");
if (STRICT) {
assert.throws(() => trim.call(null, 0), TypeError);
assert.throws(() => trim.call(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/tests/es.symbol.async-iterator.js 0000664 0000000 0000000 00000001126 13600575677 0022623 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Symbol.asyncIterator', assert => {
assert.ok('asyncIterator' in Symbol, 'Symbol.asyncIterator available');
assert.nonEnumerable(Symbol, 'asyncIterator');
assert.ok(Object(Symbol.asyncIterator) instanceof Symbol, 'Symbol.asyncIterator is symbol');
if (DESCRIPTORS) {
const descriptor = Object.getOwnPropertyDescriptor(Symbol, 'asyncIterator');
assert.ok(!descriptor.enumerble, 'non-enumerable');
assert.ok(!descriptor.writable, 'non-writable');
assert.ok(!descriptor.configurable, 'non-configurable');
}
});
core-js-3.6.1/tests/tests/es.symbol.description.js 0000664 0000000 0000000 00000002355 13600575677 0022207 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Symbol#description', assert => {
assert.same(Symbol('foo').description, 'foo');
assert.same(Symbol('').description, '');
assert.same(Symbol(')').description, ')');
assert.same(Symbol({}).description, '[object Object]');
assert.same(Symbol(null).description, 'null');
assert.same(Symbol(undefined).description, undefined);
assert.same(Symbol().description, undefined);
assert.same(Object(Symbol('foo')).description, 'foo');
assert.same(Object(Symbol()).description, undefined);
if (DESCRIPTORS) {
assert.ok(!Object.prototype.hasOwnProperty.call(Symbol('foo'), 'description'));
const descriptor = Object.getOwnPropertyDescriptor(Symbol.prototype, 'description');
assert.same(descriptor.enumerable, false);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
}
if (typeof Symbol() == 'symbol') {
assert.same(Symbol('foo').toString(), 'Symbol(foo)');
assert.same(String(Symbol('foo')), 'Symbol(foo)');
assert.same(Symbol('').toString(), 'Symbol()');
assert.same(String(Symbol('')), 'Symbol()');
assert.same(Symbol().toString(), 'Symbol()');
assert.same(String(Symbol()), 'Symbol()');
}
});
core-js-3.6.1/tests/tests/es.symbol.js 0000664 0000000 0000000 00000024274 13600575677 0017671 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, NATIVE } from '../helpers/constants';
const {
defineProperty,
defineProperties,
getOwnPropertyDescriptor,
getOwnPropertyNames,
getOwnPropertySymbols,
keys,
create,
} = Object;
const { ownKeys } = GLOBAL.Reflect || {};
QUnit.test('Symbol', assert => {
assert.isFunction(Symbol);
if (NATIVE) assert.strictEqual(Symbol.length, 0, 'arity is 0');
assert.name(Symbol, 'Symbol');
assert.looksNative(Symbol);
const symbol1 = Symbol('symbol');
const symbol2 = Symbol('symbol');
assert.ok(symbol1 !== symbol2, 'Symbol("symbol") !== Symbol("symbol")');
const object = {};
object[symbol1] = 42;
assert.ok(object[symbol1] === 42, 'Symbol() work as key');
assert.ok(object[symbol2] !== 42, 'Various symbols from one description are various keys');
if (DESCRIPTORS) {
let count = 0;
// eslint-disable-next-line no-unused-vars
for (const key in object) count++;
assert.ok(count === 0, 'object[Symbol()] is not enumerable');
}
});
QUnit.test('Well-known Symbols', assert => {
const wks = [
'hasInstance',
'isConcatSpreadable',
'iterator',
'match',
'matchAll',
'replace',
'search',
'species',
'split',
'toPrimitive',
'toStringTag',
'unscopables',
];
for (const name of wks) {
assert.ok(name in Symbol, `Symbol.${ name } available`);
assert.ok(Object(Symbol[name]) instanceof Symbol, `Symbol.${ name } is symbol`);
if (DESCRIPTORS) {
const descriptor = getOwnPropertyDescriptor(Symbol, name);
assert.ok(!descriptor.enumerble, 'non-enumerable');
assert.ok(!descriptor.writable, 'non-writable');
assert.ok(!descriptor.configurable, 'non-configurable');
}
}
});
QUnit.test('Global symbol registry', assert => {
assert.isFunction(Symbol.for, 'Symbol.for is function');
assert.nonEnumerable(Symbol, 'for');
assert.strictEqual(Symbol.for.length, 1, 'Symbol.for arity is 1');
if (NATIVE) assert.strictEqual(Symbol.for.name, 'for', 'Symbol.for.name is "for"');
assert.looksNative(Symbol.for, 'Symbol.for looks like native');
assert.isFunction(Symbol.keyFor, 'Symbol.keyFor is function');
assert.nonEnumerable(Symbol, 'keyFor');
assert.strictEqual(Symbol.keyFor.length, 1, 'Symbol.keyFor arity is 1');
assert.strictEqual(Symbol.keyFor.name, 'keyFor', 'Symbol.keyFor.name is "keyFor"');
assert.looksNative(Symbol.keyFor, 'Symbol.keyFor looks like native');
const symbol = Symbol.for('foo');
assert.strictEqual(Symbol.for('foo'), symbol);
assert.strictEqual(Symbol.keyFor(symbol), 'foo');
assert.throws(() => Symbol.keyFor('foo'), 'throws on non-symbol');
});
QUnit.test('Symbol#@@toPrimitive', assert => {
const symbol = Symbol();
assert.isFunction(Symbol.prototype[Symbol.toPrimitive]);
assert.same(symbol, symbol[Symbol.toPrimitive](), 'works');
});
QUnit.test('Symbol#@@toStringTag', assert => {
assert.ok(Symbol.prototype[Symbol.toStringTag] === 'Symbol', 'Symbol::@@toStringTag is `Symbol`');
});
QUnit.test('Object.getOwnPropertySymbols', assert => {
assert.isFunction(getOwnPropertySymbols);
assert.nonEnumerable(Object, 'getOwnPropertySymbols');
assert.strictEqual(getOwnPropertySymbols.length, 1, 'arity is 1');
assert.name(getOwnPropertySymbols, 'getOwnPropertySymbols');
assert.looksNative(getOwnPropertySymbols);
const prototype = { q: 1, w: 2, e: 3 };
prototype[Symbol()] = 42;
prototype[Symbol()] = 43;
assert.deepEqual(getOwnPropertyNames(prototype).sort(), ['e', 'q', 'w']);
assert.strictEqual(getOwnPropertySymbols(prototype).length, 2);
const object = create(prototype);
object.a = 1;
object.s = 2;
object.d = 3;
object[Symbol()] = 44;
assert.deepEqual(getOwnPropertyNames(object).sort(), ['a', 'd', 's']);
assert.strictEqual(getOwnPropertySymbols(object).length, 1);
assert.strictEqual(getOwnPropertySymbols(Object.prototype).length, 0);
const primitives = [42, 'foo', false];
for (const value of primitives) {
assert.notThrows(() => getOwnPropertySymbols(value), `accept ${ typeof value }`);
}
});
if (JSON) {
QUnit.test('Symbols & JSON.stringify', assert => {
assert.strictEqual(JSON.stringify([
1,
Symbol('foo'),
false,
Symbol('bar'),
{},
]), '[1,null,false,null,{}]', 'array value');
assert.strictEqual(JSON.stringify({
symbol: Symbol('symbol'),
}), '{}', 'object value');
if (DESCRIPTORS) {
const object = { bar: 2 };
object[Symbol('symbol')] = 1;
assert.strictEqual(JSON.stringify(object), '{"bar":2}', 'object key');
}
assert.strictEqual(JSON.stringify(Symbol('symbol')), undefined, 'symbol value');
if (typeof Symbol() === 'symbol') {
assert.strictEqual(JSON.stringify(Object(Symbol('symbol'))), '{}', 'boxed symbol');
}
assert.strictEqual(JSON.stringify(undefined, () => 42), '42', 'replacer works with top-level undefined');
});
}
if (DESCRIPTORS) {
QUnit.test('Symbols & descriptors', assert => {
const d = Symbol('d');
const e = Symbol('e');
const f = Symbol('f');
const i = Symbol('i');
const j = Symbol('j');
const prototype = { g: 'g' };
prototype[i] = 'i';
defineProperty(prototype, 'h', {
value: 'h',
});
defineProperty(prototype, 'j', {
value: 'j',
});
const object = create(prototype);
object.a = 'a';
object[d] = 'd';
defineProperty(object, 'b', {
value: 'b',
});
defineProperty(object, 'c', {
value: 'c',
enumerable: true,
});
defineProperty(object, e, {
configurable: true,
writable: true,
value: 'e',
});
const descriptor = {
value: 'f',
enumerable: true,
};
defineProperty(object, f, descriptor);
assert.strictEqual(descriptor.enumerable, true, 'defineProperty not changes descriptor object');
assert.deepEqual(getOwnPropertyDescriptor(object, 'a'), {
configurable: true,
writable: true,
enumerable: true,
value: 'a',
}, 'getOwnPropertyDescriptor a');
assert.deepEqual(getOwnPropertyDescriptor(object, 'b'), {
configurable: false,
writable: false,
enumerable: false,
value: 'b',
}, 'getOwnPropertyDescriptor b');
assert.deepEqual(getOwnPropertyDescriptor(object, 'c'), {
configurable: false,
writable: false,
enumerable: true,
value: 'c',
}, 'getOwnPropertyDescriptor c');
assert.deepEqual(getOwnPropertyDescriptor(object, d), {
configurable: true,
writable: true,
enumerable: true,
value: 'd',
}, 'getOwnPropertyDescriptor d');
assert.deepEqual(getOwnPropertyDescriptor(object, e), {
configurable: true,
writable: true,
enumerable: false,
value: 'e',
}, 'getOwnPropertyDescriptor e');
assert.deepEqual(getOwnPropertyDescriptor(object, f), {
configurable: false,
writable: false,
enumerable: true,
value: 'f',
}, 'getOwnPropertyDescriptor f');
assert.strictEqual(getOwnPropertyDescriptor(object, 'g'), undefined, 'getOwnPropertyDescriptor g');
assert.strictEqual(getOwnPropertyDescriptor(object, 'h'), undefined, 'getOwnPropertyDescriptor h');
assert.strictEqual(getOwnPropertyDescriptor(object, i), undefined, 'getOwnPropertyDescriptor i');
assert.strictEqual(getOwnPropertyDescriptor(object, j), undefined, 'getOwnPropertyDescriptor j');
assert.strictEqual(getOwnPropertyDescriptor(object, 'k'), undefined, 'getOwnPropertyDescriptor k');
assert.strictEqual(getOwnPropertyDescriptor(Object.prototype, 'toString').enumerable, false, 'getOwnPropertyDescriptor on Object.prototype');
assert.strictEqual(getOwnPropertyDescriptor(Object.prototype, d), undefined, 'getOwnPropertyDescriptor on Object.prototype missed symbol');
assert.strictEqual(keys(object).length, 2, 'Object.keys');
assert.strictEqual(getOwnPropertyNames(object).length, 3, 'Object.getOwnPropertyNames');
assert.strictEqual(getOwnPropertySymbols(object).length, 3, 'Object.getOwnPropertySymbols');
assert.strictEqual(ownKeys(object).length, 6, 'Reflect.ownKeys');
delete object[e];
object[e] = 'e';
assert.deepEqual(getOwnPropertyDescriptor(object, e), {
configurable: true,
writable: true,
enumerable: true,
value: 'e',
}, 'redefined non-enum key');
});
QUnit.test('Symbols & Object.defineProperties', assert => {
const c = Symbol('c');
const d = Symbol('d');
const descriptors = {
a: {
value: 'a',
},
};
descriptors[c] = {
value: 'c',
};
defineProperty(descriptors, 'b', {
value: {
value: 'b',
},
});
defineProperty(descriptors, d, {
value: {
value: 'd',
},
});
const object = defineProperties({}, descriptors);
assert.strictEqual(object.a, 'a', 'a');
assert.strictEqual(object.b, undefined, 'b');
assert.strictEqual(object[c], 'c', 'c');
assert.strictEqual(object[d], undefined, 'd');
});
QUnit.test('Symbols & Object.create', assert => {
const c = Symbol('c');
const d = Symbol('d');
const descriptors = {
a: {
value: 'a',
},
};
descriptors[c] = {
value: 'c',
};
defineProperty(descriptors, 'b', {
value: {
value: 'b',
},
});
defineProperty(descriptors, d, {
value: {
value: 'd',
},
});
const object = create(null, descriptors);
assert.strictEqual(object.a, 'a', 'a');
assert.strictEqual(object.b, undefined, 'b');
assert.strictEqual(object[c], 'c', 'c');
assert.strictEqual(object[d], undefined, 'd');
});
const constructors = ['Map', 'Set', 'Promise'];
for (const name of constructors) {
QUnit.test(`${ name }@@species`, assert => {
assert.strictEqual(GLOBAL[name][Symbol.species], GLOBAL[name], `${ name }@@species === ${ name }`);
const Subclass = create(GLOBAL[name]);
assert.strictEqual(Subclass[Symbol.species], Subclass, `${ name } subclass`);
});
}
QUnit.test('Array@@species', assert => {
assert.strictEqual(Array[Symbol.species], Array, 'Array@@species === Array');
const Subclass = create(Array);
assert.strictEqual(Subclass[Symbol.species], Subclass, 'Array subclass');
});
QUnit.test('Symbol.sham flag', assert => {
assert.same(Symbol.sham, typeof Symbol() === 'symbol' ? undefined : true);
});
}
core-js-3.6.1/tests/tests/es.typed-array.constructors.js 0000664 0000000 0000000 00000030561 13600575677 0023370 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, NATIVE, TYPED_ARRAYS } from '../helpers/constants';
import { createIterable } from '../helpers/helpers';
const Symbol = GLOBAL.Symbol || {};
const { keys, getOwnPropertyDescriptor, getPrototypeOf, defineProperty, assign } = Object;
if (DESCRIPTORS) {
for (const name in TYPED_ARRAYS) {
const bytes = TYPED_ARRAYS[name];
const TypedArray = GLOBAL[name];
QUnit.test(`${ name } constructor`, assert => {
assert.isFunction(TypedArray);
assert.arity(TypedArray, 3);
assert.name(TypedArray, name);
// Safari 5 bug
if (NATIVE) assert.looksNative(TypedArray);
assert.same(TypedArray.BYTES_PER_ELEMENT, bytes, `${ name }.BYTES_PER_ELEMENT`);
let array = new TypedArray(4);
assert.same(array.BYTES_PER_ELEMENT, bytes, '#BYTES_PER_ELEMENT');
assert.same(array.byteOffset, 0, `${ name }#byteOffset, passed number`);
assert.same(array.byteLength, 4 * bytes, '#byteLength, passed number');
assert.arrayEqual(array, [0, 0, 0, 0], 'correct values, passed number');
assert.notThrows(() => {
// throws in IE / Edge / FF
array = new TypedArray('0x4');
assert.same(array.byteOffset, 0, '#byteOffset, passed string');
assert.same(array.byteLength, 4 * bytes, '#byteLength, passed string');
assert.arrayEqual(array, [0, 0, 0, 0], 'correct values, passed string');
return true;
}, 'passed string');
assert.notThrows(() => {
// throws in IE / Edge / FF
array = new TypedArray(true);
assert.same(array.byteOffset, 0, '#byteOffset, passed boolean');
assert.same(array.byteLength, 1 * bytes, '#byteLength, passed boolean');
assert.arrayEqual(array, [0], 'correct values, passed boolean');
return true;
}, 'passed boolean');
assert.notThrows(() => {
array = new TypedArray();
assert.same(array.byteOffset, 0, '#byteOffset, without arguments');
assert.same(array.byteLength, 0, '#byteLength, without arguments');
assert.arrayEqual(array, [], 'correct values, without arguments');
return true;
}, 'without arguments');
assert.notThrows(() => {
array = new TypedArray(undefined);
assert.same(array.byteOffset, 0, '#byteOffset, passed undefined');
assert.same(array.byteLength, 0, '#byteLength, passed undefined');
assert.arrayEqual(array, [], 'correct values, passed undefined');
return true;
}, 'passed undefined');
assert.notThrows(() => {
array = new TypedArray(-0);
assert.same(array.byteOffset, 0, '#byteOffset, passed -0');
assert.same(array.byteLength, 0, '#byteLength, passed -0');
assert.arrayEqual(array, [], 'correct values, passed -0');
return true;
}, 'passed -0');
assert.notThrows(() => {
array = new TypedArray(NaN);
assert.same(array.byteOffset, 0, '#byteOffset, passed NaN');
assert.same(array.byteLength, 0, '#byteLength, passed NaN');
assert.arrayEqual(array, [], 'correct values, passed NaN');
return true;
}, 'passed NaN');
assert.notThrows(() => {
array = new TypedArray(1.5);
assert.same(array.byteOffset, 0, '#byteOffset, passed 1.5');
assert.same(array.byteLength, 1 * bytes, '#byteLength, passed 1.5');
assert.arrayEqual(array, [0], 'correct values, passed 1.5');
return true;
}, 'passed 1.5');
if (NATIVE) assert.throws(() => new TypedArray(-1), RangeError, 'throws on -1');
assert.notThrows(() => {
array = new TypedArray(null);
assert.same(array.byteOffset, 0, '#byteOffset, passed null');
assert.same(array.byteLength, 0, '#byteLength, passed null');
assert.arrayEqual(array, [], 'correct values, passed null');
return true;
}, 'passed null');
array = new TypedArray([1, 2, 3, 4]);
assert.same(array.byteOffset, 0, '#byteOffset, passed array');
assert.same(array.byteLength, 4 * bytes, '#byteLength, passed array');
assert.arrayEqual(array, [1, 2, 3, 4], 'correct values, passed array');
array = new TypedArray({
0: 1,
1: 2,
2: 3,
3: 4,
length: 4,
});
assert.same(array.byteOffset, 0, '#byteOffset, passed array-like');
assert.same(array.byteLength, 4 * bytes, '#byteLength, passed array-like');
assert.arrayEqual(array, [1, 2, 3, 4], 'correct values, passed array-like');
assert.notThrows(() => {
// throws in IE / Edge
array = new TypedArray({});
assert.same(array.byteOffset, 0, '#byteOffset, passed empty object (also array-like case)');
assert.same(array.byteLength, 0, '#byteLength, passed empty object (also array-like case)');
assert.arrayEqual(array, [], 'correct values, passed empty object (also array-like case)');
return true;
}, 'passed empty object (also array-like case)');
assert.notThrows(() => {
array = new TypedArray(createIterable([1, 2, 3, 4]));
assert.same(array.byteOffset, 0, '#byteOffset, passed iterable');
assert.same(array.byteLength, 4 * bytes, '#byteLength, passed iterable');
assert.arrayEqual(array, [1, 2, 3, 4], 'correct values, passed iterable');
return true;
}, 'passed iterable');
array = new TypedArray(new TypedArray([1, 2, 3, 4]));
assert.same(array.byteOffset, 0, '#byteOffset, passed typed array');
assert.same(array.byteLength, 4 * bytes, '#byteLength, passed typed array');
assert.arrayEqual(array, [1, 2, 3, 4], 'correct values, passed typed array');
const fake = new TypedArray([1, 2, 3, 4]);
fake[Symbol.iterator] = function () {
return createIterable([4, 3, 2, 1])[Symbol.iterator]();
};
array = new TypedArray(fake);
assert.same(array.byteOffset, 0, '#byteOffset, passed typed array with custom iterator');
assert.same(array.byteLength, 4 * bytes, '#byteLength, passed typed array with custom iterator');
// https://code.google.com/p/v8/issues/detail?id=4552
assert.arrayEqual(array, [1, 2, 3, 4], 'correct values, passed typed array with custom iterator');
array = new TypedArray(new ArrayBuffer(8));
assert.same(array.byteOffset, 0, '#byteOffset, passed buffer');
assert.same(array.byteLength, 8, '#byteLength, passed buffer');
assert.same(array.length, 8 / bytes, 'correct length, passed buffer');
array = new TypedArray(new ArrayBuffer(16), 8);
assert.same(array.byteOffset, 8, '#byteOffset, passed buffer and byteOffset');
assert.same(array.byteLength, 8, '#byteLength, passed buffer and byteOffset');
assert.same(array.length, 8 / bytes, 'correct length, passed buffer and byteOffset');
array = new TypedArray(new ArrayBuffer(24), 8, 8 / bytes);
assert.same(array.byteOffset, 8, '#byteOffset, passed buffer, byteOffset and length');
assert.same(array.byteLength, 8, '#byteLength, passed buffer, byteOffset and length');
assert.same(array.length, 8 / bytes, 'correct length, passed buffer, byteOffset and length');
array = new TypedArray(new ArrayBuffer(8), undefined);
assert.same(array.byteOffset, 0, '#byteOffset, passed buffer and undefined');
assert.same(array.byteLength, 8, '#byteLength, passed buffer and undefined');
assert.same(array.length, 8 / bytes, 'correct length, passed buffer and undefined');
array = new TypedArray(new ArrayBuffer(16), 8, undefined);
assert.same(array.byteOffset, 8, '#byteOffset, passed buffer, byteOffset and undefined');
assert.same(array.byteLength, 8, '#byteLength, passed buffer, byteOffset and undefined');
assert.same(array.length, 8 / bytes, 'correct length, passed buffer, byteOffset and undefined');
array = new TypedArray(new ArrayBuffer(8), 8);
assert.same(array.byteOffset, 8, '#byteOffset, passed buffer and byteOffset with buffer length');
assert.same(array.byteLength, 0, '#byteLength, passed buffer and byteOffset with buffer length');
assert.arrayEqual(array, [], 'correct values, passed buffer and byteOffset with buffer length');
// FF bug - TypeError instead of RangeError
assert.throws(() => new TypedArray(new ArrayBuffer(8), -1), RangeError, 'If offset < 0, throw a RangeError exception');
if (bytes !== 1) {
// FF bug - TypeError instead of RangeError
assert.throws(() => new TypedArray(new ArrayBuffer(8), 3), RangeError, 'If offset modulo elementSize ≠ 0, throw a RangeError exception');
}
if (NATIVE) {
if (bytes !== 1) {
// fails in Opera 12
assert.throws(() => new TypedArray(new ArrayBuffer(9)), RangeError, 'If bufferByteLength modulo elementSize ≠ 0, throw a RangeError exception');
}
assert.throws(() => new TypedArray(new ArrayBuffer(8), 16), RangeError, 'If newByteLength < 0, throw a RangeError exception');
assert.throws(() => new TypedArray(new ArrayBuffer(24), 8, 24), RangeError, 'If offset+newByteLength > bufferByteLength, throw a RangeError exception');
} else { // FF bug - TypeError instead of RangeError
assert.throws(() => new TypedArray(new ArrayBuffer(8), 16), 'If newByteLength < 0, throw a RangeError exception');
assert.throws(() => new TypedArray(new ArrayBuffer(24), 8, 24), 'If offset+newByteLength > bufferByteLength, throw a RangeError exception');
}
assert.throws(() => TypedArray(1), TypeError, 'throws without `new`');
assert.same(TypedArray[Symbol.species], TypedArray, '@@species');
});
QUnit.test(`${ name } descriptors`, assert => {
const array = new TypedArray(2);
const descriptor = getOwnPropertyDescriptor(array, 0);
const base = NATIVE ? {
writable: true,
enumerable: true,
configurable: false,
} : {
writable: descriptor.writable,
enumerable: true,
configurable: descriptor.configurable,
};
assert.deepEqual(getOwnPropertyDescriptor(array, 0), assign({
value: 0,
}, base), 'Object.getOwnPropertyDescriptor');
if (NATIVE) {
// fails in old WebKit
assert.arrayEqual(keys(array), ['0', '1'], 'Object.keys');
const results = [];
for (const key in array) results.push(key);
// fails in old WebKit
assert.arrayEqual(results, ['0', '1'], 'for-in');
defineProperty(array, 0, {
value: 1,
writable: true,
enumerable: true,
configurable: false,
});
array[0] = array[1] = 2.5;
assert.deepEqual(getOwnPropertyDescriptor(array, 0), assign({
value: array[1],
}, base), 'Object.defineProperty, valid descriptor #1');
defineProperty(array, 0, {
value: 1,
});
array[0] = array[1] = 3.5;
assert.deepEqual(getOwnPropertyDescriptor(array, 0), assign({
value: array[1],
}, base), 'Object.defineProperty, valid descriptor #2');
assert.throws(() => defineProperty(array, 0, {
value: 2,
writable: false,
enumerable: true,
configurable: false,
}), 'Object.defineProperty, invalid descriptor #1');
assert.throws(() => defineProperty(array, 0, {
value: 2,
writable: true,
enumerable: false,
configurable: false,
}), 'Object.defineProperty, invalid descriptor #2');
assert.throws(() => defineProperty(array, 0, {
get() {
return 2;
},
}), 'Object.defineProperty, invalid descriptor #3');
}
assert.throws(() => defineProperty(array, 0, {
value: 2,
get() {
return 2;
},
}), 'Object.defineProperty, invalid descriptor #4');
});
QUnit.test(`${ name } @@toStringTag`, assert => {
const TypedArrayPrototype = getPrototypeOf(TypedArray.prototype);
const descriptor = getOwnPropertyDescriptor(TypedArrayPrototype, Symbol.toStringTag);
const getter = descriptor.get;
assert.isFunction(getter);
assert.same(getter.call(new Int8Array(1)), 'Int8Array');
assert.same(getter.call(new TypedArray(1)), name);
assert.same(getter.call([]), undefined);
assert.same(getter.call({}), undefined);
assert.same(getter.call(), undefined);
});
QUnit.test(`${ name }.sham`, assert => {
if (TypedArray.sham) assert.ok(true, `${ name }.sham flag exists`);
else assert.ok(true, `${ name }.sham flag missed`);
});
}
}
core-js-3.6.1/tests/tests/es.typed-array.copy-within.js 0000664 0000000 0000000 00000003672 13600575677 0023075 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.copyWithin', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { copyWithin } = TypedArray.prototype;
assert.isFunction(copyWithin, `${ name }::copyWithin is function`);
assert.arity(copyWithin, 2, `${ name }::copyWithin arity is 2`);
assert.name(copyWithin, 'copyWithin', `${ name }::copyWithin name is 'copyWithin'`);
assert.looksNative(copyWithin, `${ name }::copyWithin looks native`);
const array = new TypedArray(5);
assert.strictEqual(array.copyWithin(0), array, 'return this');
assert.arrayEqual(new TypedArray([1, 2, 3, 4, 5]).copyWithin(0, 3), [4, 5, 3, 4, 5]);
assert.arrayEqual(new TypedArray([1, 2, 3, 4, 5]).copyWithin(1, 3), [1, 4, 5, 4, 5]);
assert.arrayEqual(new TypedArray([1, 2, 3, 4, 5]).copyWithin(1, 2), [1, 3, 4, 5, 5]);
assert.arrayEqual(new TypedArray([1, 2, 3, 4, 5]).copyWithin(2, 2), [1, 2, 3, 4, 5]);
assert.arrayEqual(new TypedArray([1, 2, 3, 4, 5]).copyWithin(0, 3, 4), [4, 2, 3, 4, 5]);
assert.arrayEqual(new TypedArray([1, 2, 3, 4, 5]).copyWithin(1, 3, 4), [1, 4, 3, 4, 5]);
assert.arrayEqual(new TypedArray([1, 2, 3, 4, 5]).copyWithin(1, 2, 4), [1, 3, 4, 4, 5]);
assert.arrayEqual(new TypedArray([1, 2, 3, 4, 5]).copyWithin(0, -2), [4, 5, 3, 4, 5]);
assert.arrayEqual(new TypedArray([1, 2, 3, 4, 5]).copyWithin(0, -2, -1), [4, 2, 3, 4, 5]);
assert.arrayEqual(new TypedArray([1, 2, 3, 4, 5]).copyWithin(-4, -3, -2), [1, 3, 3, 4, 5]);
assert.arrayEqual(new TypedArray([1, 2, 3, 4, 5]).copyWithin(-4, -3, -1), [1, 3, 4, 4, 5]);
assert.arrayEqual(new TypedArray([1, 2, 3, 4, 5]).copyWithin(-4, -3), [1, 3, 4, 5, 5]);
assert.throws(() => copyWithin.call([0], 1), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.every.js 0000664 0000000 0000000 00000003360 13600575677 0021747 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.every', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { every } = TypedArray.prototype;
assert.isFunction(every, `${ name }::every is function`);
assert.arity(every, 1, `${ name }::every arity is 1`);
assert.name(every, 'every', `${ name }::every name is 'every'`);
assert.looksNative(every, `${ name }::every looks native`);
const array = new TypedArray([1]);
const context = {};
array.every(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.ok(new TypedArray([1, 2, 3]).every(it => typeof it === 'number'));
assert.ok(new TypedArray([1, 2, 3]).every(it => it < 4));
assert.ok(!new TypedArray([1, 2, 3]).every(it => it < 3));
assert.ok(!new TypedArray([1, 2, 3]).every(it => typeof it === 'string'));
assert.ok(new TypedArray([1, 2, 3]).every(function () {
return +this === 1;
}, 1));
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).every((value, key) => {
values += value;
keys += key;
return true;
});
assert.same(values, '123');
assert.same(keys, '012');
assert.throws(() => every.call([0], () => { /* empty */ }), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.fill.js 0000664 0000000 0000000 00000002302 13600575677 0021536 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.fill', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { fill } = TypedArray.prototype;
assert.isFunction(fill, `${ name }::fill is function`);
assert.arity(fill, 1, `${ name }::fill arity is 1`);
assert.name(fill, 'fill', `${ name }::fill name is 'fill'`);
assert.looksNative(fill, `${ name }::fill looks native`);
const array = new TypedArray(5);
assert.strictEqual(array.fill(5), array, 'return this');
assert.arrayEqual(new TypedArray(5).fill(5), [5, 5, 5, 5, 5], 'basic');
assert.arrayEqual(new TypedArray(5).fill(5, 1), [0, 5, 5, 5, 5], 'start index');
assert.arrayEqual(new TypedArray(5).fill(5, 1, 4), [0, 5, 5, 5, 0], 'end index');
assert.arrayEqual(new TypedArray(5).fill(5, 6, 1), [0, 0, 0, 0, 0], 'start > end');
assert.arrayEqual(new TypedArray(5).fill(5, -3, 4), [0, 0, 5, 5, 0], 'negative start index');
assert.throws(() => fill.call([0], 1), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.filter.js 0000664 0000000 0000000 00000003105 13600575677 0022077 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.filter', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { filter } = TypedArray.prototype;
assert.isFunction(filter, `${ name }::filter is function`);
assert.arity(filter, 1, `${ name }::filter arity is 1`);
assert.name(filter, 'filter', `${ name }::filter name is 'filter'`);
assert.looksNative(filter, `${ name }::filter looks native`);
const array = new TypedArray([1]);
const context = {};
array.filter(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
const instance = new TypedArray([1, 2, 3, 4, 5, 6, 7, 8, 9]).filter(it => it % 2);
assert.ok(instance instanceof TypedArray, 'correct instance');
assert.arrayEqual(instance, [1, 3, 5, 7, 9], 'works');
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).filter((value, key) => {
values += value;
keys += key;
});
assert.same(values, '123');
assert.same(keys, '012');
assert.throws(() => filter.call([0], () => { /* empty */ }), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.find-index.js 0000664 0000000 0000000 00000003061 13600575677 0022640 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.findIndex', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { findIndex } = TypedArray.prototype;
assert.isFunction(findIndex, `${ name }::findIndex is function`);
assert.arity(findIndex, 1, `${ name }::findIndex arity is 1`);
assert.name(findIndex, 'findIndex', `${ name }::findIndex name is 'findIndex'`);
assert.looksNative(findIndex, `${ name }::findIndex looks native`);
const array = new TypedArray([1]);
const context = {};
array.findIndex(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new TypedArray([1, 2, 3]).findIndex(it => !(it % 2)), 1);
assert.same(new TypedArray([1, 2, 3]).findIndex(it => it === 4), -1);
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).findIndex((value, key) => {
values += value;
keys += key;
});
assert.same(values, '123');
assert.same(keys, '012');
assert.throws(() => findIndex.call([0], () => { /* empty */ }), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.find.js 0000664 0000000 0000000 00000002743 13600575677 0021541 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.find', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { find } = TypedArray.prototype;
assert.isFunction(find, `${ name }::find is function`);
assert.arity(find, 1, `${ name }::find arity is 1`);
assert.name(find, 'find', `${ name }::find name is 'find'`);
assert.looksNative(find, `${ name }::find looks native`);
const array = new TypedArray([1]);
const context = {};
array.find(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new TypedArray([1, 2, 3]).find(it => !(it % 2)), 2);
assert.same(new TypedArray([1, 2, 3]).find(it => it === 4), undefined);
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).find((value, key) => {
values += value;
keys += key;
});
assert.same(values, '123');
assert.same(keys, '012');
assert.throws(() => find.call([0], () => { /* empty */ }), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.for-each.js 0000664 0000000 0000000 00000002714 13600575677 0022303 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.forEach', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { forEach } = TypedArray.prototype;
assert.isFunction(forEach, `${ name }::forEach is function`);
assert.arity(forEach, 1, `${ name }::forEach arity is 1`);
assert.name(forEach, 'forEach', `${ name }::forEach name is 'forEach'`);
assert.looksNative(forEach, `${ name }::forEach looks native`);
const array = new TypedArray([1]);
const context = {};
array.forEach(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new TypedArray([1, 2, 3]).forEach(it => it % 2), undefined);
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).forEach((value, key) => {
values += value;
keys += key;
});
assert.same(values, '123');
assert.same(keys, '012');
assert.throws(() => forEach.call([0], () => { /* empty */ }), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.from.js 0000664 0000000 0000000 00000004112 13600575677 0021554 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, NATIVE, TYPED_ARRAYS } from '../helpers/constants';
import { createIterable } from '../helpers/helpers';
if (DESCRIPTORS) QUnit.test('%TypedArray%.from', assert => {
// we can't implement %TypedArray% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
assert.isFunction(TypedArray.from, `${ name }.from is function`);
assert.arity(TypedArray.from, 1, `${ name }.from arity is 1`);
assert.name(TypedArray.from, 'from', `${ name }.from name is 'from'`);
assert.looksNative(TypedArray.from, `${ name }.from looks native`);
let instance = TypedArray.from([1, 2, 3]);
assert.ok(instance instanceof TypedArray, 'correct instance with array');
assert.arrayEqual(instance, [1, 2, 3], 'correct elements with array');
instance = TypedArray.from({
0: 1,
1: 2,
2: 3,
length: 3,
});
assert.ok(instance instanceof TypedArray, 'correct instance with array-like');
assert.arrayEqual(instance, [1, 2, 3], 'correct elements with array-like');
instance = TypedArray.from(createIterable([1, 2, 3]));
assert.ok(instance instanceof TypedArray, 'correct instance with iterable');
assert.arrayEqual(instance, [1, 2, 3], 'correct elements with iterable');
assert.arrayEqual(TypedArray.from([1, 2, 3], it => it * it), [1, 4, 9], 'accept callback');
const context = {};
TypedArray.from([1], function (value, key) {
assert.same(arguments.length, 2, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.throws(() => TypedArray.from.call(undefined, []), "isn't generic #1");
if (NATIVE) {
assert.throws(() => TypedArray.from.call(Array, []), "isn't generic #2");
assert.notThrows(() => TypedArray.from({
length: -1,
0: 1,
}, () => {
throw new Error();
}), 'uses ToLength');
}
}
});
core-js-3.6.1/tests/tests/es.typed-array.includes.js 0000664 0000000 0000000 00000002051 13600575677 0022417 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.includes', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { includes } = TypedArray.prototype;
assert.isFunction(includes, `${ name }::includes is function`);
assert.arity(includes, 1, `${ name }::includes arity is 1`);
assert.name(includes, 'includes', `${ name }::includes name is 'includes'`);
assert.looksNative(includes, `${ name }::includes looks native`);
assert.same(new TypedArray([1, 1, 1]).includes(1), true);
assert.same(new TypedArray([1, 2, 3]).includes(1, 1), false);
assert.same(new TypedArray([1, 2, 3]).includes(2, 1), true);
assert.same(new TypedArray([1, 2, 3]).includes(2, -1), false);
assert.same(new TypedArray([1, 2, 3]).includes(2, -2), true);
assert.throws(() => includes.call([1], 1), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.index-of.js 0000664 0000000 0000000 00000002010 13600575677 0022315 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.indexOf', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { indexOf } = TypedArray.prototype;
assert.isFunction(indexOf, `${ name }::indexOf is function`);
assert.arity(indexOf, 1, `${ name }::indexOf arity is 1`);
assert.name(indexOf, 'indexOf', `${ name }::indexOf name is 'indexOf'`);
assert.looksNative(indexOf, `${ name }::indexOf looks native`);
assert.same(new TypedArray([1, 1, 1]).indexOf(1), 0);
assert.same(new TypedArray([1, 2, 3]).indexOf(1, 1), -1);
assert.same(new TypedArray([1, 2, 3]).indexOf(2, 1), 1);
assert.same(new TypedArray([1, 2, 3]).indexOf(2, -1), -1);
assert.same(new TypedArray([1, 2, 3]).indexOf(2, -2), 1);
assert.throws(() => indexOf.call([1], 1), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.iterator.js 0000664 0000000 0000000 00000012136 13600575677 0022447 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, NATIVE, TYPED_ARRAYS } from '../helpers/constants';
const Symbol = GLOBAL.Symbol || {};
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.keys', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { keys } = TypedArray.prototype;
assert.isFunction(keys, `${ name }::keys is function`);
assert.arity(keys, 0, `${ name }::keys arity is 0`);
assert.name(keys, 'keys', `${ name }::keys name is 'keys'`);
assert.looksNative(keys, `${ name }::keys looks native`);
const iterator = new TypedArray([1, 2, 3]).keys();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Array Iterator');
assert.deepEqual(iterator.next(), {
value: 0,
done: false,
}, 'step 1');
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
}, 'step 2');
assert.deepEqual(iterator.next(), {
value: 2,
done: false,
}, 'step 3');
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
}, 'done');
if (NATIVE) assert.throws(() => keys.call([1, 2]), "isn't generic");
}
});
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.values', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { values } = TypedArray.prototype;
assert.isFunction(values, `${ name }::values is function`);
assert.arity(values, 0, `${ name }::values arity is 0`);
assert.name(values, 'values', `${ name }::values name is 'values'`);
assert.looksNative(values, `${ name }::values looks native`);
const iterator = new TypedArray([1, 2, 3]).values();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Array Iterator');
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
}, 'step 1');
assert.deepEqual(iterator.next(), {
value: 2,
done: false,
}, 'step 2');
assert.deepEqual(iterator.next(), {
value: 3,
done: false,
}, 'step 3');
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
}, 'done');
if (NATIVE) assert.throws(() => values.call([1, 2]), "isn't generic");
}
});
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.entries', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { entries } = TypedArray.prototype;
assert.isFunction(entries, `${ name }::entries is function`);
assert.arity(entries, 0, `${ name }::entries arity is 0`);
assert.name(entries, 'entries', `${ name }::entries name is 'entries'`);
assert.looksNative(entries, `${ name }::entries looks native`);
const iterator = new TypedArray([1, 2, 3]).entries();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Array Iterator');
assert.deepEqual(iterator.next(), {
value: [0, 1],
done: false,
}, 'step 1');
assert.deepEqual(iterator.next(), {
value: [1, 2],
done: false,
}, 'step 2');
assert.deepEqual(iterator.next(), {
value: [2, 3],
done: false,
}, 'step 3');
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
}, 'done');
if (NATIVE) assert.throws(() => entries.call([1, 2]), "isn't generic");
}
});
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.@@iterator', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
assert.isIterable(TypedArray.prototype, `${ name } is itrable`);
assert.arity(TypedArray.prototype[Symbol.iterator], 0, `${ name }::@@iterator arity is 0`);
assert.name(TypedArray.prototype[Symbol.iterator], 'values', `${ name }::@@iterator name is 'values'`);
assert.looksNative(TypedArray.prototype[Symbol.iterator], `${ name }::@@iterator looks native`);
assert.strictEqual(TypedArray.prototype[Symbol.iterator], TypedArray.prototype.values);
const iterator = new TypedArray([1, 2, 3])[Symbol.iterator]();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Array Iterator');
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
}, 'step 1');
assert.deepEqual(iterator.next(), {
value: 2,
done: false,
}, 'step 2');
assert.deepEqual(iterator.next(), {
value: 3,
done: false,
}, 'step 3');
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
}, 'done');
if (NATIVE) assert.throws(() => TypedArray.prototype[Symbol.iterator].call([1, 2]), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.join.js 0000664 0000000 0000000 00000001505 13600575677 0021553 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.join', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { join } = TypedArray.prototype;
assert.isFunction(join, `${ name }::join is function`);
assert.arity(join, 1, `${ name }::join arity is 1`);
assert.name(join, 'join', `${ name }::join name is 'join'`);
assert.looksNative(join, `${ name }::join looks native`);
assert.same(new TypedArray([1, 2, 3]).join('|'), '1|2|3', 'works #1');
assert.same(new TypedArray([1, 2, 3]).join(), '1,2,3', 'works #2');
assert.throws(() => join.call([1, 2, 3]), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.last-index-of.js 0000664 0000000 0000000 00000002120 13600575677 0023260 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.lastIndexOf', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { lastIndexOf } = TypedArray.prototype;
assert.isFunction(lastIndexOf, `${ name }::lastIndexOf is function`);
assert.arity(lastIndexOf, 1, `${ name }::lastIndexOf arity is 1`);
assert.name(lastIndexOf, 'lastIndexOf', `${ name }::lastIndexOf name is 'lastIndexOf'`);
assert.looksNative(lastIndexOf, `${ name }::lastIndexOf looks native`);
assert.same(new TypedArray([1, 1, 1]).lastIndexOf(1), 2);
assert.same(new TypedArray([1, 2, 3]).lastIndexOf(3, 1), -1);
assert.same(new TypedArray([1, 2, 3]).lastIndexOf(2, 1), 1);
assert.same(new TypedArray([1, 2, 3]).lastIndexOf(2, -3), -1);
assert.same(new TypedArray([1, 2, 3]).lastIndexOf(2, -2), 1);
assert.throws(() => lastIndexOf.call([1], 1), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.map.js 0000664 0000000 0000000 00000003012 13600575677 0021364 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.map', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { map } = TypedArray.prototype;
assert.isFunction(map, `${ name }::map is function`);
assert.arity(map, 1, `${ name }::map arity is 1`);
assert.name(map, 'map', `${ name }::map name is 'map'`);
assert.looksNative(map, `${ name }::map looks native`);
const array = new TypedArray([1]);
const context = {};
array.map(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
const instance = new TypedArray([1, 2, 3, 4, 5]).map(it => it * 2);
assert.ok(instance instanceof TypedArray, 'correct instance');
assert.arrayEqual(instance, [2, 4, 6, 8, 10], 'works');
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).map((value, key) => {
values += value;
keys += key;
});
assert.same(values, '123');
assert.same(keys, '012');
assert.throws(() => map.call([0], () => { /* empty */ }), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.of.js 0000664 0000000 0000000 00000002515 13600575677 0021222 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, NATIVE, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArray%.of', assert => {
// we can't implement %TypedArray% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
assert.isFunction(TypedArray.of, `${ name }.of is function`);
assert.arity(TypedArray.of, 0, `${ name }.of arity is 0`);
assert.name(TypedArray.of, 'of', `${ name }.of name is 'of'`);
assert.looksNative(TypedArray.of, `${ name }.of looks native`);
let instance = TypedArray.of();
assert.ok(instance instanceof TypedArray, 'correct instance with 0 arguments');
assert.arrayEqual(instance, [], 'correct elements with 0 arguments');
instance = TypedArray.of(1);
assert.ok(instance instanceof TypedArray, 'correct instance with 1 argument');
assert.arrayEqual(instance, [1], 'correct elements with 1 argument');
instance = TypedArray.of(1, 2, 3);
assert.ok(instance instanceof TypedArray, 'correct instance with several arguments');
assert.arrayEqual(instance, [1, 2, 3], 'correct elements with several arguments');
assert.throws(() => TypedArray.of.call(undefined, 1), "isn't generic #1");
if (NATIVE) assert.throws(() => TypedArray.of.call(Array, 1), "isn't generic #2");
}
});
core-js-3.6.1/tests/tests/es.typed-array.reduce-right.js 0000664 0000000 0000000 00000004006 13600575677 0023175 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.reduceRight', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { reduceRight } = TypedArray.prototype;
assert.isFunction(reduceRight, `${ name }::reduceRight is function`);
assert.arity(reduceRight, 1, `${ name }::reduceRight arity is 1`);
assert.name(reduceRight, 'reduceRight', `${ name }::reduceRight name is 'reduceRight'`);
assert.looksNative(reduceRight, `${ name }::reduceRight looks native`);
const array = new TypedArray([1]);
const accumulator = {};
array.reduceRight(function (memo, value, key, that) {
assert.same(arguments.length, 4, 'correct number of callback arguments');
assert.same(memo, accumulator, 'correct callback accumulator');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
}, accumulator);
assert.same(new TypedArray([1, 2, 3]).reduceRight(((a, b) => a + b), 1), 7, 'works with initial accumulator');
new TypedArray([1, 2]).reduceRight((memo, value, key) => {
assert.same(memo, 2, 'correct default accumulator');
assert.same(value, 1, 'correct start value without initial accumulator');
assert.same(key, 0, 'correct start index without initial accumulator');
});
assert.same(new TypedArray([1, 2, 3]).reduceRight((a, b) => a + b), 6, 'works without initial accumulator');
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).reduceRight((memo, value, key) => {
values += value;
keys += key;
}, 0);
assert.same(values, '321', 'correct order #1');
assert.same(keys, '210', 'correct order #2');
assert.throws(() => reduceRight.call([0], () => { /* empty */ }), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.reduce.js 0000664 0000000 0000000 00000003654 13600575677 0022072 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.reduce', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { reduce } = TypedArray.prototype;
assert.isFunction(reduce, `${ name }::reduce is function`);
assert.arity(reduce, 1, `${ name }::reduce arity is 1`);
assert.name(reduce, 'reduce', `${ name }::reduce name is 'reduce'`);
assert.looksNative(reduce, `${ name }::reduce looks native`);
const array = new TypedArray([1]);
const accumulator = {};
array.reduce(function (memo, value, key, that) {
assert.same(arguments.length, 4, 'correct number of callback arguments');
assert.same(memo, accumulator, 'correct callback accumulator');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
}, accumulator);
assert.same(new TypedArray([1, 2, 3]).reduce(((a, b) => a + b), 1), 7, 'works with initial accumulator');
new TypedArray([1, 2]).reduce((memo, value, key) => {
assert.same(memo, 1, 'correct default accumulator');
assert.same(value, 2, 'correct start value without initial accumulator');
assert.same(key, 1, 'correct start index without initial accumulator');
});
assert.same(new TypedArray([1, 2, 3]).reduce((a, b) => a + b), 6, 'works without initial accumulator');
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).reduce((memo, value, key) => {
values += value;
keys += key;
}, 0);
assert.same(values, '123', 'correct order #1');
assert.same(keys, '012', 'correct order #2');
assert.throws(() => reduce.call([0], () => { /* empty */ }), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.reverse.js 0000664 0000000 0000000 00000001744 13600575677 0022274 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.reverse', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { reverse } = TypedArray.prototype;
assert.isFunction(reverse, `${ name }::reverse is function`);
assert.arity(reverse, 0, `${ name }::reverse arity is 0`);
assert.name(reverse, 'reverse', `${ name }::reverse name is 'reverse'`);
assert.looksNative(reverse, `${ name }::reverse looks native`);
const array = new TypedArray([1, 2]);
assert.same(array.reverse(), array, 'return this');
assert.arrayEqual(new TypedArray([1, 2, 3, 4]).reverse(), [4, 3, 2, 1], 'works #1');
assert.arrayEqual(new TypedArray([1, 2, 3]).reverse(), [3, 2, 1], 'works #2');
assert.throws(() => reverse.call([1, 2]), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.set.js 0000664 0000000 0000000 00000002704 13600575677 0021411 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, NATIVE, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.set', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { set } = TypedArray.prototype;
assert.isFunction(set, `${ name }::set is function`);
if (NATIVE) assert.arity(set, 1, `${ name }::set arity is 1`);
assert.name(set, 'set', `${ name }::set name is 'set'`);
assert.looksNative(set, `${ name }::set looks native`);
assert.same(new TypedArray(1).set([1]), undefined, 'void');
const array1 = new TypedArray([1, 2, 3, 4, 5]);
const array2 = new TypedArray(5);
array2.set(array1);
assert.arrayEqual(array2, [1, 2, 3, 4, 5]);
assert.throws(() => array2.set(array1, 1));
assert.throws(() => array2.set(array1, -1));
array2.set(new TypedArray([99, 98]), 2);
assert.arrayEqual(array2, [1, 2, 99, 98, 5]);
array2.set(new TypedArray([99, 98, 97]), 2);
assert.arrayEqual(array2, [1, 2, 99, 98, 97]);
assert.throws(() => array2.set(new TypedArray([99, 98, 97, 96]), 2));
assert.throws(() => array2.set([101, 102, 103, 104], 4));
const array3 = new TypedArray(2);
array3.set({ length: 2, 0: 1, 1: 2 });
assert.arrayEqual(array3, [1, 2]);
assert.throws(() => set.call([1, 2, 3], [1]), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.slice.js 0000664 0000000 0000000 00000002366 13600575677 0021721 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.slice', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { slice } = TypedArray.prototype;
assert.isFunction(slice, `${ name }::slice is function`);
assert.arity(slice, 2, `${ name }::slice arity is 0`);
assert.name(slice, 'slice', `${ name }::slice name is 'slice'`);
assert.looksNative(slice, `${ name }::slice looks native`);
const array = new TypedArray([1, 2, 3, 4, 5]);
assert.ok(array.slice() !== array, 'returns new array');
assert.ok(array.slice() instanceof TypedArray, 'correct instance');
assert.ok(array.slice().buffer !== array.buffer, 'with new buffer');
assert.arrayEqual(array.slice(), array);
assert.arrayEqual(array.slice(1, 3), [2, 3]);
assert.arrayEqual(array.slice(1, undefined), [2, 3, 4, 5]);
assert.arrayEqual(array.slice(1, -1), [2, 3, 4]);
assert.arrayEqual(array.slice(-2, -1), [4]);
assert.arrayEqual(array.slice(-2, -3), []);
assert.throws(() => slice.call([1, 2], 1), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.some.js 0000664 0000000 0000000 00000003311 13600575677 0021554 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.some', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { some } = TypedArray.prototype;
assert.isFunction(some, `${ name }::some is function`);
assert.arity(some, 1, `${ name }::some arity is 1`);
assert.name(some, 'some', `${ name }::some name is 'some'`);
assert.looksNative(some, `${ name }::some looks native`);
const array = new TypedArray([1]);
const context = {};
array.some(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 0, 'correct index in callback');
assert.same(that, array, 'correct link to array in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.ok(new TypedArray([1, 2, 3]).some(it => typeof it === 'number'));
assert.ok(new TypedArray([1, 2, 3]).some(it => it < 3));
assert.ok(!new TypedArray([1, 2, 3]).some(it => it < 0));
assert.ok(!new TypedArray([1, 2, 3]).some(it => typeof it === 'string'));
assert.ok(new TypedArray([1, 2, 3]).some(function () {
return +this === 1;
}, 1));
let values = '';
let keys = '';
new TypedArray([1, 2, 3]).some((value, key) => {
values += value;
keys += key;
});
assert.same(values, '123');
assert.same(keys, '012');
assert.throws(() => some.call([0], () => { /* empty */ }), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.subarray.js 0000664 0000000 0000000 00000003065 13600575677 0022447 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, NATIVE, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.subarray', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { subarray } = TypedArray.prototype;
assert.isFunction(subarray, `${ name }::subarray is function`);
if (NATIVE) assert.arity(subarray, 2, `${ name }::subarray arity is 2`);
assert.name(subarray, 'subarray', `${ name }::subarray name is 'subarray'`);
assert.looksNative(subarray, `${ name }::subarray looks native`);
const array1 = new TypedArray([1, 2, 3, 4, 5]);
const array2 = array1.subarray(3);
assert.ok(array1 !== array2, 'creates new array');
assert.ok(array2 instanceof TypedArray, `instance ${ name }`);
assert.same(array1.buffer, array2.buffer, 'with the same buffer');
assert.arrayEqual(array2, [4, 5]);
assert.arrayEqual(array1.subarray(1, 3), [2, 3]);
assert.arrayEqual(array1.subarray(-3), [3, 4, 5]);
assert.arrayEqual(array1.subarray(-3, -1), [3, 4]);
assert.arrayEqual(array1.subarray(3, 2), []);
assert.arrayEqual(array1.subarray(-2, -3), []);
assert.arrayEqual(array1.subarray(4, 1), []);
assert.arrayEqual(array1.subarray(-1, -4), []);
assert.arrayEqual(array1.subarray(1).subarray(1), [3, 4, 5]);
assert.arrayEqual(array1.subarray(1, 4).subarray(1, 2), [3]);
assert.throws(() => subarray.call([1, 2, 3], 1), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.to-locale-string.js 0000664 0000000 0000000 00000001626 13600575677 0024003 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.toLocaleString', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { toLocaleString } = TypedArray.prototype;
assert.isFunction(toLocaleString, `${ name }::toLocaleString is function`);
assert.arity(toLocaleString, 0, `${ name }::toLocaleString arity is 0`);
assert.name(toLocaleString, 'toLocaleString', `${ name }::toLocaleString name is 'toLocaleString'`);
assert.looksNative(toLocaleString, `${ name }::toLocaleString looks native`);
assert.same(new TypedArray([1, 2, 3]).toLocaleString(), [1, 2, 3].toLocaleString(), 'works');
assert.throws(() => toLocaleString.call([1, 2, 3]), "isn't generic");
}
});
core-js-3.6.1/tests/tests/es.typed-array.to-string.js 0000664 0000000 0000000 00000001452 13600575677 0022543 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, TYPED_ARRAYS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('%TypedArrayPrototype%.toString', assert => {
// we can't implement %TypedArrayPrototype% in all engines, so run all tests for each typed array constructor
for (const name in TYPED_ARRAYS) {
const TypedArray = GLOBAL[name];
const { toString } = TypedArray.prototype;
assert.isFunction(toString, `${ name }::toString is function`);
assert.arity(toString, 0, `${ name }::toString arity is 0`);
assert.name(toString, 'toString', `${ name }::toString name is 'toString'`);
assert.looksNative(toString, `${ name }::toString looks native`);
assert.same(new TypedArray([1, 2, 3]).toString(), '1,2,3', 'works');
assert.same(toString.call([1, 2, 3]), '1,2,3', 'generic');
}
});
core-js-3.6.1/tests/tests/es.typed.conversions.float32.js 0000664 0000000 0000000 00000007474 13600575677 0023334 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, LITTLE_ENDIAN } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('Float32 conversions', assert => {
const float32array = new Float32Array(1);
const uint8array = new Uint8Array(float32array.buffer);
const dataview = new DataView(float32array.buffer);
function viewFrom(it) {
return new DataView(new Uint8Array(it).buffer);
}
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
const data = [
[0, 0, [0, 0, 0, 0]],
[-0, -0, [0, 0, 0, 128]],
[1, 1, [0, 0, 128, 63]],
[-1, -1, [0, 0, 128, 191]],
[1.1, 1.100000023841858, [205, 204, 140, 63]],
[-1.1, -1.100000023841858, [205, 204, 140, 191]],
[1.9, 1.899999976158142, [51, 51, 243, 63]],
[-1.9, -1.899999976158142, [51, 51, 243, 191]],
[127, 127, [0, 0, 254, 66]],
[-127, -127, [0, 0, 254, 194]],
[128, 128, [0, 0, 0, 67]],
[-128, -128, [0, 0, 0, 195]],
[255, 255, [0, 0, 127, 67]],
[-255, -255, [0, 0, 127, 195]],
[255.1, 255.10000610351562, [154, 25, 127, 67]],
[255.9, 255.89999389648438, [102, 230, 127, 67]],
[256, 256, [0, 0, 128, 67]],
[32767, 32767, [0, 254, 255, 70]],
[-32767, -32767, [0, 254, 255, 198]],
[32768, 32768, [0, 0, 0, 71]],
[-32768, -32768, [0, 0, 0, 199]],
[65535, 65535, [0, 255, 127, 71]],
[65536, 65536, [0, 0, 128, 71]],
[65537, 65537, [128, 0, 128, 71]],
[65536.54321, 65536.546875, [70, 0, 128, 71]],
[-65536.54321, -65536.546875, [70, 0, 128, 199]],
[2147483647, 2147483648, [0, 0, 0, 79]],
[-2147483647, -2147483648, [0, 0, 0, 207]],
[2147483648, 2147483648, [0, 0, 0, 79]],
[-2147483648, -2147483648, [0, 0, 0, 207]],
[2147483649, 2147483648, [0, 0, 0, 79]],
[-2147483649, -2147483648, [0, 0, 0, 207]],
[4294967295, 4294967296, [0, 0, 128, 79]],
[4294967296, 4294967296, [0, 0, 128, 79]],
[4294967297, 4294967296, [0, 0, 128, 79]],
[9007199254740991, 9007199254740992, [0, 0, 0, 90]],
[-9007199254740991, -9007199254740992, [0, 0, 0, 218]],
[9007199254740992, 9007199254740992, [0, 0, 0, 90]],
[-9007199254740992, -9007199254740992, [0, 0, 0, 218]],
[9007199254740994, 9007199254740992, [0, 0, 0, 90]],
[-9007199254740994, -9007199254740992, [0, 0, 0, 218]],
[Infinity, Infinity, [0, 0, 128, 127]],
[-Infinity, -Infinity, [0, 0, 128, 255]],
[1.7976931348623157e+308, Infinity, [0, 0, 128, 127]],
[-1.7976931348623157e+308, -Infinity, [0, 0, 128, 255]],
[5e-324, 0, [0, 0, 0, 0]],
[-5e-324, -0, [0, 0, 0, 128]],
];
for (const [value, conversion, little] of data) {
const big = little.slice().reverse();
const representation = LITTLE_ENDIAN ? little : big;
float32array[0] = value;
assert.same(float32array[0], conversion, `Float32Array ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, representation, `Float32Array ${ toString(value) } -> [${ representation }]`);
dataview.setFloat32(0, value);
assert.arrayEqual(uint8array, big, `dataview.setFloat32(0, ${ toString(value) }) -> [${ big }]`);
assert.same(viewFrom(big).getFloat32(0), conversion, `dataview{${ big }}.getFloat32(0) -> ${ toString(conversion) }`);
dataview.setFloat32(0, value, false);
assert.arrayEqual(uint8array, big, `dataview.setFloat32(0, ${ toString(value) }, false) -> [${ big }]`);
assert.same(viewFrom(big).getFloat32(0, false), conversion, `dataview{${ big }}.getFloat32(0, false) -> ${ toString(conversion) }`);
dataview.setFloat32(0, value, true);
assert.arrayEqual(uint8array, little, `dataview.setFloat32(0, ${ toString(value) }, true) -> [${ little }]`);
assert.same(viewFrom(little).getFloat32(0, true), conversion, `dataview{${ little }}.getFloat32(0, true) -> ${ toString(conversion) }`);
}
float32array[0] = NaN;
assert.same(float32array[0], NaN, 'NaN -> NaN');
});
core-js-3.6.1/tests/tests/es.typed.conversions.float64.js 0000664 0000000 0000000 00000010766 13600575677 0023337 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, LITTLE_ENDIAN } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('Float64 conversions', assert => {
const float64array = new Float64Array(1);
const uint8array = new Uint8Array(float64array.buffer);
const dataview = new DataView(float64array.buffer);
function viewFrom(it) {
return new DataView(new Uint8Array(it).buffer);
}
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
const data = [
[0, 0, [0, 0, 0, 0, 0, 0, 0, 0]],
[-0, -0, [0, 0, 0, 0, 0, 0, 0, 128]],
[1, 1, [0, 0, 0, 0, 0, 0, 240, 63]],
[-1, -1, [0, 0, 0, 0, 0, 0, 240, 191]],
[1.1, 1.1, [154, 153, 153, 153, 153, 153, 241, 63]],
[-1.1, -1.1, [154, 153, 153, 153, 153, 153, 241, 191]],
[1.9, 1.9, [102, 102, 102, 102, 102, 102, 254, 63]],
[-1.9, -1.9, [102, 102, 102, 102, 102, 102, 254, 191]],
[127, 127, [0, 0, 0, 0, 0, 192, 95, 64]],
[-127, -127, [0, 0, 0, 0, 0, 192, 95, 192]],
[128, 128, [0, 0, 0, 0, 0, 0, 96, 64]],
[-128, -128, [0, 0, 0, 0, 0, 0, 96, 192]],
[255, 255, [0, 0, 0, 0, 0, 224, 111, 64]],
[-255, -255, [0, 0, 0, 0, 0, 224, 111, 192]],
[255.1, 255.1, [51, 51, 51, 51, 51, 227, 111, 64]],
[255.9, 255.9, [205, 204, 204, 204, 204, 252, 111, 64]],
[256, 256, [0, 0, 0, 0, 0, 0, 112, 64]],
[32767, 32767, [0, 0, 0, 0, 192, 255, 223, 64]],
[-32767, -32767, [0, 0, 0, 0, 192, 255, 223, 192]],
[32768, 32768, [0, 0, 0, 0, 0, 0, 224, 64]],
[-32768, -32768, [0, 0, 0, 0, 0, 0, 224, 192]],
[65535, 65535, [0, 0, 0, 0, 224, 255, 239, 64]],
[65536, 65536, [0, 0, 0, 0, 0, 0, 240, 64]],
[65537, 65537, [0, 0, 0, 0, 16, 0, 240, 64]],
[65536.54321, 65536.54321, [14, 248, 252, 176, 8, 0, 240, 64]],
[-65536.54321, -65536.54321, [14, 248, 252, 176, 8, 0, 240, 192]],
[2147483647, 2147483647, [0, 0, 192, 255, 255, 255, 223, 65]],
[-2147483647, -2147483647, [0, 0, 192, 255, 255, 255, 223, 193]],
[2147483648, 2147483648, [0, 0, 0, 0, 0, 0, 224, 65]],
[-2147483648, -2147483648, [0, 0, 0, 0, 0, 0, 224, 193]],
[2147483649, 2147483649, [0, 0, 32, 0, 0, 0, 224, 65]],
[-2147483649, -2147483649, [0, 0, 32, 0, 0, 0, 224, 193]],
[4294967295, 4294967295, [0, 0, 224, 255, 255, 255, 239, 65]],
[4294967296, 4294967296, [0, 0, 0, 0, 0, 0, 240, 65]],
[4294967297, 4294967297, [0, 0, 16, 0, 0, 0, 240, 65]],
[9007199254740991, 9007199254740991, [255, 255, 255, 255, 255, 255, 63, 67]],
[-9007199254740991, -9007199254740991, [255, 255, 255, 255, 255, 255, 63, 195]],
[9007199254740992, 9007199254740992, [0, 0, 0, 0, 0, 0, 64, 67]],
[-9007199254740992, -9007199254740992, [0, 0, 0, 0, 0, 0, 64, 195]],
[9007199254740994, 9007199254740994, [1, 0, 0, 0, 0, 0, 64, 67]],
[-9007199254740994, -9007199254740994, [1, 0, 0, 0, 0, 0, 64, 195]],
[Infinity, Infinity, [0, 0, 0, 0, 0, 0, 240, 127]],
[-Infinity, -Infinity, [0, 0, 0, 0, 0, 0, 240, 255]],
[-1.7976931348623157e+308, -1.7976931348623157e+308,
[255, 255, 255, 255, 255, 255, 239, 255]],
[1.7976931348623157e+308, 1.7976931348623157e+308,
[255, 255, 255, 255, 255, 255, 239, 127]],
[5e-324, 5e-324, [1, 0, 0, 0, 0, 0, 0, 0]],
[-5e-324, -5e-324, [1, 0, 0, 0, 0, 0, 0, 128]],
];
for (const [value, conversion, little] of data) {
const big = little.slice().reverse();
const representation = LITTLE_ENDIAN ? little : big;
float64array[0] = value;
assert.same(float64array[0], conversion, `Float64Array ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, representation, `Float64Array ${ toString(value) } -> [${ representation }]`);
dataview.setFloat64(0, value);
assert.arrayEqual(uint8array, big, `dataview.setFloat64(0, ${ toString(value) }) -> [${ big }]`);
assert.same(viewFrom(big).getFloat64(0), conversion, `dataview{${ big }}.getFloat64(0) -> ${ toString(conversion) }`);
dataview.setFloat64(0, value, false);
assert.arrayEqual(uint8array, big, `dataview.setFloat64(0, ${ toString(value) }, false) -> [${ big }]`);
assert.same(viewFrom(big).getFloat64(0, false), conversion, `dataview{${ big }}.getFloat64(0, false) -> ${ toString(conversion) }`);
dataview.setFloat64(0, value, true);
assert.arrayEqual(uint8array, little, `dataview.setFloat64(0, ${ toString(value) }, true) -> [${ little }]`);
assert.same(viewFrom(little).getFloat64(0, true), conversion, `dataview{${ little }}.getFloat64(0, true) -> ${ toString(conversion) }`);
}
float64array[0] = NaN;
assert.same(float64array[0], NaN, 'NaN -> NaN');
});
core-js-3.6.1/tests/tests/es.typed.conversions.int16.js 0000664 0000000 0000000 00000006317 13600575677 0023016 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, LITTLE_ENDIAN, NATIVE } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('Int16 conversions', assert => {
const int16array = new Int16Array(1);
const uint8array = new Uint8Array(int16array.buffer);
const dataview = new DataView(int16array.buffer);
function viewFrom(it) {
return new DataView(new Uint8Array(it).buffer);
}
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
let data = [
[0, 0, [0, 0]],
[-0, 0, [0, 0]],
[1, 1, [1, 0]],
[-1, -1, [255, 255]],
[1.1, 1, [1, 0]],
[-1.1, -1, [255, 255]],
[1.9, 1, [1, 0]],
[-1.9, -1, [255, 255]],
[127, 127, [127, 0]],
[-127, -127, [129, 255]],
[128, 128, [128, 0]],
[-128, -128, [128, 255]],
[255, 255, [255, 0]],
[-255, -255, [1, 255]],
[255.1, 255, [255, 0]],
[255.9, 255, [255, 0]],
[256, 256, [0, 1]],
[32767, 32767, [255, 127]],
[-32767, -32767, [1, 128]],
[32768, -32768, [0, 128]],
[-32768, -32768, [0, 128]],
[65535, -1, [255, 255]],
[65536, 0, [0, 0]],
[65537, 1, [1, 0]],
[65536.54321, 0, [0, 0]],
[-65536.54321, 0, [0, 0]],
[2147483647, -1, [255, 255]],
[-2147483647, 1, [1, 0]],
[2147483648, 0, [0, 0]],
[-2147483648, 0, [0, 0]],
[4294967296, 0, [0, 0]],
[9007199254740992, 0, [0, 0]],
[-9007199254740992, 0, [0, 0]],
[Infinity, 0, [0, 0]],
[-Infinity, 0, [0, 0]],
[-1.7976931348623157e+308, 0, [0, 0]],
[1.7976931348623157e+308, 0, [0, 0]],
[5e-324, 0, [0, 0]],
[-5e-324, 0, [0, 0]],
[NaN, 0, [0, 0]],
];
// Android 4.3- bug
if (NATIVE || !/Android [2-4]/.test(GLOBAL.navigator && navigator.userAgent)) {
data = data.concat([
[2147483649, 1, [1, 0]],
[-2147483649, -1, [255, 255]],
[4294967295, -1, [255, 255]],
[4294967297, 1, [1, 0]],
[9007199254740991, -1, [255, 255]],
[-9007199254740991, 1, [1, 0]],
[9007199254740994, 2, [2, 0]],
[-9007199254740994, -2, [254, 255]],
]);
}
for (const [value, conversion, little] of data) {
const big = little.slice().reverse();
const representation = LITTLE_ENDIAN ? little : big;
int16array[0] = value;
assert.same(int16array[0], conversion, `Int16Array ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, representation, `Int16Array ${ toString(value) } -> [${ representation }]`);
dataview.setInt16(0, value);
assert.arrayEqual(uint8array, big, `dataview.setInt16(0, ${ toString(value) }) -> [${ big }]`);
assert.same(viewFrom(big).getInt16(0), conversion, `dataview{${ big }}.getInt16(0) -> ${ toString(conversion) }`);
dataview.setInt16(0, value, false);
assert.arrayEqual(uint8array, big, `dataview.setInt16(0, ${ toString(value) }, false) -> [${ big }]`);
assert.same(viewFrom(big).getInt16(0, false), conversion, `dataview{${ big }}.getInt16(0, false) -> ${ toString(conversion) }`);
dataview.setInt16(0, value, true);
assert.arrayEqual(uint8array, little, `dataview.setInt16(0, ${ toString(value) }, true) -> [${ little }]`);
assert.same(viewFrom(little).getInt16(0, true), conversion, `dataview{${ little }}.getInt16(0, true) -> ${ toString(conversion) }`);
}
});
core-js-3.6.1/tests/tests/es.typed.conversions.int32.js 0000664 0000000 0000000 00000006717 13600575677 0023020 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, LITTLE_ENDIAN } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('Int32 conversions', assert => {
const int32array = new Int32Array(1);
const uint8array = new Uint8Array(int32array.buffer);
const dataview = new DataView(int32array.buffer);
function viewFrom(it) {
return new DataView(new Uint8Array(it).buffer);
}
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
const data = [
[0, 0, [0, 0, 0, 0]],
[-0, 0, [0, 0, 0, 0]],
[1, 1, [1, 0, 0, 0]],
[-1, -1, [255, 255, 255, 255]],
[1.1, 1, [1, 0, 0, 0]],
[-1.1, -1, [255, 255, 255, 255]],
[1.9, 1, [1, 0, 0, 0]],
[-1.9, -1, [255, 255, 255, 255]],
[127, 127, [127, 0, 0, 0]],
[-127, -127, [129, 255, 255, 255]],
[128, 128, [128, 0, 0, 0]],
[-128, -128, [128, 255, 255, 255]],
[255, 255, [255, 0, 0, 0]],
[-255, -255, [1, 255, 255, 255]],
[255.1, 255, [255, 0, 0, 0]],
[255.9, 255, [255, 0, 0, 0]],
[256, 256, [0, 1, 0, 0]],
[32767, 32767, [255, 127, 0, 0]],
[-32767, -32767, [1, 128, 255, 255]],
[32768, 32768, [0, 128, 0, 0]],
[-32768, -32768, [0, 128, 255, 255]],
[65535, 65535, [255, 255, 0, 0]],
[65536, 65536, [0, 0, 1, 0]],
[65537, 65537, [1, 0, 1, 0]],
[65536.54321, 65536, [0, 0, 1, 0]],
[-65536.54321, -65536, [0, 0, 255, 255]],
[2147483647, 2147483647, [255, 255, 255, 127]],
[-2147483647, -2147483647, [1, 0, 0, 128]],
[2147483648, -2147483648, [0, 0, 0, 128]],
[-2147483648, -2147483648, [0, 0, 0, 128]],
[2147483649, -2147483647, [1, 0, 0, 128]],
[-2147483649, 2147483647, [255, 255, 255, 127]],
[4294967295, -1, [255, 255, 255, 255]],
[4294967296, 0, [0, 0, 0, 0]],
[4294967297, 1, [1, 0, 0, 0]],
[9007199254740991, -1, [255, 255, 255, 255]],
[-9007199254740991, 1, [1, 0, 0, 0]],
[9007199254740992, 0, [0, 0, 0, 0]],
[-9007199254740992, 0, [0, 0, 0, 0]],
[9007199254740994, 2, [2, 0, 0, 0]],
[-9007199254740994, -2, [254, 255, 255, 255]],
[Infinity, 0, [0, 0, 0, 0]],
[-Infinity, 0, [0, 0, 0, 0]],
[-1.7976931348623157e+308, 0, [0, 0, 0, 0]],
[1.7976931348623157e+308, 0, [0, 0, 0, 0]],
[5e-324, 0, [0, 0, 0, 0]],
[-5e-324, 0, [0, 0, 0, 0]],
[NaN, 0, [0, 0, 0, 0]],
];
for (const [value, conversion, little] of data) {
const big = little.slice().reverse();
const representation = LITTLE_ENDIAN ? little : big;
int32array[0] = value;
assert.same(int32array[0], conversion, `Int32Array ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, representation, `Int32Array ${ toString(value) } -> [${ representation }]`);
dataview.setInt32(0, value);
assert.arrayEqual(uint8array, big, `dataview.setInt32(0, ${ toString(value) }) -> [${ big }]`);
assert.same(viewFrom(big).getInt32(0), conversion, `dataview{${ big }}.getInt32(0) -> ${ toString(conversion) }`);
dataview.setInt32(0, value, false);
assert.arrayEqual(uint8array, big, `dataview.setInt32(0, ${ toString(value) }, false) -> [${ big }]`);
assert.same(viewFrom(big).getInt32(0, false), conversion, `dataview{${ big }}.getInt32(0, false) -> ${ toString(conversion) }`);
dataview.setInt32(0, value, true);
assert.arrayEqual(uint8array, little, `dataview.setInt32(0, ${ toString(value) }, true) -> [${ little }]`);
assert.same(viewFrom(little).getInt32(0, true), conversion, `dataview{${ little }}.getInt32(0, true) -> ${ toString(conversion) }`);
}
});
core-js-3.6.1/tests/tests/es.typed.conversions.int8.js 0000664 0000000 0000000 00000004701 13600575677 0022732 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, LITTLE_ENDIAN, NATIVE } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('Int8 conversions', assert => {
const int8array = new Int8Array(1);
const uint8array = new Uint8Array(int8array.buffer);
const dataview = new DataView(int8array.buffer);
function viewFrom(it) {
return new DataView(new Uint8Array(it).buffer);
}
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
let data = [
[0, 0, [0]],
[-0, 0, [0]],
[1, 1, [1]],
[-1, -1, [255]],
[1.1, 1, [1]],
[-1.1, -1, [255]],
[1.9, 1, [1]],
[-1.9, -1, [255]],
[127, 127, [127]],
[-127, -127, [129]],
[128, -128, [128]],
[-128, -128, [128]],
[255, -1, [255]],
[-255, 1, [1]],
[255.1, -1, [255]],
[255.9, -1, [255]],
[256, 0, [0]],
[32767, -1, [255]],
[-32767, 1, [1]],
[32768, 0, [0]],
[-32768, 0, [0]],
[65535, -1, [255]],
[65536, 0, [0]],
[65537, 1, [1]],
[65536.54321, 0, [0]],
[-65536.54321, 0, [0]],
[2147483647, -1, [255]],
[-2147483647, 1, [1]],
[2147483648, 0, [0]],
[-2147483648, 0, [0]],
[4294967296, 0, [0]],
[9007199254740992, 0, [0]],
[-9007199254740992, 0, [0]],
[Infinity, 0, [0]],
[-Infinity, 0, [0]],
[-1.7976931348623157e+308, 0, [0]],
[1.7976931348623157e+308, 0, [0]],
[5e-324, 0, [0]],
[-5e-324, 0, [0]],
[NaN, 0, [0]],
];
// Android 4.3- bug
if (NATIVE || !/Android [2-4]/.test(GLOBAL.navigator && navigator.userAgent)) {
data = data.concat([
[2147483649, 1, [1]],
[-2147483649, -1, [255]],
[4294967295, -1, [255]],
[4294967297, 1, [1]],
[9007199254740991, -1, [255]],
[-9007199254740991, 1, [1]],
[9007199254740994, 2, [2]],
[-9007199254740994, -2, [254]],
]);
}
for (const [value, conversion, little] of data) {
const big = little.slice().reverse();
const representation = LITTLE_ENDIAN ? little : big;
int8array[0] = value;
assert.same(int8array[0], conversion, `Int8Array ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, representation, `Int8Array ${ toString(value) } -> [${ representation }]`);
dataview.setInt8(0, value);
assert.arrayEqual(uint8array, big, `dataview.setInt8(0, ${ toString(value) }) -> [${ big }]`);
assert.same(viewFrom(big).getInt8(0), conversion, `dataview{${ big }}.getInt8(0) -> ${ toString(conversion) }`);
}
});
core-js-3.6.1/tests/tests/es.typed.conversions.uint16.js 0000664 0000000 0000000 00000006377 13600575677 0023211 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, LITTLE_ENDIAN, NATIVE } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('Uint16 conversions', assert => {
const uint16array = new Uint16Array(1);
const uint8array = new Uint8Array(uint16array.buffer);
const dataview = new DataView(uint16array.buffer);
function viewFrom(it) {
return new DataView(new Uint8Array(it).buffer);
}
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
let data = [
[0, 0, [0, 0]],
[-0, 0, [0, 0]],
[1, 1, [1, 0]],
[-1, 65535, [255, 255]],
[1.1, 1, [1, 0]],
[-1.1, 65535, [255, 255]],
[1.9, 1, [1, 0]],
[-1.9, 65535, [255, 255]],
[127, 127, [127, 0]],
[-127, 65409, [129, 255]],
[128, 128, [128, 0]],
[-128, 65408, [128, 255]],
[255, 255, [255, 0]],
[-255, 65281, [1, 255]],
[255.1, 255, [255, 0]],
[255.9, 255, [255, 0]],
[256, 256, [0, 1]],
[32767, 32767, [255, 127]],
[-32767, 32769, [1, 128]],
[32768, 32768, [0, 128]],
[-32768, 32768, [0, 128]],
[65535, 65535, [255, 255]],
[65536, 0, [0, 0]],
[65537, 1, [1, 0]],
[65536.54321, 0, [0, 0]],
[-65536.54321, 0, [0, 0]],
[2147483647, 65535, [255, 255]],
[-2147483647, 1, [1, 0]],
[2147483648, 0, [0, 0]],
[-2147483648, 0, [0, 0]],
[4294967296, 0, [0, 0]],
[9007199254740992, 0, [0, 0]],
[-9007199254740992, 0, [0, 0]],
[Infinity, 0, [0, 0]],
[-Infinity, 0, [0, 0]],
[-1.7976931348623157e+308, 0, [0, 0]],
[1.7976931348623157e+308, 0, [0, 0]],
[5e-324, 0, [0, 0]],
[-5e-324, 0, [0, 0]],
[NaN, 0, [0, 0]],
];
// Android 4.3- bug
if (NATIVE || !/Android [2-4]/.test(GLOBAL.navigator && navigator.userAgent)) {
data = data.concat([
[2147483649, 1, [1, 0]],
[-2147483649, 65535, [255, 255]],
[4294967295, 65535, [255, 255]],
[4294967297, 1, [1, 0]],
[9007199254740991, 65535, [255, 255]],
[-9007199254740991, 1, [1, 0]],
[9007199254740994, 2, [2, 0]],
[-9007199254740994, 65534, [254, 255]],
]);
}
for (const [value, conversion, little] of data) {
const big = little.slice().reverse();
const representation = LITTLE_ENDIAN ? little : big;
uint16array[0] = value;
assert.same(uint16array[0], conversion, `Uint16Array ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, representation, `Uint16Array ${ toString(value) } -> [${ representation }]`);
dataview.setUint16(0, value);
assert.arrayEqual(uint8array, big, `dataview.setUint16(0, ${ toString(value) }) -> [${ big }]`);
assert.same(viewFrom(big).getUint16(0), conversion, `dataview{${ big }}.getUint16(0) -> ${ toString(conversion) }`);
dataview.setUint16(0, value, false);
assert.arrayEqual(uint8array, big, `dataview.setUint16(0, ${ toString(value) }, false) -> [${ big }]`);
assert.same(viewFrom(big).getUint16(0, false), conversion, `dataview{${ big }}.getUint16(0, false) -> ${ toString(conversion) }`);
dataview.setUint16(0, value, true);
assert.arrayEqual(uint8array, little, `dataview.setUint16(0, ${ toString(value) }, true) -> [${ little }]`);
assert.same(viewFrom(little).getUint16(0, true), conversion, `dataview{${ little }}.getUint16(0, true) -> ${ toString(conversion) }`);
}
});
core-js-3.6.1/tests/tests/es.typed.conversions.uint32.js 0000664 0000000 0000000 00000007052 13600575677 0023176 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, LITTLE_ENDIAN } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('Uint32 conversions', assert => {
const uint32array = new Uint32Array(1);
const uint8array = new Uint8Array(uint32array.buffer);
const dataview = new DataView(uint32array.buffer);
function viewFrom(it) {
return new DataView(new Uint8Array(it).buffer);
}
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
const data = [
[0, 0, [0, 0, 0, 0]],
[-0, 0, [0, 0, 0, 0]],
[1, 1, [1, 0, 0, 0]],
[-1, 4294967295, [255, 255, 255, 255]],
[1.1, 1, [1, 0, 0, 0]],
[-1.1, 4294967295, [255, 255, 255, 255]],
[1.9, 1, [1, 0, 0, 0]],
[-1.9, 4294967295, [255, 255, 255, 255]],
[127, 127, [127, 0, 0, 0]],
[-127, 4294967169, [129, 255, 255, 255]],
[128, 128, [128, 0, 0, 0]],
[-128, 4294967168, [128, 255, 255, 255]],
[255, 255, [255, 0, 0, 0]],
[-255, 4294967041, [1, 255, 255, 255]],
[255.1, 255, [255, 0, 0, 0]],
[255.9, 255, [255, 0, 0, 0]],
[256, 256, [0, 1, 0, 0]],
[32767, 32767, [255, 127, 0, 0]],
[-32767, 4294934529, [1, 128, 255, 255]],
[32768, 32768, [0, 128, 0, 0]],
[-32768, 4294934528, [0, 128, 255, 255]],
[65535, 65535, [255, 255, 0, 0]],
[65536, 65536, [0, 0, 1, 0]],
[65537, 65537, [1, 0, 1, 0]],
[65536.54321, 65536, [0, 0, 1, 0]],
[-65536.54321, 4294901760, [0, 0, 255, 255]],
[2147483647, 2147483647, [255, 255, 255, 127]],
[-2147483647, 2147483649, [1, 0, 0, 128]],
[2147483648, 2147483648, [0, 0, 0, 128]],
[-2147483648, 2147483648, [0, 0, 0, 128]],
[2147483649, 2147483649, [1, 0, 0, 128]],
[-2147483649, 2147483647, [255, 255, 255, 127]],
[4294967295, 4294967295, [255, 255, 255, 255]],
[4294967296, 0, [0, 0, 0, 0]],
[4294967297, 1, [1, 0, 0, 0]],
[9007199254740991, 4294967295, [255, 255, 255, 255]],
[-9007199254740991, 1, [1, 0, 0, 0]],
[9007199254740992, 0, [0, 0, 0, 0]],
[-9007199254740992, 0, [0, 0, 0, 0]],
[9007199254740994, 2, [2, 0, 0, 0]],
[-9007199254740994, 4294967294, [254, 255, 255, 255]],
[Infinity, 0, [0, 0, 0, 0]], [-Infinity, 0, [0, 0, 0, 0]],
[-1.7976931348623157e+308, 0, [0, 0, 0, 0]],
[1.7976931348623157e+308, 0, [0, 0, 0, 0]],
[5e-324, 0, [0, 0, 0, 0]],
[-5e-324, 0, [0, 0, 0, 0]],
[NaN, 0, [0, 0, 0, 0]],
];
for (const [value, conversion, little] of data) {
const big = little.slice().reverse();
const representation = LITTLE_ENDIAN ? little : big;
uint32array[0] = value;
assert.same(uint32array[0], conversion, `Uint32Array ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, representation, `Uint32Array ${ toString(value) } -> [${ representation }]`);
dataview.setUint32(0, value);
assert.arrayEqual(uint8array, big, `dataview.setUint32(0, ${ toString(value) }) -> [${ big }]`);
assert.same(viewFrom(big).getUint32(0), conversion, `dataview{${ big }}.getUint32(0) -> ${ toString(conversion) }`);
dataview.setUint32(0, value, false);
assert.arrayEqual(uint8array, big, `dataview.setUint32(0, ${ toString(value) }, false) -> [${ big }]`);
assert.same(viewFrom(big).getUint32(0, false), conversion, `dataview{${ big }}.getUint32(0, false) -> ${ toString(conversion) }`);
dataview.setUint32(0, value, true);
assert.arrayEqual(uint8array, little, `dataview.setUint32(0, ${ toString(value) }, true) -> [${ little }]`);
assert.same(viewFrom(little).getUint32(0, true), conversion, `dataview{${ little }}.getUint32(0, true) -> ${ toString(conversion) }`);
}
});
core-js-3.6.1/tests/tests/es.typed.conversions.uint8-clamped.js 0000664 0000000 0000000 00000003545 13600575677 0024527 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('Uint8Clamped conversions', assert => {
const uint8clamped = new Uint8ClampedArray(1);
const uint8array = new Uint8Array(uint8clamped.buffer);
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
const data = [
[0, 0, [0]],
[-0, 0, [0]],
[1, 1, [1]],
[-1, 0, [0]],
[1.1, 1, [1]],
[-1.1, 0, [0]],
[1.9, 2, [2]],
[-1.9, 0, [0]],
[127, 127, [127]],
[-127, 0, [0]],
[128, 128, [128]],
[-128, 0, [0]],
[255, 255, [255]],
[-255, 0, [0]],
[255.1, 255, [255]],
[255.9, 255, [255]],
[256, 255, [255]],
[32767, 255, [255]],
[-32767, 0, [0]],
[32768, 255, [255]],
[-32768, 0, [0]],
[65535, 255, [255]],
[65536, 255, [255]],
[65537, 255, [255]],
[65536.54321, 255, [255]],
[-65536.54321, 0, [0]],
[2147483647, 255, [255]],
[-2147483647, 0, [0]],
[2147483648, 255, [255]],
[-2147483648, 0, [0]],
[2147483649, 255, [255]],
[-2147483649, 0, [0]],
[4294967295, 255, [255]],
[4294967296, 255, [255]],
[4294967297, 255, [255]],
[9007199254740991, 255, [255]],
[-9007199254740991, 0, [0]],
[9007199254740992, 255, [255]],
[-9007199254740992, 0, [0]],
[9007199254740994, 255, [255]],
[-9007199254740994, 0, [0]],
[Infinity, 255, [255]],
[-Infinity, 0, [0]],
[-1.7976931348623157e+308, 0, [0]],
[1.7976931348623157e+308, 255, [255]],
[5e-324, 0, [0]],
[-5e-324, 0, [0]],
[NaN, 0, [0]],
];
for (const [value, conversion, little] of data) {
uint8clamped[0] = value;
assert.same(uint8clamped[0], conversion, `Uint8ClampedArray ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, little, `Uint8ClampedArray ${ toString(value) } -> [${ little }]`);
}
});
core-js-3.6.1/tests/tests/es.typed.conversions.uint8.js 0000664 0000000 0000000 00000004446 13600575677 0023125 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, NATIVE } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('Uint8 conversions', assert => {
const uint8array = new Uint8Array(1);
const dataview = new DataView(uint8array.buffer);
function viewFrom(it) {
return new DataView(new Uint8Array(it).buffer);
}
function toString(it) {
return it === 0 && 1 / it === -Infinity ? '-0' : it;
}
let data = [
[0, 0, [0]],
[-0, 0, [0]],
[1, 1, [1]],
[-1, 255, [255]],
[1.1, 1, [1]],
[-1.1, 255, [255]],
[1.9, 1, [1]],
[-1.9, 255, [255]],
[127, 127, [127]],
[-127, 129, [129]],
[128, 128, [128]],
[-128, 128, [128]],
[255, 255, [255]],
[-255, 1, [1]],
[255.1, 255, [255]],
[255.9, 255, [255]],
[256, 0, [0]],
[32767, 255, [255]],
[-32767, 1, [1]],
[32768, 0, [0]],
[-32768, 0, [0]],
[65535, 255, [255]],
[65536, 0, [0]],
[65537, 1, [1]],
[65536.54321, 0, [0]],
[-65536.54321, 0, [0]],
[2147483647, 255, [255]],
[-2147483647, 1, [1]],
[2147483648, 0, [0]],
[-2147483648, 0, [0]],
[4294967296, 0, [0]],
[9007199254740992, 0, [0]],
[-9007199254740992, 0, [0]],
[Infinity, 0, [0]], [-Infinity, 0, [0]],
[-1.7976931348623157e+308, 0, [0]],
[1.7976931348623157e+308, 0, [0]],
[5e-324, 0, [0]],
[-5e-324, 0, [0]],
[NaN, 0, [0]],
];
// Android 4.3- bug
if (NATIVE || !/Android [2-4]/.test(GLOBAL.navigator && navigator.userAgent)) {
data = data.concat([
[2147483649, 1, [1]],
[-2147483649, 255, [255]],
[4294967295, 255, [255]],
[4294967297, 1, [1]],
[9007199254740991, 255, [255]],
[-9007199254740991, 1, [1]],
[9007199254740994, 2, [2]],
[-9007199254740994, 254, [254]],
]);
}
for (const [value, conversion, little] of data) {
uint8array[0] = value;
assert.same(uint8array[0], conversion, `Uint8Array ${ toString(value) } -> ${ toString(conversion) }`);
assert.arrayEqual(uint8array, little, `Uint8Array ${ toString(value) } -> [${ little }]`);
dataview.setUint8(0, value);
assert.arrayEqual(uint8array, little, `dataview.setUint8(0, ${ toString(value) }) -> [${ little }]`);
assert.same(viewFrom(little).getUint8(0), conversion, `dataview{${ little }}.getUint8(0) -> ${ toString(conversion) }`);
}
});
core-js-3.6.1/tests/tests/es.weak-map.js 0000664 0000000 0000000 00000015430 13600575677 0020060 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, NATIVE } from '../helpers/constants';
import { createIterable, nativeSubclass } from '../helpers/helpers';
const Symbol = GLOBAL.Symbol || {};
const { freeze, keys, getOwnPropertyNames, getOwnPropertySymbols } = Object;
const { ownKeys } = GLOBAL.Reflect || {};
QUnit.test('WeakMap', assert => {
assert.isFunction(WeakMap);
assert.name(WeakMap, 'WeakMap');
assert.arity(WeakMap, 0);
assert.looksNative(WeakMap);
assert.ok('delete' in WeakMap.prototype, 'delete in WeakMap.prototype');
assert.ok('get' in WeakMap.prototype, 'get in WeakMap.prototype');
assert.ok('has' in WeakMap.prototype, 'has in WeakMap.prototype');
assert.ok('set' in WeakMap.prototype, 'set in WeakMap.prototype');
assert.ok(new WeakMap() instanceof WeakMap, 'new WeakMap instanceof WeakMap');
let object = {};
assert.strictEqual(new WeakMap(createIterable([[object, 42]])).get(object), 42, 'Init from iterable');
let weakmap = new WeakMap();
const frozen = freeze({});
weakmap.set(frozen, 42);
assert.strictEqual(weakmap.get(frozen), 42, 'Support frozen objects');
weakmap = new WeakMap();
weakmap.set(frozen, 42);
assert.strictEqual(weakmap.has(frozen), true, 'works with frozen objects, #1');
assert.strictEqual(weakmap.get(frozen), 42, 'works with frozen objects, #2');
weakmap.delete(frozen);
assert.strictEqual(weakmap.has(frozen), false, 'works with frozen objects, #3');
assert.strictEqual(weakmap.get(frozen), undefined, 'works with frozen objects, #4');
let done = false;
try {
new WeakMap(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
assert.ok(done, '.return #throw');
assert.ok(!('clear' in WeakMap.prototype), 'should not contains `.clear` method');
const array = [];
done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return [][Symbol.iterator].call(this);
};
new WeakMap(array);
assert.ok(done);
object = {};
new WeakMap().set(object, 1);
if (DESCRIPTORS) {
const results = [];
for (const key in object) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(WeakMap);
assert.ok(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.ok(new Subclass() instanceof WeakMap, 'correct subclassing with native classes #2');
object = {};
assert.same(new Subclass().set(object, 2).get(object), 2, 'correct subclassing with native classes #3');
}
});
QUnit.test('WeakMap#delete', assert => {
assert.isFunction(WeakMap.prototype.delete);
if (NATIVE) assert.name(WeakMap.prototype.delete, 'delete');
if (NATIVE) assert.arity(WeakMap.prototype.delete, 1);
assert.looksNative(WeakMap.prototype.delete);
assert.nonEnumerable(WeakMap.prototype, 'delete');
const a = {};
const b = {};
const weakmap = new WeakMap();
weakmap.set(a, 42);
weakmap.set(b, 21);
assert.ok(weakmap.has(a) && weakmap.has(b), 'WeakMap has values before .delete()');
weakmap.delete(a);
assert.ok(!weakmap.has(a) && weakmap.has(b), 'WeakMap hasn`t value after .delete()');
assert.notThrows(() => !weakmap.delete(1), 'return false on primitive');
const object = {};
weakmap.set(object, 42);
freeze(object);
assert.ok(weakmap.has(object), 'works with frozen objects #1');
weakmap.delete(object);
assert.ok(!weakmap.has(object), 'works with frozen objects #2');
});
QUnit.test('WeakMap#get', assert => {
assert.isFunction(WeakMap.prototype.get);
assert.name(WeakMap.prototype.get, 'get');
if (NATIVE) assert.arity(WeakMap.prototype.get, 1);
assert.looksNative(WeakMap.prototype.get);
assert.nonEnumerable(WeakMap.prototype, 'get');
const weakmap = new WeakMap();
assert.strictEqual(weakmap.get({}), undefined, 'WeakMap .get() before .set() return undefined');
let object = {};
weakmap.set(object, 42);
assert.strictEqual(weakmap.get(object), 42, 'WeakMap .get() return value');
weakmap.delete(object);
assert.strictEqual(weakmap.get(object), undefined, 'WeakMap .get() after .delete() return undefined');
assert.notThrows(() => weakmap.get(1) === undefined, 'return undefined on primitive');
object = {};
weakmap.set(object, 42);
freeze(object);
assert.same(weakmap.get(object), 42, 'works with frozen objects #1');
weakmap.delete(object);
assert.same(weakmap.get(object), undefined, 'works with frozen objects #2');
});
QUnit.test('WeakMap#has', assert => {
assert.isFunction(WeakMap.prototype.has);
assert.name(WeakMap.prototype.has, 'has');
if (NATIVE) assert.arity(WeakMap.prototype.has, 1);
assert.looksNative(WeakMap.prototype.has);
assert.nonEnumerable(WeakMap.prototype, 'has');
const weakmap = new WeakMap();
assert.ok(!weakmap.has({}), 'WeakMap .has() before .set() return false');
let object = {};
weakmap.set(object, 42);
assert.ok(weakmap.has(object), 'WeakMap .has() return true');
weakmap.delete(object);
assert.ok(!weakmap.has(object), 'WeakMap .has() after .delete() return false');
assert.notThrows(() => !weakmap.has(1), 'return false on primitive');
object = {};
weakmap.set(object, 42);
freeze(object);
assert.ok(weakmap.has(object), 'works with frozen objects #1');
weakmap.delete(object);
assert.ok(!weakmap.has(object), 'works with frozen objects #2');
});
QUnit.test('WeakMap#set', assert => {
assert.isFunction(WeakMap.prototype.set);
assert.name(WeakMap.prototype.set, 'set');
assert.arity(WeakMap.prototype.set, 2);
assert.looksNative(WeakMap.prototype.set);
assert.nonEnumerable(WeakMap.prototype, 'set');
const weakmap = new WeakMap();
const object = {};
weakmap.set(object, 33);
assert.same(weakmap.get(object), 33, 'works with object as keys');
assert.ok(weakmap.set({}, 42) === weakmap, 'chaining');
assert.throws(() => new WeakMap().set(42, 42), 'throws with primitive keys');
const object1 = freeze({});
const object2 = {};
weakmap.set(object1, 42);
weakmap.set(object2, 42);
freeze(object);
assert.same(weakmap.get(object1), 42, 'works with frozen objects #1');
assert.same(weakmap.get(object2), 42, 'works with frozen objects #2');
weakmap.delete(object1);
weakmap.delete(object2);
assert.same(weakmap.get(object1), undefined, 'works with frozen objects #3');
assert.same(weakmap.get(object2), undefined, 'works with frozen objects #4');
});
QUnit.test('WeakMap#@@toStringTag', assert => {
assert.strictEqual(WeakMap.prototype[Symbol.toStringTag], 'WeakMap', 'WeakMap::@@toStringTag is `WeakMap`');
assert.strictEqual(String(new WeakMap()), '[object WeakMap]', 'correct stringification');
});
core-js-3.6.1/tests/tests/es.weak-set.js 0000664 0000000 0000000 00000010412 13600575677 0020071 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS, GLOBAL, NATIVE } from '../helpers/constants';
import { createIterable, nativeSubclass } from '../helpers/helpers';
const Symbol = GLOBAL.Symbol || {};
const { freeze, keys, getOwnPropertyNames, getOwnPropertySymbols } = Object;
const { ownKeys } = GLOBAL.Reflect || {};
QUnit.test('WeakSet', assert => {
assert.isFunction(WeakSet);
assert.name(WeakSet, 'WeakSet');
assert.arity(WeakSet, 0);
assert.looksNative(WeakSet);
assert.ok('add' in WeakSet.prototype, 'add in WeakSet.prototype');
assert.ok('delete' in WeakSet.prototype, 'delete in WeakSet.prototype');
assert.ok('has' in WeakSet.prototype, 'has in WeakSet.prototype');
assert.ok(new WeakSet() instanceof WeakSet, 'new WeakSet instanceof WeakSet');
let object = {};
assert.ok(new WeakSet(createIterable([object])).has(object), 'Init from iterable');
const weakset = new WeakSet();
const frozen = freeze({});
weakset.add(frozen);
assert.strictEqual(weakset.has(frozen), true, 'works with frozen objects, #1');
weakset.delete(frozen);
assert.strictEqual(weakset.has(frozen), false, 'works with frozen objects, #2');
let done = false;
try {
new WeakSet(createIterable([null, 1, 2], {
return() {
return done = true;
},
}));
} catch { /* empty */ }
assert.ok(done, '.return #throw');
assert.ok(!('clear' in WeakSet.prototype), 'should not contains `.clear` method');
const array = [];
done = false;
array['@@iterator'] = undefined;
array[Symbol.iterator] = function () {
done = true;
return [][Symbol.iterator].call(this);
};
new WeakSet(array);
assert.ok(done);
object = {};
new WeakSet().add(object);
if (DESCRIPTORS) {
const results = [];
for (const key in object) results.push(key);
assert.arrayEqual(results, []);
assert.arrayEqual(keys(object), []);
}
assert.arrayEqual(getOwnPropertyNames(object), []);
if (getOwnPropertySymbols) assert.arrayEqual(getOwnPropertySymbols(object), []);
if (ownKeys) assert.arrayEqual(ownKeys(object), []);
if (nativeSubclass) {
const Subclass = nativeSubclass(WeakSet);
assert.ok(new Subclass() instanceof Subclass, 'correct subclassing with native classes #1');
assert.ok(new Subclass() instanceof WeakSet, 'correct subclassing with native classes #2');
object = {};
assert.ok(new Subclass().add(object).has(object), 'correct subclassing with native classes #3');
}
});
QUnit.test('WeakSet#add', assert => {
assert.isFunction(WeakSet.prototype.add);
assert.name(WeakSet.prototype.add, 'add');
assert.arity(WeakSet.prototype.add, 1);
assert.looksNative(WeakSet.prototype.add);
assert.nonEnumerable(WeakSet.prototype, 'add');
const weakset = new WeakSet();
assert.ok(weakset.add({}) === weakset, 'chaining');
assert.throws(() => new WeakSet().add(42), 'throws with primitive keys');
});
QUnit.test('WeakSet#delete', assert => {
assert.isFunction(WeakSet.prototype.delete);
if (NATIVE) assert.arity(WeakSet.prototype.delete, 1);
assert.looksNative(WeakSet.prototype.delete);
assert.nonEnumerable(WeakSet.prototype, 'delete');
const a = {};
const b = {};
const weakset = new WeakSet().add(a).add(b);
assert.ok(weakset.has(a) && weakset.has(b), 'WeakSet has values before .delete()');
weakset.delete(a);
assert.ok(!weakset.has(a) && weakset.has(b), 'WeakSet has`nt value after .delete()');
assert.notThrows(() => !weakset.delete(1), 'return false on primitive');
});
QUnit.test('WeakSet#has', assert => {
assert.isFunction(WeakSet.prototype.has);
assert.name(WeakSet.prototype.has, 'has');
assert.arity(WeakSet.prototype.has, 1);
assert.looksNative(WeakSet.prototype.has);
assert.nonEnumerable(WeakSet.prototype, 'has');
const weakset = new WeakSet();
assert.ok(!weakset.has({}), 'WeakSet has`nt value');
const object = {};
weakset.add(object);
assert.ok(weakset.has(object), 'WeakSet has value after .add()');
weakset.delete(object);
assert.ok(!weakset.has(object), 'WeakSet hasn`t value after .delete()');
assert.notThrows(() => !weakset.has(1), 'return false on primitive');
});
QUnit.test('WeakSet::@@toStringTag', assert => {
assert.strictEqual(WeakSet.prototype[Symbol.toStringTag], 'WeakSet', 'WeakSet::@@toStringTag is `WeakSet`');
assert.strictEqual(String(new WeakSet()), '[object WeakSet]', 'correct stringification');
});
core-js-3.6.1/tests/tests/esnext.aggregate-error.js 0000664 0000000 0000000 00000001055 13600575677 0022330 0 ustar 00root root 0000000 0000000 QUnit.test('AggregateError', assert => {
assert.isFunction(AggregateError);
assert.arity(AggregateError, 2);
assert.name(AggregateError, 'AggregateError');
assert.looksNative(AggregateError);
assert.ok(new AggregateError([1]) instanceof AggregateError);
assert.ok(new AggregateError([1]) instanceof Error);
assert.ok(AggregateError([1]) instanceof AggregateError);
assert.ok(AggregateError([1]) instanceof Error);
assert.same(AggregateError([1], 'foo').message, 'foo');
assert.deepEqual(AggregateError([1, 2, 3]).errors, [1, 2, 3]);
});
core-js-3.6.1/tests/tests/esnext.array.is-template-object.js 0000664 0000000 0000000 00000001545 13600575677 0024064 0 ustar 00root root 0000000 0000000 QUnit.test('Array.isTemplateObject', assert => {
const { isTemplateObject } = Array;
const { freeze } = Object;
assert.isFunction(isTemplateObject);
assert.arity(isTemplateObject, 1);
assert.name(isTemplateObject, 'isTemplateObject');
assert.looksNative(isTemplateObject);
assert.nonEnumerable(Array, 'isTemplateObject');
assert.ok(!isTemplateObject(undefined));
assert.ok(!isTemplateObject(null));
assert.ok(!isTemplateObject({}));
assert.ok(!isTemplateObject(function () {
return arguments;
}()));
assert.ok(!isTemplateObject([]));
assert.ok(!isTemplateObject(freeze([])));
const template = (() => {
try {
// eslint-disable-next-line no-template-curly-in-string
return Function('return (it => it)`qwe${ 123 }asd`')();
} catch { /* empty */ }
})();
if (template) assert.ok(isTemplateObject(template));
});
core-js-3.6.1/tests/tests/esnext.array.last-index.js 0000664 0000000 0000000 00000000617 13600575677 0022443 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('Array#lastIndex', assert => {
const descriptor = Object.getOwnPropertyDescriptor(Array.prototype, 'lastIndex');
assert.isFunction(descriptor.get);
assert.same(descriptor.enumerable, false);
assert.same(descriptor.configurable, true);
assert.same([1, 2, 3].lastIndex, 2);
assert.same([].lastIndex, 0);
});
core-js-3.6.1/tests/tests/esnext.array.last-item.js 0000664 0000000 0000000 00000001121 13600575677 0022261 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
if (DESCRIPTORS) QUnit.test('Array#lastItem', assert => {
const descriptor = Object.getOwnPropertyDescriptor(Array.prototype, 'lastItem');
assert.isFunction(descriptor.get);
assert.isFunction(descriptor.set);
assert.same(descriptor.enumerable, false);
assert.same(descriptor.configurable, true);
assert.same([1, 2, 3].lastItem, 3);
assert.same([].lastItem, undefined);
let array = [1, 2, 3];
array.lastItem = 4;
assert.deepEqual(array, [1, 2, 4]);
array = [];
array.lastItem = 5;
assert.deepEqual(array, [5]);
});
core-js-3.6.1/tests/tests/esnext.async-iterator.as-indexed-pairs.js 0000664 0000000 0000000 00000001671 13600575677 0025357 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
QUnit.test('AsyncIterator#asIndexedPairs', assert => {
assert.expect(10);
const async = assert.async();
const { asIndexedPairs } = AsyncIterator.prototype;
assert.isFunction(asIndexedPairs);
assert.arity(asIndexedPairs, 0);
assert.name(asIndexedPairs, 'asIndexedPairs');
assert.looksNative(asIndexedPairs);
assert.nonEnumerable(AsyncIterator.prototype, 'asIndexedPairs');
asIndexedPairs.call(createIterator(['a', 'b', 'c'])).toArray().then(it => {
assert.same(it.toString(), '0,a,1,b,2,c', 'basic functionality');
async();
});
assert.throws(() => asIndexedPairs.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => asIndexedPairs.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => asIndexedPairs.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => asIndexedPairs.call([], () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.async-iterator.constructor.js 0000664 0000000 0000000 00000002624 13600575677 0024606 0 ustar 00root root 0000000 0000000 const { getPrototypeOf } = Object;
QUnit.test('AsyncIterator', assert => {
assert.isFunction(AsyncIterator);
assert.arity(AsyncIterator, 0);
assert.name(AsyncIterator, 'AsyncIterator');
assert.looksNative(AsyncIterator);
const asyncGenerator = (() => {
try {
return Function('return async function*(){}()')();
} catch { /* empty */ }
})();
if (asyncGenerator) {
const proto = getPrototypeOf(getPrototypeOf(getPrototypeOf(asyncGenerator)));
if (proto !== Object.prototype && proto !== null) {
assert.ok(asyncGenerator instanceof AsyncIterator, 'AsyncGenerator');
}
}
assert.ok(AsyncIterator.from([1, 2, 3]) instanceof AsyncIterator, 'Async From Proxy');
assert.ok(AsyncIterator.from([1, 2, 3]).drop(1) instanceof AsyncIterator, 'Async Drop Proxy');
assert.ok(new AsyncIterator() instanceof AsyncIterator, 'constructor');
assert.throws(() => AsyncIterator(), 'throws w/o `new`');
});
QUnit.test('AsyncIterator#constructor', assert => {
assert.strictEqual(AsyncIterator.prototype.constructor, AsyncIterator, 'AsyncIterator#constructor is AsyncIterator');
});
QUnit.test('AsyncIterator#@@toStringTag', assert => {
assert.strictEqual(AsyncIterator.prototype[Symbol.toStringTag], 'AsyncIterator', 'AsyncIterator::@@toStringTag is `AsyncIterator`');
assert.strictEqual(String(AsyncIterator.from([1, 2, 3])), '[object AsyncIterator]', 'correct stringification');
});
core-js-3.6.1/tests/tests/esnext.async-iterator.drop.js 0000664 0000000 0000000 00000002252 13600575677 0023162 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
QUnit.test('AsyncIterator#drop', assert => {
assert.expect(14);
const async = assert.async();
const { drop } = AsyncIterator.prototype;
assert.isFunction(drop);
assert.arity(drop, 1);
assert.name(drop, 'drop');
assert.looksNative(drop);
assert.nonEnumerable(AsyncIterator.prototype, 'drop');
drop.call(createIterator([1, 2, 3]), 1).toArray().then(it => {
assert.arrayEqual(it, [2, 3], 'basic functionality');
return drop.call(createIterator([1, 2, 3]), 1.5).toArray();
}).then(it => {
assert.arrayEqual(it, [2, 3], 'float');
return drop.call(createIterator([1, 2, 3]), 4).toArray();
}).then(it => {
assert.arrayEqual(it, [], 'big');
return drop.call(createIterator([1, 2, 3]), 0).toArray();
}).then(it => {
assert.arrayEqual(it, [1, 2, 3], 'zero');
}).then(() => async());
assert.throws(() => drop.call(undefined, 1), TypeError);
assert.throws(() => drop.call(null, 1), TypeError);
assert.throws(() => drop.call({}, 1), TypeError);
assert.throws(() => drop.call([], 1), TypeError);
assert.throws(() => drop.call(createIterator([1, 2, 3]), -1), RangeError, 'negative');
});
core-js-3.6.1/tests/tests/esnext.async-iterator.every.js 0000664 0000000 0000000 00000003137 13600575677 0023353 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('AsyncIterator#every', assert => {
assert.expect(18);
const async = assert.async();
const { every } = AsyncIterator.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.name(every, 'every');
assert.looksNative(every);
assert.nonEnumerable(AsyncIterator.prototype, 'every');
every.call(createIterator([1, 2, 3]), it => typeof it === 'number').then(result => {
assert.ok(result, 'basic functionality, +');
return every.call(createIterator([1, 2, 3]), it => it === 2);
}).then(result => {
assert.ok(!result, 'basic functionality, -');
return every.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
});
}).then(() => {
return every.call(createIterator([1]), () => { throw 42; });
}).catch(error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => async());
assert.throws(() => every.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => every.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => every.call([], () => { /* empty */ }), TypeError);
assert.throws(() => every.call(createIterator([1]), undefined), TypeError);
assert.throws(() => every.call(createIterator([1]), null), TypeError);
assert.throws(() => every.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/tests/esnext.async-iterator.filter.js 0000664 0000000 0000000 00000002772 13600575677 0023512 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('AsyncIterator#filter', assert => {
assert.expect(17);
const async = assert.async();
const { filter } = AsyncIterator.prototype;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.name(filter, 'filter');
assert.looksNative(filter);
assert.nonEnumerable(AsyncIterator.prototype, 'filter');
filter.call(createIterator([1, 2, 3]), it => it % 2).toArray().then(it => {
assert.arrayEqual(it, [1, 3], 'basic functionality');
return filter.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
}).toArray();
}).then(() => {
return filter.call(createIterator([1]), () => { throw 42; }).toArray();
}).catch(error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => async());
assert.throws(() => filter.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call([], () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(createIterator([1]), undefined), TypeError);
assert.throws(() => filter.call(createIterator([1]), null), TypeError);
assert.throws(() => filter.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/tests/esnext.async-iterator.find.js 0000664 0000000 0000000 00000003115 13600575677 0023135 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('AsyncIterator#find', assert => {
assert.expect(18);
const async = assert.async();
const { find } = AsyncIterator.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.name(find, 'find');
assert.looksNative(find);
assert.nonEnumerable(AsyncIterator.prototype, 'find');
find.call(createIterator([2, 3, 4]), it => it % 2).then(result => {
assert.same(result, 3, 'basic functionality, +');
return find.call(createIterator([1, 2, 3]), it => it === 4);
}).then(result => {
assert.same(result, undefined, 'basic functionality, -');
return find.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
});
}).then(() => {
return find.call(createIterator([1]), () => { throw 42; });
}).catch(error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => async());
assert.throws(() => find.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => find.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => find.call([], () => { /* empty */ }), TypeError);
assert.throws(() => find.call(createIterator([1]), undefined), TypeError);
assert.throws(() => find.call(createIterator([1]), null), TypeError);
assert.throws(() => find.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/tests/esnext.async-iterator.flat-map.js 0000664 0000000 0000000 00000003213 13600575677 0023715 0 ustar 00root root 0000000 0000000 import { createIterator, createIterable } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('AsyncIterator#flatMap', assert => {
assert.expect(17);
const async = assert.async();
const { flatMap } = AsyncIterator.prototype;
assert.isFunction(flatMap);
assert.arity(flatMap, 1);
assert.name(flatMap, 'flatMap');
assert.looksNative(flatMap);
assert.nonEnumerable(AsyncIterator.prototype, 'flatMap');
flatMap.call(createIterator([1, [], 2, createIterable([3, 4]), [5, 6], 'ab']), it => typeof it == 'number' ? [-it] : it).toArray().then(it => {
assert.arrayEqual(it, [-1, -2, 3, 4, 5, 6, 'a', 'b'], 'basic functionality');
return flatMap.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
return [arg];
}).toArray();
}).then(() => {
return flatMap.call(createIterator([1]), () => { throw 42; }).toArray();
}).catch(error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => async());
assert.throws(() => flatMap.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call([], () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), undefined), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), null), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/tests/esnext.async-iterator.for-each.js 0000664 0000000 0000000 00000003021 13600575677 0023675 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('AsyncIterator#forEach', assert => {
assert.expect(17);
const async = assert.async();
const { forEach } = AsyncIterator.prototype;
assert.isFunction(forEach);
assert.arity(forEach, 1);
assert.name(forEach, 'forEach');
assert.looksNative(forEach);
assert.nonEnumerable(AsyncIterator.prototype, 'forEach');
const array = [];
forEach.call(createIterator([1, 2, 3]), it => array.push(it)).then(() => {
assert.arrayEqual(array, [1, 2, 3], 'basic functionality');
return forEach.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
});
}).then(() => {
return forEach.call(createIterator([1]), () => { throw 42; });
}).catch(error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => async());
assert.throws(() => forEach.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call([], () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call(createIterator([1]), undefined), TypeError);
assert.throws(() => forEach.call(createIterator([1]), null), TypeError);
assert.throws(() => forEach.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/tests/esnext.async-iterator.from.js 0000664 0000000 0000000 00000001671 13600575677 0023165 0 ustar 00root root 0000000 0000000 QUnit.test('AsyncIterator.from', assert => {
assert.expect(12);
const async = assert.async();
const { from } = AsyncIterator;
assert.isFunction(from);
assert.arity(from, 1);
assert.name(from, 'from');
assert.looksNative(from);
assert.nonEnumerable(AsyncIterator, 'from');
assert.ok(AsyncIterator.from([].values()) instanceof AsyncIterator, 'proxy, iterator');
assert.ok(AsyncIterator.from([]) instanceof AsyncIterator, 'proxy, iterable');
AsyncIterator.from([1, 2, 3]).toArray().then(result => {
assert.arrayEqual(result, [1, 2, 3], 'just a proxy');
async();
});
const asyncIterator = Object.assign(new AsyncIterator(), {
next: () => { /* empty */ },
});
assert.same(AsyncIterator.from(asyncIterator), asyncIterator, 'does not wrap AsyncIterator instanses');
assert.throws(() => from(undefined), TypeError);
assert.throws(() => from(null), TypeError);
assert.throws(() => from({}), TypeError);
});
core-js-3.6.1/tests/tests/esnext.async-iterator.map.js 0000664 0000000 0000000 00000002710 13600575677 0022772 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('AsyncIterator#map', assert => {
assert.expect(17);
const async = assert.async();
const { map } = AsyncIterator.prototype;
assert.isFunction(map);
assert.arity(map, 1);
assert.name(map, 'map');
assert.looksNative(map);
assert.nonEnumerable(AsyncIterator.prototype, 'map');
map.call(createIterator([1, 2, 3]), it => it ** 2).toArray().then(it => {
assert.arrayEqual(it, [1, 4, 9], 'basic functionality');
return map.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
}).toArray();
}).then(() => {
return map.call(createIterator([1]), () => { throw 42; }).toArray();
}).catch(error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => async());
assert.throws(() => map.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => map.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => map.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => map.call([], () => { /* empty */ }), TypeError);
assert.throws(() => map.call(createIterator([1]), undefined), TypeError);
assert.throws(() => map.call(createIterator([1]), null), TypeError);
assert.throws(() => map.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/tests/esnext.async-iterator.reduce.js 0000664 0000000 0000000 00000003505 13600575677 0023467 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('AsyncIterator#reduce', assert => {
assert.expect(20);
const async = assert.async();
const { reduce } = AsyncIterator.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.name(reduce, 'reduce');
assert.looksNative(reduce);
assert.nonEnumerable(AsyncIterator.prototype, 'reduce');
reduce.call(createIterator([1, 2, 3]), (a, b) => a + b, 1).then(it => {
assert.same(it, 7, 'basic functionality, initial');
return reduce.call(createIterator([2]), function (a, b) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(a, 1, 'argument 1');
assert.same(b, 2, 'argument 2');
}, 1);
}).then(() => {
return reduce.call(createIterator([1, 2, 3]), (a, b) => a + b);
}).then(it => {
assert.same(it, 6, 'basic functionality, no initial');
return reduce.call(createIterator([]), (a, b) => a + b);
}).catch(() => {
assert.ok(true, 'reduce an empty interble with no initial');
return reduce.call(createIterator([1]), () => { throw 42; }, 1);
}).catch(error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => async());
assert.throws(() => reduce.call(undefined, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(null, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call({}, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call([], () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(createIterator([1]), undefined, 1), TypeError);
assert.throws(() => reduce.call(createIterator([1]), null, 1), TypeError);
assert.throws(() => reduce.call(createIterator([1]), {}, 1), TypeError);
});
core-js-3.6.1/tests/tests/esnext.async-iterator.some.js 0000664 0000000 0000000 00000003076 13600575677 0023166 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('AsyncIterator#some', assert => {
assert.expect(18);
const async = assert.async();
const { some } = AsyncIterator.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.name(some, 'some');
assert.looksNative(some);
assert.nonEnumerable(AsyncIterator.prototype, 'some');
some.call(createIterator([1, 2, 3]), it => it === 2).then(result => {
assert.ok(result, 'basic functionality, +');
return some.call(createIterator([1, 2, 3]), it => it === 4);
}).then(result => {
assert.ok(!result, 'basic functionality, -');
return some.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
});
}).then(() => {
return some.call(createIterator([1]), () => { throw 42; });
}).catch(error => {
assert.same(error, 42, 'rejection on a callback error');
}).then(() => async());
assert.throws(() => some.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => some.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => some.call([], () => { /* empty */ }), TypeError);
assert.throws(() => some.call(createIterator([1]), undefined), TypeError);
assert.throws(() => some.call(createIterator([1]), null), TypeError);
assert.throws(() => some.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/tests/esnext.async-iterator.take.js 0000664 0000000 0000000 00000002247 13600575677 0023146 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
QUnit.test('AsyncIterator#take', assert => {
assert.expect(14);
const async = assert.async();
const { take } = AsyncIterator.prototype;
assert.isFunction(take);
assert.arity(take, 1);
assert.name(take, 'take');
assert.looksNative(take);
assert.nonEnumerable(AsyncIterator.prototype, 'take');
take.call(createIterator([1, 2, 3]), 2).toArray().then(it => {
assert.arrayEqual(it, [1, 2], 'basic functionality');
return take.call(createIterator([1, 2, 3]), 1.5).toArray();
}).then(it => {
assert.arrayEqual(it, [1], 'float');
return take.call(createIterator([1, 2, 3]), 4).toArray();
}).then(it => {
assert.arrayEqual(it, [1, 2, 3], 'big');
return take.call(createIterator([1, 2, 3]), 0).toArray();
}).then(it => {
assert.arrayEqual(it, [], 'zero');
}).then(() => async());
assert.throws(() => take.call(undefined, 1), TypeError);
assert.throws(() => take.call(null, 1), TypeError);
assert.throws(() => take.call({}, 1), TypeError);
assert.throws(() => take.call([], 1), TypeError);
assert.throws(() => take.call(createIterator([1, 2, 3]), -1), RangeError, 'negative');
});
core-js-3.6.1/tests/tests/esnext.async-iterator.to-array.js 0000664 0000000 0000000 00000001322 13600575677 0023751 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
QUnit.test('AsyncIterator#toArray', assert => {
assert.expect(10);
const async = assert.async();
const { toArray } = AsyncIterator.prototype;
assert.isFunction(toArray);
assert.arity(toArray, 0);
assert.name(toArray, 'toArray');
assert.looksNative(toArray);
assert.nonEnumerable(AsyncIterator.prototype, 'toArray');
toArray.call(createIterator([1, 2, 3])).then(it => {
assert.arrayEqual(it, [1, 2, 3]);
async();
});
assert.throws(() => toArray.call(undefined), TypeError);
assert.throws(() => toArray.call(null), TypeError);
assert.throws(() => toArray.call({}), TypeError);
assert.throws(() => toArray.call([]), TypeError);
});
core-js-3.6.1/tests/tests/esnext.composite-key.js 0000664 0000000 0000000 00000003703 13600575677 0022045 0 ustar 00root root 0000000 0000000 /* eslint-disable no-self-compare */
import { FREEZING } from '../helpers/constants';
const { getPrototypeOf, isFrozen } = Object;
QUnit.test('compositeKey', assert => {
assert.isFunction(compositeKey);
assert.name(compositeKey, 'compositeKey');
assert.looksNative(compositeKey);
const key = compositeKey({});
assert.same(typeof key, 'object');
assert.same({}.toString.call(key), '[object Object]');
assert.same(getPrototypeOf(key), null);
if (FREEZING) assert.ok(isFrozen(key));
const a = ['a'];
const b = ['b'];
const c = ['c'];
assert.ok(compositeKey(a) === compositeKey(a));
assert.ok(compositeKey(a) !== compositeKey(['a']));
assert.ok(compositeKey(a) !== compositeKey(a, 1));
assert.ok(compositeKey(a) !== compositeKey(a, b));
assert.ok(compositeKey(a, 1) === compositeKey(a, 1));
assert.ok(compositeKey(a, b) === compositeKey(a, b));
assert.ok(compositeKey(a, b) !== compositeKey(b, a));
assert.ok(compositeKey(a, b, c) === compositeKey(a, b, c));
assert.ok(compositeKey(a, b, c) !== compositeKey(c, b, a));
assert.ok(compositeKey(a, b, c) !== compositeKey(a, c, b));
assert.ok(compositeKey(a, b, c, 1) !== compositeKey(a, b, c));
assert.ok(compositeKey(a, b, c, 1) === compositeKey(a, b, c, 1));
assert.ok(compositeKey(1, a) === compositeKey(1, a));
assert.ok(compositeKey(1, a) !== compositeKey(a, 1));
assert.ok(compositeKey(1, a, 2, b) === compositeKey(1, a, 2, b));
assert.ok(compositeKey(1, a, 2, b) !== compositeKey(1, a, b, 2));
assert.ok(compositeKey(1, 2, a, b) === compositeKey(1, 2, a, b));
assert.ok(compositeKey(1, 2, a, b) !== compositeKey(1, a, b, 2));
assert.ok(compositeKey(a, a) === compositeKey(a, a));
assert.ok(compositeKey(a, a) !== compositeKey(a, ['a']));
assert.ok(compositeKey(a, a) !== compositeKey(a, b));
assert.throws(() => compositeKey(), TypeError);
assert.throws(() => compositeKey(1, 2), TypeError);
assert.throws(() => compositeKey('foo', null, true), TypeError);
});
core-js-3.6.1/tests/tests/esnext.composite-symbol.js 0000664 0000000 0000000 00000003771 13600575677 0022567 0 ustar 00root root 0000000 0000000 /* eslint-disable no-self-compare */
QUnit.test('compositeSymbol', assert => {
assert.isFunction(compositeSymbol);
assert.name(compositeSymbol, 'compositeSymbol');
assert.looksNative(compositeSymbol);
assert.ok(Object(compositeSymbol({})) instanceof Symbol);
const a = ['a'];
const b = ['b'];
const c = ['c'];
assert.ok(compositeSymbol(a) === compositeSymbol(a));
assert.ok(compositeSymbol(a) !== compositeSymbol(['a']));
assert.ok(compositeSymbol(a) !== compositeSymbol(a, 1));
assert.ok(compositeSymbol(a) !== compositeSymbol(a, b));
assert.ok(compositeSymbol(a, 1) === compositeSymbol(a, 1));
assert.ok(compositeSymbol(a, b) === compositeSymbol(a, b));
assert.ok(compositeSymbol(a, b) !== compositeSymbol(b, a));
assert.ok(compositeSymbol(a, b, c) === compositeSymbol(a, b, c));
assert.ok(compositeSymbol(a, b, c) !== compositeSymbol(c, b, a));
assert.ok(compositeSymbol(a, b, c) !== compositeSymbol(a, c, b));
assert.ok(compositeSymbol(a, b, c, 1) !== compositeSymbol(a, b, c));
assert.ok(compositeSymbol(a, b, c, 1) === compositeSymbol(a, b, c, 1));
assert.ok(compositeSymbol(1, a) === compositeSymbol(1, a));
assert.ok(compositeSymbol(1, a) !== compositeSymbol(a, 1));
assert.ok(compositeSymbol(1, a, 2, b) === compositeSymbol(1, a, 2, b));
assert.ok(compositeSymbol(1, a, 2, b) !== compositeSymbol(1, a, b, 2));
assert.ok(compositeSymbol(1, 2, a, b) === compositeSymbol(1, 2, a, b));
assert.ok(compositeSymbol(1, 2, a, b) !== compositeSymbol(1, a, b, 2));
assert.ok(compositeSymbol(a, a) === compositeSymbol(a, a));
assert.ok(compositeSymbol(a, a) !== compositeSymbol(a, ['a']));
assert.ok(compositeSymbol(a, a) !== compositeSymbol(a, b));
assert.ok(compositeSymbol() === compositeSymbol());
assert.ok(compositeSymbol(1, 2) === compositeSymbol(1, 2));
assert.ok(compositeSymbol(1, 2) !== compositeSymbol(2, 1));
assert.ok(compositeSymbol('foo', null, true) === compositeSymbol('foo', null, true));
assert.ok(compositeSymbol('string') === Symbol.for('string'));
});
core-js-3.6.1/tests/tests/esnext.iterator.as-indexed-pairs.js 0000664 0000000 0000000 00000001370 13600575677 0024240 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
QUnit.test('Iterator#asIndexedPairs', assert => {
const { asIndexedPairs } = Iterator.prototype;
assert.isFunction(asIndexedPairs);
assert.arity(asIndexedPairs, 0);
assert.name(asIndexedPairs, 'asIndexedPairs');
assert.looksNative(asIndexedPairs);
assert.nonEnumerable(Iterator.prototype, 'asIndexedPairs');
assert.arrayEqual(asIndexedPairs.call(createIterator(['a', 'b', 'c'])).toArray().toString(), '0,a,1,b,2,c', 'basic functionality');
assert.throws(() => asIndexedPairs.call(undefined, TypeError));
assert.throws(() => asIndexedPairs.call(null, TypeError));
assert.throws(() => asIndexedPairs.call({}, TypeError));
assert.throws(() => asIndexedPairs.call([], TypeError));
});
core-js-3.6.1/tests/tests/esnext.iterator.constructor.js 0000664 0000000 0000000 00000003210 13600575677 0023463 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
const { getPrototypeOf } = Object;
QUnit.test('Iterator', assert => {
assert.isFunction(Iterator);
assert.arity(Iterator, 0);
assert.name(Iterator, 'Iterator');
assert.looksNative(Iterator);
const generator = (() => {
try {
return Function('return function*(){}()')();
} catch { /* empty */ }
})();
if (generator) {
const proto = getPrototypeOf(getPrototypeOf(getPrototypeOf(generator)));
if (proto !== Object.prototype && proto !== null) {
assert.ok(generator instanceof Iterator, 'Generator');
}
}
assert.ok(''[Symbol.iterator]() instanceof Iterator, 'String Iterator');
assert.ok([].values() instanceof Iterator, 'Array Iterator');
assert.ok(new Set().values() instanceof Iterator, 'Set Iterator');
assert.ok('abc'.matchAll(/./g) instanceof Iterator, 'MatchAll Iterator');
assert.ok(Iterator.from(createIterator([1, 2, 3])) instanceof Iterator, 'From Proxy');
assert.ok([].values().drop(1) instanceof Iterator, 'Drop Proxy');
assert.ok(new Iterator() instanceof Iterator, 'constructor');
assert.throws(() => Iterator(), 'throws w/o `new`');
});
QUnit.test('Iterator#constructor', assert => {
assert.strictEqual(Iterator.prototype.constructor, Iterator, 'Iterator#constructor is Iterator');
});
QUnit.test('Iterator#@@toStringTag', assert => {
assert.strictEqual(Iterator.prototype[Symbol.toStringTag], 'Iterator', 'Iterator::@@toStringTag is `Iterator`');
assert.strictEqual(String(Iterator.from({
next: () => ({ done: Math.random() > 0.9, value: Math.random() * 10 | 0 }),
})), '[object Iterator]', 'correct stringification');
});
core-js-3.6.1/tests/tests/esnext.iterator.drop.js 0000664 0000000 0000000 00000001717 13600575677 0022054 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
QUnit.test('Iterator#drop', assert => {
const { drop } = Iterator.prototype;
assert.isFunction(drop);
assert.arity(drop, 1);
assert.name(drop, 'drop');
assert.looksNative(drop);
assert.nonEnumerable(Iterator.prototype, 'drop');
assert.arrayEqual(drop.call(createIterator([1, 2, 3]), 1).toArray(), [2, 3], 'basic functionality');
assert.arrayEqual(drop.call(createIterator([1, 2, 3]), 1.5).toArray(), [2, 3], 'float');
assert.arrayEqual(drop.call(createIterator([1, 2, 3]), 4).toArray(), [], 'big');
assert.arrayEqual(drop.call(createIterator([1, 2, 3]), 0).toArray(), [1, 2, 3], 'zero');
assert.throws(() => drop.call(undefined, 1), TypeError);
assert.throws(() => drop.call(null, 1), TypeError);
assert.throws(() => drop.call({}, 1), TypeError);
assert.throws(() => drop.call([], 1), TypeError);
assert.throws(() => drop.call(createIterator([1, 2, 3]), -1), RangeError, 'negative');
});
core-js-3.6.1/tests/tests/esnext.iterator.every.js 0000664 0000000 0000000 00000002400 13600575677 0022230 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('Iterator#every', assert => {
const { every } = Iterator.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.name(every, 'every');
assert.looksNative(every);
assert.nonEnumerable(Iterator.prototype, 'every');
assert.ok(every.call(createIterator([1, 2, 3]), it => typeof it == 'number'), 'basic functionality #1');
assert.ok(!every.call(createIterator([1, 2, 3]), it => it % 2), 'basic functionality #2');
every.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
});
assert.throws(() => every.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => every.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => every.call([], () => { /* empty */ }), TypeError);
assert.throws(() => every.call(createIterator([1]), undefined), TypeError);
assert.throws(() => every.call(createIterator([1]), null), TypeError);
assert.throws(() => every.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/tests/esnext.iterator.filter.js 0000664 0000000 0000000 00000002274 13600575677 0022374 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('Iterator#filter', assert => {
const { filter } = Iterator.prototype;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.name(filter, 'filter');
assert.looksNative(filter);
assert.nonEnumerable(Iterator.prototype, 'filter');
assert.arrayEqual(filter.call(createIterator([1, 2, 3]), it => it % 2).toArray(), [1, 3], 'basic functionality');
filter.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
});
assert.throws(() => filter.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call([], () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(createIterator([1]), undefined), TypeError);
assert.throws(() => filter.call(createIterator([1]), null), TypeError);
assert.throws(() => filter.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/tests/esnext.iterator.find.js 0000664 0000000 0000000 00000002210 13600575677 0022015 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('Iterator#find', assert => {
const { find } = Iterator.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.name(find, 'find');
assert.looksNative(find);
assert.nonEnumerable(Iterator.prototype, 'find');
assert.same(find.call(createIterator([1, 2, 3]), it => !(it % 2)), 2, 'basic functionality');
find.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
});
assert.throws(() => find.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => find.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => find.call([], () => { /* empty */ }), TypeError);
assert.throws(() => find.call(createIterator([1]), undefined), TypeError);
assert.throws(() => find.call(createIterator([1]), null), TypeError);
assert.throws(() => find.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/tests/esnext.iterator.flat-map.js 0000664 0000000 0000000 00000002673 13600575677 0022613 0 ustar 00root root 0000000 0000000 import { createIterator, createIterable } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('Iterator#flatMap', assert => {
const { flatMap } = Iterator.prototype;
assert.isFunction(flatMap);
assert.arity(flatMap, 1);
assert.name(flatMap, 'flatMap');
assert.looksNative(flatMap);
assert.nonEnumerable(Iterator.prototype, 'flatMap');
assert.arrayEqual(
flatMap.call(createIterator([1, [], 2, createIterable([3, 4]), [5, 6], 'ab']), it => typeof it == 'number' ? [-it] : it).toArray(),
[-1, -2, 3, 4, 5, 6, 'a', 'b'],
'basic functionality',
);
flatMap.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
return [arg];
}).toArray();
assert.throws(() => flatMap.call([], () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), it => it).next(), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), undefined), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), null), TypeError);
assert.throws(() => flatMap.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/tests/esnext.iterator.for-each.js 0000664 0000000 0000000 00000002356 13600575677 0022574 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('Iterator#forEach', assert => {
const { forEach } = Iterator.prototype;
assert.isFunction(forEach);
assert.arity(forEach, 1);
assert.name(forEach, 'forEach');
assert.looksNative(forEach);
assert.nonEnumerable(Iterator.prototype, 'forEach');
const array = [];
forEach.call(createIterator([1, 2, 3]), it => array.push(it));
assert.arrayEqual(array, [1, 2, 3], 'basic functionality');
forEach.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
});
assert.throws(() => forEach.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call([], () => { /* empty */ }), TypeError);
assert.throws(() => forEach.call(createIterator([1]), undefined), TypeError);
assert.throws(() => forEach.call(createIterator([1]), null), TypeError);
assert.throws(() => forEach.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/tests/esnext.iterator.from.js 0000664 0000000 0000000 00000001330 13600575677 0022042 0 ustar 00root root 0000000 0000000 import { createIterable, createIterator } from '../helpers/helpers';
QUnit.test('Iterator.from', assert => {
const { from } = Iterator;
assert.isFunction(from);
assert.arity(from, 1);
assert.name(from, 'from');
assert.looksNative(from);
assert.nonEnumerable(Iterator, 'from');
assert.ok(Iterator.from(createIterator([1, 2, 3])) instanceof Iterator, 'proxy, iterator');
assert.ok(Iterator.from(createIterable([1, 2, 3])) instanceof Iterator, 'proxy, iterable');
assert.arrayEqual(Iterator.from(createIterable([1, 2, 3])).toArray(), [1, 2, 3], 'just a proxy');
assert.throws(() => from(undefined), TypeError);
assert.throws(() => from(null), TypeError);
assert.throws(() => from({}), TypeError);
});
core-js-3.6.1/tests/tests/esnext.iterator.map.js 0000664 0000000 0000000 00000002227 13600575677 0021662 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('Iterator#map', assert => {
const { map } = Iterator.prototype;
assert.isFunction(map);
assert.arity(map, 1);
assert.name(map, 'map');
assert.looksNative(map);
assert.nonEnumerable(Iterator.prototype, 'map');
assert.arrayEqual(map.call(createIterator([1, 2, 3]), it => it ** 2).toArray(), [1, 4, 9], 'basic functionality');
map.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
}).toArray();
assert.throws(() => map.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => map.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => map.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => map.call([], () => { /* empty */ }), TypeError);
assert.throws(() => map.call(createIterator([1]), undefined), TypeError);
assert.throws(() => map.call(createIterator([1]), null), TypeError);
assert.throws(() => map.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/tests/esnext.iterator.reduce.js 0000664 0000000 0000000 00000002476 13600575677 0022362 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('Iterator#reduce', assert => {
const { reduce } = Iterator.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.name(reduce, 'reduce');
assert.looksNative(reduce);
assert.nonEnumerable(Iterator.prototype, 'reduce');
assert.same(reduce.call(createIterator([1, 2, 3]), (a, b) => a + b, 1), 7, 'basic functionality');
assert.same(reduce.call(createIterator([1, 2, 3]), (a, b) => a + b), 6, 'basic functionality, no init');
reduce.call(createIterator([2]), function (a, b) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 2, 'arguments length');
assert.same(a, 1, 'argument 1');
assert.same(b, 2, 'argument 2');
}, 1);
assert.throws(() => reduce.call(undefined, (a, b) => a + b, 0), TypeError);
assert.throws(() => reduce.call(null, (a, b) => a + b, 0), TypeError);
assert.throws(() => reduce.call({}, (a, b) => a + b, 0), TypeError);
assert.throws(() => reduce.call([], (a, b) => a + b, 0), TypeError);
assert.throws(() => reduce.call(createIterator([1]), undefined, 1), TypeError);
assert.throws(() => reduce.call(createIterator([1]), null, 1), TypeError);
assert.throws(() => reduce.call(createIterator([1]), {}, 1), TypeError);
});
core-js-3.6.1/tests/tests/esnext.iterator.some.js 0000664 0000000 0000000 00000002356 13600575677 0022053 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
import { STRICT_THIS } from '../helpers/constants';
QUnit.test('Iterator#some', assert => {
const { some } = Iterator.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.name(some, 'some');
assert.looksNative(some);
assert.nonEnumerable(Iterator.prototype, 'some');
assert.ok(some.call(createIterator([1, 2, 3]), it => it % 2), 'basic functionality #1');
assert.ok(!some.call(createIterator([1, 2, 3]), it => typeof it == 'string'), 'basic functionality #2');
some.call(createIterator([1]), function (arg) {
assert.same(this, STRICT_THIS, 'this');
assert.same(arguments.length, 1, 'arguments length');
assert.same(arg, 1, 'argument');
});
assert.throws(() => some.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(null, () => { /* empty */ }), TypeError);
assert.throws(() => some.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => some.call([], () => { /* empty */ }), TypeError);
assert.throws(() => some.call(createIterator([1]), undefined), TypeError);
assert.throws(() => some.call(createIterator([1]), null), TypeError);
assert.throws(() => some.call(createIterator([1]), {}), TypeError);
});
core-js-3.6.1/tests/tests/esnext.iterator.take.js 0000664 0000000 0000000 00000001714 13600575677 0022031 0 ustar 00root root 0000000 0000000 import { createIterator } from '../helpers/helpers';
QUnit.test('Iterator#take', assert => {
const { take } = Iterator.prototype;
assert.isFunction(take);
assert.arity(take, 1);
assert.name(take, 'take');
assert.looksNative(take);
assert.nonEnumerable(Iterator.prototype, 'take');
assert.arrayEqual(take.call(createIterator([1, 2, 3]), 2).toArray(), [1, 2], 'basic functionality');
assert.arrayEqual(take.call(createIterator([1, 2, 3]), 1.5).toArray(), [1], 'float');
assert.arrayEqual(take.call(createIterator([1, 2, 3]), 4).toArray(), [1, 2, 3], 'big');
assert.arrayEqual(take.call(createIterator([1, 2, 3]), 0).toArray(), [], 'zero');
assert.throws(() => take.call(undefined, 1), TypeError);
assert.throws(() => take.call(null, 1), TypeError);
assert.throws(() => take.call({}, 1), TypeError);
assert.throws(() => take.call([], 1), TypeError);
assert.throws(() => take.call(createIterator([1, 2, 3]), -1), RangeError, 'negative');
});
core-js-3.6.1/tests/tests/esnext.iterator.to-array.js 0000664 0000000 0000000 00000001630 13600575677 0022640 0 ustar 00root root 0000000 0000000 import { createIterable, createIterator } from '../helpers/helpers';
QUnit.test('Iterator#toArray', assert => {
const { toArray } = Iterator.prototype;
assert.isFunction(toArray);
assert.arity(toArray, 0);
assert.name(toArray, 'toArray');
assert.looksNative(toArray);
assert.nonEnumerable(Iterator.prototype, 'toArray');
assert.arrayEqual([1, 2, 3].values().toArray(), [1, 2, 3]);
assert.arrayEqual(new Set([1, 2, 3]).values().toArray(), [1, 2, 3]);
assert.arrayEqual(Iterator.from('123').toArray(), ['1', '2', '3']);
assert.arrayEqual(Iterator.from(createIterable([1, 2, 3])).toArray(), [1, 2, 3]);
assert.arrayEqual(toArray.call(createIterator([1, 2, 3])), [1, 2, 3]);
assert.throws(() => toArray.call(undefined), TypeError);
assert.throws(() => toArray.call(null), TypeError);
assert.throws(() => toArray.call({}), TypeError);
assert.throws(() => toArray.call([]), TypeError);
});
core-js-3.6.1/tests/tests/esnext.map.delete-all.js 0000664 0000000 0000000 00000002147 13600575677 0022042 0 ustar 00root root 0000000 0000000 QUnit.test('Map#deleteAll', assert => {
const { deleteAll } = Map.prototype;
const { from } = Array;
assert.isFunction(deleteAll);
assert.arity(deleteAll, 0);
assert.name(deleteAll, 'deleteAll');
assert.looksNative(deleteAll);
assert.nonEnumerable(Map.prototype, 'deleteAll');
let set = new Map([[1, 2], [2, 3], [3, 4]]);
assert.same(set.deleteAll(1, 2), true);
assert.deepEqual(from(set), [[3, 4]]);
set = new Map([[1, 2], [2, 3], [3, 4]]);
assert.same(set.deleteAll(3, 4), false);
assert.deepEqual(from(set), [[1, 2], [2, 3]]);
set = new Map([[1, 2], [2, 3], [3, 4]]);
assert.same(set.deleteAll(4, 5), false);
assert.deepEqual(from(set), [[1, 2], [2, 3], [3, 4]]);
set = new Map([[1, 2], [2, 3], [3, 4]]);
assert.same(set.deleteAll(), true);
assert.deepEqual(from(set), [[1, 2], [2, 3], [3, 4]]);
assert.notThrows(() => !deleteAll.call({ delete() { /* empty */ } }, 1, 2, 3));
assert.throws(() => deleteAll.call({}, 1, 2, 3), TypeError);
assert.throws(() => deleteAll.call(undefined, 1, 2, 3), TypeError);
assert.throws(() => deleteAll.call(null, 1, 2, 3), TypeError);
});
core-js-3.6.1/tests/tests/esnext.map.every.js 0000664 0000000 0000000 00000002726 13600575677 0021167 0 ustar 00root root 0000000 0000000 QUnit.test('Map#every', assert => {
const { every } = Map.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.name(every, 'every');
assert.looksNative(every);
assert.nonEnumerable(Map.prototype, 'every');
let map = new Map([[9, 1]]);
const context = {};
map.every(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 9, 'correct index in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
map = new Map([[0, 1], [1, 2], [2, 3]]);
assert.ok(map.every(it => typeof it === 'number'));
assert.ok(map.every(it => it < 4));
assert.ok(!map.every(it => it < 3));
assert.ok(!map.every(it => typeof it === 'string'));
assert.ok(map.every(function () {
return +this === 1;
}, 1));
let result = '';
map.every((value, key) => result += key);
assert.ok(result === '012');
assert.ok(map.every((value, key, that) => that === map));
assert.throws(() => every.call(new Set(), () => { /* empty */ }), TypeError);
assert.throws(() => every.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => every.call([], () => { /* empty */ }), TypeError);
assert.throws(() => every.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.map.filter.js 0000664 0000000 0000000 00000002570 13600575677 0021317 0 ustar 00root root 0000000 0000000 QUnit.test('Map#filter', assert => {
const { filter } = Map.prototype;
const { from } = Array;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.name(filter, 'filter');
assert.looksNative(filter);
assert.nonEnumerable(Map.prototype, 'filter');
const map = new Map([[1, 2]]);
const context = {};
map.filter(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.ok(new Map().filter(it => it) instanceof Map);
assert.deepEqual(from(new Map([
['a', 1],
[1, 2],
['b', 3],
[2, 'q'],
['c', {}],
[3, 4],
['d', true],
[4, 5],
]).filter(it => typeof it === 'number')), [
['a', 1],
[1, 2],
['b', 3],
[3, 4],
[4, 5],
]);
assert.throws(() => filter.call(new Set(), () => { /* empty */ }), TypeError);
assert.throws(() => filter.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call([], () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.map.find-key.js 0000664 0000000 0000000 00000002270 13600575677 0021535 0 ustar 00root root 0000000 0000000 QUnit.test('Map#findKey', assert => {
const { findKey } = Map.prototype;
assert.isFunction(findKey);
assert.arity(findKey, 1);
assert.name(findKey, 'findKey');
assert.looksNative(findKey);
assert.nonEnumerable(Map.prototype, 'findKey');
const set = new Map([[1, 2]]);
const context = {};
set.findKey(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new Map([[1, 2], [2, 3], [3, 4]]).findKey(it => it % 2), 2);
assert.same(new Map().findKey(it => it === 42), undefined);
assert.throws(() => findKey.call(new Set(), () => { /* empty */ }), TypeError);
assert.throws(() => findKey.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => findKey.call([], () => { /* empty */ }), TypeError);
assert.throws(() => findKey.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => findKey.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.map.find.js 0000664 0000000 0000000 00000002210 13600575677 0020741 0 ustar 00root root 0000000 0000000 QUnit.test('Map#find', assert => {
const { find } = Map.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.name(find, 'find');
assert.looksNative(find);
assert.nonEnumerable(Map.prototype, 'find');
const set = new Map([[1, 2]]);
const context = {};
set.find(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new Map([[1, 2], [2, 3], [3, 4]]).find(it => it % 2), 3);
assert.same(new Map().find(it => it === 42), undefined);
assert.throws(() => find.call(new Set(), () => { /* empty */ }), TypeError);
assert.throws(() => find.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => find.call([], () => { /* empty */ }), TypeError);
assert.throws(() => find.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.map.from.js 0000664 0000000 0000000 00000002010 13600575677 0020762 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
QUnit.test('Map.from', assert => {
const { from } = Map;
const toArray = Array.from;
assert.isFunction(from);
assert.arity(from, 1);
assert.name(from, 'from');
assert.looksNative(from);
assert.nonEnumerable(Map, 'from');
assert.ok(Map.from() instanceof Map);
assert.deepEqual(toArray(Map.from([])), []);
assert.deepEqual(toArray(Map.from([[1, 2]])), [[1, 2]]);
assert.deepEqual(toArray(Map.from([[1, 2], [2, 3], [1, 4]])), [[1, 4], [2, 3]]);
assert.deepEqual(toArray(Map.from(createIterable([[1, 2], [2, 3], [1, 4]]))), [[1, 4], [2, 3]]);
const pair = [1, 2];
const context = {};
Map.from([pair], function (element, index) {
assert.same(element, pair);
assert.same(index, 0);
assert.same(this, context);
return element;
}, context);
assert.throws(() => from([1, 2]));
let arg = null;
function F(it) {
return arg = it;
}
from.call(F, createIterable([1, 2, 3]), it => it ** 2);
assert.deepEqual(arg, [1, 4, 9]);
});
core-js-3.6.1/tests/tests/esnext.map.group-by.js 0000664 0000000 0000000 00000001522 13600575677 0021572 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
QUnit.test('Map.groupBy', assert => {
const { groupBy } = Map;
const toArray = Array.from;
assert.isFunction(groupBy);
assert.arity(groupBy, 2);
assert.name(groupBy, 'groupBy');
assert.looksNative(groupBy);
assert.nonEnumerable(Map, 'groupBy');
assert.ok(Map.groupBy([], it => it) instanceof Map);
assert.deepEqual(toArray(Map.groupBy([], it => it)), []);
assert.deepEqual(toArray(Map.groupBy([1, 2], it => it ** 2)), [[1, [1]], [4, [2]]]);
assert.deepEqual(toArray(Map.groupBy([1, 2, 1], it => it ** 2)), [[1, [1, 1]], [4, [2]]]);
assert.deepEqual(toArray(Map.groupBy(createIterable([1, 2]), it => it ** 2)), [[1, [1]], [4, [2]]]);
const element = {};
Map.groupBy([element], it => assert.same(it, element));
assert.throws(() => groupBy([1, 2], it => it));
});
core-js-3.6.1/tests/tests/esnext.map.includes.js 0000664 0000000 0000000 00000001624 13600575677 0021637 0 ustar 00root root 0000000 0000000 QUnit.test('Map#includes', assert => {
const { includes } = Map.prototype;
assert.isFunction(includes);
assert.name(includes, 'includes');
assert.arity(includes, 1);
assert.looksNative(includes);
assert.nonEnumerable(Map.prototype, 'includes');
const object = {};
const map = new Map([[1, 1], [2, 2], [3, 3], [4, -0], [5, object], [6, NaN]]);
assert.ok(map.includes(1));
assert.ok(map.includes(-0));
assert.ok(map.includes(0));
assert.ok(map.includes(object));
assert.ok(!map.includes(4));
assert.ok(!map.includes(-0.5));
assert.ok(!map.includes({}));
assert.ok(map.includes(NaN));
assert.throws(() => includes.call(new Set(), 1), TypeError);
assert.throws(() => includes.call({}, 1), TypeError);
assert.throws(() => includes.call([], 1), TypeError);
assert.throws(() => includes.call(undefined, 1), TypeError);
assert.throws(() => includes.call(null, 1), TypeError);
});
core-js-3.6.1/tests/tests/esnext.map.key-by.js 0000664 0000000 0000000 00000001445 13600575677 0021232 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
QUnit.test('Map.keyBy', assert => {
const { keyBy } = Map;
const toArray = Array.from;
assert.isFunction(keyBy);
assert.arity(keyBy, 2);
assert.name(keyBy, 'keyBy');
assert.looksNative(keyBy);
assert.nonEnumerable(Map, 'keyBy');
assert.ok(Map.keyBy([], it => it) instanceof Map);
assert.deepEqual(toArray(Map.keyBy([], it => it)), []);
assert.deepEqual(toArray(Map.keyBy([1, 2], it => it ** 2)), [[1, 1], [4, 2]]);
assert.deepEqual(toArray(Map.keyBy([1, 2, 1], it => it ** 2)), [[1, 1], [4, 2]]);
assert.deepEqual(toArray(Map.keyBy(createIterable([1, 2]), it => it ** 2)), [[1, 1], [4, 2]]);
const element = {};
Map.keyBy([element], it => assert.same(it, element));
assert.throws(() => keyBy([1, 2], it => it));
});
core-js-3.6.1/tests/tests/esnext.map.key-of.js 0000664 0000000 0000000 00000001632 13600575677 0021222 0 ustar 00root root 0000000 0000000 QUnit.test('Map#keyOf', assert => {
const { keyOf } = Map.prototype;
assert.isFunction(keyOf);
assert.name(keyOf, 'keyOf');
assert.arity(keyOf, 1);
assert.looksNative(keyOf);
assert.nonEnumerable(Map.prototype, 'keyOf');
const object = {};
const map = new Map([[1, 1], [2, 2], [3, 3], [4, -0], [5, object], [6, NaN]]);
assert.same(map.keyOf(1), 1);
assert.same(map.keyOf(-0), 4);
assert.same(map.keyOf(0), 4);
assert.same(map.keyOf(object), 5);
assert.same(map.keyOf(4), undefined);
assert.same(map.keyOf(-0.5), undefined);
assert.same(map.keyOf({}), undefined);
assert.same(map.keyOf(NaN), undefined);
assert.throws(() => keyOf.call(new Set(), 1), TypeError);
assert.throws(() => keyOf.call({}, 1), TypeError);
assert.throws(() => keyOf.call([], 1), TypeError);
assert.throws(() => keyOf.call(undefined, 1), TypeError);
assert.throws(() => keyOf.call(null, 1), TypeError);
});
core-js-3.6.1/tests/tests/esnext.map.map-keys.js 0000664 0000000 0000000 00000002737 13600575677 0021565 0 ustar 00root root 0000000 0000000 QUnit.test('Map#mapKeys', assert => {
const { mapKeys } = Map.prototype;
const { from } = Array;
assert.isFunction(mapKeys);
assert.arity(mapKeys, 1);
assert.name(mapKeys, 'mapKeys');
assert.looksNative(mapKeys);
assert.nonEnumerable(Map.prototype, 'mapKeys');
const map = new Map([[1, 2]]);
const context = {};
map.mapKeys(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.ok(new Map().mapKeys(it => it) instanceof Map);
assert.deepEqual(from(new Map([
['a', 1],
[1, 2],
['b', 3],
[2, 'q'],
['c', {}],
[3, 4],
['d', true],
[4, 5],
]).mapKeys((value, key) => `${ key }${ value }`)), [
['a1', 1],
['12', 2],
['b3', 3],
['2q', 'q'],
['c[object Object]', {}],
['34', 4],
['dtrue', true],
['45', 5],
]);
assert.throws(() => mapKeys.call(new Set(), () => { /* empty */ }), TypeError);
assert.throws(() => mapKeys.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => mapKeys.call([], () => { /* empty */ }), TypeError);
assert.throws(() => mapKeys.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => mapKeys.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.map.map-values.js 0000664 0000000 0000000 00000003001 13600575677 0022072 0 ustar 00root root 0000000 0000000 QUnit.test('Map#mapValues', assert => {
const { mapValues } = Map.prototype;
const { from } = Array;
assert.isFunction(mapValues);
assert.arity(mapValues, 1);
assert.name(mapValues, 'mapValues');
assert.looksNative(mapValues);
assert.nonEnumerable(Map.prototype, 'mapValues');
const map = new Map([[1, 2]]);
const context = {};
map.mapValues(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.ok(new Map().mapValues(it => it) instanceof Map);
assert.deepEqual(from(new Map([
['a', 1],
[1, 2],
['b', 3],
[2, 'q'],
['c', {}],
[3, 4],
['d', true],
[4, 5],
]).mapValues((value, key) => `${ key }${ value }`)), [
['a', 'a1'],
[1, '12'],
['b', 'b3'],
[2, '2q'],
['c', 'c[object Object]'],
[3, '34'],
['d', 'dtrue'],
[4, '45'],
]);
assert.throws(() => mapValues.call(new Set(), () => { /* empty */ }), TypeError);
assert.throws(() => mapValues.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => mapValues.call([], () => { /* empty */ }), TypeError);
assert.throws(() => mapValues.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => mapValues.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.map.merge.js 0000664 0000000 0000000 00000001721 13600575677 0021126 0 ustar 00root root 0000000 0000000 QUnit.test('Map#merge', assert => {
const { merge } = Map.prototype;
const { from } = Array;
assert.isFunction(merge);
assert.arity(merge, 1);
assert.name(merge, 'merge');
assert.looksNative(merge);
assert.nonEnumerable(Map.prototype, 'merge');
const map = new Map([[1, 2]]);
const result = map.merge([[3, 4]]);
assert.ok(result === map);
assert.ok(result instanceof Map);
assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([[5, 6]])), [[1, 2], [3, 4], [5, 6]]);
assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([[3, 5], [5, 6]])), [[1, 2], [3, 5], [5, 6]]);
assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([])), [[1, 2], [3, 4]]);
assert.deepEqual(from(new Map([[1, 2], [3, 4]]).merge([[3, 5]], [[5, 6]])), [[1, 2], [3, 5], [5, 6]]);
assert.throws(() => merge.call({}, [[1, 2]]), TypeError);
assert.throws(() => merge.call(undefined, [[1, 2]]), TypeError);
assert.throws(() => merge.call(null, [[1, 2]]), TypeError);
});
core-js-3.6.1/tests/tests/esnext.map.of.js 0000664 0000000 0000000 00000001042 13600575677 0020427 0 ustar 00root root 0000000 0000000 QUnit.test('Map.of', assert => {
const { of } = Map;
const toArray = Array.from;
assert.isFunction(of);
assert.arity(of, 0);
assert.name(of, 'of');
assert.looksNative(of);
assert.nonEnumerable(Map, 'of');
assert.ok(Map.of() instanceof Map);
assert.deepEqual(toArray(Map.of([1, 2])), [[1, 2]]);
assert.deepEqual(toArray(Map.of([1, 2], [2, 3], [1, 4])), [[1, 4], [2, 3]]);
assert.throws(() => of(1));
let arg = null;
function F(it) {
return arg = it;
}
of.call(F, 1, 2, 3);
assert.deepEqual(arg, [1, 2, 3]);
});
core-js-3.6.1/tests/tests/esnext.map.reduce.js 0000664 0000000 0000000 00000003655 13600575677 0021306 0 ustar 00root root 0000000 0000000 QUnit.test('Map#reduce', assert => {
const { reduce } = Map.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.name(reduce, 'reduce');
assert.looksNative(reduce);
assert.nonEnumerable(Map.prototype, 'reduce');
const set = new Map([['a', 1]]);
const accumulator = {};
set.reduce(function (memo, value, key, that) {
assert.same(arguments.length, 4, 'correct number of callback arguments');
assert.same(memo, accumulator, 'correct callback accumulator');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 'a', 'correct index in callback');
assert.same(that, set, 'correct link to set in callback');
}, accumulator);
assert.same(new Map([
['a', 1],
['b', 2],
['c', 3],
]).reduce(((a, b) => a + b), 1), 7, 'works with initial accumulator');
new Map([
['a', 1],
['b', 2],
]).reduce((memo, value, key) => {
assert.same(memo, 1, 'correct default accumulator');
assert.same(value, 2, 'correct start value without initial accumulator');
assert.same(key, 'b', 'correct start index without initial accumulator');
});
assert.same(new Map([
['a', 1],
['b', 2],
['c', 3],
]).reduce((a, b) => a + b), 6, 'works without initial accumulator');
let values = '';
let keys = '';
new Map([
['a', 1],
['b', 2],
['c', 3],
]).reduce((memo, value, key, s) => {
s.delete('b');
values += value;
keys += key;
}, 0);
assert.same(values, '13', 'correct order #1');
assert.same(keys, 'ac', 'correct order #2');
assert.throws(() => reduce.call(new Set(), () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call({}, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call([], () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(undefined, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(null, () => { /* empty */ }, 1), TypeError);
});
core-js-3.6.1/tests/tests/esnext.map.some.js 0000664 0000000 0000000 00000002737 13600575677 0021002 0 ustar 00root root 0000000 0000000 QUnit.test('Map#some', assert => {
const { some } = Map.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.name(some, 'some');
assert.looksNative(some);
assert.nonEnumerable(Map.prototype, 'some');
let map = new Map([[9, 1]]);
const context = {};
map.some(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 9, 'correct index in callback');
assert.same(that, map, 'correct link to map in callback');
assert.same(this, context, 'correct callback context');
}, context);
map = new Map([[0, 1], [1, '2'], [2, 3]]);
assert.ok(map.some(it => typeof it === 'number'));
assert.ok(map.some(it => it < 3));
assert.ok(!map.some(it => it < 0));
assert.ok(map.some(it => typeof it === 'string'));
assert.ok(!map.some(function () {
return +this !== 1;
}, 1));
let result = '';
map.some((value, key) => {
result += key;
return false;
});
assert.same(result, '012');
assert.ok(map.some((value, key, that) => that === map));
assert.throws(() => some.call(new Set(), () => { /* empty */ }), TypeError);
assert.throws(() => some.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => some.call([], () => { /* empty */ }), TypeError);
assert.throws(() => some.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.map.update-or-insert.js 0000664 0000000 0000000 00000003313 13600575677 0023230 0 ustar 00root root 0000000 0000000 QUnit.test('Map#updateOrInsert', assert => {
const { updateOrInsert } = Map.prototype;
assert.isFunction(updateOrInsert);
assert.arity(updateOrInsert, 2);
assert.name(updateOrInsert, 'upsert');
assert.looksNative(updateOrInsert);
assert.nonEnumerable(Map.prototype, 'upsert');
const map = new Map([['a', 2]]);
assert.same(map.updateOrInsert('a', function (value) {
assert.same(arguments.length, 1, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
return value ** 2;
}, () => {
assert.ok(false, 'should not be called');
return 3;
}), 4, 'returns a correct value');
assert.same(map.updateOrInsert('b', value => {
assert.ok(false, 'should not be called');
return value ** 2;
}, function () {
assert.same(arguments.length, 0, 'correct number of callback arguments');
return 3;
}), 3, 'returns a correct value');
assert.same(map.size, 2, 'correct size');
assert.same(map.get('a'), 4, 'correct result #1');
assert.same(map.get('b'), 3, 'correct result #2');
assert.same(new Map([['a', 2]]).updateOrInsert('b', null, () => 3), 3);
assert.same(new Map([['a', 2]]).updateOrInsert('a', value => value ** 2), 4);
assert.throws(() => new Map().updateOrInsert('a'), TypeError);
assert.throws(() => updateOrInsert.call({}, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => updateOrInsert.call([], 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => updateOrInsert.call(undefined, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => updateOrInsert.call(null, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.map.update.js 0000664 0000000 0000000 00000003550 13600575677 0021313 0 ustar 00root root 0000000 0000000 QUnit.test('Map#update', assert => {
const { update } = Map.prototype;
assert.isFunction(update);
assert.arity(update, 2);
assert.name(update, 'update');
assert.looksNative(update);
assert.nonEnumerable(Map.prototype, 'update');
let map = new Map([[9, 2]]);
assert.same(map.update(9, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 9, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
return value * 2;
}), map, 'returns this');
assert.same(map.size, 1, 'correct size');
assert.same(map.get(9), 4, 'correct result');
map = new Map([[4, 5]]);
map.update(9, function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
assert.same(key, 9, 'correct key in callback');
assert.same(that, map, 'correct link to map in callback');
return value * 2;
}, function (key, that) {
assert.same(arguments.length, 2, 'correct number of thunk arguments');
assert.same(key, 9, 'correct key in thunk');
assert.same(that, map, 'correct link to map in thunk');
return 2;
});
assert.same(map.size, 2, 'correct size');
assert.same(map.get(4), 5, 'correct result #1');
assert.same(map.get(9), 4, 'correct result #2');
assert.throws(() => new Map([[9, 2]]).update(9), TypeError);
assert.throws(() => new Map().update(9, () => { /* empty */ }), TypeError);
assert.throws(() => update.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => update.call([], () => { /* empty */ }), TypeError);
assert.throws(() => update.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => update.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.map.upsert.js 0000664 0000000 0000000 00000003123 13600575677 0021347 0 ustar 00root root 0000000 0000000 QUnit.test('Map#upsert', assert => {
const { upsert } = Map.prototype;
assert.isFunction(upsert);
assert.arity(upsert, 2);
assert.name(upsert, 'upsert');
assert.looksNative(upsert);
assert.nonEnumerable(Map.prototype, 'upsert');
const map = new Map([['a', 2]]);
assert.same(map.upsert('a', function (value) {
assert.same(arguments.length, 1, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
return value ** 2;
}, () => {
assert.ok(false, 'should not be called');
return 3;
}), 4, 'returns a correct value');
assert.same(map.upsert('b', value => {
assert.ok(false, 'should not be called');
return value ** 2;
}, function () {
assert.same(arguments.length, 0, 'correct number of callback arguments');
return 3;
}), 3, 'returns a correct value');
assert.same(map.size, 2, 'correct size');
assert.same(map.get('a'), 4, 'correct result #1');
assert.same(map.get('b'), 3, 'correct result #2');
assert.same(new Map([['a', 2]]).upsert('b', null, () => 3), 3);
assert.same(new Map([['a', 2]]).upsert('a', value => value ** 2), 4);
assert.throws(() => new Map().upsert('a'), TypeError);
assert.throws(() => upsert.call({}, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call([], 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call(undefined, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call(null, 'a', () => { /* empty */ }, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.math.clamp.js 0000664 0000000 0000000 00000000502 13600575677 0021273 0 ustar 00root root 0000000 0000000 QUnit.test('Math.clamp', assert => {
const { clamp } = Math;
assert.isFunction(clamp);
assert.name(clamp, 'clamp');
assert.arity(clamp, 3);
assert.looksNative(clamp);
assert.nonEnumerable(Math, 'clamp');
assert.same(clamp(2, 4, 6), 4);
assert.same(clamp(4, 2, 6), 4);
assert.same(clamp(6, 2, 4), 4);
});
core-js-3.6.1/tests/tests/esnext.math.deg-per-rad.js 0000664 0000000 0000000 00000000375 13600575677 0022276 0 ustar 00root root 0000000 0000000 QUnit.test('Math.DEG_PER_RAD', assert => {
const { DEG_PER_RAD } = Math;
assert.ok('DEG_PER_RAD' in Math, 'DEG_PER_RAD in Math');
assert.nonEnumerable(Math, 'DEG_PER_RAD');
assert.strictEqual(DEG_PER_RAD, Math.PI / 180, 'Is Math.PI / 180');
});
core-js-3.6.1/tests/tests/esnext.math.degrees.js 0000664 0000000 0000000 00000000607 13600575677 0021623 0 ustar 00root root 0000000 0000000 QUnit.test('Math.degrees', assert => {
const { degrees } = Math;
assert.isFunction(degrees);
assert.name(degrees, 'degrees');
assert.arity(degrees, 1);
assert.looksNative(degrees);
assert.nonEnumerable(Math, 'degrees');
assert.same(degrees(0), 0);
assert.same(degrees(Math.PI / 2), 90);
assert.same(degrees(Math.PI), 180);
assert.same(degrees(3 * Math.PI / 2), 270);
});
core-js-3.6.1/tests/tests/esnext.math.fscale.js 0000664 0000000 0000000 00000000766 13600575677 0021450 0 ustar 00root root 0000000 0000000 QUnit.test('Math.fscale', assert => {
const { fscale, fround, PI } = Math;
assert.isFunction(fscale);
assert.name(fscale, 'fscale');
assert.arity(fscale, 5);
assert.looksNative(fscale);
assert.nonEnumerable(Math, 'fscale');
assert.same(fscale(3, 1, 2, 1, 2), 3);
assert.same(fscale(0, 3, 5, 8, 10), 5);
assert.same(fscale(1, 1, 1, 1, 1), NaN);
assert.same(fscale(-1, -1, -1, -1, -1), NaN);
assert.strictEqual(fscale(3, 1, 2, 1, PI), fround((3 - 1) * (PI - 1) / (2 - 1) + 1));
});
core-js-3.6.1/tests/tests/esnext.math.iaddh.js 0000664 0000000 0000000 00000000647 13600575677 0021262 0 ustar 00root root 0000000 0000000 QUnit.test('Math.iaddh', assert => {
const { iaddh } = Math;
assert.isFunction(iaddh);
assert.name(iaddh, 'iaddh');
assert.arity(iaddh, 4);
assert.looksNative(iaddh);
assert.nonEnumerable(Math, 'iaddh');
assert.same(iaddh(0, 2, 1, 0), 2);
assert.same(iaddh(0, 4, 1, 1), 5);
assert.same(iaddh(2, 4, 1, 1), 5);
assert.same(iaddh(0xFFFFFFFF, 4, 1, 1), 6);
assert.same(iaddh(1, 4, 0xFFFFFFFF, 1), 6);
});
core-js-3.6.1/tests/tests/esnext.math.imulh.js 0000664 0000000 0000000 00000000555 13600575677 0021325 0 ustar 00root root 0000000 0000000 QUnit.test('Math.imulh', assert => {
const { imulh } = Math;
assert.isFunction(imulh);
assert.name(imulh, 'imulh');
assert.arity(imulh, 2);
assert.looksNative(imulh);
assert.nonEnumerable(Math, 'imulh');
assert.same(imulh(0xFFFFFFFF, 7), -1);
assert.same(imulh(0xFFFFFFF, 77), 4);
assert.same(imulh(1, 7), 0);
assert.same(imulh(-1, 7), -1);
});
core-js-3.6.1/tests/tests/esnext.math.isubh.js 0000664 0000000 0000000 00000000647 13600575677 0021323 0 ustar 00root root 0000000 0000000 QUnit.test('Math.isubh', assert => {
const { isubh } = Math;
assert.isFunction(isubh);
assert.name(isubh, 'isubh');
assert.arity(isubh, 4);
assert.looksNative(isubh);
assert.nonEnumerable(Math, 'isubh');
assert.same(isubh(0, 2, 1, 0), 1);
assert.same(isubh(0, 4, 1, 1), 2);
assert.same(isubh(2, 4, 1, 1), 3);
assert.same(isubh(0xFFFFFFFF, 4, 1, 1), 3);
assert.same(isubh(1, 4, 0xFFFFFFFF, 1), 2);
});
core-js-3.6.1/tests/tests/esnext.math.rad-per-deg.js 0000664 0000000 0000000 00000000375 13600575677 0022276 0 ustar 00root root 0000000 0000000 QUnit.test('Math.RAD_PER_DEG', assert => {
const { RAD_PER_DEG } = Math;
assert.ok('RAD_PER_DEG' in Math, 'RAD_PER_DEG in Math');
assert.nonEnumerable(Math, 'RAD_PER_DEG');
assert.strictEqual(RAD_PER_DEG, 180 / Math.PI, 'Is 180 / Math.PI');
});
core-js-3.6.1/tests/tests/esnext.math.radians.js 0000664 0000000 0000000 00000000607 13600575677 0021626 0 ustar 00root root 0000000 0000000 QUnit.test('Math.radians', assert => {
const { radians } = Math;
assert.isFunction(radians);
assert.name(radians, 'radians');
assert.arity(radians, 1);
assert.looksNative(radians);
assert.nonEnumerable(Math, 'radians');
assert.same(radians(0), 0);
assert.same(radians(90), Math.PI / 2);
assert.same(radians(180), Math.PI);
assert.same(radians(270), 3 * Math.PI / 2);
});
core-js-3.6.1/tests/tests/esnext.math.scale.js 0000664 0000000 0000000 00000000606 13600575677 0021273 0 ustar 00root root 0000000 0000000 QUnit.test('Math.scale', assert => {
const { scale } = Math;
assert.isFunction(scale);
assert.name(scale, 'scale');
assert.arity(scale, 5);
assert.looksNative(scale);
assert.nonEnumerable(Math, 'scale');
assert.same(scale(3, 1, 2, 1, 2), 3);
assert.same(scale(0, 3, 5, 8, 10), 5);
assert.same(scale(1, 1, 1, 1, 1), NaN);
assert.same(scale(-1, -1, -1, -1, -1), NaN);
});
core-js-3.6.1/tests/tests/esnext.math.seeded-prng.js 0000664 0000000 0000000 00000002526 13600575677 0022404 0 ustar 00root root 0000000 0000000 QUnit.test('Math.seededPRNG', assert => {
const { seededPRNG } = Math;
assert.isFunction(seededPRNG);
assert.name(seededPRNG, 'seededPRNG');
assert.arity(seededPRNG, 1);
assert.looksNative(seededPRNG);
assert.nonEnumerable(Math, 'seededPRNG');
for (const gen of [seededPRNG({ seed: 42 }), seededPRNG({ seed: 42 })]) {
assert.deepEqual(gen.next(), { value: 0.16461519912315087, done: false });
assert.deepEqual(gen.next(), { value: 0.2203933906000046, done: false });
assert.deepEqual(gen.next(), { value: 0.8249682894209105, done: false });
assert.deepEqual(gen.next(), { value: 0.10750079537509083, done: false });
assert.deepEqual(gen.next(), { value: 0.004673248161257476, done: false });
}
for (const gen of [seededPRNG({ seed: 43 }), seededPRNG({ seed: 43 })]) {
assert.deepEqual(gen.next(), { value: 0.1923438591811283, done: false });
assert.deepEqual(gen.next(), { value: 0.7896811578326683, done: false });
assert.deepEqual(gen.next(), { value: 0.9518230761883996, done: false });
assert.deepEqual(gen.next(), { value: 0.1414634102410296, done: false });
assert.deepEqual(gen.next(), { value: 0.7379838030207752, done: false });
}
assert.throws(() => seededPRNG(), TypeError);
assert.throws(() => seededPRNG(5), TypeError);
assert.throws(() => seededPRNG({ seed: null }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.math.signbit.js 0000664 0000000 0000000 00000001273 13600575677 0021644 0 ustar 00root root 0000000 0000000 QUnit.test('Math.signbit', assert => {
const { signbit } = Math;
assert.isFunction(signbit);
assert.name(signbit, 'signbit');
assert.arity(signbit, 1);
assert.looksNative(signbit);
assert.nonEnumerable(Math, 'signbit');
assert.strictEqual(signbit(NaN), false);
assert.strictEqual(signbit(), false);
assert.strictEqual(signbit(-0), true);
assert.strictEqual(signbit(0), false);
assert.strictEqual(signbit(Infinity), false);
assert.strictEqual(signbit(-Infinity), true);
assert.strictEqual(signbit(13510798882111488), false);
assert.strictEqual(signbit(-13510798882111488), true);
assert.strictEqual(signbit(42.5), false);
assert.strictEqual(signbit(-42.5), true);
});
core-js-3.6.1/tests/tests/esnext.math.umulh.js 0000664 0000000 0000000 00000000553 13600575677 0021337 0 ustar 00root root 0000000 0000000 QUnit.test('Math.umulh', assert => {
const { umulh } = Math;
assert.isFunction(umulh);
assert.name(umulh, 'umulh');
assert.arity(umulh, 2);
assert.looksNative(umulh);
assert.nonEnumerable(Math, 'umulh');
assert.same(umulh(0xFFFFFFFF, 7), 6);
assert.same(umulh(0xFFFFFFF, 77), 4);
assert.same(umulh(1, 7), 0);
assert.same(umulh(-1, 7), 6);
});
core-js-3.6.1/tests/tests/esnext.number.from-string.js 0000664 0000000 0000000 00000004015 13600575677 0023010 0 ustar 00root root 0000000 0000000 QUnit.test('Number.fromString', assert => {
const { fromString } = Number;
assert.isFunction(fromString);
assert.name(fromString, 'fromString');
assert.arity(fromString, 2);
assert.looksNative(fromString);
assert.nonEnumerable(Number, 'fromString');
assert.throws(() => fromString(undefined), TypeError, 'The first argument should be a string #1');
assert.throws(() => fromString(Object('10')), TypeError, 'The first argument should be a string #1');
assert.throws(() => fromString(''), SyntaxError, 'Empty string');
assert.same(fromString('-10', 2), -2, 'Works with negative numbers');
assert.throws(() => fromString('-'), SyntaxError, '-');
assert.same(fromString('10'), 10, 'Default radix is 10 #1');
assert.same(fromString('10', undefined), 10, 'Default radix is 10 #2');
for (let radix = 2; radix <= 36; ++radix) {
assert.same(fromString('10', radix), radix, `Radix ${ radix }`);
}
assert.throws(() => fromString('10', -4294967294), RangeError, 'Radix uses ToInteger #1');
assert.same(fromString('10', 2.5), 2, 'Radix uses ToInteger #2');
assert.same(fromString('42'), 42);
assert.same(fromString('42', 10), 42);
assert.throws(() => fromString('0xc0ffee'), SyntaxError);
assert.throws(() => fromString('0o755'), SyntaxError);
assert.throws(() => fromString('0b00101010'), SyntaxError);
assert.throws(() => fromString('C0FFEE', 16), SyntaxError);
assert.same(fromString('c0ffee', 16), 12648430);
assert.same(fromString('755', 8), 493);
assert.throws(() => fromString(''), SyntaxError);
assert.throws(() => fromString(' '), SyntaxError);
assert.throws(() => fromString(' 1'), SyntaxError);
assert.throws(() => fromString(' \n '), SyntaxError);
assert.throws(() => fromString('x'), SyntaxError);
assert.throws(() => fromString('1234', 0), RangeError);
assert.throws(() => fromString('1234', 1), RangeError);
assert.throws(() => fromString('1234', 37), RangeError);
assert.throws(() => fromString('010'), SyntaxError);
assert.throws(() => fromString('1_000_000_000'), SyntaxError);
});
core-js-3.6.1/tests/tests/esnext.object.iterate-entries.js 0000664 0000000 0000000 00000001432 13600575677 0023623 0 ustar 00root root 0000000 0000000 QUnit.test('Object.iterateEntries', assert => {
const { iterateEntries } = Object;
assert.isFunction(iterateEntries);
assert.name(iterateEntries, 'iterateEntries');
assert.arity(iterateEntries, 1);
assert.looksNative(iterateEntries);
assert.nonEnumerable(Object, 'iterateEntries');
const object = {
q: 1,
w: 2,
e: 3,
};
const iterator = iterateEntries(object);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Object Iterator');
assert.deepEqual(iterator.next(), {
value: ['q', 1],
done: false,
});
delete object.w;
assert.deepEqual(iterator.next(), {
value: ['e', 3],
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
core-js-3.6.1/tests/tests/esnext.object.iterate-keys.js 0000664 0000000 0000000 00000001365 13600575677 0023132 0 ustar 00root root 0000000 0000000 QUnit.test('Object.iterateKeys', assert => {
const { iterateKeys } = Object;
assert.isFunction(iterateKeys);
assert.name(iterateKeys, 'iterateKeys');
assert.arity(iterateKeys, 1);
assert.looksNative(iterateKeys);
assert.nonEnumerable(Object, 'iterateKeys');
const object = {
q: 1,
w: 2,
e: 3,
};
const iterator = iterateKeys(object);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Object Iterator');
assert.deepEqual(iterator.next(), {
value: 'q',
done: false,
});
delete object.w;
assert.deepEqual(iterator.next(), {
value: 'e',
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
core-js-3.6.1/tests/tests/esnext.object.iterate-values.js 0000664 0000000 0000000 00000001403 13600575677 0023447 0 ustar 00root root 0000000 0000000 QUnit.test('Object.iterateValues', assert => {
const { iterateValues } = Object;
assert.isFunction(iterateValues);
assert.name(iterateValues, 'iterateValues');
assert.arity(iterateValues, 1);
assert.looksNative(iterateValues);
assert.nonEnumerable(Object, 'iterateValues');
const object = {
q: 1,
w: 2,
e: 3,
};
const iterator = iterateValues(object);
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'Object Iterator');
assert.deepEqual(iterator.next(), {
value: 1,
done: false,
});
delete object.w;
assert.deepEqual(iterator.next(), {
value: 3,
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
core-js-3.6.1/tests/tests/esnext.observable.js 0000664 0000000 0000000 00000004267 13600575677 0021407 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
QUnit.test('Observable', assert => {
assert.isFunction(Observable);
assert.arity(Observable, 1);
assert.name(Observable, 'Observable');
assert.looksNative(Observable);
assert.throws(() => Observable(() => { /* empty */ }), 'throws w/o `new`');
const observable = new Observable(function (subscriptionObserver) {
assert.same(typeof subscriptionObserver, 'object', 'Subscription observer is object');
assert.same(subscriptionObserver.constructor, Object);
const { next, error, complete } = subscriptionObserver;
assert.isFunction(next);
assert.isFunction(error);
assert.isFunction(complete);
assert.arity(next, 1);
assert.arity(error, 1);
assert.arity(complete, 0);
if (STRICT) {
assert.same(this, undefined, 'correct executor context');
}
});
observable.subscribe({});
assert.ok(observable instanceof Observable);
});
QUnit.test('Observable#subscribe', assert => {
assert.isFunction(Observable.prototype.subscribe);
assert.arity(Observable.prototype.subscribe, 1);
assert.name(Observable.prototype.subscribe, 'subscribe');
assert.looksNative(Observable.prototype.subscribe);
const subscription = new Observable(() => { /* empty */ }).subscribe({});
assert.same(typeof subscription, 'object', 'Subscription is object');
assert.same(subscription.constructor, Object);
assert.isFunction(subscription.unsubscribe);
assert.arity(subscription.unsubscribe, 0);
});
QUnit.test('Observable#constructor', assert => {
assert.same(Observable.prototype.constructor, Observable);
});
QUnit.test('Observable#@@observable', assert => {
assert.isFunction(Observable.prototype[Symbol.observable]);
const observable = new Observable(() => { /* empty*/ });
assert.same(observable[Symbol.observable](), observable);
});
QUnit.test('Observable.of', assert => {
assert.isFunction(Observable.of);
assert.arity(Observable.of, 0);
assert.name(Observable.of, 'of');
assert.looksNative(Observable.of);
});
QUnit.test('Observable.from', assert => {
assert.isFunction(Observable.from);
assert.arity(Observable.from, 1);
assert.name(Observable.from, 'from');
assert.looksNative(Observable.from);
});
core-js-3.6.1/tests/tests/esnext.promise.any.js 0000664 0000000 0000000 00000002653 13600575677 0021524 0 ustar 00root root 0000000 0000000 QUnit.test('Promise.any', assert => {
assert.isFunction(Promise.any);
assert.arity(Promise.any, 1);
assert.looksNative(Promise.any);
assert.nonEnumerable(Promise, 'any');
assert.ok(Promise.any([1, 2, 3]) instanceof Promise, 'returns a promise');
});
QUnit.test('Promise.any, resolved', assert => {
assert.expect(1);
const async = assert.async();
Promise.any([
Promise.resolve(1),
Promise.reject(2),
Promise.resolve(3),
]).then(it => {
assert.same(it, 1, 'resolved with a correct value');
async();
});
});
QUnit.test('Promise.any, rejected #1', assert => {
assert.expect(2);
const async = assert.async();
Promise.any([
Promise.reject(1),
Promise.reject(2),
Promise.reject(3),
]).catch(error => {
assert.ok(error instanceof AggregateError, 'instanceof AggregateError');
assert.deepEqual(error.errors, [1, 2, 3], 'rejected with a correct value');
async();
});
});
QUnit.test('Promise.any, rejected #2', assert => {
assert.expect(1);
const async = assert.async();
Promise.any().catch(() => {
assert.ok(true, 'rejected as expected');
async();
});
});
QUnit.test('Promise.any, rejected #3', assert => {
assert.expect(2);
const async = assert.async();
Promise.any([]).catch(error => {
assert.ok(error instanceof AggregateError, 'instanceof AggregateError');
assert.deepEqual(error.errors, [], 'rejected with a correct value');
async();
});
});
core-js-3.6.1/tests/tests/esnext.promise.try.js 0000664 0000000 0000000 00000001307 13600575677 0021546 0 ustar 00root root 0000000 0000000 QUnit.test('Promise.try', assert => {
assert.isFunction(Promise.try);
assert.arity(Promise.try, 1);
assert.looksNative(Promise.try);
assert.nonEnumerable(Promise, 'try');
assert.ok(Promise.try(() => 42) instanceof Promise, 'returns a promise');
});
QUnit.test('Promise.try, resolved', assert => {
assert.expect(1);
const async = assert.async();
Promise.try(() => 42).then(it => {
assert.same(it, 42, 'resolved with a correct value');
async();
});
});
QUnit.test('Promise.try, rejected', assert => {
assert.expect(1);
const async = assert.async();
Promise.try(() => {
throw new Error();
}).catch(() => {
assert.ok(true, 'rejected as expected');
async();
});
});
core-js-3.6.1/tests/tests/esnext.reflect.define-metadata.js 0000664 0000000 0000000 00000001024 13600575677 0023702 0 ustar 00root root 0000000 0000000 QUnit.test('Reflect.defineMetadata', assert => {
const { defineMetadata } = Reflect;
assert.isFunction(defineMetadata);
assert.arity(defineMetadata, 3);
assert.name(defineMetadata, 'defineMetadata');
assert.looksNative(defineMetadata);
assert.nonEnumerable(Reflect, 'defineMetadata');
assert.throws(() => defineMetadata('key', 'value', undefined, undefined), TypeError);
assert.same(defineMetadata('key', 'value', {}, undefined), undefined);
assert.same(defineMetadata('key', 'value', {}, 'name'), undefined);
});
core-js-3.6.1/tests/tests/esnext.reflect.delete-metadata.js 0000664 0000000 0000000 00000001707 13600575677 0023722 0 ustar 00root root 0000000 0000000 QUnit.test('Reflect.deleteMetadata', assert => {
const { defineMetadata, hasOwnMetadata, deleteMetadata } = Reflect;
const { create } = Object;
assert.isFunction(deleteMetadata);
assert.arity(deleteMetadata, 2);
assert.name(deleteMetadata, 'deleteMetadata');
assert.looksNative(deleteMetadata);
assert.nonEnumerable(Reflect, 'deleteMetadata');
assert.throws(() => deleteMetadata('key', undefined, undefined), TypeError);
assert.same(deleteMetadata('key', {}, undefined), false);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.same(deleteMetadata('key', object, undefined), true);
const prototype = {};
defineMetadata('key', 'value', prototype, undefined);
assert.same(deleteMetadata('key', create(prototype), undefined), false);
object = {};
defineMetadata('key', 'value', object, undefined);
deleteMetadata('key', object, undefined);
assert.same(hasOwnMetadata('key', object, undefined), false);
});
core-js-3.6.1/tests/tests/esnext.reflect.get-metadata-keys.js 0000664 0000000 0000000 00000004560 13600575677 0024210 0 ustar 00root root 0000000 0000000 QUnit.test('Reflect.getMetadataKeys', assert => {
const { defineMetadata, getMetadataKeys } = Reflect;
const { create } = Object;
assert.isFunction(getMetadataKeys);
assert.arity(getMetadataKeys, 1);
assert.name(getMetadataKeys, 'getMetadataKeys');
assert.looksNative(getMetadataKeys);
assert.nonEnumerable(Reflect, 'getMetadataKeys');
assert.throws(() => getMetadataKeys(undefined, undefined), TypeError);
assert.deepEqual(getMetadataKeys({}, undefined), []);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key']);
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key']);
object = {};
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key0', 'key1']);
object = {};
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
defineMetadata('key0', 'value', object, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key0', 'key1']);
prototype = {};
defineMetadata('key2', 'value', prototype, undefined);
object = create(prototype);
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
assert.deepEqual(getMetadataKeys(object, undefined), ['key0', 'key1', 'key2']);
object = {};
assert.deepEqual(getMetadataKeys({}, 'name'), []);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.deepEqual(getMetadataKeys(object, 'name'), ['key']);
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.deepEqual(getMetadataKeys(object, 'name'), ['key']);
object = {};
defineMetadata('key0', 'value', object, 'name');
defineMetadata('key1', 'value', object, 'name');
defineMetadata('key0', 'value', object, 'name');
assert.deepEqual(getMetadataKeys(object, 'name'), ['key0', 'key1']);
prototype = {};
defineMetadata('key2', 'value', prototype, 'name');
object = create(prototype);
defineMetadata('key0', 'value', object, 'name');
defineMetadata('key1', 'value', object, 'name');
assert.deepEqual(getMetadataKeys(object, 'name'), ['key0', 'key1', 'key2']);
});
core-js-3.6.1/tests/tests/esnext.reflect.get-metadata.js 0000664 0000000 0000000 00000002125 13600575677 0023232 0 ustar 00root root 0000000 0000000 QUnit.test('Reflect.getMetadata', assert => {
const { defineMetadata, getMetadata } = Reflect;
const { create } = Object;
assert.isFunction(getMetadata);
assert.arity(getMetadata, 2);
assert.name(getMetadata, 'getMetadata');
assert.looksNative(getMetadata);
assert.nonEnumerable(Reflect, 'getMetadata');
assert.throws(() => getMetadata('key', undefined, undefined), TypeError);
assert.same(getMetadata('key', {}, undefined), undefined);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.same(getMetadata('key', object, undefined), 'value');
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.same(getMetadata('key', object, undefined), 'value');
assert.same(getMetadata('key', {}, 'name'), undefined);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.same(getMetadata('key', object, 'name'), 'value');
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.same(getMetadata('key', object, 'name'), 'value');
});
core-js-3.6.1/tests/tests/esnext.reflect.get-own-matadata.js 0000664 0000000 0000000 00000002206 13600575677 0024027 0 ustar 00root root 0000000 0000000 QUnit.test('Reflect.getOwnMetadata', assert => {
const { defineMetadata, getOwnMetadata } = Reflect;
const { create } = Object;
assert.isFunction(getOwnMetadata);
assert.arity(getOwnMetadata, 2);
assert.name(getOwnMetadata, 'getOwnMetadata');
assert.looksNative(getOwnMetadata);
assert.nonEnumerable(Reflect, 'getOwnMetadata');
assert.throws(() => getOwnMetadata('key', undefined, undefined), TypeError);
assert.same(getOwnMetadata('key', {}, undefined), undefined);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.same(getOwnMetadata('key', object, undefined), 'value');
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.same(getOwnMetadata('key', object, undefined), undefined);
assert.same(getOwnMetadata('key', {}, 'name'), undefined);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.same(getOwnMetadata('key', object, 'name'), 'value');
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.same(getOwnMetadata('key', object, 'name'), undefined);
});
core-js-3.6.1/tests/tests/esnext.reflect.get-own-metadata-keys.js 0000664 0000000 0000000 00000004622 13600575677 0025010 0 ustar 00root root 0000000 0000000 QUnit.test('Reflect.getOwnMetadataKeys', assert => {
const { defineMetadata, getOwnMetadataKeys } = Reflect;
const { create } = Object;
assert.isFunction(getOwnMetadataKeys);
assert.arity(getOwnMetadataKeys, 1);
assert.name(getOwnMetadataKeys, 'getOwnMetadataKeys');
assert.looksNative(getOwnMetadataKeys);
assert.nonEnumerable(Reflect, 'getOwnMetadataKeys');
assert.throws(() => getOwnMetadataKeys(undefined, undefined), TypeError);
assert.deepEqual(getOwnMetadataKeys({}, undefined), []);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.deepEqual(getOwnMetadataKeys(object, undefined), ['key']);
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.deepEqual(getOwnMetadataKeys(object, undefined), []);
object = {};
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
assert.deepEqual(getOwnMetadataKeys(object, undefined), ['key0', 'key1']);
object = {};
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
defineMetadata('key0', 'value', object, undefined);
assert.deepEqual(getOwnMetadataKeys(object, undefined), ['key0', 'key1']);
prototype = {};
defineMetadata('key2', 'value', prototype, undefined);
object = create(prototype);
defineMetadata('key0', 'value', object, undefined);
defineMetadata('key1', 'value', object, undefined);
assert.deepEqual(getOwnMetadataKeys(object, undefined), ['key0', 'key1']);
object = {};
assert.deepEqual(getOwnMetadataKeys({}, 'name'), []);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.deepEqual(getOwnMetadataKeys(object, 'name'), ['key']);
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.deepEqual(getOwnMetadataKeys(object, 'name'), []);
object = {};
defineMetadata('key0', 'value', object, 'name');
defineMetadata('key1', 'value', object, 'name');
defineMetadata('key0', 'value', object, 'name');
assert.deepEqual(getOwnMetadataKeys(object, 'name'), ['key0', 'key1']);
prototype = {};
defineMetadata('key2', 'value', prototype, 'name');
object = create(prototype);
defineMetadata('key0', 'value', object, 'name');
defineMetadata('key1', 'value', object, 'name');
assert.deepEqual(getOwnMetadataKeys(object, 'name'), ['key0', 'key1']);
});
core-js-3.6.1/tests/tests/esnext.reflect.has-metadata.js 0000664 0000000 0000000 00000002101 13600575677 0023220 0 ustar 00root root 0000000 0000000 QUnit.test('Reflect.hasMetadata', assert => {
const { defineMetadata, hasMetadata } = Reflect;
const { create } = Object;
assert.isFunction(hasMetadata);
assert.arity(hasMetadata, 2);
assert.name(hasMetadata, 'hasMetadata');
assert.looksNative(hasMetadata);
assert.nonEnumerable(Reflect, 'hasMetadata');
assert.throws(() => hasMetadata('key', undefined, undefined), TypeError);
assert.same(hasMetadata('key', {}, undefined), false);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.same(hasMetadata('key', object, undefined), true);
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.same(hasMetadata('key', object, undefined), true);
assert.same(hasMetadata('key', {}, 'name'), false);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.same(hasMetadata('key', object, 'name'), true);
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.same(hasMetadata('key', object, 'name'), true);
});
core-js-3.6.1/tests/tests/esnext.reflect.has-own-metadata.js 0000664 0000000 0000000 00000002160 13600575677 0024026 0 ustar 00root root 0000000 0000000 QUnit.test('Reflect.hasOwnMetadata', assert => {
const { defineMetadata, hasOwnMetadata } = Reflect;
const { create } = Object;
assert.isFunction(hasOwnMetadata);
assert.arity(hasOwnMetadata, 2);
assert.name(hasOwnMetadata, 'hasOwnMetadata');
assert.looksNative(hasOwnMetadata);
assert.nonEnumerable(Reflect, 'hasOwnMetadata');
assert.throws(() => hasOwnMetadata('key', undefined, undefined), TypeError);
assert.same(hasOwnMetadata('key', {}, undefined), false);
let object = {};
defineMetadata('key', 'value', object, undefined);
assert.same(hasOwnMetadata('key', object, undefined), true);
let prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, undefined);
assert.same(hasOwnMetadata('key', object, undefined), false);
assert.same(hasOwnMetadata('key', {}, 'name'), false);
object = {};
defineMetadata('key', 'value', object, 'name');
assert.same(hasOwnMetadata('key', object, 'name'), true);
prototype = {};
object = create(prototype);
defineMetadata('key', 'value', prototype, 'name');
assert.same(hasOwnMetadata('key', object, 'name'), false);
});
core-js-3.6.1/tests/tests/esnext.reflect.metadata.js 0000664 0000000 0000000 00000001222 13600575677 0022452 0 ustar 00root root 0000000 0000000 QUnit.test('Reflect.metadata', assert => {
const { metadata, hasOwnMetadata } = Reflect;
assert.isFunction(metadata);
assert.arity(metadata, 2);
assert.name(metadata, 'metadata');
assert.looksNative(metadata);
assert.isFunction(metadata('key', 'value'));
assert.nonEnumerable(Reflect, 'metadata');
const decorator = metadata('key', 'value');
assert.throws(() => decorator(undefined, 'name'), TypeError);
let target = function () { /* empty */ };
decorator(target);
assert.same(hasOwnMetadata('key', target, undefined), true);
target = {};
decorator(target, 'name');
assert.same(hasOwnMetadata('key', target, 'name'), true);
});
core-js-3.6.1/tests/tests/esnext.set.add-all.js 0000664 0000000 0000000 00000001461 13600575677 0021344 0 ustar 00root root 0000000 0000000 QUnit.test('Set#addAll', assert => {
const { addAll } = Set.prototype;
const { from } = Array;
assert.isFunction(addAll);
assert.arity(addAll, 0);
assert.name(addAll, 'addAll');
assert.looksNative(addAll);
assert.nonEnumerable(Set.prototype, 'addAll');
const set = new Set([1]);
assert.same(set.addAll(2), set);
assert.deepEqual(from(new Set([1, 2, 3]).addAll(4, 5)), [1, 2, 3, 4, 5]);
assert.deepEqual(from(new Set([1, 2, 3]).addAll(3, 4)), [1, 2, 3, 4]);
assert.deepEqual(from(new Set([1, 2, 3]).addAll()), [1, 2, 3]);
assert.notThrows(() => addAll.call({ add() { /* empty */ } }, 1, 2, 3));
assert.throws(() => addAll.call({}, 1, 2, 3), TypeError);
assert.throws(() => addAll.call(undefined, 1, 2, 3), TypeError);
assert.throws(() => addAll.call(null, 1, 2, 3), TypeError);
});
core-js-3.6.1/tests/tests/esnext.set.delete-all.js 0000664 0000000 0000000 00000001776 13600575677 0022067 0 ustar 00root root 0000000 0000000 QUnit.test('Set#deleteAll', assert => {
const { deleteAll } = Set.prototype;
const { from } = Array;
assert.isFunction(deleteAll);
assert.arity(deleteAll, 0);
assert.name(deleteAll, 'deleteAll');
assert.looksNative(deleteAll);
assert.nonEnumerable(Set.prototype, 'deleteAll');
let set = new Set([1, 2, 3]);
assert.same(set.deleteAll(1, 2), true);
assert.deepEqual(from(set), [3]);
set = new Set([1, 2, 3]);
assert.same(set.deleteAll(3, 4), false);
assert.deepEqual(from(set), [1, 2]);
set = new Set([1, 2, 3]);
assert.same(set.deleteAll(4, 5), false);
assert.deepEqual(from(set), [1, 2, 3]);
set = new Set([1, 2, 3]);
assert.same(set.deleteAll(), true);
assert.deepEqual(from(set), [1, 2, 3]);
assert.notThrows(() => !deleteAll.call({ delete() { /* empty */ } }, 1, 2, 3));
assert.throws(() => deleteAll.call({}, 1, 2, 3), TypeError);
assert.throws(() => deleteAll.call(undefined, 1, 2, 3), TypeError);
assert.throws(() => deleteAll.call(null, 1, 2, 3), TypeError);
});
core-js-3.6.1/tests/tests/esnext.set.difference.js 0000664 0000000 0000000 00000001660 13600575677 0022141 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
QUnit.test('Set#difference', assert => {
const { difference } = Set.prototype;
const { from } = Array;
assert.isFunction(difference);
assert.arity(difference, 1);
assert.name(difference, 'difference');
assert.looksNative(difference);
assert.nonEnumerable(Set.prototype, 'difference');
const set = new Set([1]);
assert.ok(set.difference([2]) !== set);
assert.deepEqual(from(new Set([1, 2, 3]).difference([4, 5])), [1, 2, 3]);
assert.deepEqual(from(new Set([1, 2, 3]).difference([3, 4])), [1, 2]);
assert.deepEqual(from(new Set([1, 2, 3]).difference(createIterable([3, 4]))), [1, 2]);
assert.throws(() => new Set([1, 2, 3]).difference(), TypeError);
assert.throws(() => difference.call({}, [1, 2, 3]), TypeError);
assert.throws(() => difference.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => difference.call(null, [1, 2, 3]), TypeError);
});
core-js-3.6.1/tests/tests/esnext.set.every.js 0000664 0000000 0000000 00000002502 13600575677 0021175 0 ustar 00root root 0000000 0000000 QUnit.test('Set#every', assert => {
const { every } = Set.prototype;
assert.isFunction(every);
assert.arity(every, 1);
assert.name(every, 'every');
assert.looksNative(every);
assert.nonEnumerable(Set.prototype, 'every');
const set = new Set([1]);
const context = {};
set.every(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new Set([1, 2, 3]).every(it => typeof it === 'number'), true);
assert.same(new Set(['1', '2', '3']).some(it => typeof it === 'number'), false);
assert.same(new Set([1, '2', 3]).every(it => typeof it === 'number'), false);
assert.same(new Set().every(it => typeof it === 'number'), true);
assert.throws(() => every.call(new Map(), () => { /* empty */ }), TypeError);
assert.throws(() => every.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => every.call([], () => { /* empty */ }), TypeError);
assert.throws(() => every.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => every.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.set.filter.js 0000664 0000000 0000000 00000002350 13600575677 0021331 0 ustar 00root root 0000000 0000000 QUnit.test('Set#filter', assert => {
const { filter } = Set.prototype;
const { from } = Array;
assert.isFunction(filter);
assert.arity(filter, 1);
assert.name(filter, 'filter');
assert.looksNative(filter);
assert.nonEnumerable(Set.prototype, 'filter');
const set = new Set([1]);
const context = {};
set.filter(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.ok(new Set().filter(it => it) instanceof Set);
assert.deepEqual(from(new Set([1, 2, 3, 'q', {}, 4, true, 5]).filter(it => typeof it === 'number')), [1, 2, 3, 4, 5]);
assert.throws(() => filter.call(new Map(), () => { /* empty */ }), TypeError);
assert.throws(() => filter.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call([], () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => filter.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.set.find.js 0000664 0000000 0000000 00000002164 13600575677 0020767 0 ustar 00root root 0000000 0000000 QUnit.test('Set#find', assert => {
const { find } = Set.prototype;
assert.isFunction(find);
assert.arity(find, 1);
assert.name(find, 'find');
assert.looksNative(find);
assert.nonEnumerable(Set.prototype, 'find');
const set = new Set([1]);
const context = {};
set.find(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new Set([2, 3, 4]).find(it => it % 2), 3);
assert.same(new Set().find(it => it === 42), undefined);
assert.throws(() => find.call(new Map(), () => { /* empty */ }), TypeError);
assert.throws(() => find.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => find.call([], () => { /* empty */ }), TypeError);
assert.throws(() => find.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => find.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.set.from.js 0000664 0000000 0000000 00000001674 13600575677 0021017 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
QUnit.test('Set.from', assert => {
const { from } = Set;
const toArray = Array.from;
assert.isFunction(from);
assert.arity(from, 1);
assert.name(from, 'from');
assert.looksNative(from);
assert.nonEnumerable(Set, 'from');
assert.ok(Set.from() instanceof Set);
assert.deepEqual(toArray(Set.from([])), []);
assert.deepEqual(toArray(Set.from([1])), [1]);
assert.deepEqual(toArray(Set.from([1, 2, 3, 2, 1])), [1, 2, 3]);
assert.deepEqual(toArray(Set.from(createIterable([1, 2, 3, 2, 1]))), [1, 2, 3]);
const context = {};
Set.from([1], function (element, index) {
assert.same(element, 1);
assert.same(index, 0);
assert.same(this, context);
return element;
}, context);
assert.throws(() => from(1));
let arg = null;
function F(it) {
return arg = it;
}
from.call(F, createIterable([1, 2, 3]), it => it ** 2);
assert.deepEqual(arg, [1, 4, 9]);
});
core-js-3.6.1/tests/tests/esnext.set.intersection.js 0000664 0000000 0000000 00000001717 13600575677 0022560 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
QUnit.test('Set#intersection', assert => {
const { intersection } = Set.prototype;
const { from } = Array;
assert.isFunction(intersection);
assert.arity(intersection, 1);
assert.name(intersection, 'intersection');
assert.looksNative(intersection);
assert.nonEnumerable(Set.prototype, 'intersection');
const set = new Set([1]);
assert.ok(set.intersection([2]) !== set);
assert.deepEqual(from(new Set([1, 2, 3]).intersection([4, 5])), []);
assert.deepEqual(from(new Set([1, 2, 3]).intersection([2, 3, 4])), [2, 3]);
assert.deepEqual(from(new Set([1, 2, 3]).intersection(createIterable([2, 3, 4]))), [2, 3]);
assert.throws(() => new Set([1, 2, 3]).intersection(), TypeError);
assert.throws(() => intersection.call({}, [1, 2, 3]), TypeError);
assert.throws(() => intersection.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => intersection.call(null, [1, 2, 3]), TypeError);
});
core-js-3.6.1/tests/tests/esnext.set.is-disjoint-from.js 0000664 0000000 0000000 00000001746 13600575677 0023251 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
QUnit.test('Set#isDisjointFrom', assert => {
const { isDisjointFrom } = Set.prototype;
assert.isFunction(isDisjointFrom);
assert.arity(isDisjointFrom, 1);
assert.name(isDisjointFrom, 'isDisjointFrom');
assert.looksNative(isDisjointFrom);
assert.nonEnumerable(Set.prototype, 'isDisjointFrom');
assert.ok(new Set([1]).isDisjointFrom([2]));
assert.ok(!new Set([1]).isDisjointFrom([1]));
assert.ok(new Set([1, 2, 3]).isDisjointFrom([4, 5, 6]));
assert.ok(!new Set([1, 2, 3]).isDisjointFrom([5, 4, 3]));
assert.ok(new Set([1]).isDisjointFrom(createIterable([2])));
assert.ok(!new Set([1]).isDisjointFrom(createIterable([1])));
assert.throws(() => new Set([1, 2, 3]).isDisjointFrom(), TypeError);
assert.throws(() => isDisjointFrom.call({}, [1, 2, 3]), TypeError);
assert.throws(() => isDisjointFrom.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => isDisjointFrom.call(null, [1, 2, 3]), TypeError);
});
core-js-3.6.1/tests/tests/esnext.set.is-subset-of.js 0000664 0000000 0000000 00000002232 13600575677 0022363 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
QUnit.test('Set#isSubsetOf', assert => {
const { isSubsetOf } = Set.prototype;
assert.isFunction(isSubsetOf);
assert.arity(isSubsetOf, 1);
assert.name(isSubsetOf, 'isSubsetOf');
assert.looksNative(isSubsetOf);
assert.nonEnumerable(Set.prototype, 'isSubsetOf');
assert.ok(new Set([1]).isSubsetOf([1, 2, 3]));
assert.ok(!new Set([1]).isSubsetOf([2, 3, 4]));
assert.ok(new Set([1, 2, 3]).isSubsetOf([5, 4, 3, 2, 1]));
assert.ok(!new Set([1, 2, 3]).isSubsetOf([5, 4, 3, 2]));
assert.ok(new Set([1]).isSubsetOf(createIterable([1, 2, 3])));
assert.ok(!new Set([1]).isSubsetOf(createIterable([2, 3, 4])));
assert.ok(new Set([1]).isSubsetOf({ has: () => true }));
assert.ok(!new Set([1]).isSubsetOf({ has: () => false }));
assert.ok(isSubsetOf.call('ab', ['a', 'b', 'c']));
assert.ok(!isSubsetOf.call('ab', ['a']));
assert.throws(() => new Set([1, 2, 3]).isSubsetOf(), TypeError);
assert.throws(() => isSubsetOf.call({}, [1, 2, 3]), TypeError);
assert.throws(() => isSubsetOf.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => isSubsetOf.call(null, [1, 2, 3]), TypeError);
});
core-js-3.6.1/tests/tests/esnext.set.is-superset-of.js 0000664 0000000 0000000 00000001743 13600575677 0022736 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
QUnit.test('Set#isSupersetOf', assert => {
const { isSupersetOf } = Set.prototype;
assert.isFunction(isSupersetOf);
assert.arity(isSupersetOf, 1);
assert.name(isSupersetOf, 'isSupersetOf');
assert.looksNative(isSupersetOf);
assert.nonEnumerable(Set.prototype, 'isSupersetOf');
assert.ok(new Set([1, 2, 3]).isSupersetOf([1]));
assert.ok(!new Set([2, 3, 4]).isSupersetOf([1]));
assert.ok(new Set([5, 4, 3, 2, 1]).isSupersetOf([1, 2, 3]));
assert.ok(!new Set([5, 4, 3, 2]).isSupersetOf([1, 2, 3]));
assert.ok(new Set([1, 2, 3]).isSupersetOf(createIterable([1])));
assert.ok(!new Set([2, 3, 4]).isSupersetOf(createIterable([1])));
assert.throws(() => new Set([1, 2, 3]).isSupersetOf(), TypeError);
assert.throws(() => isSupersetOf.call({}, [1, 2, 3]), TypeError);
assert.throws(() => isSupersetOf.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => isSupersetOf.call(null, [1, 2, 3]), TypeError);
});
core-js-3.6.1/tests/tests/esnext.set.join.js 0000664 0000000 0000000 00000001247 13600575677 0021007 0 ustar 00root root 0000000 0000000 QUnit.test('Set#join', assert => {
const { join } = Set.prototype;
assert.isFunction(join);
assert.arity(join, 1);
assert.name(join, 'join');
assert.looksNative(join);
assert.nonEnumerable(Set.prototype, 'join');
assert.strictEqual(new Set([1, 2, 3]).join(), '1,2,3');
assert.strictEqual(new Set([1, 2, 3]).join(undefined), '1,2,3');
assert.strictEqual(new Set([1, 2, 3]).join('|'), '1|2|3');
assert.throws(() => join.call(new Map()), TypeError);
assert.throws(() => join.call({}), TypeError);
assert.throws(() => join.call([]), TypeError);
assert.throws(() => join.call(undefined), TypeError);
assert.throws(() => join.call(null), TypeError);
});
core-js-3.6.1/tests/tests/esnext.set.map.js 0000664 0000000 0000000 00000002326 13600575677 0020624 0 ustar 00root root 0000000 0000000 QUnit.test('Set#map', assert => {
const { map } = Set.prototype;
const { from } = Array;
assert.isFunction(map);
assert.arity(map, 1);
assert.name(map, 'map');
assert.looksNative(map);
assert.nonEnumerable(Set.prototype, 'map');
const set = new Set([1]);
const context = {};
set.map(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.ok(new Set().map(it => it) instanceof Set);
assert.deepEqual(from(new Set([1, 2, 3]).map(it => it ** 2)), [1, 4, 9]);
assert.deepEqual(from(new Set([1, 2, 3]).map(it => it % 2)), [1, 0]);
assert.throws(() => map.call(new Map(), () => { /* empty */ }), TypeError);
assert.throws(() => map.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => map.call([], () => { /* empty */ }), TypeError);
assert.throws(() => map.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => map.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.set.of.js 0000664 0000000 0000000 00000001010 13600575677 0020440 0 ustar 00root root 0000000 0000000 QUnit.test('Set.of', assert => {
const { of } = Set;
const toArray = Array.from;
assert.isFunction(of);
assert.arity(of, 0);
assert.name(of, 'of');
assert.looksNative(of);
assert.nonEnumerable(Set, 'of');
assert.ok(Set.of() instanceof Set);
assert.deepEqual(toArray(Set.of(1)), [1]);
assert.deepEqual(toArray(Set.of(1, 2, 3, 2, 1)), [1, 2, 3]);
assert.throws(() => of(1));
let arg = null;
function F(it) {
return arg = it;
}
of.call(F, 1, 2, 3);
assert.deepEqual(arg, [1, 2, 3]);
});
core-js-3.6.1/tests/tests/esnext.set.reduce.js 0000664 0000000 0000000 00000003423 13600575677 0021315 0 ustar 00root root 0000000 0000000 QUnit.test('Set#reduce', assert => {
const { reduce } = Set.prototype;
assert.isFunction(reduce);
assert.arity(reduce, 1);
assert.name(reduce, 'reduce');
assert.looksNative(reduce);
assert.nonEnumerable(Set.prototype, 'reduce');
const set = new Set([1]);
const accumulator = {};
set.reduce(function (memo, value, key, that) {
assert.same(arguments.length, 4, 'correct number of callback arguments');
assert.same(memo, accumulator, 'correct callback accumulator');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 1, 'correct index in callback');
assert.same(that, set, 'correct link to set in callback');
}, accumulator);
assert.same(new Set([1, 2, 3]).reduce(((a, b) => a + b), 1), 7, 'works with initial accumulator');
new Set([1, 2]).reduce((memo, value, key) => {
assert.same(memo, 1, 'correct default accumulator');
assert.same(value, 2, 'correct start value without initial accumulator');
assert.same(key, 2, 'correct start index without initial accumulator');
});
assert.same(new Set([1, 2, 3]).reduce((a, b) => a + b), 6, 'works without initial accumulator');
let values = '';
let keys = '';
new Set([1, 2, 3]).reduce((memo, value, key, s) => {
s.delete(2);
values += value;
keys += key;
}, 0);
assert.same(values, '13', 'correct order #1');
assert.same(keys, '13', 'correct order #2');
assert.throws(() => reduce.call(new Map(), () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call({}, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call([], () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(undefined, () => { /* empty */ }, 1), TypeError);
assert.throws(() => reduce.call(null, () => { /* empty */ }, 1), TypeError);
});
core-js-3.6.1/tests/tests/esnext.set.some.js 0000664 0000000 0000000 00000002461 13600575677 0021012 0 ustar 00root root 0000000 0000000 QUnit.test('Set#some', assert => {
const { some } = Set.prototype;
assert.isFunction(some);
assert.arity(some, 1);
assert.name(some, 'some');
assert.looksNative(some);
assert.nonEnumerable(Set.prototype, 'some');
const set = new Set([1]);
const context = {};
set.some(function (value, key, that) {
assert.same(arguments.length, 3, 'correct number of callback arguments');
assert.same(value, 1, 'correct value in callback');
assert.same(key, 1, 'correct key in callback');
assert.same(that, set, 'correct link to set in callback');
assert.same(this, context, 'correct callback context');
}, context);
assert.same(new Set([1, 2, 3]).some(it => typeof it === 'number'), true);
assert.same(new Set(['1', '2', '3']).some(it => typeof it === 'number'), false);
assert.same(new Set([1, '2', 3]).some(it => typeof it === 'number'), true);
assert.same(new Set().some(it => typeof it === 'number'), false);
assert.throws(() => some.call(new Map(), () => { /* empty */ }), TypeError);
assert.throws(() => some.call({}, () => { /* empty */ }), TypeError);
assert.throws(() => some.call([], () => { /* empty */ }), TypeError);
assert.throws(() => some.call(undefined, () => { /* empty */ }), TypeError);
assert.throws(() => some.call(null, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.set.symmetric-difference.js 0000664 0000000 0000000 00000002114 13600575677 0024146 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
QUnit.test('Set#symmetricDifference', assert => {
const { symmetricDifference } = Set.prototype;
const { from } = Array;
assert.isFunction(symmetricDifference);
assert.arity(symmetricDifference, 1);
assert.name(symmetricDifference, 'symmetricDifference');
assert.looksNative(symmetricDifference);
assert.nonEnumerable(Set.prototype, 'symmetricDifference');
const set = new Set([1]);
assert.ok(set.symmetricDifference([2]) !== set);
assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference([4, 5])), [1, 2, 3, 4, 5]);
assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference([3, 4])), [1, 2, 4]);
assert.deepEqual(from(new Set([1, 2, 3]).symmetricDifference(createIterable([3, 4]))), [1, 2, 4]);
assert.throws(() => new Set([1, 2, 3]).symmetricDifference(), TypeError);
assert.throws(() => symmetricDifference.call({}, [1, 2, 3]), TypeError);
assert.throws(() => symmetricDifference.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => symmetricDifference.call(null, [1, 2, 3]), TypeError);
});
core-js-3.6.1/tests/tests/esnext.set.union.js 0000664 0000000 0000000 00000001562 13600575677 0021200 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
QUnit.test('Set#union', assert => {
const { union } = Set.prototype;
const { from } = Array;
assert.isFunction(union);
assert.arity(union, 1);
assert.name(union, 'union');
assert.looksNative(union);
assert.nonEnumerable(Set.prototype, 'union');
const set = new Set([1]);
assert.ok(set.union([2]) !== set);
assert.deepEqual(from(new Set([1, 2, 3]).union([4, 5])), [1, 2, 3, 4, 5]);
assert.deepEqual(from(new Set([1, 2, 3]).union([3, 4])), [1, 2, 3, 4]);
assert.deepEqual(from(new Set([1, 2, 3]).union(createIterable([3, 4]))), [1, 2, 3, 4]);
assert.throws(() => new Set([1, 2, 3]).union(), TypeError);
assert.throws(() => union.call({}, [1, 2, 3]), TypeError);
assert.throws(() => union.call(undefined, [1, 2, 3]), TypeError);
assert.throws(() => union.call(null, [1, 2, 3]), TypeError);
});
core-js-3.6.1/tests/tests/esnext.string.at.js 0000664 0000000 0000000 00000011164 13600575677 0021166 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
QUnit.test('String#at', assert => {
const { at } = String.prototype;
assert.isFunction(at);
assert.arity(at, 1);
assert.name(at, 'at');
assert.looksNative(at);
assert.nonEnumerable(String.prototype, 'at');
// String that starts with a BMP symbol
assert.strictEqual('abc\uD834\uDF06def'.at(-Infinity), '');
assert.strictEqual('abc\uD834\uDF06def'.at(-1), '');
assert.strictEqual('abc\uD834\uDF06def'.at(-0), 'a');
assert.strictEqual('abc\uD834\uDF06def'.at(+0), 'a');
assert.strictEqual('abc\uD834\uDF06def'.at(1), 'b');
assert.strictEqual('abc\uD834\uDF06def'.at(3), '\uD834\uDF06');
assert.strictEqual('abc\uD834\uDF06def'.at(4), '\uDF06');
assert.strictEqual('abc\uD834\uDF06def'.at(5), 'd');
assert.strictEqual('abc\uD834\uDF06def'.at(42), '');
assert.strictEqual('abc\uD834\uDF06def'.at(Infinity), '');
assert.strictEqual('abc\uD834\uDF06def'.at(null), 'a');
assert.strictEqual('abc\uD834\uDF06def'.at(undefined), 'a');
assert.strictEqual('abc\uD834\uDF06def'.at(), 'a');
assert.strictEqual('abc\uD834\uDF06def'.at(false), 'a');
assert.strictEqual('abc\uD834\uDF06def'.at(NaN), 'a');
assert.strictEqual('abc\uD834\uDF06def'.at(''), 'a');
assert.strictEqual('abc\uD834\uDF06def'.at('_'), 'a');
assert.strictEqual('abc\uD834\uDF06def'.at('1'), 'b');
assert.strictEqual('abc\uD834\uDF06def'.at([]), 'a');
assert.strictEqual('abc\uD834\uDF06def'.at({}), 'a');
assert.strictEqual('abc\uD834\uDF06def'.at(-0.9), 'a');
assert.strictEqual('abc\uD834\uDF06def'.at(1.9), 'b');
assert.strictEqual('abc\uD834\uDF06def'.at(7.9), 'f');
assert.strictEqual('abc\uD834\uDF06def'.at(2 ** 32), '');
// String that starts with an astral symbol
assert.strictEqual('\uD834\uDF06def'.at(-Infinity), '');
assert.strictEqual('\uD834\uDF06def'.at(-1), '');
assert.strictEqual('\uD834\uDF06def'.at(-0), '\uD834\uDF06');
assert.strictEqual('\uD834\uDF06def'.at(0), '\uD834\uDF06');
assert.strictEqual('\uD834\uDF06def'.at(1), '\uDF06');
assert.strictEqual('\uD834\uDF06def'.at(2), 'd');
assert.strictEqual('\uD834\uDF06def'.at(3), 'e');
assert.strictEqual('\uD834\uDF06def'.at(4), 'f');
assert.strictEqual('\uD834\uDF06def'.at(42), '');
assert.strictEqual('\uD834\uDF06def'.at(Infinity), '');
assert.strictEqual('\uD834\uDF06def'.at(null), '\uD834\uDF06');
assert.strictEqual('\uD834\uDF06def'.at(undefined), '\uD834\uDF06');
assert.strictEqual('\uD834\uDF06def'.at(), '\uD834\uDF06');
assert.strictEqual('\uD834\uDF06def'.at(false), '\uD834\uDF06');
assert.strictEqual('\uD834\uDF06def'.at(NaN), '\uD834\uDF06');
assert.strictEqual('\uD834\uDF06def'.at(''), '\uD834\uDF06');
assert.strictEqual('\uD834\uDF06def'.at('_'), '\uD834\uDF06');
assert.strictEqual('\uD834\uDF06def'.at('1'), '\uDF06');
// Lone high surrogates
assert.strictEqual('\uD834abc'.at(-Infinity), '');
assert.strictEqual('\uD834abc'.at(-1), '');
assert.strictEqual('\uD834abc'.at(-0), '\uD834');
assert.strictEqual('\uD834abc'.at(0), '\uD834');
assert.strictEqual('\uD834abc'.at(1), 'a');
assert.strictEqual('\uD834abc'.at(42), '');
assert.strictEqual('\uD834abc'.at(Infinity), '');
assert.strictEqual('\uD834abc'.at(null), '\uD834');
assert.strictEqual('\uD834abc'.at(undefined), '\uD834');
assert.strictEqual('\uD834abc'.at(), '\uD834');
assert.strictEqual('\uD834abc'.at(false), '\uD834');
assert.strictEqual('\uD834abc'.at(NaN), '\uD834');
assert.strictEqual('\uD834abc'.at(''), '\uD834');
assert.strictEqual('\uD834abc'.at('_'), '\uD834');
assert.strictEqual('\uD834abc'.at('1'), 'a');
// Lone low surrogates
assert.strictEqual('\uDF06abc'.at(-Infinity), '');
assert.strictEqual('\uDF06abc'.at(-1), '');
assert.strictEqual('\uDF06abc'.at(-0), '\uDF06');
assert.strictEqual('\uDF06abc'.at(0), '\uDF06');
assert.strictEqual('\uDF06abc'.at(1), 'a');
assert.strictEqual('\uDF06abc'.at(42), '');
assert.strictEqual('\uDF06abc'.at(Infinity), '');
assert.strictEqual('\uDF06abc'.at(null), '\uDF06');
assert.strictEqual('\uDF06abc'.at(undefined), '\uDF06');
assert.strictEqual('\uDF06abc'.at(), '\uDF06');
assert.strictEqual('\uDF06abc'.at(false), '\uDF06');
assert.strictEqual('\uDF06abc'.at(NaN), '\uDF06');
assert.strictEqual('\uDF06abc'.at(''), '\uDF06');
assert.strictEqual('\uDF06abc'.at('_'), '\uDF06');
assert.strictEqual('\uDF06abc'.at('1'), 'a');
assert.strictEqual(at.call(42, 0), '4');
assert.strictEqual(at.call(42, 1), '2');
assert.strictEqual(at.call({
toString() {
return 'abc';
},
}, 2), 'c');
if (STRICT) {
assert.throws(() => at.call(null, 0), TypeError);
assert.throws(() => at.call(undefined, 0), TypeError);
}
});
core-js-3.6.1/tests/tests/esnext.string.code-points.js 0000664 0000000 0000000 00000002656 13600575677 0023014 0 ustar 00root root 0000000 0000000 import { GLOBAL } from '../helpers/constants';
const Symbol = GLOBAL.Symbol || {};
QUnit.test('String#codePoints', assert => {
const { codePoints } = String.prototype;
assert.isFunction(codePoints);
assert.arity(codePoints, 0);
assert.name(codePoints, 'codePoints');
assert.looksNative(codePoints);
assert.nonEnumerable(String.prototype, 'codePoints');
let iterator = 'qwe'.codePoints();
assert.isIterator(iterator);
assert.isIterable(iterator);
assert.strictEqual(iterator[Symbol.toStringTag], 'String Iterator');
assert.strictEqual(String(iterator), '[object String Iterator]');
assert.deepEqual(iterator.next(), {
value: { codePoint: 113, position: 0 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: { codePoint: 119, position: 1 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: { codePoint: 101, position: 2 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
iterator = '𠮷𠮷𠮷'.codePoints();
assert.deepEqual(iterator.next(), {
value: { codePoint: 134071, position: 0 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: { codePoint: 134071, position: 2 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: { codePoint: 134071, position: 4 },
done: false,
});
assert.deepEqual(iterator.next(), {
value: undefined,
done: true,
});
});
core-js-3.6.1/tests/tests/esnext.string.replace-all.js 0000664 0000000 0000000 00000003241 13600575677 0022740 0 ustar 00root root 0000000 0000000 import { STRICT } from '../helpers/constants';
QUnit.test('String#replaceAll', assert => {
const { replaceAll } = String.prototype;
assert.isFunction(replaceAll);
assert.arity(replaceAll, 2);
assert.name(replaceAll, 'replaceAll');
assert.looksNative(replaceAll);
assert.nonEnumerable(String.prototype, 'replaceAll');
assert.same('q=query+string+parameters'.replaceAll('+', ' '), 'q=query string parameters');
assert.same('foo'.replaceAll('o', {}), 'f[object Object][object Object]');
assert.same('[object Object]x[object Object]'.replaceAll({}, 'y'), 'yxy');
assert.same(replaceAll.call({}, 'bject', 'lolo'), '[ololo Ololo]');
assert.same('aba'.replaceAll('b', (search, i, string) => {
assert.same(search, 'b', '`search` is `b`');
assert.same(i, 1, '`i` is 1');
assert.same(string, 'aba', '`string` is `aba`');
return 'c';
}), 'aca');
const searcher = {
[Symbol.replace](O, replaceValue) {
assert.same(this, searcher, '`this` is `searcher`');
assert.same(String(O), 'aba', '`O` is `aba`');
assert.same(String(replaceValue), 'c', '`replaceValue` is `c`');
return 'foo';
},
};
assert.same('aba'.replaceAll(searcher, 'c'), 'foo');
assert.same('aba'.replaceAll('b'), 'aundefineda');
assert.same('xxx'.replaceAll('', '_'), '_x_x_x_');
if (STRICT) {
assert.throws(() => replaceAll.call(null, 'a', 'b'), TypeError);
assert.throws(() => replaceAll.call(undefined, 'a', 'b'), TypeError);
}
assert.throws(() => 'b.b.b.b.b'.replaceAll(/\./, 'a'), TypeError);
assert.same('b.b.b.b.b'.replaceAll(/\./g, 'a'), 'babababab');
const object = {};
assert.same('[object Object]'.replaceAll(object, 'a'), 'a');
});
core-js-3.6.1/tests/tests/esnext.symbol.async-dispose.js 0000664 0000000 0000000 00000001117 13600575677 0023337 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Symbol.asyncDispose', assert => {
assert.ok('asyncDispose' in Symbol, 'Symbol.asyncDispose available');
assert.nonEnumerable(Symbol, 'asyncDispose');
assert.ok(Object(Symbol.asyncDispose) instanceof Symbol, 'Symbol.asyncDispose is symbol');
if (DESCRIPTORS) {
const descriptor = Object.getOwnPropertyDescriptor(Symbol, 'asyncDispose');
assert.ok(!descriptor.enumerble, 'non-enumerable');
assert.ok(!descriptor.writable, 'non-writable');
assert.ok(!descriptor.configurable, 'non-configurable');
}
});
core-js-3.6.1/tests/tests/esnext.symbol.dispose.js 0000664 0000000 0000000 00000001054 13600575677 0022224 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Symbol.dispose', assert => {
assert.ok('dispose' in Symbol, 'Symbol.dispose available');
assert.nonEnumerable(Symbol, 'dispose');
assert.ok(Object(Symbol.dispose) instanceof Symbol, 'Symbol.dispose is symbol');
if (DESCRIPTORS) {
const descriptor = Object.getOwnPropertyDescriptor(Symbol, 'dispose');
assert.ok(!descriptor.enumerble, 'non-enumerable');
assert.ok(!descriptor.writable, 'non-writable');
assert.ok(!descriptor.configurable, 'non-configurable');
}
});
core-js-3.6.1/tests/tests/esnext.symbol.observable.js 0000664 0000000 0000000 00000001101 13600575677 0022673 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Symbol.observable', assert => {
assert.ok('observable' in Symbol, 'Symbol.observable available');
assert.nonEnumerable(Symbol, 'observable');
assert.ok(Object(Symbol.observable) instanceof Symbol, 'Symbol.observable is symbol');
if (DESCRIPTORS) {
const descriptor = Object.getOwnPropertyDescriptor(Symbol, 'observable');
assert.ok(!descriptor.enumerble, 'non-enumerable');
assert.ok(!descriptor.writable, 'non-writable');
assert.ok(!descriptor.configurable, 'non-configurable');
}
});
core-js-3.6.1/tests/tests/esnext.symbol.pattern-match.js 0000664 0000000 0000000 00000001117 13600575677 0023325 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Symbol.patternMatch', assert => {
assert.ok('patternMatch' in Symbol, 'Symbol.patternMatch available');
assert.nonEnumerable(Symbol, 'patternMatch');
assert.ok(Object(Symbol.patternMatch) instanceof Symbol, 'Symbol.patternMatch is symbol');
if (DESCRIPTORS) {
const descriptor = Object.getOwnPropertyDescriptor(Symbol, 'patternMatch');
assert.ok(!descriptor.enumerble, 'non-enumerable');
assert.ok(!descriptor.writable, 'non-writable');
assert.ok(!descriptor.configurable, 'non-configurable');
}
});
core-js-3.6.1/tests/tests/esnext.symbol.replace-all.js 0000664 0000000 0000000 00000001104 13600575677 0022733 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
QUnit.test('Symbol.replaceAll', assert => {
assert.ok('replaceAll' in Symbol, 'Symbol.replaceAll is available');
assert.nonEnumerable(Symbol, 'replaceAll');
assert.ok(Object(Symbol.replaceAll) instanceof Symbol, 'Symbol.replaceAll is symbol');
if (DESCRIPTORS) {
const descriptor = Object.getOwnPropertyDescriptor(Symbol, 'replaceAll');
assert.ok(!descriptor.enumerble, 'non-enumerable');
assert.ok(!descriptor.writable, 'non-writable');
assert.ok(!descriptor.configurable, 'non-configurable');
}
});
core-js-3.6.1/tests/tests/esnext.weak-map.delete-all.js 0000664 0000000 0000000 00000002755 13600575677 0022774 0 ustar 00root root 0000000 0000000 QUnit.test('WeakMap#deleteAll', assert => {
const { deleteAll } = WeakMap.prototype;
assert.isFunction(deleteAll);
assert.arity(deleteAll, 0);
assert.name(deleteAll, 'deleteAll');
assert.looksNative(deleteAll);
assert.nonEnumerable(WeakMap.prototype, 'deleteAll');
const a = [];
const b = [];
const c = [];
const d = [];
const e = [];
let set = new WeakMap([[a, 1], [b, 2], [c, 3]]);
assert.same(set.deleteAll(a, b), true);
assert.ok(!set.has(a));
assert.ok(!set.has(b));
assert.ok(set.has(c));
assert.ok(!set.has(d));
assert.ok(!set.has(e));
set = new WeakMap([[a, 1], [b, 2], [c, 3]]);
assert.same(set.deleteAll(c, d), false);
assert.ok(set.has(a));
assert.ok(set.has(b));
assert.ok(!set.has(c));
assert.ok(!set.has(d));
assert.ok(!set.has(e));
set = new WeakMap([[a, 1], [b, 2], [c, 3]]);
assert.same(set.deleteAll(d, e), false);
assert.ok(set.has(a));
assert.ok(set.has(b));
assert.ok(set.has(c));
assert.ok(!set.has(d));
assert.ok(!set.has(e));
set = new WeakMap([[a, 1], [b, 2], [c, 3]]);
assert.same(set.deleteAll(), true);
assert.ok(set.has(a));
assert.ok(set.has(b));
assert.ok(set.has(c));
assert.ok(!set.has(d));
assert.ok(!set.has(e));
assert.notThrows(() => !deleteAll.call({ delete() { /* empty */ } }, a, b, c));
assert.throws(() => deleteAll.call({}, a, b, c), TypeError);
assert.throws(() => deleteAll.call(undefined, a, b, c), TypeError);
assert.throws(() => deleteAll.call(null, a, b, c), TypeError);
});
core-js-3.6.1/tests/tests/esnext.weak-map.from.js 0000664 0000000 0000000 00000001572 13600575677 0021723 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
QUnit.test('WeakMap.from', assert => {
const { from } = WeakMap;
assert.isFunction(from);
assert.arity(from, 1);
assert.name(from, 'from');
assert.looksNative(from);
assert.nonEnumerable(WeakMap, 'from');
assert.ok(WeakMap.from() instanceof WeakMap);
const array = [];
assert.same(WeakMap.from([[array, 2]]).get(array), 2);
assert.same(WeakMap.from(createIterable([[array, 2]])).get(array), 2);
const pair = [{}, 1];
const context = {};
WeakMap.from([pair], function (element, index) {
assert.same(element, pair);
assert.same(index, 0);
assert.same(this, context);
return element;
}, context);
assert.throws(() => from([{}, 1]));
let arg = null;
function F(it) {
return arg = it;
}
from.call(F, createIterable([1, 2, 3]), it => it ** 2);
assert.deepEqual(arg, [1, 4, 9]);
});
core-js-3.6.1/tests/tests/esnext.weak-map.of.js 0000664 0000000 0000000 00000000733 13600575677 0021362 0 ustar 00root root 0000000 0000000 QUnit.test('WeakMap.of', assert => {
const { of } = WeakMap;
assert.isFunction(of);
assert.arity(of, 0);
assert.name(of, 'of');
assert.looksNative(of);
assert.nonEnumerable(WeakMap, 'of');
const array = [];
assert.ok(WeakMap.of() instanceof WeakMap);
assert.same(WeakMap.of([array, 2]).get(array), 2);
assert.throws(() => of(1));
let arg = null;
function F(it) {
return arg = it;
}
of.call(F, 1, 2, 3);
assert.deepEqual(arg, [1, 2, 3]);
});
core-js-3.6.1/tests/tests/esnext.weak-map.upsert.js 0000664 0000000 0000000 00000003110 13600575677 0022270 0 ustar 00root root 0000000 0000000 QUnit.test('WeakMap#upsert', assert => {
const { upsert } = WeakMap.prototype;
assert.isFunction(upsert);
assert.arity(upsert, 2);
assert.name(upsert, 'upsert');
assert.looksNative(upsert);
assert.nonEnumerable(WeakMap.prototype, 'upsert');
const a = {};
const b = {};
const map = new WeakMap([[a, 2]]);
assert.same(map.upsert(a, function (value) {
assert.same(arguments.length, 1, 'correct number of callback arguments');
assert.same(value, 2, 'correct value in callback');
return value ** 2;
}, () => {
assert.ok(false, 'should not be called');
return 3;
}), 4, 'returns a correct value');
assert.same(map.upsert(b, value => {
assert.ok(false, 'should not be called');
return value ** 2;
}, function () {
assert.same(arguments.length, 0, 'correct number of callback arguments');
return 3;
}), 3, 'returns a correct value');
assert.same(map.get(a), 4, 'correct result #1');
assert.same(map.get(b), 3, 'correct result #2');
assert.same(new WeakMap([[a, 2]]).upsert(b, null, () => 3), 3);
assert.same(new WeakMap([[a, 2]]).upsert(a, value => value ** 2), 4);
assert.throws(() => new WeakMap().upsert(a), TypeError);
assert.throws(() => upsert.call({}, a, () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call([], a, () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call(undefined, a, () => { /* empty */ }, () => { /* empty */ }), TypeError);
assert.throws(() => upsert.call(null, a, () => { /* empty */ }, () => { /* empty */ }), TypeError);
});
core-js-3.6.1/tests/tests/esnext.weak-set.add-all.js 0000664 0000000 0000000 00000001610 13600575677 0022265 0 ustar 00root root 0000000 0000000 QUnit.test('WeakSet#addAll', assert => {
const { addAll } = WeakSet.prototype;
assert.isFunction(addAll);
assert.arity(addAll, 0);
assert.name(addAll, 'addAll');
assert.looksNative(addAll);
assert.nonEnumerable(WeakSet.prototype, 'addAll');
const a = [];
const b = [];
const c = [];
let set = new WeakSet([a]);
assert.same(set.addAll(b), set);
set = new WeakSet([a]).addAll(b, c);
assert.ok(set.has(a));
assert.ok(set.has(b));
assert.ok(set.has(c));
set = new WeakSet([a]).addAll(a, b);
assert.ok(set.has(a));
assert.ok(set.has(b));
set = new WeakSet([a]).addAll();
assert.ok(set.has(a));
assert.notThrows(() => addAll.call({ add() { /* empty */ } }, a, b, c));
assert.throws(() => addAll.call({}, a, b, c), TypeError);
assert.throws(() => addAll.call(undefined, a, b, c), TypeError);
assert.throws(() => addAll.call(null, a, b, c), TypeError);
});
core-js-3.6.1/tests/tests/esnext.weak-set.delete-all.js 0000664 0000000 0000000 00000002661 13600575677 0023006 0 ustar 00root root 0000000 0000000 QUnit.test('WeakSet#deleteAll', assert => {
const { deleteAll } = WeakSet.prototype;
assert.isFunction(deleteAll);
assert.arity(deleteAll, 0);
assert.name(deleteAll, 'deleteAll');
assert.looksNative(deleteAll);
assert.nonEnumerable(WeakSet.prototype, 'deleteAll');
const a = [];
const b = [];
const c = [];
const d = [];
const e = [];
let set = new WeakSet([a, b, c]);
assert.same(set.deleteAll(a, b), true);
assert.ok(!set.has(a));
assert.ok(!set.has(b));
assert.ok(set.has(c));
assert.ok(!set.has(d));
assert.ok(!set.has(e));
set = new WeakSet([a, b, c]);
assert.same(set.deleteAll(c, d), false);
assert.ok(set.has(a));
assert.ok(set.has(b));
assert.ok(!set.has(c));
assert.ok(!set.has(d));
assert.ok(!set.has(e));
set = new WeakSet([a, b, c]);
assert.same(set.deleteAll(d, e), false);
assert.ok(set.has(a));
assert.ok(set.has(b));
assert.ok(set.has(c));
assert.ok(!set.has(d));
assert.ok(!set.has(e));
set = new WeakSet([a, b, c]);
assert.same(set.deleteAll(), true);
assert.ok(set.has(a));
assert.ok(set.has(b));
assert.ok(set.has(c));
assert.ok(!set.has(d));
assert.ok(!set.has(e));
assert.notThrows(() => !deleteAll.call({ delete() { /* empty */ } }, a, b, c));
assert.throws(() => deleteAll.call({}, a, b, c), TypeError);
assert.throws(() => deleteAll.call(undefined, a, b, c), TypeError);
assert.throws(() => deleteAll.call(null, a, b, c), TypeError);
});
core-js-3.6.1/tests/tests/esnext.weak-set.from.js 0000664 0000000 0000000 00000001542 13600575677 0021736 0 ustar 00root root 0000000 0000000 import { createIterable } from '../helpers/helpers';
QUnit.test('WeakSet.from', assert => {
const { from } = WeakSet;
assert.isFunction(from);
assert.arity(from, 1);
assert.name(from, 'from');
assert.looksNative(from);
assert.nonEnumerable(WeakSet, 'from');
assert.ok(WeakSet.from() instanceof WeakSet);
const array = [];
assert.ok(WeakSet.from([array]).has(array));
assert.ok(WeakSet.from(createIterable([array])).has(array));
const object = {};
const context = {};
WeakSet.from([object], function (element, index) {
assert.same(element, object);
assert.same(index, 0);
assert.same(this, context);
return element;
}, context);
assert.throws(() => from({}));
let arg = null;
function F(it) {
return arg = it;
}
from.call(F, createIterable([1, 2, 3]), it => it ** 2);
assert.deepEqual(arg, [1, 4, 9]);
});
core-js-3.6.1/tests/tests/esnext.weak-set.of.js 0000664 0000000 0000000 00000000712 13600575677 0021375 0 ustar 00root root 0000000 0000000 QUnit.test('WeakSet.of', assert => {
const { of } = WeakSet;
assert.isFunction(of);
assert.arity(of, 0);
assert.name(of, 'of');
assert.looksNative(of);
assert.nonEnumerable(WeakSet, 'of');
const array = [];
assert.ok(WeakSet.of() instanceof WeakSet);
assert.ok(WeakSet.of(array).has(array));
assert.throws(() => of(1));
let arg = null;
function F(it) {
arg = it;
}
of.call(F, 1, 2, 3);
assert.deepEqual(arg, [1, 2, 3]);
});
core-js-3.6.1/tests/tests/index.js 0000664 0000000 0000000 00000024266 13600575677 0017066 0 ustar 00root root 0000000 0000000 /* eslint-disable import/first */
QUnit.module('ES');
import './es.array.concat';
import './es.array.copy-within';
import './es.array.every';
import './es.array.fill';
import './es.array.filter';
import './es.array.find-index';
import './es.array.find';
import './es.array.for-each';
import './es.array.flat';
import './es.array.flat-map';
import './es.array.from';
import './es.array.includes';
import './es.array.index-of';
import './es.array.is-array';
import './es.array.iterator';
import './es.array.join';
import './es.array.last-index-of';
import './es.array.map';
import './es.array.of';
import './es.array.reduce-right';
import './es.array.reduce';
import './es.array.reverse';
import './es.array.slice';
import './es.array.some';
import './es.array.sort';
import './es.array.splice';
import './es.date.now';
import './es.date.to-iso-string';
import './es.date.to-json';
import './es.date.to-primitive';
import './es.date.to-string';
import './es.function.bind';
import './es.function.has-instance';
import './es.function.name';
import './es.global-this';
import './es.json.stringify';
import './es.map';
import './es.math.acosh';
import './es.math.asinh';
import './es.math.atanh';
import './es.math.cbrt';
import './es.math.clz32';
import './es.math.cosh';
import './es.math.expm1';
import './es.math.fround';
import './es.math.hypot';
import './es.math.imul';
import './es.math.log10';
import './es.math.log1p';
import './es.math.log2';
import './es.math.sign';
import './es.math.sinh';
import './es.math.tanh';
import './es.math.trunc';
import './es.number.constructor';
import './es.number.epsilon';
import './es.number.is-finite';
import './es.number.is-integer';
import './es.number.is-nan';
import './es.number.is-safe-integer';
import './es.number.max-safe-integer';
import './es.number.min-safe-integer';
import './es.number.parse-float';
import './es.number.parse-int';
import './es.number.to-fixed';
import './es.number.to-precision';
import './es.object.assign';
import './es.object.create';
import './es.object.define-getter';
import './es.object.define-properties';
import './es.object.define-property';
import './es.object.define-setter';
import './es.object.entries';
import './es.object.from-entries';
import './es.object.freeze';
import './es.object.get-own-property-descriptor';
import './es.object.get-own-property-descriptors';
import './es.object.get-own-property-names';
import './es.object.get-prototype-of';
import './es.object.is-extensible';
import './es.object.is-frozen';
import './es.object.is-sealed';
import './es.object.is';
import './es.object.keys';
import './es.object.lookup-getter';
import './es.object.lookup-setter';
import './es.object.prevent-extensions';
import './es.object.seal';
import './es.object.set-prototype-of';
import './es.object.to-string';
import './es.object.values';
import './es.parse-float';
import './es.parse-int';
import './es.promise';
import './es.promise.all-settled';
import './es.promise.finally';
import './es.reflect.apply';
import './es.reflect.construct';
import './es.reflect.define-property';
import './es.reflect.delete-property';
import './es.reflect.get-own-property-descriptor';
import './es.reflect.get-prototype-of';
import './es.reflect.get';
import './es.reflect.has';
import './es.reflect.is-extensible';
import './es.reflect.own-keys';
import './es.reflect.prevent-extensions';
import './es.reflect.set-prototype-of';
import './es.reflect.set';
import './es.regexp.constructor';
import './es.regexp.exec';
import './es.regexp.flags';
import './es.regexp.sticky';
import './es.regexp.test';
import './es.regexp.to-string';
import './es.set';
import './es.string.anchor';
import './es.string.big';
import './es.string.blink';
import './es.string.bold';
import './es.string.code-point-at';
import './es.string.ends-with';
import './es.string.fixed';
import './es.string.fontcolor';
import './es.string.fontsize';
import './es.string.from-code-point';
import './es.string.includes';
import './es.string.italics';
import './es.string.iterator';
import './es.string.link';
import './es.string.match';
import './es.string.match-all';
import './es.string.pad-end';
import './es.string.pad-start';
import './es.string.raw';
import './es.string.repeat';
import './es.string.replace';
import './es.string.search';
import './es.string.small';
import './es.string.split';
import './es.string.starts-with';
import './es.string.strike';
import './es.string.sub';
import './es.string.sup';
import './es.string.trim';
import './es.string.trim-start';
import './es.string.trim-end';
import './es.symbol';
import './es.symbol.async-iterator';
import './es.symbol.description';
import './es.array-buffer.constructor';
import './es.array-buffer.is-view';
import './es.array-buffer.slice';
import './es.data-view';
import './es.typed.conversions.float32';
import './es.typed.conversions.float64';
import './es.typed.conversions.int16';
import './es.typed.conversions.int32';
import './es.typed.conversions.int8';
import './es.typed.conversions.uint16';
import './es.typed.conversions.uint32';
import './es.typed.conversions.uint8-clamped';
import './es.typed.conversions.uint8';
import './es.typed-array.constructors';
import './es.typed-array.copy-within';
import './es.typed-array.every';
import './es.typed-array.fill';
import './es.typed-array.filter';
import './es.typed-array.find-index';
import './es.typed-array.find';
import './es.typed-array.for-each';
import './es.typed-array.from';
import './es.typed-array.includes';
import './es.typed-array.index-of';
import './es.typed-array.iterator';
import './es.typed-array.join';
import './es.typed-array.last-index-of';
import './es.typed-array.map';
import './es.typed-array.of';
import './es.typed-array.reduce-right';
import './es.typed-array.reduce';
import './es.typed-array.reverse';
import './es.typed-array.set';
import './es.typed-array.slice';
import './es.typed-array.some';
import './es.typed-array.subarray';
import './es.typed-array.to-locale-string';
import './es.typed-array.to-string';
import './es.weak-map';
import './es.weak-set';
QUnit.module('ESNext');
import './esnext.aggregate-error';
import './esnext.array.is-template-object';
import './esnext.array.last-item';
import './esnext.array.last-index';
import './esnext.async-iterator.constructor';
import './esnext.async-iterator.as-indexed-pairs';
import './esnext.async-iterator.drop';
import './esnext.async-iterator.every';
import './esnext.async-iterator.filter';
import './esnext.async-iterator.find';
import './esnext.async-iterator.flat-map';
import './esnext.async-iterator.for-each';
import './esnext.async-iterator.from';
import './esnext.async-iterator.map';
import './esnext.async-iterator.reduce';
import './esnext.async-iterator.some';
import './esnext.async-iterator.take';
import './esnext.async-iterator.to-array';
import './esnext.composite-key';
import './esnext.composite-symbol';
import './esnext.iterator.constructor';
import './esnext.iterator.as-indexed-pairs';
import './esnext.iterator.drop';
import './esnext.iterator.every';
import './esnext.iterator.filter';
import './esnext.iterator.find';
import './esnext.iterator.flat-map';
import './esnext.iterator.for-each';
import './esnext.iterator.from';
import './esnext.iterator.map';
import './esnext.iterator.reduce';
import './esnext.iterator.some';
import './esnext.iterator.take';
import './esnext.iterator.to-array';
import './esnext.map.from';
import './esnext.map.of';
import './esnext.math.clamp';
import './esnext.math.deg-per-rad';
import './esnext.math.degrees';
import './esnext.math.fscale';
import './esnext.math.iaddh';
import './esnext.math.imulh';
import './esnext.math.isubh';
import './esnext.math.rad-per-deg';
import './esnext.math.radians';
import './esnext.math.scale';
import './esnext.math.signbit';
import './esnext.math.umulh';
import './esnext.math.seeded-prng';
import './esnext.number.from-string';
import './esnext.object.iterate-entries';
import './esnext.object.iterate-keys';
import './esnext.object.iterate-values';
import './esnext.observable';
import './esnext.promise.any';
import './esnext.promise.try';
import './esnext.reflect.define-metadata';
import './esnext.reflect.delete-metadata';
import './esnext.reflect.get-metadata-keys';
import './esnext.reflect.get-metadata';
import './esnext.reflect.get-own-matadata';
import './esnext.reflect.get-own-metadata-keys';
import './esnext.reflect.has-metadata';
import './esnext.reflect.has-own-metadata';
import './esnext.reflect.metadata';
import './esnext.map.delete-all';
import './esnext.map.every';
import './esnext.map.filter';
import './esnext.map.find';
import './esnext.map.find-key';
import './esnext.map.group-by';
import './esnext.map.includes';
import './esnext.map.key-by';
import './esnext.map.key-of';
import './esnext.map.map-keys';
import './esnext.map.map-values';
import './esnext.map.merge';
import './esnext.map.reduce';
import './esnext.map.some';
import './esnext.map.update';
import './esnext.map.update-or-insert';
import './esnext.map.upsert';
import './esnext.set.add-all';
import './esnext.set.delete-all';
import './esnext.set.difference';
import './esnext.set.every';
import './esnext.set.filter';
import './esnext.set.find';
import './esnext.set.from';
import './esnext.set.intersection';
import './esnext.set.is-disjoint-from';
import './esnext.set.is-subset-of';
import './esnext.set.is-superset-of';
import './esnext.set.join';
import './esnext.set.map';
import './esnext.set.of';
import './esnext.set.reduce';
import './esnext.set.some';
import './esnext.set.symmetric-difference';
import './esnext.set.union';
import './esnext.string.at';
import './esnext.string.code-points';
import './esnext.string.replace-all';
import './esnext.symbol.async-dispose';
import './esnext.symbol.dispose';
import './esnext.symbol.observable';
import './esnext.symbol.pattern-match';
import './esnext.symbol.replace-all';
import './esnext.weak-map.delete-all';
import './esnext.weak-map.from';
import './esnext.weak-map.of';
import './esnext.weak-map.upsert';
import './esnext.weak-set.add-all';
import './esnext.weak-set.delete-all';
import './esnext.weak-set.from';
import './esnext.weak-set.of';
QUnit.module('Web');
import './web.dom-collections.for-each';
import './web.dom-collections.iterator';
import './web.immediate';
import './web.queue-microtask';
import './web.timers';
import './web.url';
import './web.url-search-params';
core-js-3.6.1/tests/tests/web.dom-collections.for-each.js 0000664 0000000 0000000 00000001155 13600575677 0023301 0 ustar 00root root 0000000 0000000 import { GLOBAL } from '../helpers/constants';
QUnit.test('forEach method on iterable DOM collections', assert => {
let absent = true;
const collections = [
'NodeList',
'DOMTokenList',
];
for (const name of collections) {
const Collection = GLOBAL[name];
if (Collection) {
absent = false;
assert.isFunction(Collection.prototype.forEach, `${ name }::forEach is a function`);
assert.same(Collection.prototype.forEach, Array.prototype.forEach, `${ name }::forEach is equal of Array::forEach`);
}
}
if (absent) {
assert.ok(true, 'DOM collections are absent');
}
});
core-js-3.6.1/tests/tests/web.dom-collections.iterator.js 0000664 0000000 0000000 00000004350 13600575677 0023446 0 ustar 00root root 0000000 0000000 import { GLOBAL } from '../helpers/constants';
const Symbol = GLOBAL.Symbol || {};
QUnit.test('Iterable DOM collections', assert => {
let absent = true;
let collections = [
'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',
];
for (const name of collections) {
const Collection = GLOBAL[name];
if (Collection) {
assert.same(Collection.prototype[Symbol.toStringTag], name, `${ name }::@@toStringTag is '${ name }'`);
assert.isFunction(Collection.prototype[Symbol.iterator], `${ name }::@@iterator is function`);
absent = false;
}
}
if (GLOBAL.NodeList && GLOBAL.document && document.querySelectorAll && document.querySelectorAll('div') instanceof NodeList) {
assert.isFunction(document.querySelectorAll('div')[Symbol.iterator], 'works with document.querySelectorAll');
}
collections = [
'NodeList',
'DOMTokenList',
];
for (const name of collections) {
const Collection = GLOBAL[name];
if (Collection) {
assert.isFunction(Collection.prototype.values, `${ name }::values is function`);
assert.same(Collection.prototype.values, Array.prototype.values, `${ name }::values is equal of Array::values`);
assert.isFunction(Collection.prototype.keys, `${ name }::keys is function`);
assert.same(Collection.prototype.keys, Array.prototype.keys, `${ name }::keys is equal of Array::keys`);
assert.isFunction(Collection.prototype.entries, `${ name }::entries is function`);
assert.same(Collection.prototype.entries, Array.prototype.entries, `${ name }::entries is equal of Array::entries`);
}
}
if (absent) {
assert.ok(true, 'DOM collections are absent');
}
});
core-js-3.6.1/tests/tests/web.immediate.js 0000664 0000000 0000000 00000002351 13600575677 0020460 0 ustar 00root root 0000000 0000000 import { timeLimitedPromise } from '../helpers/helpers';
QUnit.test('setImmediate / clearImmediate', assert => {
let called = false;
assert.expect(8);
assert.isFunction(setImmediate, 'setImmediate is function');
assert.isFunction(clearImmediate, 'clearImmediate is function');
assert.name(setImmediate, 'setImmediate');
assert.name(clearImmediate, 'clearImmediate');
timeLimitedPromise(1e3, resolve => {
setImmediate(() => {
called = true;
resolve();
});
}).then(() => {
assert.ok(true, 'setImmediate works');
}).catch(() => {
assert.ok(false, 'setImmediate works');
}).then(assert.async());
assert.strictEqual(called, false, 'setImmediate is async');
timeLimitedPromise(1e3, resolve => {
setImmediate((a, b) => {
resolve(a + b);
}, 'a', 'b');
}).then(it => {
assert.strictEqual(it, 'ab', 'setImmediate works with additional args');
}).catch(() => {
assert.ok(false, 'setImmediate works with additional args');
}).then(assert.async());
timeLimitedPromise(50, resolve => {
clearImmediate(setImmediate(resolve));
}).then(() => {
assert.ok(false, 'clearImmediate works');
}).catch(() => {
assert.ok(true, 'clearImmediate works');
}).then(assert.async());
});
core-js-3.6.1/tests/tests/web.queue-microtask.js 0000664 0000000 0000000 00000001054 13600575677 0021637 0 ustar 00root root 0000000 0000000 QUnit.test('queueMicrotask', assert => {
assert.expect(5);
assert.isFunction(queueMicrotask);
assert.arity(queueMicrotask, 1);
assert.name(queueMicrotask, 'queueMicrotask');
assert.looksNative(queueMicrotask);
const async = assert.async();
let done = false;
let after = false;
queueMicrotask(() => {
if (!done) {
done = true;
assert.ok(after, 'works');
async();
}
});
setTimeout(() => {
if (!done) {
done = true;
assert.ok(false, 'fails');
async();
}
}, 3e3);
after = true;
});
core-js-3.6.1/tests/tests/web.timers.js 0000664 0000000 0000000 00000002552 13600575677 0020030 0 ustar 00root root 0000000 0000000 import { timeLimitedPromise } from '../helpers/helpers';
QUnit.test('setTimeout / clearTimeout', assert => {
assert.expect(2);
timeLimitedPromise(1e3, resolve => {
setTimeout((a, b) => { resolve(a + b); }, 10, 'a', 'b');
}).then(it => {
assert.strictEqual(it, 'ab', 'setTimeout works with additional args');
}).catch(() => {
assert.ok(false, 'setTimeout works with additional args');
}).then(assert.async());
timeLimitedPromise(50, resolve => {
clearTimeout(setTimeout(resolve, 10));
}).then(() => {
assert.ok(false, 'clearImmediate works with wraped setTimeout');
}).catch(() => {
assert.ok(true, 'clearImmediate works with wraped setTimeout');
}).then(assert.async());
});
QUnit.test('setInterval / clearInterval', assert => {
assert.expect(1);
timeLimitedPromise(1e4, (resolve, reject) => {
let i = 0;
const interval = setInterval((a, b) => {
if (a + b !== 'ab' || i > 2) reject({ a, b, i });
if (i++ === 2) {
clearInterval(interval);
setTimeout(resolve, 30);
}
}, 5, 'a', 'b');
}).then(() => {
assert.ok(true, 'setInterval & clearInterval works with additional args');
}).catch(error => {
if (!error) error = {};
assert.ok(false, `setInterval & clearInterval works with additional args: ${ error.a }, ${ error.b }, times: ${ error.i }`);
}).then(assert.async());
});
core-js-3.6.1/tests/tests/web.url-search-params.js 0000664 0000000 0000000 00000070777 13600575677 0022071 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import { createIterable } from '../helpers/helpers';
QUnit.test('URLSearchParams', assert => {
assert.isFunction(URLSearchParams);
assert.arity(URLSearchParams, 0);
assert.name(URLSearchParams, 'URLSearchParams');
assert.looksNative(URLSearchParams);
assert.same(String(new URLSearchParams()), '');
assert.same(String(new URLSearchParams('')), '');
assert.same(String(new URLSearchParams('a=b')), 'a=b');
assert.same(String(new URLSearchParams(new URLSearchParams('a=b'))), 'a=b');
assert.same(String(new URLSearchParams([])), '');
assert.same(String(new URLSearchParams([[1, 2], ['a', 'b']])), '1=2&a=b');
assert.same(String(new URLSearchParams(createIterable([createIterable(['a', 'b']), createIterable(['c', 'd'])]))), 'a=b&c=d');
assert.same(String(new URLSearchParams({})), '');
assert.same(String(new URLSearchParams({ 1: 2, a: 'b' })), '1=2&a=b');
assert.same(String(new URLSearchParams('?a=b')), 'a=b', 'leading ? should be ignored');
assert.same(String(new URLSearchParams('??a=b')), '%3Fa=b');
assert.same(String(new URLSearchParams('?')), '');
assert.same(String(new URLSearchParams('??')), '%3F=');
assert.same(String(new URLSearchParams('a=b c')), 'a=b+c');
assert.same(String(new URLSearchParams('a=b&b=c&a=d')), 'a=b&b=c&a=d');
assert.same(String(new URLSearchParams('a==')), 'a=%3D');
assert.same(String(new URLSearchParams('a=b=')), 'a=b%3D');
assert.same(String(new URLSearchParams('a=b=c')), 'a=b%3Dc');
assert.same(String(new URLSearchParams('a==b')), 'a=%3Db');
let params = new URLSearchParams('a=b');
assert.same(params.has('a'), true, 'search params object has name "a"');
assert.same(params.has('b'), false, 'search params object has not got name "b"');
params = new URLSearchParams('a=b&c');
assert.same(params.has('a'), true, 'search params object has name "a"');
assert.same(params.has('c'), true, 'search params object has name "c"');
params = new URLSearchParams('&a&&& &&&&&a+b=& c&m%c3%b8%c3%b8');
assert.same(params.has('a'), true, 'search params object has name "a"');
assert.same(params.has('a b'), true, 'search params object has name "a b"');
assert.same(params.has(' '), true, 'search params object has name " "');
assert.same(params.has('c'), false, 'search params object did not have the name "c"');
assert.same(params.has(' c'), true, 'search params object has name " c"');
assert.same(params.has('møø'), true, 'search params object has name "møø"');
params = new URLSearchParams('a=b+c');
assert.same(params.get('a'), 'b c', 'parse +');
params = new URLSearchParams('a+b=c');
assert.same(params.get('a b'), 'c', 'parse +');
params = new URLSearchParams('a=b c');
assert.same(params.get('a'), 'b c', 'parse " "');
params = new URLSearchParams('a b=c');
assert.same(params.get('a b'), 'c', 'parse " "');
params = new URLSearchParams('a=b%20c');
assert.same(params.get('a'), 'b c', 'parse %20');
params = new URLSearchParams('a%20b=c');
assert.same(params.get('a b'), 'c', 'parse %20');
params = new URLSearchParams('a=b\0c');
assert.same(params.get('a'), 'b\0c', 'parse \\0');
params = new URLSearchParams('a\0b=c');
assert.same(params.get('a\0b'), 'c', 'parse \\0');
params = new URLSearchParams('a=b%00c');
assert.same(params.get('a'), 'b\0c', 'parse %00');
params = new URLSearchParams('a%00b=c');
assert.same(params.get('a\0b'), 'c', 'parse %00');
params = new URLSearchParams('a=b\u2384');
assert.same(params.get('a'), 'b\u2384', 'parse \u2384');
params = new URLSearchParams('a\u2384b=c');
assert.same(params.get('a\u2384b'), 'c', 'parse \u2384');
params = new URLSearchParams('a=b%e2%8e%84');
assert.same(params.get('a'), 'b\u2384', 'parse %e2%8e%84');
params = new URLSearchParams('a%e2%8e%84b=c');
assert.same(params.get('a\u2384b'), 'c', 'parse %e2%8e%84');
params = new URLSearchParams('a=b\uD83D\uDCA9c');
assert.same(params.get('a'), 'b\uD83D\uDCA9c', 'parse \uD83D\uDCA9');
params = new URLSearchParams('a\uD83D\uDCA9b=c');
assert.same(params.get('a\uD83D\uDCA9b'), 'c', 'parse \uD83D\uDCA9');
params = new URLSearchParams('a=b%f0%9f%92%a9c');
assert.same(params.get('a'), 'b\uD83D\uDCA9c', 'parse %f0%9f%92%a9');
params = new URLSearchParams('a%f0%9f%92%a9b=c');
assert.same(params.get('a\uD83D\uDCA9b'), 'c', 'parse %f0%9f%92%a9');
params = new URLSearchParams();
params.set('query', '+15555555555');
assert.same(params.toString(), 'query=%2B15555555555');
assert.same(params.get('query'), '+15555555555', 'parse encoded +');
params = new URLSearchParams(params.toString());
assert.same(params.get('query'), '+15555555555', 'parse encoded +');
const testData = [
{ input: '?a=%', output: [['a', '%']], name: 'handling %' },
{ input: { '+': '%C2' }, output: [['+', '%C2']], name: 'object with +' },
{ input: { c: 'x', a: '?' }, output: [['c', 'x'], ['a', '?']], name: 'object with two keys' },
{ input: [['c', 'x'], ['a', '?']], output: [['c', 'x'], ['a', '?']], name: 'array with two keys' },
// eslint-disable-next-line max-len
// !!! { input: { 'a\0b': '42', 'c\uD83D': '23', dሴ: 'foo' }, output: [['a\0b', '42'], ['c\uFFFD', '23'], ['d\u1234', 'foo']], name: 'object with NULL, non-ASCII, and surrogate keys' },
];
for (const { input, output, name } of testData) {
params = new URLSearchParams(input);
let i = 0;
params.forEach((value, key) => {
const [reqKey, reqValue] = output[i++];
assert.same(key, reqKey, `construct with ${ name }`);
assert.same(value, reqValue, `construct with ${ name }`);
});
}
assert.throws(() => {
URLSearchParams('');
}, 'throws w/o `new`');
assert.throws(() => {
new URLSearchParams([[1, 2, 3]]);
}, 'sequence elements must be pairs #1');
assert.throws(() => {
new URLSearchParams([createIterable([createIterable([1, 2, 3])])]);
}, 'sequence elements must be pairs #2');
assert.throws(() => {
new URLSearchParams([[1]]);
}, 'sequence elements must be pairs #3');
assert.throws(() => {
new URLSearchParams([createIterable([createIterable([1])])]);
}, 'sequence elements must be pairs #4');
});
QUnit.test('URLSearchParams#append', assert => {
const { append } = URLSearchParams.prototype;
assert.isFunction(append);
assert.arity(append, 2);
assert.name(append, 'append');
assert.enumerable(URLSearchParams.prototype, 'append');
assert.looksNative(append);
assert.same(new URLSearchParams().append('a', 'b'), undefined, 'void');
let params = new URLSearchParams();
params.append('a', 'b');
assert.same(String(params), 'a=b');
params.append('a', 'b');
assert.same(String(params), 'a=b&a=b');
params.append('a', 'c');
assert.same(String(params), 'a=b&a=b&a=c');
params = new URLSearchParams();
params.append('', '');
assert.same(String(params), '=');
params.append('', '');
assert.same(String(params), '=&=');
params = new URLSearchParams();
params.append(undefined, undefined);
assert.same(String(params), 'undefined=undefined');
params.append(undefined, undefined);
assert.same(String(params), 'undefined=undefined&undefined=undefined');
params = new URLSearchParams();
params.append(null, null);
assert.same(String(params), 'null=null');
params.append(null, null);
assert.same(String(params), 'null=null&null=null');
params = new URLSearchParams();
params.append('first', 1);
params.append('second', 2);
params.append('third', '');
params.append('first', 10);
assert.ok(params.has('first'), 'search params object has name "first"');
assert.same(params.get('first'), '1', 'search params object has name "first" with value "1"');
assert.same(params.get('second'), '2', 'search params object has name "second" with value "2"');
assert.same(params.get('third'), '', 'search params object has name "third" with value ""');
params.append('first', 10);
assert.same(params.get('first'), '1', 'search params object has name "first" with value "1"');
assert.throws(() => {
return new URLSearchParams('').append();
}, 'throws w/o arguments');
});
QUnit.test('URLSearchParams#delete', assert => {
const $delete = URLSearchParams.prototype.delete;
assert.isFunction($delete);
assert.arity($delete, 1);
assert.enumerable(URLSearchParams.prototype, 'delete');
assert.looksNative($delete);
let params = new URLSearchParams('a=b&c=d');
params.delete('a');
assert.same(String(params), 'c=d');
params = new URLSearchParams('a=a&b=b&a=a&c=c');
params.delete('a');
assert.same(String(params), 'b=b&c=c');
params = new URLSearchParams('a=a&=&b=b&c=c');
params.delete('');
assert.same(String(params), 'a=a&b=b&c=c');
params = new URLSearchParams('a=a&null=null&b=b');
params.delete(null);
assert.same(String(params), 'a=a&b=b');
params = new URLSearchParams('a=a&undefined=undefined&b=b');
params.delete(undefined);
assert.same(String(params), 'a=a&b=b');
params = new URLSearchParams();
params.append('first', 1);
assert.same(params.has('first'), true, 'search params object has name "first"');
assert.same(params.get('first'), '1', 'search params object has name "first" with value "1"');
params.delete('first');
assert.same(params.has('first'), false, 'search params object has no "first" name');
params.append('first', 1);
params.append('first', 10);
params.delete('first');
assert.same(params.has('first'), false, 'search params object has no "first" name');
if (DESCRIPTORS) {
let url = new URL('http://example.com/?param1¶m2');
url.searchParams.delete('param1');
url.searchParams.delete('param2');
assert.same(String(url), 'http://example.com/', 'url.href does not have ?');
assert.same(url.search, '', 'url.search does not have ?');
url = new URL('http://example.com/?');
url.searchParams.delete('param1');
// assert.same(String(url), 'http://example.com/', 'url.href does not have ?'); // Safari bug
assert.same(url.search, '', 'url.search does not have ?');
}
assert.throws(() => {
return new URLSearchParams('').delete();
}, 'throws w/o arguments');
});
QUnit.test('URLSearchParams#get', assert => {
const { get } = URLSearchParams.prototype;
assert.isFunction(get);
assert.arity(get, 1);
assert.name(get, 'get');
assert.enumerable(URLSearchParams.prototype, 'get');
assert.looksNative(get);
let params = new URLSearchParams('a=b&c=d');
assert.same(params.get('a'), 'b');
assert.same(params.get('c'), 'd');
assert.same(params.get('e'), null);
params = new URLSearchParams('a=b&c=d&a=e');
assert.same(params.get('a'), 'b');
params = new URLSearchParams('=b&c=d');
assert.same(params.get(''), 'b');
params = new URLSearchParams('a=&c=d&a=e');
assert.same(params.get('a'), '');
params = new URLSearchParams('first=second&third&&');
assert.same(params.has('first'), true, 'Search params object has name "first"');
assert.same(params.get('first'), 'second', 'Search params object has name "first" with value "second"');
assert.same(params.get('third'), '', 'Search params object has name "third" with the empty value.');
assert.same(params.get('fourth'), null, 'Search params object has no "fourth" name and value.');
assert.same(new URLSearchParams('a=b c').get('a'), 'b c');
assert.same(new URLSearchParams('a b=c').get('a b'), 'c');
assert.same(new URLSearchParams('a=b%20c').get('a'), 'b c', 'parse %20');
assert.same(new URLSearchParams('a%20b=c').get('a b'), 'c', 'parse %20');
assert.same(new URLSearchParams('a=b\0c').get('a'), 'b\0c', 'parse \\0');
assert.same(new URLSearchParams('a\0b=c').get('a\0b'), 'c', 'parse \\0');
assert.same(new URLSearchParams('a=b%2Bc').get('a'), 'b+c', 'parse %2B');
assert.same(new URLSearchParams('a%2Bb=c').get('a+b'), 'c', 'parse %2B');
assert.same(new URLSearchParams('a=b%00c').get('a'), 'b\0c', 'parse %00');
assert.same(new URLSearchParams('a%00b=c').get('a\0b'), 'c', 'parse %00');
assert.same(new URLSearchParams('a==').get('a'), '=', 'parse =');
assert.same(new URLSearchParams('a=b=').get('a'), 'b=', 'parse =');
assert.same(new URLSearchParams('a=b=c').get('a'), 'b=c', 'parse =');
assert.same(new URLSearchParams('a==b').get('a'), '=b', 'parse =');
assert.same(new URLSearchParams('a=b\u2384').get('a'), 'b\u2384', 'parse \\u2384');
assert.same(new URLSearchParams('a\u2384b=c').get('a\u2384b'), 'c', 'parse \\u2384');
assert.same(new URLSearchParams('a=b%e2%8e%84').get('a'), 'b\u2384', 'parse %e2%8e%84');
assert.same(new URLSearchParams('a%e2%8e%84b=c').get('a\u2384b'), 'c', 'parse %e2%8e%84');
assert.same(new URLSearchParams('a=b\uD83D\uDCA9c').get('a'), 'b\uD83D\uDCA9c', 'parse \\uD83D\\uDCA9');
assert.same(new URLSearchParams('a\uD83D\uDCA9b=c').get('a\uD83D\uDCA9b'), 'c', 'parse \\uD83D\\uDCA9');
assert.same(new URLSearchParams('a=b%f0%9f%92%a9c').get('a'), 'b\uD83D\uDCA9c', 'parse %f0%9f%92%a9');
assert.same(new URLSearchParams('a%f0%9f%92%a9b=c').get('a\uD83D\uDCA9b'), 'c', 'parse %f0%9f%92%a9');
assert.same(new URLSearchParams('=').get(''), '', 'parse =');
assert.throws(() => {
return new URLSearchParams('').get();
}, 'throws w/o arguments');
});
QUnit.test('URLSearchParams#getAll', assert => {
const { getAll } = URLSearchParams.prototype;
assert.isFunction(getAll);
assert.arity(getAll, 1);
assert.name(getAll, 'getAll');
assert.enumerable(URLSearchParams.prototype, 'getAll');
assert.looksNative(getAll);
let params = new URLSearchParams('a=b&c=d');
assert.arrayEqual(params.getAll('a'), ['b']);
assert.arrayEqual(params.getAll('c'), ['d']);
assert.arrayEqual(params.getAll('e'), []);
params = new URLSearchParams('a=b&c=d&a=e');
assert.arrayEqual(params.getAll('a'), ['b', 'e']);
params = new URLSearchParams('=b&c=d');
assert.arrayEqual(params.getAll(''), ['b']);
params = new URLSearchParams('a=&c=d&a=e');
assert.arrayEqual(params.getAll('a'), ['', 'e']);
params = new URLSearchParams('a=1&a=2&a=3&a');
assert.arrayEqual(params.getAll('a'), ['1', '2', '3', ''], 'search params object has expected name "a" values');
params.set('a', 'one');
assert.arrayEqual(params.getAll('a'), ['one'], 'search params object has expected name "a" values');
assert.throws(() => {
return new URLSearchParams('').getAll();
}, 'throws w/o arguments');
});
QUnit.test('URLSearchParams#has', assert => {
const { has } = URLSearchParams.prototype;
assert.isFunction(has);
assert.arity(has, 1);
assert.name(has, 'has');
assert.enumerable(URLSearchParams.prototype, 'has');
assert.looksNative(has);
let params = new URLSearchParams('a=b&c=d');
assert.same(params.has('a'), true);
assert.same(params.has('c'), true);
assert.same(params.has('e'), false);
params = new URLSearchParams('a=b&c=d&a=e');
assert.same(params.has('a'), true);
params = new URLSearchParams('=b&c=d');
assert.same(params.has(''), true);
params = new URLSearchParams('null=a');
assert.same(params.has(null), true);
params = new URLSearchParams('a=b&c=d&&');
params.append('first', 1);
params.append('first', 2);
assert.same(params.has('a'), true, 'search params object has name "a"');
assert.same(params.has('c'), true, 'search params object has name "c"');
assert.same(params.has('first'), true, 'search params object has name "first"');
assert.same(params.has('d'), false, 'search params object has no name "d"');
params.delete('first');
assert.same(params.has('first'), false, 'search params object has no name "first"');
assert.throws(() => {
return new URLSearchParams('').has();
}, 'throws w/o arguments');
});
QUnit.test('URLSearchParams#set', assert => {
const { set } = URLSearchParams.prototype;
assert.isFunction(set);
assert.arity(set, 2);
assert.name(set, 'set');
assert.enumerable(URLSearchParams.prototype, 'set');
assert.looksNative(set);
let params = new URLSearchParams('a=b&c=d');
params.set('a', 'B');
assert.same(String(params), 'a=B&c=d');
params = new URLSearchParams('a=b&c=d&a=e');
params.set('a', 'B');
assert.same(String(params), 'a=B&c=d');
params.set('e', 'f');
assert.same(String(params), 'a=B&c=d&e=f');
params = new URLSearchParams('a=1&a=2&a=3');
assert.same(params.has('a'), true, 'search params object has name "a"');
assert.same(params.get('a'), '1', 'search params object has name "a" with value "1"');
params.set('first', 4);
assert.same(params.has('a'), true, 'search params object has name "a"');
assert.same(params.get('a'), '1', 'search params object has name "a" with value "1"');
assert.same(String(params), 'a=1&a=2&a=3&first=4');
params.set('a', 4);
assert.same(params.has('a'), true, 'search params object has name "a"');
assert.same(params.get('a'), '4', 'search params object has name "a" with value "4"');
assert.same(String(params), 'a=4&first=4');
assert.throws(() => {
return new URLSearchParams('').set();
}, 'throws w/o arguments');
});
QUnit.test('URLSearchParams#sort', assert => {
const { sort } = URLSearchParams.prototype;
assert.isFunction(sort);
assert.arity(sort, 0);
assert.name(sort, 'sort');
assert.enumerable(URLSearchParams.prototype, 'sort');
assert.looksNative(sort);
let params = new URLSearchParams('a=1&b=4&a=3&b=2');
params.sort();
assert.same(String(params), 'a=1&a=3&b=4&b=2');
params.delete('a');
params.append('a', '0');
params.append('b', '0');
params.sort();
assert.same(String(params), 'a=0&b=4&b=2&b=0');
const testData = [
{
input: 'z=b&a=b&z=a&a=a',
output: [['a', 'b'], ['a', 'a'], ['z', 'b'], ['z', 'a']],
},
{
input: '\uFFFD=x&\uFFFC&\uFFFD=a',
output: [['\uFFFC', ''], ['\uFFFD', 'x'], ['\uFFFD', 'a']],
},
{
input: 'ffi&🌈', // 🌈 > code point, but < code unit because two code units
output: [['🌈', ''], ['ffi', '']],
},
{
input: 'é&e\uFFFD&e\u0301',
output: [['e\u0301', ''], ['e\uFFFD', ''], ['é', '']],
},
{
input: 'z=z&a=a&z=y&a=b&z=x&a=c&z=w&a=d&z=v&a=e&z=u&a=f&z=t&a=g',
// eslint-disable-next-line max-len
output: [['a', 'a'], ['a', 'b'], ['a', 'c'], ['a', 'd'], ['a', 'e'], ['a', 'f'], ['a', 'g'], ['z', 'z'], ['z', 'y'], ['z', 'x'], ['z', 'w'], ['z', 'v'], ['z', 'u'], ['z', 't']],
},
{
input: 'bbb&bb&aaa&aa=x&aa=y',
output: [['aa', 'x'], ['aa', 'y'], ['aaa', ''], ['bb', ''], ['bbb', '']],
},
{
input: 'z=z&=f&=t&=x',
output: [['', 'f'], ['', 't'], ['', 'x'], ['z', 'z']],
},
{
input: 'a🌈&a💩',
output: [['a🌈', ''], ['a💩', '']],
},
];
for (const { input, output } of testData) {
let i = 0;
params = new URLSearchParams(input);
params.sort();
params.forEach((value, key) => {
const [reqKey, reqValue] = output[i++];
assert.same(key, reqKey);
assert.same(value, reqValue);
});
i = 0;
const url = new URL(`?${ input }`, 'https://example/');
params = url.searchParams;
params.sort();
params.forEach((value, key) => {
const [reqKey, reqValue] = output[i++];
assert.same(key, reqKey);
assert.same(value, reqValue);
});
}
if (DESCRIPTORS) {
const url = new URL('http://example.com/?');
url.searchParams.sort();
assert.same(url.href, 'http://example.com/', 'Sorting non-existent params removes ? from URL');
assert.same(url.search, '', 'Sorting non-existent params removes ? from URL');
}
});
QUnit.test('URLSearchParams#toString', assert => {
const { toString } = URLSearchParams.prototype;
assert.isFunction(toString);
assert.arity(toString, 0);
assert.name(toString, 'toString');
assert.looksNative(toString);
let params = new URLSearchParams();
params.append('a', 'b c');
assert.same(String(params), 'a=b+c');
params.delete('a');
params.append('a b', 'c');
assert.same(String(params), 'a+b=c');
params = new URLSearchParams();
params.append('a', '');
assert.same(String(params), 'a=');
params.append('a', '');
assert.same(String(params), 'a=&a=');
params.append('', 'b');
assert.same(String(params), 'a=&a=&=b');
params.append('', '');
assert.same(String(params), 'a=&a=&=b&=');
params.append('', '');
assert.same(String(params), 'a=&a=&=b&=&=');
params = new URLSearchParams();
params.append('', 'b');
assert.same(String(params), '=b');
params.append('', 'b');
assert.same(String(params), '=b&=b');
params = new URLSearchParams();
params.append('', '');
assert.same(String(params), '=');
params.append('', '');
assert.same(String(params), '=&=');
params = new URLSearchParams();
params.append('a', 'b+c');
assert.same(String(params), 'a=b%2Bc');
params.delete('a');
params.append('a+b', 'c');
assert.same(String(params), 'a%2Bb=c');
params = new URLSearchParams();
params.append('=', 'a');
assert.same(String(params), '%3D=a');
params.append('b', '=');
assert.same(String(params), '%3D=a&b=%3D');
params = new URLSearchParams();
params.append('&', 'a');
assert.same(String(params), '%26=a');
params.append('b', '&');
assert.same(String(params), '%26=a&b=%26');
params = new URLSearchParams();
params.append('a', '\r');
assert.same(String(params), 'a=%0D');
params = new URLSearchParams();
params.append('a', '\n');
assert.same(String(params), 'a=%0A');
params = new URLSearchParams();
params.append('a', '\r\n');
assert.same(String(params), 'a=%0D%0A');
params = new URLSearchParams();
params.append('a', 'b%c');
assert.same(String(params), 'a=b%25c');
params.delete('a');
params.append('a%b', 'c');
assert.same(String(params), 'a%25b=c');
params = new URLSearchParams();
params.append('a', 'b\0c');
assert.same(String(params), 'a=b%00c');
params.delete('a');
params.append('a\0b', 'c');
assert.same(String(params), 'a%00b=c');
params = new URLSearchParams();
params.append('a', 'b\uD83D\uDCA9c');
assert.same(String(params), 'a=b%F0%9F%92%A9c');
params.delete('a');
params.append('a\uD83D\uDCA9b', 'c');
assert.same(String(params), 'a%F0%9F%92%A9b=c');
params = new URLSearchParams('a=b&c=d&&e&&');
assert.same(String(params), 'a=b&c=d&e=');
params = new URLSearchParams('a = b &a=b&c=d%20');
assert.same(String(params), 'a+=+b+&a=b&c=d+');
params = new URLSearchParams('a=&a=b');
assert.same(String(params), 'a=&a=b');
});
QUnit.test('URLSearchParams#forEach', assert => {
const { forEach } = URLSearchParams.prototype;
assert.isFunction(forEach);
assert.arity(forEach, 1);
assert.name(forEach, 'forEach');
assert.enumerable(URLSearchParams.prototype, 'forEach');
assert.looksNative(forEach);
const expectedValues = { a: '1', b: '2', c: '3' };
let params = new URLSearchParams('a=1&b=2&c=3');
let result = '';
params.forEach((value, key, that) => {
assert.same(params.get(key), expectedValues[key]);
assert.same(value, expectedValues[key]);
assert.same(that, params);
result += key;
});
assert.same(result, 'abc');
new URL('http://a.b/c').searchParams.forEach(() => {
assert.ok(false, 'should not be called');
});
// fails in Chrome 66-
if (DESCRIPTORS) {
const url = new URL('http://a.b/c?a=1&b=2&c=3&d=4');
params = url.searchParams;
result = '';
params.forEach((val, key) => {
url.search = 'x=1&y=2&z=3';
result += key + val;
});
assert.same(result, 'a1y2z3');
}
// fails in Chrome 66-
params = new URLSearchParams('a=1&b=2&c=3');
result = '';
params.forEach((value, key) => {
params.delete('b');
result += key + value;
});
assert.same(result, 'a1c3');
});
QUnit.test('URLSearchParams#entries', assert => {
const { entries } = URLSearchParams.prototype;
assert.isFunction(entries);
assert.arity(entries, 0);
assert.name(entries, 'entries');
assert.enumerable(URLSearchParams.prototype, 'entries');
assert.looksNative(entries);
const expectedValues = { a: '1', b: '2', c: '3' };
let params = new URLSearchParams('a=1&b=2&c=3');
let iterator = params.entries();
let result = '';
let entry;
while (!(entry = iterator.next()).done) {
const [key, value] = entry.value;
assert.same(params.get(key), expectedValues[key]);
assert.same(value, expectedValues[key]);
result += key;
}
assert.same(result, 'abc');
assert.ok(new URL('http://a.b/c').searchParams.entries().next().done, 'should be finished');
// fails in Chrome 66-
if (DESCRIPTORS) {
const url = new URL('http://a.b/c?a=1&b=2&c=3&d=4');
iterator = url.searchParams.entries();
result = '';
while (!(entry = iterator.next()).done) {
const [key, value] = entry.value;
url.search = 'x=1&y=2&z=3';
result += key + value;
}
assert.same(result, 'a1y2z3');
}
// fails in Chrome 66-
params = new URLSearchParams('a=1&b=2&c=3');
iterator = params.entries();
result = '';
while (!(entry = iterator.next()).done) {
params.delete('b');
const [key, value] = entry.value;
result += key + value;
}
assert.same(result, 'a1c3');
});
QUnit.test('URLSearchParams#keys', assert => {
const { keys } = URLSearchParams.prototype;
assert.isFunction(keys);
assert.arity(keys, 0);
assert.name(keys, 'keys');
assert.enumerable(URLSearchParams.prototype, 'keys');
assert.looksNative(keys);
let iterator = new URLSearchParams('a=1&b=2&c=3').keys();
let result = '';
let entry;
while (!(entry = iterator.next()).done) {
result += entry.value;
}
assert.same(result, 'abc');
assert.ok(new URL('http://a.b/c').searchParams.keys().next().done, 'should be finished');
// fails in Chrome 66-
if (DESCRIPTORS) {
const url = new URL('http://a.b/c?a=1&b=2&c=3&d=4');
iterator = url.searchParams.keys();
result = '';
while (!(entry = iterator.next()).done) {
const key = entry.value;
url.search = 'x=1&y=2&z=3';
result += key;
}
assert.same(result, 'ayz');
}
// fails in Chrome 66-
const params = new URLSearchParams('a=1&b=2&c=3');
iterator = params.keys();
result = '';
while (!(entry = iterator.next()).done) {
params.delete('b');
const key = entry.value;
result += key;
}
assert.same(result, 'ac');
});
QUnit.test('URLSearchParams#values', assert => {
const { values } = URLSearchParams.prototype;
assert.isFunction(values);
assert.arity(values, 0);
assert.name(values, 'values');
assert.enumerable(URLSearchParams.prototype, 'values');
assert.looksNative(values);
let iterator = new URLSearchParams('a=1&b=2&c=3').values();
let result = '';
let entry;
while (!(entry = iterator.next()).done) {
result += entry.value;
}
assert.same(result, '123');
assert.ok(new URL('http://a.b/c').searchParams.values().next().done, 'should be finished');
// fails in Chrome 66-
if (DESCRIPTORS) {
const url = new URL('http://a.b/c?a=a&b=b&c=c&d=d');
iterator = url.searchParams.keys();
result = '';
while (!(entry = iterator.next()).done) {
const { value } = entry;
url.search = 'x=x&y=y&z=z';
result += value;
}
assert.same(result, 'ayz');
}
// fails in Chrome 66-
const params = new URLSearchParams('a=1&b=2&c=3');
iterator = params.values();
result = '';
while (!(entry = iterator.next()).done) {
params.delete('b');
const key = entry.value;
result += key;
}
assert.same(result, '13');
});
QUnit.test('URLSearchParams#@@iterator', assert => {
const entries = URLSearchParams.prototype[Symbol.iterator];
assert.isFunction(entries);
assert.arity(entries, 0);
assert.name(entries, 'entries');
assert.looksNative(entries);
assert.same(entries, URLSearchParams.prototype.entries);
const expectedValues = { a: '1', b: '2', c: '3' };
let params = new URLSearchParams('a=1&b=2&c=3');
let iterator = params[Symbol.iterator]();
let result = '';
let entry;
while (!(entry = iterator.next()).done) {
const [key, value] = entry.value;
assert.same(params.get(key), expectedValues[key]);
assert.same(value, expectedValues[key]);
result += key;
}
assert.same(result, 'abc');
assert.ok(new URL('http://a.b/c').searchParams[Symbol.iterator]().next().done, 'should be finished');
// fails in Chrome 66-
if (DESCRIPTORS) {
const url = new URL('http://a.b/c?a=1&b=2&c=3&d=4');
iterator = url.searchParams[Symbol.iterator]();
result = '';
while (!(entry = iterator.next()).done) {
const [key, value] = entry.value;
url.search = 'x=1&y=2&z=3';
result += key + value;
}
assert.same(result, 'a1y2z3');
}
// fails in Chrome 66-
params = new URLSearchParams('a=1&b=2&c=3');
iterator = params[Symbol.iterator]();
result = '';
while (!(entry = iterator.next()).done) {
params.delete('b');
const [key, value] = entry.value;
result += key + value;
}
assert.same(result, 'a1c3');
});
QUnit.test('URLSearchParams#@@toStringTag', assert => {
const params = new URLSearchParams('a=b');
assert.same(({}).toString.call(params), '[object URLSearchParams]');
});
core-js-3.6.1/tests/tests/web.url.js 0000664 0000000 0000000 00000067511 13600575677 0017335 0 ustar 00root root 0000000 0000000 import { DESCRIPTORS } from '../helpers/constants';
import urlTestData from '../wpt-url-resources/urltestdata';
import settersTestData from '../wpt-url-resources/setters';
import toASCIITestData from '../wpt-url-resources/toascii';
const { hasOwnProperty } = Object.prototype;
QUnit.test('URL constructor', assert => {
assert.isFunction(URL);
assert.arity(URL, 1);
assert.name(URL, 'URL');
assert.looksNative(URL);
assert.same(String(new URL('http://www.domain.com/a/b')), 'http://www.domain.com/a/b');
assert.same(String(new URL('/c/d', 'http://www.domain.com/a/b')), 'http://www.domain.com/c/d');
assert.same(String(new URL('b/c', 'http://www.domain.com/a/b')), 'http://www.domain.com/a/b/c');
assert.same(String(new URL('b/c', new URL('http://www.domain.com/a/b'))), 'http://www.domain.com/a/b/c');
assert.same(String(new URL({ toString: () => 'https://example.org/' })), 'https://example.org/');
assert.same(String(new URL('nonspecial://example.com/')), 'nonspecial://example.com/');
assert.same(String(new URL('https://測試')), 'https://xn--g6w251d/', 'unicode parsing');
assert.same(String(new URL('https://xxпривет.тест')), 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
assert.same(String(new URL('https://xxПРИВЕТ.тест')), 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
assert.same(String(new URL('http://Example.com/', 'https://example.org/')), 'http://example.com/');
assert.same(String(new URL('https://Example.com/', 'https://example.org/')), 'https://example.com/');
assert.same(String(new URL('nonspecial://Example.com/', 'https://example.org/')), 'nonspecial://Example.com/');
assert.same(String(new URL('http:Example.com/', 'https://example.org/')), 'http://example.com/');
assert.same(String(new URL('https:Example.com/', 'https://example.org/')), 'https://example.org/Example.com/');
assert.same(String(new URL('nonspecial:Example.com/', 'https://example.org/')), 'nonspecial:Example.com/');
assert.same(String(new URL('http://0300.168.0xF0')), 'http://192.168.0.240/');
assert.same(String(new URL('http://[20:0:0:1:0:0:0:ff]')), 'http://[20:0:0:1::ff]/');
// assert.same(String(new URL('http://257.168.0xF0')), 'http://257.168.0xf0/', 'incorrect IPv4 parsed as host'); // TypeError in Chrome and Safari
assert.same(String(new URL('http://0300.168.0xG0')), 'http://0300.168.0xg0/', 'incorrect IPv4 parsed as host');
assert.same(String(new URL('file:///var/log/system.log')), 'file:///var/log/system.log', 'file scheme');
// assert.same(String(new URL('file://nnsc.nsf.net/bar/baz')), 'file://nnsc.nsf.net/bar/baz', 'file scheme'); // 'file:///bar/baz' in FF
// assert.same(String(new URL('file://localhost/bar/baz')), 'file:///bar/baz', 'file scheme'); // 'file://localhost/bar/baz' in Chrome
assert.throws(() => new URL(), 'TypeError: Failed to construct \'URL\': 1 argument required, but only 0 present.');
assert.throws(() => new URL(''), 'TypeError: Failed to construct \'URL\': Invalid URL');
assert.throws(() => new URL('', 'about:blank'), 'TypeError: Failed to construct \'URL\': Invalid URL');
assert.throws(() => new URL('abc'), 'TypeError: Failed to construct \'URL\': Invalid URL');
assert.throws(() => new URL('//abc'), 'TypeError: Failed to construct \'URL\': Invalid URL');
assert.throws(() => new URL('http:///www.domain.com/', 'abc'), 'TypeError: Failed to construct \'URL\': Invalid base URL');
assert.throws(() => new URL('http:///www.domain.com/', null), 'TypeError: Failed to construct \'URL\': Invalid base URL');
assert.throws(() => new URL('//abc', null), 'TypeError: Failed to construct \'URL\': Invalid base URL');
assert.throws(() => new URL('http://[20:0:0:1:0:0:0:ff'), 'incorrect IPv6');
assert.throws(() => new URL('http://[20:0:0:1:0:0:0:fg]'), 'incorrect IPv6');
// assert.throws(() => new URL('http://a%b'), 'forbidden host code point'); // no error in FF
assert.throws(() => new URL('1http://zloirock.ru'), 'incorrect scheme');
});
QUnit.test('URL#href', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'href'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'href');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.href, 'http://zloirock.ru/');
if (DESCRIPTORS) {
url.searchParams.append('foo', 'bar');
assert.same(url.href, 'http://zloirock.ru/?foo=bar');
url = new URL('http://zloirock.ru/foo');
url.href = 'https://測試';
assert.same(url.href, 'https://xn--g6w251d/', 'unicode parsing');
assert.same(String(url), 'https://xn--g6w251d/', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.href = 'https://xxпривет.тест';
assert.same(url.href, 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
assert.same(String(url), 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.href = 'https://xxПРИВЕТ.тест';
assert.same(url.href, 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
assert.same(String(url), 'https://xn--xx-flcmn5bht.xn--e1aybc/', 'unicode parsing');
url = new URL('http://zloirock.ru/');
url.href = 'http://0300.168.0xF0';
assert.same(url.href, 'http://192.168.0.240/');
assert.same(String(url), 'http://192.168.0.240/');
url = new URL('http://zloirock.ru/');
url.href = 'http://[20:0:0:1:0:0:0:ff]';
assert.same(url.href, 'http://[20:0:0:1::ff]/');
assert.same(String(url), 'http://[20:0:0:1::ff]/');
// url = new URL('http://zloirock.ru/');
// url.href = 'http://257.168.0xF0'; // TypeError and Safari
// assert.same(url.href, 'http://257.168.0xf0/', 'incorrect IPv4 parsed as host'); // `F` instead of `f` in Chrome
// assert.same(String(url), 'http://257.168.0xf0/', 'incorrect IPv4 parsed as host'); // `F` instead of `f` in Chrome
url = new URL('http://zloirock.ru/');
url.href = 'http://0300.168.0xG0';
assert.same(url.href, 'http://0300.168.0xg0/', 'incorrect IPv4 parsed as host');
assert.same(String(url), 'http://0300.168.0xg0/', 'incorrect IPv4 parsed as host');
url = new URL('http://192.168.0.240/');
url.href = 'file:///var/log/system.log';
assert.same(url.href, 'file:///var/log/system.log', 'file -> ip');
assert.same(String(url), 'file:///var/log/system.log', 'file -> ip');
url = new URL('file:///var/log/system.log');
url.href = 'http://0300.168.0xF0';
assert.same(url.href, 'http://192.168.0.240/', 'file -> http');
assert.same(String(url), 'http://192.168.0.240/', 'file -> http');
// assert.throws(() => new URL('http://zloirock.ru/').href = undefined, 'incorrect URL'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = '', 'incorrect URL'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = 'abc', 'incorrect URL'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = '//abc', 'incorrect URL'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = 'http://[20:0:0:1:0:0:0:ff', 'incorrect IPv6'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = 'http://[20:0:0:1:0:0:0:fg]', 'incorrect IPv6'); // no error in Chrome
// assert.throws(() => new URL('http://zloirock.ru/').href = 'http://a%b', 'forbidden host code point'); // no error in Chrome and FF
// assert.throws(() => new URL('http://zloirock.ru/').href = '1http://zloirock.ru', 'incorrect scheme'); // no error in Chrome
}
});
QUnit.test('URL#origin', assert => {
const url = new URL('http://es6.zloirock.ru/tests.html');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'origin'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'origin');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
}
assert.same(url.origin, 'http://es6.zloirock.ru');
assert.same(new URL('https://測試/tests').origin, 'https://xn--g6w251d');
});
QUnit.test('URL#protocol', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'protocol'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'protocol');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.protocol, 'http:');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.protocol = 'https';
assert.same(url.protocol, 'https:');
assert.same(String(url), 'https://zloirock.ru/');
// https://nodejs.org/api/url.html#url_special_schemes
// url = new URL('http://zloirock.ru/');
// url.protocol = 'fish';
// assert.same(url.protocol, 'http:');
// assert.same(url.href, 'http://zloirock.ru/');
// assert.same(String(url), 'http://zloirock.ru/');
url = new URL('http://zloirock.ru/');
url.protocol = '1http';
assert.same(url.protocol, 'http:');
assert.same(url.href, 'http://zloirock.ru/', 'incorrect scheme');
assert.same(String(url), 'http://zloirock.ru/', 'incorrect scheme');
}
});
QUnit.test('URL#username', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'username'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'username');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.username, '');
url = new URL('http://username@zloirock.ru/');
assert.same(url.username, 'username');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.username = 'username';
assert.same(url.username, 'username');
assert.same(String(url), 'http://username@zloirock.ru/');
}
});
QUnit.test('URL#password', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'password'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'password');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.password, '');
url = new URL('http://username:password@zloirock.ru/');
assert.same(url.password, 'password');
// url = new URL('http://:password@zloirock.ru/'); // TypeError in FF
// assert.same(url.password, 'password');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.username = 'username';
url.password = 'password';
assert.same(url.password, 'password');
assert.same(String(url), 'http://username:password@zloirock.ru/');
// url = new URL('http://zloirock.ru/');
// url.password = 'password';
// assert.same(url.password, 'password'); // '' in FF
// assert.same(String(url), 'http://:password@zloirock.ru/'); // 'http://zloirock.ru/' in FF
}
});
QUnit.test('URL#host', assert => {
let url = new URL('http://zloirock.ru:81/path');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'host'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'host');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.host, 'zloirock.ru:81');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru:81/path');
url.host = 'example.com:82';
assert.same(url.host, 'example.com:82');
assert.same(String(url), 'http://example.com:82/path');
// url = new URL('http://zloirock.ru:81/path');
// url.host = 'other?domain.com';
// assert.same(String(url), 'http://other:81/path'); // 'http://other/?domain.com/path' in Safari
url = new URL('https://www.mydomain.com:8080/path/');
url.host = 'www.otherdomain.com:80';
assert.same(url.href, 'https://www.otherdomain.com:80/path/', 'set default port for another protocol');
// url = new URL('https://www.mydomain.com:8080/path/');
// url.host = 'www.otherdomain.com:443';
// assert.same(url.href, 'https://www.otherdomain.com/path/', 'set default port');
url = new URL('http://zloirock.ru/foo');
url.host = '測試';
assert.same(url.host, 'xn--g6w251d', 'unicode parsing');
assert.same(String(url), 'http://xn--g6w251d/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.host = 'xxпривет.тест';
assert.same(url.host, 'xn--xx-flcmn5bht.xn--e1aybc', 'unicode parsing');
assert.same(String(url), 'http://xn--xx-flcmn5bht.xn--e1aybc/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.host = 'xxПРИВЕТ.тест';
assert.same(url.host, 'xn--xx-flcmn5bht.xn--e1aybc', 'unicode parsing');
assert.same(String(url), 'http://xn--xx-flcmn5bht.xn--e1aybc/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.host = '0300.168.0xF0';
assert.same(url.host, '192.168.0.240');
assert.same(String(url), 'http://192.168.0.240/foo');
// url = new URL('http://zloirock.ru/foo');
// url.host = '[20:0:0:1:0:0:0:ff]';
// assert.same(url.host, '[20:0:0:1::ff]'); // ':0' in Chrome, 'zloirock.ru' in Safari
// assert.same(String(url), 'http://[20:0:0:1::ff]/foo'); // 'http://[20:0/foo' in Chrome, 'http://zloirock.ru/foo' in Safari
// url = new URL('file:///var/log/system.log');
// url.host = 'nnsc.nsf.net'; // does not work in FF
// assert.same(url.hostname, 'nnsc.nsf.net', 'file');
// assert.same(String(url), 'file://nnsc.nsf.net/var/log/system.log', 'file');
// url = new URL('http://zloirock.ru/');
// url.host = '[20:0:0:1:0:0:0:ff';
// assert.same(url.host, 'zloirock.ru', 'incorrect IPv6'); // ':0' in Chrome
// assert.same(String(url), 'http://zloirock.ru/', 'incorrect IPv6'); // 'http://[20:0/' in Chrome
// url = new URL('http://zloirock.ru/');
// url.host = '[20:0:0:1:0:0:0:fg]';
// assert.same(url.host, 'zloirock.ru', 'incorrect IPv6'); // ':0' in Chrome
// assert.same(String(url), 'http://zloirock.ru/', 'incorrect IPv6'); // 'http://[20:0/' in Chrome
// url = new URL('http://zloirock.ru/');
// url.host = 'a%b';
// assert.same(url.host, 'zloirock.ru', 'forbidden host code point'); // '' in Chrome, 'a%b' in FF
// assert.same(String(url), 'http://zloirock.ru/', 'forbidden host code point'); // 'http://a%25b/' in Chrome, 'http://a%b/' in FF
}
});
QUnit.test('URL#hostname', assert => {
let url = new URL('http://zloirock.ru:81/');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'hostname'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'hostname');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.hostname, 'zloirock.ru');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru:81/');
url.hostname = 'example.com';
assert.same(url.hostname, 'example.com');
assert.same(String(url), 'http://example.com:81/');
// url = new URL('http://zloirock.ru:81/');
// url.hostname = 'example.com:82';
// assert.same(url.hostname, 'example.com'); // '' in Chrome
// assert.same(String(url), 'http://example.com:81/'); // 'ttp://example.com:82:81/' in Chrome
url = new URL('http://zloirock.ru/foo');
url.hostname = '測試';
assert.same(url.hostname, 'xn--g6w251d', 'unicode parsing');
assert.same(String(url), 'http://xn--g6w251d/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.hostname = 'xxпривет.тест';
assert.same(url.hostname, 'xn--xx-flcmn5bht.xn--e1aybc', 'unicode parsing');
assert.same(String(url), 'http://xn--xx-flcmn5bht.xn--e1aybc/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.hostname = 'xxПРИВЕТ.тест';
assert.same(url.hostname, 'xn--xx-flcmn5bht.xn--e1aybc', 'unicode parsing');
assert.same(String(url), 'http://xn--xx-flcmn5bht.xn--e1aybc/foo', 'unicode parsing');
url = new URL('http://zloirock.ru/foo');
url.hostname = '0300.168.0xF0';
assert.same(url.hostname, '192.168.0.240');
assert.same(String(url), 'http://192.168.0.240/foo');
// url = new URL('http://zloirock.ru/foo');
// url.hostname = '[20:0:0:1:0:0:0:ff]';
// assert.same(url.hostname, '[20:0:0:1::ff]'); // 'zloirock.ru' in Safari
// assert.same(String(url), 'http://[20:0:0:1::ff]/foo'); // 'http://zloirock.ru/foo' in Safari
// url = new URL('file:///var/log/system.log');
// url.hostname = 'nnsc.nsf.net'; // does not work in FF
// assert.same(url.hostname, 'nnsc.nsf.net', 'file');
// assert.same(String(url), 'file://nnsc.nsf.net/var/log/system.log', 'file');
// url = new URL('http://zloirock.ru/');
// url.hostname = '[20:0:0:1:0:0:0:ff';
// assert.same(url.hostname, 'zloirock.ru', 'incorrect IPv6'); // '' in Chrome
// assert.same(String(url), 'http://zloirock.ru/', 'incorrect IPv6'); // 'http://[20:0:0:1:0:0:0:ff' in Chrome
// url = new URL('http://zloirock.ru/');
// url.hostname = '[20:0:0:1:0:0:0:fg]';
// assert.same(url.hostname, 'zloirock.ru', 'incorrect IPv6'); // '' in Chrome
// assert.same(String(url), 'http://zloirock.ru/', 'incorrect IPv6'); // 'http://[20:0:0:1:0:0:0:ff/' in Chrome
// url = new URL('http://zloirock.ru/');
// url.hostname = 'a%b';
// assert.same(url.hostname, 'zloirock.ru', 'forbidden host code point'); // '' in Chrome, 'a%b' in FF
// assert.same(String(url), 'http://zloirock.ru/', 'forbidden host code point'); // 'http://a%25b/' in Chrome, 'http://a%b/' in FF
}
});
QUnit.test('URL#port', assert => {
let url = new URL('http://zloirock.ru:1337/');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'port'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'port');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.port, '1337');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.port = 80;
assert.same(url.port, '');
assert.same(String(url), 'http://zloirock.ru/');
url.port = 1337;
assert.same(url.port, '1337');
assert.same(String(url), 'http://zloirock.ru:1337/');
// url.port = 'abcd';
// assert.same(url.port, '1337'); // '0' in Chrome
// assert.same(String(url), 'http://zloirock.ru:1337/'); // 'http://zloirock.ru:0/' in Chrome
// url.port = '5678abcd';
// assert.same(url.port, '5678'); // '1337' in FF
// assert.same(String(url), 'http://zloirock.ru:5678/'); // 'http://zloirock.ru:1337/"' in FF
url.port = 1234.5678;
assert.same(url.port, '1234');
assert.same(String(url), 'http://zloirock.ru:1234/');
// url.port = 1e10;
// assert.same(url.port, '1234'); // '0' in Chrome
// assert.same(String(url), 'http://zloirock.ru:1234/'); // 'http://zloirock.ru:0/' in Chrome
}
});
QUnit.test('URL#pathname', assert => {
let url = new URL('http://zloirock.ru/foo/bar');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'pathname'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'pathname');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.pathname, '/foo/bar');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.pathname = 'bar/baz';
assert.same(url.pathname, '/bar/baz');
assert.same(String(url), 'http://zloirock.ru/bar/baz');
}
});
QUnit.test('URL#search', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'search'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'search');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.search, '');
url = new URL('http://zloirock.ru/?foo=bar');
assert.same(url.search, '?foo=bar');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/?');
assert.same(url.search, '');
assert.same(String(url), 'http://zloirock.ru/?');
url.search = 'foo=bar';
assert.same(url.search, '?foo=bar');
assert.same(String(url), 'http://zloirock.ru/?foo=bar');
url.search = '?bar=baz';
assert.same(url.search, '?bar=baz');
assert.same(String(url), 'http://zloirock.ru/?bar=baz');
url.search = '';
assert.same(url.search, '');
assert.same(String(url), 'http://zloirock.ru/');
}
});
QUnit.test('URL#searchParams', assert => {
let url = new URL('http://zloirock.ru/?foo=bar&bar=baz');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'searchParams'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'searchParams');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
}
assert.ok(url.searchParams instanceof URLSearchParams);
assert.same(url.searchParams.get('foo'), 'bar');
assert.same(url.searchParams.get('bar'), 'baz');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/');
url.searchParams.append('foo', 'bar');
assert.same(String(url), 'http://zloirock.ru/?foo=bar');
url = new URL('http://zloirock.ru/');
url.search = 'foo=bar';
assert.same(url.searchParams.get('foo'), 'bar');
url = new URL('http://zloirock.ru/?foo=bar&bar=baz');
url.search = '';
assert.same(url.searchParams.has('foo'), false);
}
});
QUnit.test('URL#hash', assert => {
let url = new URL('http://zloirock.ru/');
if (DESCRIPTORS) {
assert.ok(!hasOwnProperty.call(url, 'hash'));
const descriptor = Object.getOwnPropertyDescriptor(URL.prototype, 'hash');
assert.same(descriptor.enumerable, true);
assert.same(descriptor.configurable, true);
assert.same(typeof descriptor.get, 'function');
assert.same(typeof descriptor.set, 'function');
}
assert.same(url.hash, '');
url = new URL('http://zloirock.ru/#foo');
assert.same(url.hash, '#foo');
url = new URL('http://zloirock.ru/#');
assert.same(url.hash, '');
assert.same(String(url), 'http://zloirock.ru/#');
if (DESCRIPTORS) {
url = new URL('http://zloirock.ru/#');
url.hash = 'foo';
assert.same(url.hash, '#foo');
assert.same(String(url), 'http://zloirock.ru/#foo');
url.hash = '';
assert.same(url.hash, '');
assert.same(String(url), 'http://zloirock.ru/');
// url.hash = '#';
// assert.same(url.hash, '');
// assert.same(String(url), 'http://zloirock.ru/'); // 'http://zloirock.ru/#' in FF
url.hash = '#foo';
assert.same(url.hash, '#foo');
assert.same(String(url), 'http://zloirock.ru/#foo');
url.hash = '#foo#bar';
assert.same(url.hash, '#foo#bar');
assert.same(String(url), 'http://zloirock.ru/#foo#bar');
url = new URL('http://zloirock.ru/');
url.hash = 'абa';
assert.same(url.hash, '#%D0%B0%D0%B1a');
// url = new URL('http://zloirock.ru/');
// url.hash = '\udc01\ud802a';
// assert.same(url.hash, '#%EF%BF%BD%EF%BF%BDa', 'unmatched surrogates');
}
});
QUnit.test('URL#toJSON', assert => {
const { toJSON } = URL.prototype;
assert.isFunction(toJSON);
assert.arity(toJSON, 0);
assert.name(toJSON, 'toJSON');
assert.enumerable(URL.prototype, 'toJSON');
assert.looksNative(toJSON);
const url = new URL('http://zloirock.ru/');
assert.same(url.toJSON(), 'http://zloirock.ru/');
if (DESCRIPTORS) {
url.searchParams.append('foo', 'bar');
assert.same(url.toJSON(), 'http://zloirock.ru/?foo=bar');
}
});
QUnit.test('URL#toString', assert => {
const { toString } = URL.prototype;
assert.isFunction(toString);
assert.arity(toString, 0);
assert.name(toString, 'toString');
assert.enumerable(URL.prototype, 'toString');
assert.looksNative(toString);
const url = new URL('http://zloirock.ru/');
assert.same(url.toString(), 'http://zloirock.ru/');
if (DESCRIPTORS) {
url.searchParams.append('foo', 'bar');
assert.same(url.toString(), 'http://zloirock.ru/?foo=bar');
}
});
QUnit.test('URL#@@toStringTag', assert => {
const url = new URL('http://zloirock.ru/');
assert.same(({}).toString.call(url), '[object URL]');
});
QUnit.test('URL.sham', assert => {
assert.same(URL.sham, DESCRIPTORS ? undefined : true);
});
// `core-js` URL implementation pass all (exclude some encoding-ralated) tests
// from the next 3 test cases, but URLs from all of popular browsers fail a serious part of tests.
// Replacing all of them does not looks like a good idea, so next test cases disabled by default.
// see https://github.com/web-platform-tests/wpt/blob/master/url
QUnit.skip('WPT URL constructor tests', assert => {
for (const expected of urlTestData) {
if (typeof expected == 'string') continue;
const name = `Parsing: <${ expected.input }> against <${ expected.base }>`;
if (expected.failure) {
assert.throws(() => new URL(expected.input, expected.base || 'about:blank'), name);
} else {
const url = new URL(expected.input, expected.base || 'about:blank');
assert.same(url.href, expected.href, `${ name }: href`);
assert.same(url.protocol, expected.protocol, `${ name }: protocol`);
assert.same(url.username, expected.username, `${ name }: username`);
assert.same(url.password, expected.password, `${ name }: password`);
assert.same(url.host, expected.host, `${ name }: host`);
assert.same(url.hostname, expected.hostname, `${ name }: hostname`);
assert.same(url.port, expected.port, `${ name }: port`);
assert.same(url.pathname, expected.pathname, `${ name }: pathname`);
assert.same(url.search, expected.search, `${ name }: search`);
if ('searchParams' in expected) {
assert.same(url.searchParams.toString(), expected.searchParams, `${ name }: searchParams`);
}
assert.same(url.hash, expected.hash, `${ name }: hash`);
if ('origin' in expected) {
assert.same(url.origin, expected.origin, `${ name }: origin`);
}
}
}
});
// see https://github.com/web-platform-tests/wpt/blob/master/url
if (DESCRIPTORS) QUnit.skip('WPT URL setters tests', assert => {
for (const setter in settersTestData) {
const testCases = settersTestData[setter];
for (const { href, newValue, comment, expected } of testCases) {
let name = `Setting <${ href }>.${ setter } = '${ newValue }'.`;
if (comment) name += ` ${ comment }`;
const url = new URL(href);
url[setter] = newValue;
for (const attribute in expected) {
assert.same(url[attribute], expected[attribute], name);
}
}
}
});
// see https://github.com/web-platform-tests/wpt/blob/master/url
QUnit.skip('WPT conversion to ASCII tests', assert => {
for (const { comment, input, output } of toASCIITestData) {
let name = `Parsing: <${ input }>`;
if (comment) name += ` ${ comment }`;
if (output === null) {
assert.throws(() => new URL(`https://${ input }/x`), name);
} else {
const url = new URL(`https://${ input }/x`);
assert.same(url.host, output, name);
assert.same(url.hostname, output, name);
assert.same(url.pathname, '/x', name);
assert.same(url.href, `https://${ output }/x`, name);
}
}
});
core-js-3.6.1/tests/worker.html 0000664 0000000 0000000 00000000117 13600575677 0016443 0 ustar 00root root 0000000 0000000
Test',
newValue: 'view-source+data:foo : bar',
expected: {
href: 'view-source+data:text/html,
Test',
protocol: 'view-source+data:',
},
},
{
comment: 'Port is set to null if it is the default for new scheme.',
href: 'http://foo.com:443/',
newValue: 'https',
expected: {
href: 'https://foo.com/',
protocol: 'https:',
port: '',
},
},
],
username: [
{
comment: 'No host means no username',
href: 'file:///home/you/index.html',
newValue: 'me',
expected: {
href: 'file:///home/you/index.html',
username: '',
},
},
{
comment: 'No host means no username',
href: 'unix:/run/foo.socket',
newValue: 'me',
expected: {
href: 'unix:/run/foo.socket',
username: '',
},
},
{
comment: 'Cannot-be-a-base means no username',
href: 'mailto:you@example.net',
newValue: 'me',
expected: {
href: 'mailto:you@example.net',
username: '',
},
},
{
href: 'javascript:alert(1)',
newValue: 'wario',
expected: {
href: 'javascript:alert(1)',
username: '',
},
},
{
href: 'http://example.net',
newValue: 'me',
expected: {
href: 'http://me@example.net/',
username: 'me',
},
},
{
href: 'http://:secret@example.net',
newValue: 'me',
expected: {
href: 'http://me:secret@example.net/',
username: 'me',
},
},
{
href: 'http://me@example.net',
newValue: '',
expected: {
href: 'http://example.net/',
username: '',
},
},
{
href: 'http://me:secret@example.net',
newValue: '',
expected: {
href: 'http://:secret@example.net/',
username: '',
},
},
{
comment: 'UTF-8 percent encoding with the userinfo encode set.',
href: 'http://example.net',
newValue: "\u0000\u0001\t\n\r\u001f !\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~\u007f\u0080\u0081Éé",
expected: {
href: "http://%00%01%09%0A%0D%1F%20!%22%23$%&'()*+,-.%2F09%3A%3B%3C%3D%3E%3F%40AZ%5B%5C%5D%5E_%60az%7B%7C%7D~%7F%C2%80%C2%81%C3%89%C3%A9@example.net/",
username: "%00%01%09%0A%0D%1F%20!%22%23$%&'()*+,-.%2F09%3A%3B%3C%3D%3E%3F%40AZ%5B%5C%5D%5E_%60az%7B%7C%7D~%7F%C2%80%C2%81%C3%89%C3%A9",
},
},
{
comment: 'Bytes already percent-encoded are left as-is.',
href: 'http://example.net',
newValue: '%c3%89té',
expected: {
href: 'http://%c3%89t%C3%A9@example.net/',
username: '%c3%89t%C3%A9',
},
},
{
href: 'sc:///',
newValue: 'x',
expected: {
href: 'sc:///',
username: '',
},
},
{
href: 'javascript://x/',
newValue: 'wario',
expected: {
href: 'javascript://wario@x/',
username: 'wario',
},
},
{
href: 'file://test/',
newValue: 'test',
expected: {
href: 'file://test/',
username: '',
},
},
],
password: [
{
comment: 'No host means no password',
href: 'file:///home/me/index.html',
newValue: 'secret',
expected: {
href: 'file:///home/me/index.html',
password: '',
},
},
{
comment: 'No host means no password',
href: 'unix:/run/foo.socket',
newValue: 'secret',
expected: {
href: 'unix:/run/foo.socket',
password: '',
},
},
{
comment: 'Cannot-be-a-base means no password',
href: 'mailto:me@example.net',
newValue: 'secret',
expected: {
href: 'mailto:me@example.net',
password: '',
},
},
{
href: 'http://example.net',
newValue: 'secret',
expected: {
href: 'http://:secret@example.net/',
password: 'secret',
},
},
{
href: 'http://me@example.net',
newValue: 'secret',
expected: {
href: 'http://me:secret@example.net/',
password: 'secret',
},
},
{
href: 'http://:secret@example.net',
newValue: '',
expected: {
href: 'http://example.net/',
password: '',
},
},
{
href: 'http://me:secret@example.net',
newValue: '',
expected: {
href: 'http://me@example.net/',
password: '',
},
},
{
comment: 'UTF-8 percent encoding with the userinfo encode set.',
href: 'http://example.net',
newValue: "\u0000\u0001\t\n\r\u001f !\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~\u007f\u0080\u0081Éé",
expected: {
href: "http://:%00%01%09%0A%0D%1F%20!%22%23$%&'()*+,-.%2F09%3A%3B%3C%3D%3E%3F%40AZ%5B%5C%5D%5E_%60az%7B%7C%7D~%7F%C2%80%C2%81%C3%89%C3%A9@example.net/",
password: "%00%01%09%0A%0D%1F%20!%22%23$%&'()*+,-.%2F09%3A%3B%3C%3D%3E%3F%40AZ%5B%5C%5D%5E_%60az%7B%7C%7D~%7F%C2%80%C2%81%C3%89%C3%A9",
},
},
{
comment: 'Bytes already percent-encoded are left as-is.',
href: 'http://example.net',
newValue: '%c3%89té',
expected: {
href: 'http://:%c3%89t%C3%A9@example.net/',
password: '%c3%89t%C3%A9',
},
},
{
href: 'sc:///',
newValue: 'x',
expected: {
href: 'sc:///',
password: '',
},
},
{
href: 'javascript://x/',
newValue: 'bowser',
expected: {
href: 'javascript://:bowser@x/',
password: 'bowser',
},
},
{
href: 'file://test/',
newValue: 'test',
expected: {
href: 'file://test/',
password: '',
},
},
],
host: [
{
comment: 'Non-special scheme',
href: 'sc://x/',
newValue: '\u0000',
expected: {
href: 'sc://x/',
host: 'x',
hostname: 'x',
},
},
{
href: 'sc://x/',
newValue: '\u0009',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '\u000A',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '\u000D',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: ' ',
expected: {
href: 'sc://x/',
host: 'x',
hostname: 'x',
},
},
{
href: 'sc://x/',
newValue: '#',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '/',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '?',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '@',
expected: {
href: 'sc://x/',
host: 'x',
hostname: 'x',
},
},
{
href: 'sc://x/',
newValue: 'ß',
expected: {
href: 'sc://%C3%9F/',
host: '%C3%9F',
hostname: '%C3%9F',
},
},
{
comment: 'IDNA Nontransitional_Processing',
href: 'https://x/',
newValue: 'ß',
expected: {
href: 'https://xn--zca/',
host: 'xn--zca',
hostname: 'xn--zca',
},
},
{
comment: 'Cannot-be-a-base means no host',
href: 'mailto:me@example.net',
newValue: 'example.com',
expected: {
href: 'mailto:me@example.net',
host: '',
},
},
{
comment: 'Cannot-be-a-base means no password',
href: 'data:text/plain,Stuff',
newValue: 'example.net',
expected: {
href: 'data:text/plain,Stuff',
host: '',
},
},
{
href: 'http://example.net',
newValue: 'example.com:8080',
expected: {
href: 'http://example.com:8080/',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Port number is unchanged if not specified in the new value',
href: 'http://example.net:8080',
newValue: 'example.com',
expected: {
href: 'http://example.com:8080/',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Port number is unchanged if not specified',
href: 'http://example.net:8080',
newValue: 'example.com:',
expected: {
href: 'http://example.com:8080/',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'The empty host is not valid for special schemes',
href: 'http://example.net',
newValue: '',
expected: {
href: 'http://example.net/',
host: 'example.net',
},
},
{
comment: 'The empty host is OK for non-special schemes',
href: 'view-source+http://example.net/foo',
newValue: '',
expected: {
href: 'view-source+http:///foo',
host: '',
},
},
{
comment: 'Path-only URLs can gain a host',
href: 'a:/foo',
newValue: 'example.net',
expected: {
href: 'a://example.net/foo',
host: 'example.net',
},
},
{
comment: 'IPv4 address syntax is normalized',
href: 'http://example.net',
newValue: '0x7F000001:8080',
expected: {
href: 'http://127.0.0.1:8080/',
host: '127.0.0.1:8080',
hostname: '127.0.0.1',
port: '8080',
},
},
{
comment: 'IPv6 address syntax is normalized',
href: 'http://example.net',
newValue: '[::0:01]:2',
expected: {
href: 'http://[::1]:2/',
host: '[::1]:2',
hostname: '[::1]',
port: '2',
},
},
{
comment: 'Default port number is removed',
href: 'http://example.net',
newValue: 'example.com:80',
expected: {
href: 'http://example.com/',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Default port number is removed',
href: 'https://example.net',
newValue: 'example.com:443',
expected: {
href: 'https://example.com/',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Default port number is only removed for the relevant scheme',
href: 'https://example.net',
newValue: 'example.com:80',
expected: {
href: 'https://example.com:80/',
host: 'example.com:80',
hostname: 'example.com',
port: '80',
},
},
{
comment: 'Port number is removed if new port is scheme default and existing URL has a non-default port',
href: 'http://example.net:8080',
newValue: 'example.com:80',
expected: {
href: 'http://example.com/',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a / delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com/stuff',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a / delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com:8080/stuff',
expected: {
href: 'http://example.com:8080/path',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Stuff after a ? delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com?stuff',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a ? delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com:8080?stuff',
expected: {
href: 'http://example.com:8080/path',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Stuff after a # delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com#stuff',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a # delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com:8080#stuff',
expected: {
href: 'http://example.com:8080/path',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Stuff after a \\ delimiter is ignored for special schemes',
href: 'http://example.net/path',
newValue: 'example.com\\stuff',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a \\ delimiter is ignored for special schemes',
href: 'http://example.net/path',
newValue: 'example.com:8080\\stuff',
expected: {
href: 'http://example.com:8080/path',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: '\\ is not a delimiter for non-special schemes, but still forbidden in hosts',
href: 'view-source+http://example.net/path',
newValue: 'example.com\\stuff',
expected: {
href: 'view-source+http://example.net/path',
host: 'example.net',
hostname: 'example.net',
port: '',
},
},
{
comment: 'Anything other than ASCII digit stops the port parser in a setter but is not an error',
href: 'view-source+http://example.net/path',
newValue: 'example.com:8080stuff2',
expected: {
href: 'view-source+http://example.com:8080/path',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Anything other than ASCII digit stops the port parser in a setter but is not an error',
href: 'http://example.net/path',
newValue: 'example.com:8080stuff2',
expected: {
href: 'http://example.com:8080/path',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Anything other than ASCII digit stops the port parser in a setter but is not an error',
href: 'http://example.net/path',
newValue: 'example.com:8080+2',
expected: {
href: 'http://example.com:8080/path',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Port numbers are 16 bit integers',
href: 'http://example.net/path',
newValue: 'example.com:65535',
expected: {
href: 'http://example.com:65535/path',
host: 'example.com:65535',
hostname: 'example.com',
port: '65535',
},
},
{
comment: 'Port numbers are 16 bit integers, overflowing is an error. Hostname is still set, though.',
href: 'http://example.net/path',
newValue: 'example.com:65536',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Broken IPv6',
href: 'http://example.net/',
newValue: '[google.com]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'http://example.net/',
newValue: '[::1.2.3.4x]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'http://example.net/',
newValue: '[::1.2.3.]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'http://example.net/',
newValue: '[::1.2.]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'http://example.net/',
newValue: '[::1.]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'file://y/',
newValue: 'x:123',
expected: {
href: 'file://y/',
host: 'y',
hostname: 'y',
port: '',
},
},
{
href: 'file://y/',
newValue: 'loc%41lhost',
expected: {
href: 'file:///',
host: '',
hostname: '',
port: '',
},
},
{
href: 'file://hi/x',
newValue: '',
expected: {
href: 'file:///x',
host: '',
hostname: '',
port: '',
},
},
{
href: 'sc://test@test/',
newValue: '',
expected: {
href: 'sc://test@test/',
host: 'test',
hostname: 'test',
username: 'test',
},
},
{
href: 'sc://test:12/',
newValue: '',
expected: {
href: 'sc://test:12/',
host: 'test:12',
hostname: 'test',
port: '12',
},
},
],
hostname: [
{
comment: 'Non-special scheme',
href: 'sc://x/',
newValue: '\u0000',
expected: {
href: 'sc://x/',
host: 'x',
hostname: 'x',
},
},
{
href: 'sc://x/',
newValue: '\u0009',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '\u000A',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '\u000D',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: ' ',
expected: {
href: 'sc://x/',
host: 'x',
hostname: 'x',
},
},
{
href: 'sc://x/',
newValue: '#',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '/',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '?',
expected: {
href: 'sc:///',
host: '',
hostname: '',
},
},
{
href: 'sc://x/',
newValue: '@',
expected: {
href: 'sc://x/',
host: 'x',
hostname: 'x',
},
},
{
comment: 'Cannot-be-a-base means no host',
href: 'mailto:me@example.net',
newValue: 'example.com',
expected: {
href: 'mailto:me@example.net',
host: '',
},
},
{
comment: 'Cannot-be-a-base means no password',
href: 'data:text/plain,Stuff',
newValue: 'example.net',
expected: {
href: 'data:text/plain,Stuff',
host: '',
},
},
{
href: 'http://example.net:8080',
newValue: 'example.com',
expected: {
href: 'http://example.com:8080/',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'The empty host is not valid for special schemes',
href: 'http://example.net',
newValue: '',
expected: {
href: 'http://example.net/',
host: 'example.net',
},
},
{
comment: 'The empty host is OK for non-special schemes',
href: 'view-source+http://example.net/foo',
newValue: '',
expected: {
href: 'view-source+http:///foo',
host: '',
},
},
{
comment: 'Path-only URLs can gain a host',
href: 'a:/foo',
newValue: 'example.net',
expected: {
href: 'a://example.net/foo',
host: 'example.net',
},
},
{
comment: 'IPv4 address syntax is normalized',
href: 'http://example.net:8080',
newValue: '0x7F000001',
expected: {
href: 'http://127.0.0.1:8080/',
host: '127.0.0.1:8080',
hostname: '127.0.0.1',
port: '8080',
},
},
{
comment: 'IPv6 address syntax is normalized',
href: 'http://example.net',
newValue: '[::0:01]',
expected: {
href: 'http://[::1]/',
host: '[::1]',
hostname: '[::1]',
port: '',
},
},
{
comment: 'Stuff after a : delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com:8080',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a : delimiter is ignored',
href: 'http://example.net:8080/path',
newValue: 'example.com:',
expected: {
href: 'http://example.com:8080/path',
host: 'example.com:8080',
hostname: 'example.com',
port: '8080',
},
},
{
comment: 'Stuff after a / delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com/stuff',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a ? delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com?stuff',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a # delimiter is ignored',
href: 'http://example.net/path',
newValue: 'example.com#stuff',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: 'Stuff after a \\ delimiter is ignored for special schemes',
href: 'http://example.net/path',
newValue: 'example.com\\stuff',
expected: {
href: 'http://example.com/path',
host: 'example.com',
hostname: 'example.com',
port: '',
},
},
{
comment: '\\ is not a delimiter for non-special schemes, but still forbidden in hosts',
href: 'view-source+http://example.net/path',
newValue: 'example.com\\stuff',
expected: {
href: 'view-source+http://example.net/path',
host: 'example.net',
hostname: 'example.net',
port: '',
},
},
{
comment: 'Broken IPv6',
href: 'http://example.net/',
newValue: '[google.com]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'http://example.net/',
newValue: '[::1.2.3.4x]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'http://example.net/',
newValue: '[::1.2.3.]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'http://example.net/',
newValue: '[::1.2.]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'http://example.net/',
newValue: '[::1.]',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
},
},
{
href: 'file://y/',
newValue: 'x:123',
expected: {
href: 'file://y/',
host: 'y',
hostname: 'y',
port: '',
},
},
{
href: 'file://y/',
newValue: 'loc%41lhost',
expected: {
href: 'file:///',
host: '',
hostname: '',
port: '',
},
},
{
href: 'file://hi/x',
newValue: '',
expected: {
href: 'file:///x',
host: '',
hostname: '',
port: '',
},
},
{
href: 'sc://test@test/',
newValue: '',
expected: {
href: 'sc://test@test/',
host: 'test',
hostname: 'test',
username: 'test',
},
},
{
href: 'sc://test:12/',
newValue: '',
expected: {
href: 'sc://test:12/',
host: 'test:12',
hostname: 'test',
port: '12',
},
},
],
port: [
{
href: 'http://example.net',
newValue: '8080',
expected: {
href: 'http://example.net:8080/',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Port number is removed if empty is the new value',
href: 'http://example.net:8080',
newValue: '',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
port: '',
},
},
{
comment: 'Default port number is removed',
href: 'http://example.net:8080',
newValue: '80',
expected: {
href: 'http://example.net/',
host: 'example.net',
hostname: 'example.net',
port: '',
},
},
{
comment: 'Default port number is removed',
href: 'https://example.net:4433',
newValue: '443',
expected: {
href: 'https://example.net/',
host: 'example.net',
hostname: 'example.net',
port: '',
},
},
{
comment: 'Default port number is only removed for the relevant scheme',
href: 'https://example.net',
newValue: '80',
expected: {
href: 'https://example.net:80/',
host: 'example.net:80',
hostname: 'example.net',
port: '80',
},
},
{
comment: 'Stuff after a / delimiter is ignored',
href: 'http://example.net/path',
newValue: '8080/stuff',
expected: {
href: 'http://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Stuff after a ? delimiter is ignored',
href: 'http://example.net/path',
newValue: '8080?stuff',
expected: {
href: 'http://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Stuff after a # delimiter is ignored',
href: 'http://example.net/path',
newValue: '8080#stuff',
expected: {
href: 'http://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Stuff after a \\ delimiter is ignored for special schemes',
href: 'http://example.net/path',
newValue: '8080\\stuff',
expected: {
href: 'http://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Anything other than ASCII digit stops the port parser in a setter but is not an error',
href: 'view-source+http://example.net/path',
newValue: '8080stuff2',
expected: {
href: 'view-source+http://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Anything other than ASCII digit stops the port parser in a setter but is not an error',
href: 'http://example.net/path',
newValue: '8080stuff2',
expected: {
href: 'http://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Anything other than ASCII digit stops the port parser in a setter but is not an error',
href: 'http://example.net/path',
newValue: '8080+2',
expected: {
href: 'http://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Port numbers are 16 bit integers',
href: 'http://example.net/path',
newValue: '65535',
expected: {
href: 'http://example.net:65535/path',
host: 'example.net:65535',
hostname: 'example.net',
port: '65535',
},
},
{
comment: 'Port numbers are 16 bit integers, overflowing is an error',
href: 'http://example.net:8080/path',
newValue: '65536',
expected: {
href: 'http://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
comment: 'Port numbers are 16 bit integers, overflowing is an error',
href: 'non-special://example.net:8080/path',
newValue: '65536',
expected: {
href: 'non-special://example.net:8080/path',
host: 'example.net:8080',
hostname: 'example.net',
port: '8080',
},
},
{
href: 'file://test/',
newValue: '12',
expected: {
href: 'file://test/',
port: '',
},
},
{
href: 'file://localhost/',
newValue: '12',
expected: {
href: 'file:///',
port: '',
},
},
{
href: 'non-base:value',
newValue: '12',
expected: {
href: 'non-base:value',
port: '',
},
},
{
href: 'sc:///',
newValue: '12',
expected: {
href: 'sc:///',
port: '',
},
},
{
href: 'sc://x/',
newValue: '12',
expected: {
href: 'sc://x:12/',
port: '12',
},
},
{
href: 'javascript://x/',
newValue: '12',
expected: {
href: 'javascript://x:12/',
port: '12',
},
},
],
pathname: [
{
comment: 'Cannot-be-a-base don’t have a path',
href: 'mailto:me@example.net',
newValue: '/foo',
expected: {
href: 'mailto:me@example.net',
pathname: 'me@example.net',
},
},
{
href: 'unix:/run/foo.socket?timeout=10',
newValue: '/var/log/../run/bar.socket',
expected: {
href: 'unix:/var/run/bar.socket?timeout=10',
pathname: '/var/run/bar.socket',
},
},
{
href: 'https://example.net#nav',
newValue: 'home',
expected: {
href: 'https://example.net/home#nav',
pathname: '/home',
},
},
{
href: 'https://example.net#nav',
newValue: '../home',
expected: {
href: 'https://example.net/home#nav',
pathname: '/home',
},
},
{
comment: "\\ is a segment delimiter for 'special' URLs",
href: 'http://example.net/home?lang=fr#nav',
newValue: '\\a\\%2E\\b\\%2e.\\c',
expected: {
href: 'http://example.net/a/c?lang=fr#nav',
pathname: '/a/c',
},
},
{
comment: "\\ is *not* a segment delimiter for non-'special' URLs",
href: 'view-source+http://example.net/home?lang=fr#nav',
newValue: '\\a\\%2E\\b\\%2e.\\c',
expected: {
href: 'view-source+http://example.net/\\a\\%2E\\b\\%2e.\\c?lang=fr#nav',
pathname: '/\\a\\%2E\\b\\%2e.\\c',
},
},
{
comment: 'UTF-8 percent encoding with the default encode set. Tabs and newlines are removed.',
href: 'a:/',
newValue: "\u0000\u0001\t\n\r\u001f !\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~\u007f\u0080\u0081Éé",
expected: {
href: "a:/%00%01%1F%20!%22%23$%&'()*+,-./09:;%3C=%3E%3F@AZ[\\]^_%60az%7B|%7D~%7F%C2%80%C2%81%C3%89%C3%A9",
pathname: "/%00%01%1F%20!%22%23$%&'()*+,-./09:;%3C=%3E%3F@AZ[\\]^_%60az%7B|%7D~%7F%C2%80%C2%81%C3%89%C3%A9",
},
},
{
comment: 'Bytes already percent-encoded are left as-is, including %2E outside dotted segments.',
href: 'http://example.net',
newValue: '%2e%2E%c3%89té',
expected: {
href: 'http://example.net/%2e%2E%c3%89t%C3%A9',
pathname: '/%2e%2E%c3%89t%C3%A9',
},
},
{
comment: '? needs to be encoded',
href: 'http://example.net',
newValue: '?',
expected: {
href: 'http://example.net/%3F',
pathname: '/%3F',
},
},
{
comment: '# needs to be encoded',
href: 'http://example.net',
newValue: '#',
expected: {
href: 'http://example.net/%23',
pathname: '/%23',
},
},
{
comment: '? needs to be encoded, non-special scheme',
href: 'sc://example.net',
newValue: '?',
expected: {
href: 'sc://example.net/%3F',
pathname: '/%3F',
},
},
{
comment: '# needs to be encoded, non-special scheme',
href: 'sc://example.net',
newValue: '#',
expected: {
href: 'sc://example.net/%23',
pathname: '/%23',
},
},
{
comment: 'File URLs and (back)slashes',
href: 'file://monkey/',
newValue: '\\\\',
expected: {
href: 'file://monkey/',
pathname: '/',
},
},
{
comment: 'File URLs and (back)slashes',
href: 'file:///unicorn',
newValue: '//\\/',
expected: {
href: 'file:///',
pathname: '/',
},
},
{
comment: 'File URLs and (back)slashes',
href: 'file:///unicorn',
newValue: '//monkey/..//',
expected: {
href: 'file:///',
pathname: '/',
},
},
],
search: [
{
href: 'https://example.net#nav',
newValue: 'lang=fr',
expected: {
href: 'https://example.net/?lang=fr#nav',
search: '?lang=fr',
},
},
{
href: 'https://example.net?lang=en-US#nav',
newValue: 'lang=fr',
expected: {
href: 'https://example.net/?lang=fr#nav',
search: '?lang=fr',
},
},
{
href: 'https://example.net?lang=en-US#nav',
newValue: '?lang=fr',
expected: {
href: 'https://example.net/?lang=fr#nav',
search: '?lang=fr',
},
},
{
href: 'https://example.net?lang=en-US#nav',
newValue: '??lang=fr',
expected: {
href: 'https://example.net/??lang=fr#nav',
search: '??lang=fr',
},
},
{
href: 'https://example.net?lang=en-US#nav',
newValue: '?',
expected: {
href: 'https://example.net/?#nav',
search: '',
},
},
{
href: 'https://example.net?lang=en-US#nav',
newValue: '',
expected: {
href: 'https://example.net/#nav',
search: '',
},
},
{
href: 'https://example.net?lang=en-US',
newValue: '',
expected: {
href: 'https://example.net/',
search: '',
},
},
{
href: 'https://example.net',
newValue: '',
expected: {
href: 'https://example.net/',
search: '',
},
},
/* URI malformed
{
comment: 'UTF-8 percent encoding with the query encode set. Tabs and newlines are removed.',
href: 'a:/',
newValue: "\u0000\u0001\t\n\r\u001f !\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~\u007f\u0080\u0081Éé",
expected: {
href: "a:/?%00%01%1F%20!%22%23$%&'()*+,-./09:;%3C=%3E?@AZ[\\]^_`az{|}~%7F%C2%80%C2%81%C3%89%C3%A9",
search: "?%00%01%1F%20!%22%23$%&'()*+,-./09:;%3C=%3E?@AZ[\\]^_`az{|}~%7F%C2%80%C2%81%C3%89%C3%A9",
},
},
*/
{
comment: 'Bytes already percent-encoded are left as-is',
href: 'http://example.net',
newValue: '%c3%89té',
expected: {
href: 'http://example.net/?%c3%89t%C3%A9',
search: '?%c3%89t%C3%A9',
},
},
],
hash: [
{
href: 'https://example.net',
newValue: 'main',
expected: {
href: 'https://example.net/#main',
hash: '#main',
},
},
{
href: 'https://example.net#nav',
newValue: 'main',
expected: {
href: 'https://example.net/#main',
hash: '#main',
},
},
{
href: 'https://example.net?lang=en-US',
newValue: '##nav',
expected: {
href: 'https://example.net/?lang=en-US##nav',
hash: '##nav',
},
},
{
href: 'https://example.net?lang=en-US#nav',
newValue: '#main',
expected: {
href: 'https://example.net/?lang=en-US#main',
hash: '#main',
},
},
{
href: 'https://example.net?lang=en-US#nav',
newValue: '#',
expected: {
href: 'https://example.net/?lang=en-US#',
hash: '',
},
},
{
href: 'https://example.net?lang=en-US#nav',
newValue: '',
expected: {
href: 'https://example.net/?lang=en-US',
hash: '',
},
},
{
href: 'http://example.net',
newValue: '#foo bar',
expected: {
href: 'http://example.net/#foo%20bar',
hash: '#foo%20bar',
},
},
{
href: 'http://example.net',
newValue: '#foo"bar',
expected: {
href: 'http://example.net/#foo%22bar',
hash: '#foo%22bar',
},
},
{
href: 'http://example.net',
newValue: '#foobar',
expected: {
href: 'http://example.net/#foo%3Ebar',
hash: '#foo%3Ebar',
},
},
{
href: 'http://example.net',
newValue: '#foo`bar',
expected: {
href: 'http://example.net/#foo%60bar',
hash: '#foo%60bar',
},
},
{
comment: 'Simple percent-encoding; nuls, tabs, and newlines are removed',
href: 'a:/',
newValue: "\u0000\u0001\t\n\r\u001f !\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~\u007f\u0080\u0081Éé",
expected: {
href: "a:/#%01%1F%20!%22#$%&'()*+,-./09:;%3C=%3E?@AZ[\\]^_%60az{|}~%7F%C2%80%C2%81%C3%89%C3%A9",
hash: "#%01%1F%20!%22#$%&'()*+,-./09:;%3C=%3E?@AZ[\\]^_%60az{|}~%7F%C2%80%C2%81%C3%89%C3%A9",
},
},
{
comment: 'Bytes already percent-encoded are left as-is',
href: 'http://example.net',
newValue: '%c3%89té',
expected: {
href: 'http://example.net/#%c3%89t%C3%A9',
hash: '#%c3%89t%C3%A9',
},
},
{
href: 'javascript:alert(1)',
newValue: 'castle',
expected: {
href: 'javascript:alert(1)#castle',
hash: '#castle',
},
},
],
};
core-js-3.6.1/tests/wpt-url-resources/toascii.js 0000664 0000000 0000000 00000010604 13600575677 0021661 0 ustar 00root root 0000000 0000000 /* eslint-disable max-len */
export default [
{
comment: 'Label with hyphens in 3rd and 4th position',
input: 'aa--',
output: 'aa--',
},
{
input: 'a†--',
output: 'xn--a---kp0a',
},
{
input: 'ab--c',
output: 'ab--c',
},
{
comment: 'Label with leading hyphen',
input: '-x',
output: '-x',
},
{
input: '-†',
output: 'xn----xhn',
},
{
input: '-x.xn--nxa',
output: '-x.xn--nxa',
},
{
input: '-x.β',
output: '-x.xn--nxa',
},
{
comment: 'Label with trailing hyphen',
input: 'x-.xn--nxa',
output: 'x-.xn--nxa',
},
{
input: 'x-.β',
output: 'x-.xn--nxa',
},
{
comment: 'Empty labels',
input: 'x..xn--nxa',
output: 'x..xn--nxa',
},
{
input: 'x..β',
output: 'x..xn--nxa',
},
{
comment: 'Invalid Punycode',
input: 'xn--a',
output: null,
},
{
input: 'xn--a.xn--nxa',
output: null,
},
{
input: 'xn--a.β',
output: null,
},
{
comment: 'Valid Punycode',
input: 'xn--nxa.xn--nxa',
output: 'xn--nxa.xn--nxa',
},
{
comment: 'Mixed',
input: 'xn--nxa.β',
output: 'xn--nxa.xn--nxa',
},
{
input: 'ab--c.xn--nxa',
output: 'ab--c.xn--nxa',
},
{
input: 'ab--c.β',
output: 'ab--c.xn--nxa',
},
{
comment: 'CheckJoiners is true',
input: '\u200D.example',
output: null,
},
{
input: 'xn--1ug.example',
output: null,
},
{
comment: 'CheckBidi is true',
input: 'يa',
output: null,
},
{
input: 'xn--a-yoc',
output: null,
},
{
comment: 'processing_option is Nontransitional_Processing',
input: 'ශ්රී',
output: 'xn--10cl1a0b660p',
},
{
input: 'نامهای',
output: 'xn--mgba3gch31f060k',
},
{
comment: 'U+FFFD',
input: '\uFFFD.com',
output: null,
},
{
comment: 'U+FFFD character encoded in Punycode',
input: 'xn--zn7c.com',
output: null,
},
{
comment: 'Label longer than 63 code points',
input: 'x01234567890123456789012345678901234567890123456789012345678901x',
output: 'x01234567890123456789012345678901234567890123456789012345678901x',
},
{
input: 'x01234567890123456789012345678901234567890123456789012345678901†',
output: 'xn--x01234567890123456789012345678901234567890123456789012345678901-6963b',
},
{
input: 'x01234567890123456789012345678901234567890123456789012345678901x.xn--nxa',
output: 'x01234567890123456789012345678901234567890123456789012345678901x.xn--nxa',
},
{
input: 'x01234567890123456789012345678901234567890123456789012345678901x.β',
output: 'x01234567890123456789012345678901234567890123456789012345678901x.xn--nxa',
},
{
comment: 'Domain excluding TLD longer than 253 code points',
input: '01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.x',
output: '01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.x',
},
{
input: '01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.xn--nxa',
output: '01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.xn--nxa',
},
{
input: '01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.β',
output: '01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.xn--nxa',
},
];
core-js-3.6.1/tests/wpt-url-resources/urltestdata.js 0000664 0000000 0000000 00000410313 13600575677 0022563 0 ustar 00root root 0000000 0000000 /* eslint-disable no-script-url */
export default [
'# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/script-tests/segments.js',
{
input: 'http://example\t.\norg',
base: 'http://example.org/foo/bar',
href: 'http://example.org/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://user:pass@foo:21/bar;par?b#c',
base: 'http://example.org/foo/bar',
href: 'http://user:pass@foo:21/bar;par?b#c',
origin: 'http://foo:21',
protocol: 'http:',
username: 'user',
password: 'pass',
host: 'foo:21',
hostname: 'foo',
port: '21',
pathname: '/bar;par',
search: '?b',
hash: '#c',
},
{
input: 'https://test:@test',
base: 'about:blank',
href: 'https://test@test/',
origin: 'https://test',
protocol: 'https:',
username: 'test',
password: '',
host: 'test',
hostname: 'test',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https://:@test',
base: 'about:blank',
href: 'https://test/',
origin: 'https://test',
protocol: 'https:',
username: '',
password: '',
host: 'test',
hostname: 'test',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'non-special://test:@test/x',
base: 'about:blank',
href: 'non-special://test@test/x',
origin: 'null',
protocol: 'non-special:',
username: 'test',
password: '',
host: 'test',
hostname: 'test',
port: '',
pathname: '/x',
search: '',
hash: '',
},
{
input: 'non-special://:@test/x',
base: 'about:blank',
href: 'non-special://test/x',
origin: 'null',
protocol: 'non-special:',
username: '',
password: '',
host: 'test',
hostname: 'test',
port: '',
pathname: '/x',
search: '',
hash: '',
},
{
input: 'http:foo.com',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/foo.com',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/foo.com',
search: '',
hash: '',
},
{
input: '\t :foo.com \n',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:foo.com',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:foo.com',
search: '',
hash: '',
},
{
input: ' foo.com ',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/foo.com',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/foo.com',
search: '',
hash: '',
},
{
input: 'a:\t foo.com',
base: 'http://example.org/foo/bar',
href: 'a: foo.com',
origin: 'null',
protocol: 'a:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: ' foo.com',
search: '',
hash: '',
},
{
input: 'http://f:21/ b ? d # e ',
base: 'http://example.org/foo/bar',
href: 'http://f:21/%20b%20?%20d%20#%20e',
origin: 'http://f:21',
protocol: 'http:',
username: '',
password: '',
host: 'f:21',
hostname: 'f',
port: '21',
pathname: '/%20b%20',
search: '?%20d%20',
hash: '#%20e',
},
{
input: 'lolscheme:x x#x x',
base: 'about:blank',
href: 'lolscheme:x x#x%20x',
protocol: 'lolscheme:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'x x',
search: '',
hash: '#x%20x',
},
{
input: 'http://f:/c',
base: 'http://example.org/foo/bar',
href: 'http://f/c',
origin: 'http://f',
protocol: 'http:',
username: '',
password: '',
host: 'f',
hostname: 'f',
port: '',
pathname: '/c',
search: '',
hash: '',
},
{
input: 'http://f:0/c',
base: 'http://example.org/foo/bar',
href: 'http://f:0/c',
origin: 'http://f:0',
protocol: 'http:',
username: '',
password: '',
host: 'f:0',
hostname: 'f',
port: '0',
pathname: '/c',
search: '',
hash: '',
},
{
input: 'http://f:00000000000000/c',
base: 'http://example.org/foo/bar',
href: 'http://f:0/c',
origin: 'http://f:0',
protocol: 'http:',
username: '',
password: '',
host: 'f:0',
hostname: 'f',
port: '0',
pathname: '/c',
search: '',
hash: '',
},
{
input: 'http://f:00000000000000000000080/c',
base: 'http://example.org/foo/bar',
href: 'http://f/c',
origin: 'http://f',
protocol: 'http:',
username: '',
password: '',
host: 'f',
hostname: 'f',
port: '',
pathname: '/c',
search: '',
hash: '',
},
{
input: 'http://f:b/c',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'http://f: /c',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'http://f:\n/c',
base: 'http://example.org/foo/bar',
href: 'http://f/c',
origin: 'http://f',
protocol: 'http:',
username: '',
password: '',
host: 'f',
hostname: 'f',
port: '',
pathname: '/c',
search: '',
hash: '',
},
{
input: 'http://f:fifty-two/c',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'http://f:999999/c',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'non-special://f:999999/c',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'http://f: 21 / b ? d # e ',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: '',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
hash: '',
},
{
input: ' \t',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
hash: '',
},
{
input: ':foo.com/',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:foo.com/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:foo.com/',
search: '',
hash: '',
},
{
input: ':foo.com\\',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:foo.com/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:foo.com/',
search: '',
hash: '',
},
{
input: ':',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:',
search: '',
hash: '',
},
{
input: ':a',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:a',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:a',
search: '',
hash: '',
},
{
input: ':/',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:/',
search: '',
hash: '',
},
{
input: ':\\',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:/',
search: '',
hash: '',
},
{
input: ':#',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:#',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:',
search: '',
hash: '',
},
{
input: '#',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar#',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
hash: '',
},
{
input: '#/',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar#/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
hash: '#/',
},
{
input: '#\\',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar#\\',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
hash: '#\\',
},
{
input: '#;?',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar#;?',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
hash: '#;?',
},
{
input: '?',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar?',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
hash: '',
},
{
input: '/',
base: 'http://example.org/foo/bar',
href: 'http://example.org/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: ':23',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:23',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:23',
search: '',
hash: '',
},
{
input: '/:23',
base: 'http://example.org/foo/bar',
href: 'http://example.org/:23',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/:23',
search: '',
hash: '',
},
{
input: '::',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/::',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/::',
search: '',
hash: '',
},
{
input: '::23',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/::23',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/::23',
search: '',
hash: '',
},
{
input: 'foo://',
base: 'http://example.org/foo/bar',
href: 'foo://',
origin: 'null',
protocol: 'foo:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '',
search: '',
hash: '',
},
{
input: 'http://a:b@c:29/d',
base: 'http://example.org/foo/bar',
href: 'http://a:b@c:29/d',
origin: 'http://c:29',
protocol: 'http:',
username: 'a',
password: 'b',
host: 'c:29',
hostname: 'c',
port: '29',
pathname: '/d',
search: '',
hash: '',
},
{
input: 'http::@c:29',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/:@c:29',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/:@c:29',
search: '',
hash: '',
},
{
input: 'http://&a:foo(b]c@d:2/',
base: 'http://example.org/foo/bar',
href: 'http://&a:foo(b%5Dc@d:2/',
origin: 'http://d:2',
protocol: 'http:',
username: '&a',
password: 'foo(b%5Dc',
host: 'd:2',
hostname: 'd',
port: '2',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://::@c@d:2',
base: 'http://example.org/foo/bar',
href: 'http://:%3A%40c@d:2/',
origin: 'http://d:2',
protocol: 'http:',
username: '',
password: '%3A%40c',
host: 'd:2',
hostname: 'd',
port: '2',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://foo.com:b@d/',
base: 'http://example.org/foo/bar',
href: 'http://foo.com:b@d/',
origin: 'http://d',
protocol: 'http:',
username: 'foo.com',
password: 'b',
host: 'd',
hostname: 'd',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://foo.com/\\@',
base: 'http://example.org/foo/bar',
href: 'http://foo.com//@',
origin: 'http://foo.com',
protocol: 'http:',
username: '',
password: '',
host: 'foo.com',
hostname: 'foo.com',
port: '',
pathname: '//@',
search: '',
hash: '',
},
{
input: 'http:\\\\foo.com\\',
base: 'http://example.org/foo/bar',
href: 'http://foo.com/',
origin: 'http://foo.com',
protocol: 'http:',
username: '',
password: '',
host: 'foo.com',
hostname: 'foo.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:\\\\a\\b:c\\d@foo.com\\',
base: 'http://example.org/foo/bar',
href: 'http://a/b:c/d@foo.com/',
origin: 'http://a',
protocol: 'http:',
username: '',
password: '',
host: 'a',
hostname: 'a',
port: '',
pathname: '/b:c/d@foo.com/',
search: '',
hash: '',
},
{
input: 'foo:/',
base: 'http://example.org/foo/bar',
href: 'foo:/',
origin: 'null',
protocol: 'foo:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'foo:/bar.com/',
base: 'http://example.org/foo/bar',
href: 'foo:/bar.com/',
origin: 'null',
protocol: 'foo:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/bar.com/',
search: '',
hash: '',
},
{
input: 'foo://///////',
base: 'http://example.org/foo/bar',
href: 'foo://///////',
origin: 'null',
protocol: 'foo:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '///////',
search: '',
hash: '',
},
{
input: 'foo://///////bar.com/',
base: 'http://example.org/foo/bar',
href: 'foo://///////bar.com/',
origin: 'null',
protocol: 'foo:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '///////bar.com/',
search: '',
hash: '',
},
{
input: 'foo:////://///',
base: 'http://example.org/foo/bar',
href: 'foo:////://///',
origin: 'null',
protocol: 'foo:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '//://///',
search: '',
hash: '',
},
{
input: 'c:/foo',
base: 'http://example.org/foo/bar',
href: 'c:/foo',
origin: 'null',
protocol: 'c:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/foo',
search: '',
hash: '',
},
{
input: '//foo/bar',
base: 'http://example.org/foo/bar',
href: 'http://foo/bar',
origin: 'http://foo',
protocol: 'http:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/bar',
search: '',
hash: '',
},
{
input: 'http://foo/path;a??e#f#g',
base: 'http://example.org/foo/bar',
href: 'http://foo/path;a??e#f#g',
origin: 'http://foo',
protocol: 'http:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/path;a',
search: '??e',
hash: '#f#g',
},
{
input: 'http://foo/abcd?efgh?ijkl',
base: 'http://example.org/foo/bar',
href: 'http://foo/abcd?efgh?ijkl',
origin: 'http://foo',
protocol: 'http:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/abcd',
search: '?efgh?ijkl',
hash: '',
},
{
input: 'http://foo/abcd#foo?bar',
base: 'http://example.org/foo/bar',
href: 'http://foo/abcd#foo?bar',
origin: 'http://foo',
protocol: 'http:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/abcd',
search: '',
hash: '#foo?bar',
},
{
input: '[61:24:74]:98',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/[61:24:74]:98',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/[61:24:74]:98',
search: '',
hash: '',
},
{
input: 'http:[61:27]/:foo',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/[61:27]/:foo',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/[61:27]/:foo',
search: '',
hash: '',
},
{
input: 'http://[1::2]:3:4',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'http://2001::1',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'http://2001::1]',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'http://2001::1]:80',
base: 'http://example.org/foo/bar',
failure: true,
},
{
input: 'http://[2001::1]',
base: 'http://example.org/foo/bar',
href: 'http://[2001::1]/',
origin: 'http://[2001::1]',
protocol: 'http:',
username: '',
password: '',
host: '[2001::1]',
hostname: '[2001::1]',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://[::127.0.0.1]',
base: 'http://example.org/foo/bar',
href: 'http://[::7f00:1]/',
origin: 'http://[::7f00:1]',
protocol: 'http:',
username: '',
password: '',
host: '[::7f00:1]',
hostname: '[::7f00:1]',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://[0:0:0:0:0:0:13.1.68.3]',
base: 'http://example.org/foo/bar',
href: 'http://[::d01:4403]/',
origin: 'http://[::d01:4403]',
protocol: 'http:',
username: '',
password: '',
host: '[::d01:4403]',
hostname: '[::d01:4403]',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://[2001::1]:80',
base: 'http://example.org/foo/bar',
href: 'http://[2001::1]/',
origin: 'http://[2001::1]',
protocol: 'http:',
username: '',
password: '',
host: '[2001::1]',
hostname: '[2001::1]',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:/example.com/',
base: 'http://example.org/foo/bar',
href: 'http://example.org/example.com/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'ftp:/example.com/',
base: 'http://example.org/foo/bar',
href: 'ftp://example.com/',
origin: 'ftp://example.com',
protocol: 'ftp:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https:/example.com/',
base: 'http://example.org/foo/bar',
href: 'https://example.com/',
origin: 'https://example.com',
protocol: 'https:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'madeupscheme:/example.com/',
base: 'http://example.org/foo/bar',
href: 'madeupscheme:/example.com/',
origin: 'null',
protocol: 'madeupscheme:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'file:/example.com/',
base: 'http://example.org/foo/bar',
href: 'file:///example.com/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'file://example:1/',
base: 'about:blank',
failure: true,
},
{
input: 'file://example:test/',
base: 'about:blank',
failure: true,
},
{
input: 'file://example%/',
base: 'about:blank',
failure: true,
},
{
input: 'file://[example]/',
base: 'about:blank',
failure: true,
},
{
input: 'ftps:/example.com/',
base: 'http://example.org/foo/bar',
href: 'ftps:/example.com/',
origin: 'null',
protocol: 'ftps:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'ws:/example.com/',
base: 'http://example.org/foo/bar',
href: 'ws://example.com/',
origin: 'ws://example.com',
protocol: 'ws:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'wss:/example.com/',
base: 'http://example.org/foo/bar',
href: 'wss://example.com/',
origin: 'wss://example.com',
protocol: 'wss:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'data:/example.com/',
base: 'http://example.org/foo/bar',
href: 'data:/example.com/',
origin: 'null',
protocol: 'data:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'javascript:/example.com/',
base: 'http://example.org/foo/bar',
href: 'javascript:/example.com/',
origin: 'null',
protocol: 'javascript:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'mailto:/example.com/',
base: 'http://example.org/foo/bar',
href: 'mailto:/example.com/',
origin: 'null',
protocol: 'mailto:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'http:example.com/',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/example.com/',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/example.com/',
search: '',
hash: '',
},
{
input: 'ftp:example.com/',
base: 'http://example.org/foo/bar',
href: 'ftp://example.com/',
origin: 'ftp://example.com',
protocol: 'ftp:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https:example.com/',
base: 'http://example.org/foo/bar',
href: 'https://example.com/',
origin: 'https://example.com',
protocol: 'https:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'madeupscheme:example.com/',
base: 'http://example.org/foo/bar',
href: 'madeupscheme:example.com/',
origin: 'null',
protocol: 'madeupscheme:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: 'ftps:example.com/',
base: 'http://example.org/foo/bar',
href: 'ftps:example.com/',
origin: 'null',
protocol: 'ftps:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: 'ws:example.com/',
base: 'http://example.org/foo/bar',
href: 'ws://example.com/',
origin: 'ws://example.com',
protocol: 'ws:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'wss:example.com/',
base: 'http://example.org/foo/bar',
href: 'wss://example.com/',
origin: 'wss://example.com',
protocol: 'wss:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'data:example.com/',
base: 'http://example.org/foo/bar',
href: 'data:example.com/',
origin: 'null',
protocol: 'data:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: 'javascript:example.com/',
base: 'http://example.org/foo/bar',
href: 'javascript:example.com/',
origin: 'null',
protocol: 'javascript:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: 'mailto:example.com/',
base: 'http://example.org/foo/bar',
href: 'mailto:example.com/',
origin: 'null',
protocol: 'mailto:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: '/a/b/c',
base: 'http://example.org/foo/bar',
href: 'http://example.org/a/b/c',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/a/b/c',
search: '',
hash: '',
},
{
input: '/a/ /c',
base: 'http://example.org/foo/bar',
href: 'http://example.org/a/%20/c',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/a/%20/c',
search: '',
hash: '',
},
{
input: '/a%2fc',
base: 'http://example.org/foo/bar',
href: 'http://example.org/a%2fc',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/a%2fc',
search: '',
hash: '',
},
{
input: '/a/%2f/c',
base: 'http://example.org/foo/bar',
href: 'http://example.org/a/%2f/c',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/a/%2f/c',
search: '',
hash: '',
},
{
input: '#β',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar#%CE%B2',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
hash: '#%CE%B2',
},
{
input: 'data:text/html,test#test',
base: 'http://example.org/foo/bar',
href: 'data:text/html,test#test',
origin: 'null',
protocol: 'data:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'text/html,test',
search: '',
hash: '#test',
},
{
input: 'tel:1234567890',
base: 'http://example.org/foo/bar',
href: 'tel:1234567890',
origin: 'null',
protocol: 'tel:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '1234567890',
search: '',
hash: '',
},
'# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/file.html',
{
input: 'file:c:\\foo\\bar.html',
base: 'file:///tmp/mock/path',
href: 'file:///c:/foo/bar.html',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/c:/foo/bar.html',
search: '',
hash: '',
},
{
input: ' File:c|////foo\\bar.html',
base: 'file:///tmp/mock/path',
href: 'file:///c:////foo/bar.html',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/c:////foo/bar.html',
search: '',
hash: '',
},
{
input: 'C|/foo/bar',
base: 'file:///tmp/mock/path',
href: 'file:///C:/foo/bar',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/foo/bar',
search: '',
hash: '',
},
{
input: '/C|\\foo\\bar',
base: 'file:///tmp/mock/path',
href: 'file:///C:/foo/bar',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/foo/bar',
search: '',
hash: '',
},
{
input: '//C|/foo/bar',
base: 'file:///tmp/mock/path',
href: 'file:///C:/foo/bar',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/foo/bar',
search: '',
hash: '',
},
{
input: '//server/file',
base: 'file:///tmp/mock/path',
href: 'file://server/file',
protocol: 'file:',
username: '',
password: '',
host: 'server',
hostname: 'server',
port: '',
pathname: '/file',
search: '',
hash: '',
},
{
input: '\\\\server\\file',
base: 'file:///tmp/mock/path',
href: 'file://server/file',
protocol: 'file:',
username: '',
password: '',
host: 'server',
hostname: 'server',
port: '',
pathname: '/file',
search: '',
hash: '',
},
{
input: '/\\server/file',
base: 'file:///tmp/mock/path',
href: 'file://server/file',
protocol: 'file:',
username: '',
password: '',
host: 'server',
hostname: 'server',
port: '',
pathname: '/file',
search: '',
hash: '',
},
{
input: 'file:///foo/bar.txt',
base: 'file:///tmp/mock/path',
href: 'file:///foo/bar.txt',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/foo/bar.txt',
search: '',
hash: '',
},
{
input: 'file:///home/me',
base: 'file:///tmp/mock/path',
href: 'file:///home/me',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/home/me',
search: '',
hash: '',
},
{
input: '//',
base: 'file:///tmp/mock/path',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '///',
base: 'file:///tmp/mock/path',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '///test',
base: 'file:///tmp/mock/path',
href: 'file:///test',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test',
search: '',
hash: '',
},
{
input: 'file://test',
base: 'file:///tmp/mock/path',
href: 'file://test/',
protocol: 'file:',
username: '',
password: '',
host: 'test',
hostname: 'test',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file://localhost',
base: 'file:///tmp/mock/path',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file://localhost/',
base: 'file:///tmp/mock/path',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file://localhost/test',
base: 'file:///tmp/mock/path',
href: 'file:///test',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test',
search: '',
hash: '',
},
{
input: 'test',
base: 'file:///tmp/mock/path',
href: 'file:///tmp/mock/test',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/tmp/mock/test',
search: '',
hash: '',
},
{
input: 'file:test',
base: 'file:///tmp/mock/path',
href: 'file:///tmp/mock/test',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/tmp/mock/test',
search: '',
hash: '',
},
'# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/script-tests/path.js',
{
input: 'http://example.com/././foo',
base: 'about:blank',
href: 'http://example.com/foo',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo',
search: '',
hash: '',
},
{
input: 'http://example.com/./.foo',
base: 'about:blank',
href: 'http://example.com/.foo',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/.foo',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/.',
base: 'about:blank',
href: 'http://example.com/foo/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/./',
base: 'about:blank',
href: 'http://example.com/foo/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/bar/..',
base: 'about:blank',
href: 'http://example.com/foo/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/bar/../',
base: 'about:blank',
href: 'http://example.com/foo/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/..bar',
base: 'about:blank',
href: 'http://example.com/foo/..bar',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/..bar',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/bar/../ton',
base: 'about:blank',
href: 'http://example.com/foo/ton',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/ton',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/bar/../ton/../../a',
base: 'about:blank',
href: 'http://example.com/a',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/a',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/../../..',
base: 'about:blank',
href: 'http://example.com/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/../../../ton',
base: 'about:blank',
href: 'http://example.com/ton',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/ton',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/%2e',
base: 'about:blank',
href: 'http://example.com/foo/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/%2e%2',
base: 'about:blank',
href: 'http://example.com/foo/%2e%2',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/%2e%2',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/%2e./%2e%2e/.%2e/%2e.bar',
base: 'about:blank',
href: 'http://example.com/%2e.bar',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/%2e.bar',
search: '',
hash: '',
},
{
input: 'http://example.com////../..',
base: 'about:blank',
href: 'http://example.com//',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '//',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/bar//../..',
base: 'about:blank',
href: 'http://example.com/foo/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/',
search: '',
hash: '',
},
{
input: 'http://example.com/foo/bar//..',
base: 'about:blank',
href: 'http://example.com/foo/bar/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo/bar/',
search: '',
hash: '',
},
{
input: 'http://example.com/foo',
base: 'about:blank',
href: 'http://example.com/foo',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo',
search: '',
hash: '',
},
{
input: 'http://example.com/%20foo',
base: 'about:blank',
href: 'http://example.com/%20foo',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/%20foo',
search: '',
hash: '',
},
{
input: 'http://example.com/foo%',
base: 'about:blank',
href: 'http://example.com/foo%',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo%',
search: '',
hash: '',
},
{
input: 'http://example.com/foo%2',
base: 'about:blank',
href: 'http://example.com/foo%2',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo%2',
search: '',
hash: '',
},
{
input: 'http://example.com/foo%2zbar',
base: 'about:blank',
href: 'http://example.com/foo%2zbar',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo%2zbar',
search: '',
hash: '',
},
{
input: 'http://example.com/foo%2©zbar',
base: 'about:blank',
href: 'http://example.com/foo%2%C3%82%C2%A9zbar',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo%2%C3%82%C2%A9zbar',
search: '',
hash: '',
},
{
input: 'http://example.com/foo%41%7a',
base: 'about:blank',
href: 'http://example.com/foo%41%7a',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo%41%7a',
search: '',
hash: '',
},
{
input: 'http://example.com/foo\t\u0091%91',
base: 'about:blank',
href: 'http://example.com/foo%C2%91%91',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo%C2%91%91',
search: '',
hash: '',
},
{
input: 'http://example.com/foo%00%51',
base: 'about:blank',
href: 'http://example.com/foo%00%51',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foo%00%51',
search: '',
hash: '',
},
{
input: 'http://example.com/(%28:%3A%29)',
base: 'about:blank',
href: 'http://example.com/(%28:%3A%29)',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/(%28:%3A%29)',
search: '',
hash: '',
},
{
input: 'http://example.com/%3A%3a%3C%3c',
base: 'about:blank',
href: 'http://example.com/%3A%3a%3C%3c',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/%3A%3a%3C%3c',
search: '',
hash: '',
},
{
input: 'http://example.com/foo\tbar',
base: 'about:blank',
href: 'http://example.com/foobar',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/foobar',
search: '',
hash: '',
},
{
input: 'http://example.com\\\\foo\\\\bar',
base: 'about:blank',
href: 'http://example.com//foo//bar',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '//foo//bar',
search: '',
hash: '',
},
{
input: 'http://example.com/%7Ffp3%3Eju%3Dduvgw%3Dd',
base: 'about:blank',
href: 'http://example.com/%7Ffp3%3Eju%3Dduvgw%3Dd',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/%7Ffp3%3Eju%3Dduvgw%3Dd',
search: '',
hash: '',
},
{
input: 'http://example.com/@asdf%40',
base: 'about:blank',
href: 'http://example.com/@asdf%40',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/@asdf%40',
search: '',
hash: '',
},
{
input: 'http://example.com/你好你好',
base: 'about:blank',
href: 'http://example.com/%E4%BD%A0%E5%A5%BD%E4%BD%A0%E5%A5%BD',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/%E4%BD%A0%E5%A5%BD%E4%BD%A0%E5%A5%BD',
search: '',
hash: '',
},
{
input: 'http://example.com/‥/foo',
base: 'about:blank',
href: 'http://example.com/%E2%80%A5/foo',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/%E2%80%A5/foo',
search: '',
hash: '',
},
{
input: 'http://example.com//foo',
base: 'about:blank',
href: 'http://example.com/%EF%BB%BF/foo',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/%EF%BB%BF/foo',
search: '',
hash: '',
},
{
input: 'http://example.com//foo//bar',
base: 'about:blank',
href: 'http://example.com/%E2%80%AE/foo/%E2%80%AD/bar',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/%E2%80%AE/foo/%E2%80%AD/bar',
search: '',
hash: '',
},
'# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/script-tests/relative.js',
{
input: 'http://www.google.com/foo?bar=baz#',
base: 'about:blank',
href: 'http://www.google.com/foo?bar=baz#',
origin: 'http://www.google.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.google.com',
hostname: 'www.google.com',
port: '',
pathname: '/foo',
search: '?bar=baz',
hash: '',
},
{
input: 'http://www.google.com/foo?bar=baz# »',
base: 'about:blank',
href: 'http://www.google.com/foo?bar=baz#%20%C2%BB',
origin: 'http://www.google.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.google.com',
hostname: 'www.google.com',
port: '',
pathname: '/foo',
search: '?bar=baz',
hash: '#%20%C2%BB',
},
{
input: 'data:test# »',
base: 'about:blank',
href: 'data:test#%20%C2%BB',
origin: 'null',
protocol: 'data:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'test',
search: '',
hash: '#%20%C2%BB',
},
{
input: 'http://www.google.com',
base: 'about:blank',
href: 'http://www.google.com/',
origin: 'http://www.google.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.google.com',
hostname: 'www.google.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://192.0x00A80001',
base: 'about:blank',
href: 'http://192.168.0.1/',
origin: 'http://192.168.0.1',
protocol: 'http:',
username: '',
password: '',
host: '192.168.0.1',
hostname: '192.168.0.1',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://www/foo%2Ehtml',
base: 'about:blank',
href: 'http://www/foo%2Ehtml',
origin: 'http://www',
protocol: 'http:',
username: '',
password: '',
host: 'www',
hostname: 'www',
port: '',
pathname: '/foo%2Ehtml',
search: '',
hash: '',
},
{
input: 'http://www/foo/%2E/html',
base: 'about:blank',
href: 'http://www/foo/html',
origin: 'http://www',
protocol: 'http:',
username: '',
password: '',
host: 'www',
hostname: 'www',
port: '',
pathname: '/foo/html',
search: '',
hash: '',
},
{
input: 'http://user:pass@/',
base: 'about:blank',
failure: true,
},
{
input: 'http://%25DOMAIN:foobar@foodomain.com/',
base: 'about:blank',
href: 'http://%25DOMAIN:foobar@foodomain.com/',
origin: 'http://foodomain.com',
protocol: 'http:',
username: '%25DOMAIN',
password: 'foobar',
host: 'foodomain.com',
hostname: 'foodomain.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:\\\\www.google.com\\foo',
base: 'about:blank',
href: 'http://www.google.com/foo',
origin: 'http://www.google.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.google.com',
hostname: 'www.google.com',
port: '',
pathname: '/foo',
search: '',
hash: '',
},
{
input: 'http://foo:80/',
base: 'about:blank',
href: 'http://foo/',
origin: 'http://foo',
protocol: 'http:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://foo:81/',
base: 'about:blank',
href: 'http://foo:81/',
origin: 'http://foo:81',
protocol: 'http:',
username: '',
password: '',
host: 'foo:81',
hostname: 'foo',
port: '81',
pathname: '/',
search: '',
hash: '',
},
{
input: 'httpa://foo:80/',
base: 'about:blank',
href: 'httpa://foo:80/',
origin: 'null',
protocol: 'httpa:',
username: '',
password: '',
host: 'foo:80',
hostname: 'foo',
port: '80',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://foo:-80/',
base: 'about:blank',
failure: true,
},
{
input: 'https://foo:443/',
base: 'about:blank',
href: 'https://foo/',
origin: 'https://foo',
protocol: 'https:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https://foo:80/',
base: 'about:blank',
href: 'https://foo:80/',
origin: 'https://foo:80',
protocol: 'https:',
username: '',
password: '',
host: 'foo:80',
hostname: 'foo',
port: '80',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ftp://foo:21/',
base: 'about:blank',
href: 'ftp://foo/',
origin: 'ftp://foo',
protocol: 'ftp:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ftp://foo:80/',
base: 'about:blank',
href: 'ftp://foo:80/',
origin: 'ftp://foo:80',
protocol: 'ftp:',
username: '',
password: '',
host: 'foo:80',
hostname: 'foo',
port: '80',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ws://foo:80/',
base: 'about:blank',
href: 'ws://foo/',
origin: 'ws://foo',
protocol: 'ws:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ws://foo:81/',
base: 'about:blank',
href: 'ws://foo:81/',
origin: 'ws://foo:81',
protocol: 'ws:',
username: '',
password: '',
host: 'foo:81',
hostname: 'foo',
port: '81',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ws://foo:443/',
base: 'about:blank',
href: 'ws://foo:443/',
origin: 'ws://foo:443',
protocol: 'ws:',
username: '',
password: '',
host: 'foo:443',
hostname: 'foo',
port: '443',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ws://foo:815/',
base: 'about:blank',
href: 'ws://foo:815/',
origin: 'ws://foo:815',
protocol: 'ws:',
username: '',
password: '',
host: 'foo:815',
hostname: 'foo',
port: '815',
pathname: '/',
search: '',
hash: '',
},
{
input: 'wss://foo:80/',
base: 'about:blank',
href: 'wss://foo:80/',
origin: 'wss://foo:80',
protocol: 'wss:',
username: '',
password: '',
host: 'foo:80',
hostname: 'foo',
port: '80',
pathname: '/',
search: '',
hash: '',
},
{
input: 'wss://foo:81/',
base: 'about:blank',
href: 'wss://foo:81/',
origin: 'wss://foo:81',
protocol: 'wss:',
username: '',
password: '',
host: 'foo:81',
hostname: 'foo',
port: '81',
pathname: '/',
search: '',
hash: '',
},
{
input: 'wss://foo:443/',
base: 'about:blank',
href: 'wss://foo/',
origin: 'wss://foo',
protocol: 'wss:',
username: '',
password: '',
host: 'foo',
hostname: 'foo',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'wss://foo:815/',
base: 'about:blank',
href: 'wss://foo:815/',
origin: 'wss://foo:815',
protocol: 'wss:',
username: '',
password: '',
host: 'foo:815',
hostname: 'foo',
port: '815',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:/example.com/',
base: 'about:blank',
href: 'http://example.com/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ftp:/example.com/',
base: 'about:blank',
href: 'ftp://example.com/',
origin: 'ftp://example.com',
protocol: 'ftp:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https:/example.com/',
base: 'about:blank',
href: 'https://example.com/',
origin: 'https://example.com',
protocol: 'https:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'madeupscheme:/example.com/',
base: 'about:blank',
href: 'madeupscheme:/example.com/',
origin: 'null',
protocol: 'madeupscheme:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'file:/example.com/',
base: 'about:blank',
href: 'file:///example.com/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'ftps:/example.com/',
base: 'about:blank',
href: 'ftps:/example.com/',
origin: 'null',
protocol: 'ftps:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'ws:/example.com/',
base: 'about:blank',
href: 'ws://example.com/',
origin: 'ws://example.com',
protocol: 'ws:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'wss:/example.com/',
base: 'about:blank',
href: 'wss://example.com/',
origin: 'wss://example.com',
protocol: 'wss:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'data:/example.com/',
base: 'about:blank',
href: 'data:/example.com/',
origin: 'null',
protocol: 'data:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'javascript:/example.com/',
base: 'about:blank',
href: 'javascript:/example.com/',
origin: 'null',
protocol: 'javascript:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'mailto:/example.com/',
base: 'about:blank',
href: 'mailto:/example.com/',
origin: 'null',
protocol: 'mailto:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/example.com/',
search: '',
hash: '',
},
{
input: 'http:example.com/',
base: 'about:blank',
href: 'http://example.com/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ftp:example.com/',
base: 'about:blank',
href: 'ftp://example.com/',
origin: 'ftp://example.com',
protocol: 'ftp:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https:example.com/',
base: 'about:blank',
href: 'https://example.com/',
origin: 'https://example.com',
protocol: 'https:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'madeupscheme:example.com/',
base: 'about:blank',
href: 'madeupscheme:example.com/',
origin: 'null',
protocol: 'madeupscheme:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: 'ftps:example.com/',
base: 'about:blank',
href: 'ftps:example.com/',
origin: 'null',
protocol: 'ftps:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: 'ws:example.com/',
base: 'about:blank',
href: 'ws://example.com/',
origin: 'ws://example.com',
protocol: 'ws:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'wss:example.com/',
base: 'about:blank',
href: 'wss://example.com/',
origin: 'wss://example.com',
protocol: 'wss:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'data:example.com/',
base: 'about:blank',
href: 'data:example.com/',
origin: 'null',
protocol: 'data:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: 'javascript:example.com/',
base: 'about:blank',
href: 'javascript:example.com/',
origin: 'null',
protocol: 'javascript:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
{
input: 'mailto:example.com/',
base: 'about:blank',
href: 'mailto:example.com/',
origin: 'null',
protocol: 'mailto:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'example.com/',
search: '',
hash: '',
},
'# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/segments-userinfo-vs-host.html',
{
input: 'http:@www.example.com',
base: 'about:blank',
href: 'http://www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:/@www.example.com',
base: 'about:blank',
href: 'http://www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://@www.example.com',
base: 'about:blank',
href: 'http://www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:a:b@www.example.com',
base: 'about:blank',
href: 'http://a:b@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: 'a',
password: 'b',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:/a:b@www.example.com',
base: 'about:blank',
href: 'http://a:b@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: 'a',
password: 'b',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://a:b@www.example.com',
base: 'about:blank',
href: 'http://a:b@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: 'a',
password: 'b',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://@pple.com',
base: 'about:blank',
href: 'http://pple.com/',
origin: 'http://pple.com',
protocol: 'http:',
username: '',
password: '',
host: 'pple.com',
hostname: 'pple.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http::b@www.example.com',
base: 'about:blank',
href: 'http://:b@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: 'b',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:/:b@www.example.com',
base: 'about:blank',
href: 'http://:b@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: 'b',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://:b@www.example.com',
base: 'about:blank',
href: 'http://:b@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: 'b',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:/:@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http://user@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http:@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http:/@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http://@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'https:@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http:a:b@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http:/a:b@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http://a:b@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http::@/www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http:a:@www.example.com',
base: 'about:blank',
href: 'http://a@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: 'a',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:/a:@www.example.com',
base: 'about:blank',
href: 'http://a@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: 'a',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://a:@www.example.com',
base: 'about:blank',
href: 'http://a@www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: 'a',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://www.@pple.com',
base: 'about:blank',
href: 'http://www.@pple.com/',
origin: 'http://pple.com',
protocol: 'http:',
username: 'www.',
password: '',
host: 'pple.com',
hostname: 'pple.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http:@:www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http:/@:www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http://@:www.example.com',
base: 'about:blank',
failure: true,
},
{
input: 'http://:@www.example.com',
base: 'about:blank',
href: 'http://www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
'# Others',
{
input: '/',
base: 'http://www.example.com/test',
href: 'http://www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '/test.txt',
base: 'http://www.example.com/test',
href: 'http://www.example.com/test.txt',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/test.txt',
search: '',
hash: '',
},
{
input: '.',
base: 'http://www.example.com/test',
href: 'http://www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '..',
base: 'http://www.example.com/test',
href: 'http://www.example.com/',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'test.txt',
base: 'http://www.example.com/test',
href: 'http://www.example.com/test.txt',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/test.txt',
search: '',
hash: '',
},
{
input: './test.txt',
base: 'http://www.example.com/test',
href: 'http://www.example.com/test.txt',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/test.txt',
search: '',
hash: '',
},
{
input: '../test.txt',
base: 'http://www.example.com/test',
href: 'http://www.example.com/test.txt',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/test.txt',
search: '',
hash: '',
},
{
input: '../aaa/test.txt',
base: 'http://www.example.com/test',
href: 'http://www.example.com/aaa/test.txt',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/aaa/test.txt',
search: '',
hash: '',
},
{
input: '../../test.txt',
base: 'http://www.example.com/test',
href: 'http://www.example.com/test.txt',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/test.txt',
search: '',
hash: '',
},
{
input: '中/test.txt',
base: 'http://www.example.com/test',
href: 'http://www.example.com/%E4%B8%AD/test.txt',
origin: 'http://www.example.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example.com',
hostname: 'www.example.com',
port: '',
pathname: '/%E4%B8%AD/test.txt',
search: '',
hash: '',
},
{
input: 'http://www.example2.com',
base: 'http://www.example.com/test',
href: 'http://www.example2.com/',
origin: 'http://www.example2.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example2.com',
hostname: 'www.example2.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '//www.example2.com',
base: 'http://www.example.com/test',
href: 'http://www.example2.com/',
origin: 'http://www.example2.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.example2.com',
hostname: 'www.example2.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file:...',
base: 'http://www.example.com/test',
href: 'file:///...',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/...',
search: '',
hash: '',
},
{
input: 'file:..',
base: 'http://www.example.com/test',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file:a',
base: 'http://www.example.com/test',
href: 'file:///a',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/a',
search: '',
hash: '',
},
'# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/host.html',
'Basic canonicalization, uppercase should be converted to lowercase',
{
input: 'http://ExAmPlE.CoM',
base: 'http://other.com/',
href: 'http://example.com/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://example example.com',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://Goo%20 goo%7C|.com',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://[]',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://[:]',
base: 'http://other.com/',
failure: true,
},
'U+3000 is mapped to U+0020 (space) which is disallowed',
{
input: 'http://GOO\u00A0\u3000goo.com',
base: 'http://other.com/',
failure: true,
},
'Other types of space (no-break, zero-width, zero-width-no-break) are name-prepped away to nothing. U+200B, U+2060, and U+FEFF, are ignored',
{
input: 'http://GOO\u200B\u2060\uFEFFgoo.com',
base: 'http://other.com/',
href: 'http://googoo.com/',
origin: 'http://googoo.com',
protocol: 'http:',
username: '',
password: '',
host: 'googoo.com',
hostname: 'googoo.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
'Leading and trailing C0 control or space',
{
input: '\u0000\u001B\u0004\u0012 http://example.com/\u001F \u000D ',
base: 'about:blank',
href: 'http://example.com/',
origin: 'http://example.com',
protocol: 'http:',
username: '',
password: '',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
'Ideographic full stop (full-width period for Chinese, etc.) should be treated as a dot. U+3002 is mapped to U+002E (dot)',
{
input: 'http://www.foo。bar.com',
base: 'http://other.com/',
href: 'http://www.foo.bar.com/',
origin: 'http://www.foo.bar.com',
protocol: 'http:',
username: '',
password: '',
host: 'www.foo.bar.com',
hostname: 'www.foo.bar.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
'Invalid unicode characters should fail... U+FDD0 is disallowed; %ef%b7%90 is U+FDD0',
{
input: 'http://\uFDD0zyx.com',
base: 'http://other.com/',
failure: true,
},
'This is the same as previous but escaped',
{
input: 'http://%ef%b7%90zyx.com',
base: 'http://other.com/',
failure: true,
},
'U+FFFD',
{
input: 'https://\uFFFD',
base: 'about:blank',
failure: true,
},
{
input: 'https://%EF%BF%BD',
base: 'about:blank',
failure: true,
},
{
input: 'https://x/\uFFFD?\uFFFD#\uFFFD',
base: 'about:blank',
href: 'https://x/%EF%BF%BD?%EF%BF%BD#%EF%BF%BD',
origin: 'https://x',
protocol: 'https:',
username: '',
password: '',
host: 'x',
hostname: 'x',
port: '',
pathname: '/%EF%BF%BD',
search: '?%EF%BF%BD',
hash: '#%EF%BF%BD',
},
"Test name prepping, fullwidth input should be converted to ASCII and NOT IDN-ized. This is 'Go' in fullwidth UTF-8/UTF-16.",
{
input: 'http://Ｇｏ.com',
base: 'http://other.com/',
href: 'http://go.com/',
origin: 'http://go.com',
protocol: 'http:',
username: '',
password: '',
host: 'go.com',
hostname: 'go.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
'URL spec forbids the following. https://www.w3.org/Bugs/Public/show_bug.cgi?id=24257',
{
input: 'http://％４１.com',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://%ef%bc%85%ef%bc%94%ef%bc%91.com',
base: 'http://other.com/',
failure: true,
},
'...%00 in fullwidth should fail (also as escaped UTF-8 input)',
{
input: 'http://％００.com',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://%ef%bc%85%ef%bc%90%ef%bc%90.com',
base: 'http://other.com/',
failure: true,
},
'Basic IDN support, UTF-8 and UTF-16 input should be converted to IDN',
{
input: 'http://你好你好',
base: 'http://other.com/',
href: 'http://xn--6qqa088eba/',
origin: 'http://xn--6qqa088eba',
protocol: 'http:',
username: '',
password: '',
host: 'xn--6qqa088eba',
hostname: 'xn--6qqa088eba',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https://faß.ExAmPlE/',
base: 'about:blank',
href: 'https://xn--fa-hia.example/',
origin: 'https://xn--fa-hia.example',
protocol: 'https:',
username: '',
password: '',
host: 'xn--fa-hia.example',
hostname: 'xn--fa-hia.example',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'sc://faß.ExAmPlE/',
base: 'about:blank',
href: 'sc://fa%C3%9F.ExAmPlE/',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: 'fa%C3%9F.ExAmPlE',
hostname: 'fa%C3%9F.ExAmPlE',
port: '',
pathname: '/',
search: '',
hash: '',
},
'Invalid escaped characters should fail and the percents should be escaped. https://www.w3.org/Bugs/Public/show_bug.cgi?id=24191',
{
input: 'http://%zz%66%a.com',
base: 'http://other.com/',
failure: true,
},
'If we get an invalid character that has been escaped.',
{
input: 'http://%25',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://hello%00',
base: 'http://other.com/',
failure: true,
},
'Escaped numbers should be treated like IP addresses if they are.',
/*
{
input: 'http://%30%78%63%30%2e%30%32%35%30.01',
base: 'http://other.com/',
href: 'http://192.168.0.1/',
origin: 'http://192.168.0.1',
protocol: 'http:',
username: '',
password: '',
host: '192.168.0.1',
hostname: '192.168.0.1',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://%30%78%63%30%2e%30%32%35%30.01%2e',
base: 'http://other.com/',
href: 'http://192.168.0.1/',
origin: 'http://192.168.0.1',
protocol: 'http:',
username: '',
password: '',
host: '192.168.0.1',
hostname: '192.168.0.1',
port: '',
pathname: '/',
search: '',
hash: '',
},
*/
{
input: 'http://192.168.0.257',
base: 'http://other.com/',
failure: true,
},
'Invalid escaping in hosts causes failure',
{
input: 'http://%3g%78%63%30%2e%30%32%35%30%2E.01',
base: 'http://other.com/',
failure: true,
},
'A space in a host causes failure',
{
input: 'http://192.168.0.1 hello',
base: 'http://other.com/',
failure: true,
},
{
input: 'https://x x:12',
base: 'about:blank',
failure: true,
},
'Fullwidth and escaped UTF-8 fullwidth should still be treated as IP',
{
input: 'http://０Ｘｃ０．０２５０．０１',
base: 'http://other.com/',
href: 'http://192.168.0.1/',
origin: 'http://192.168.0.1',
protocol: 'http:',
username: '',
password: '',
host: '192.168.0.1',
hostname: '192.168.0.1',
port: '',
pathname: '/',
search: '',
hash: '',
},
'Domains with empty labels',
{
input: 'http://./',
base: 'about:blank',
href: 'http://./',
origin: 'http://.',
protocol: 'http:',
username: '',
password: '',
host: '.',
hostname: '.',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://../',
base: 'about:blank',
href: 'http://../',
origin: 'http://..',
protocol: 'http:',
username: '',
password: '',
host: '..',
hostname: '..',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://0..0x300/',
base: 'about:blank',
href: 'http://0..0x300/',
origin: 'http://0..0x300',
protocol: 'http:',
username: '',
password: '',
host: '0..0x300',
hostname: '0..0x300',
port: '',
pathname: '/',
search: '',
hash: '',
},
'Broken IPv6',
{
input: 'http://[www.google.com]/',
base: 'about:blank',
failure: true,
},
{
input: 'http://[google.com]',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://[::1.2.3.4x]',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://[::1.2.3.]',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://[::1.2.]',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://[::1.]',
base: 'http://other.com/',
failure: true,
},
'Misc Unicode',
{
input: 'http://foo:💩@example.com/bar',
base: 'http://other.com/',
href: 'http://foo:%F0%9F%92%A9@example.com/bar',
origin: 'http://example.com',
protocol: 'http:',
username: 'foo',
password: '%F0%9F%92%A9',
host: 'example.com',
hostname: 'example.com',
port: '',
pathname: '/bar',
search: '',
hash: '',
},
'# resolving a fragment against any scheme succeeds',
{
input: '#',
base: 'test:test',
href: 'test:test#',
origin: 'null',
protocol: 'test:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'test',
search: '',
hash: '',
},
{
input: '#x',
base: 'mailto:x@x.com',
href: 'mailto:x@x.com#x',
origin: 'null',
protocol: 'mailto:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'x@x.com',
search: '',
hash: '#x',
},
{
input: '#x',
base: 'data:,',
href: 'data:,#x',
origin: 'null',
protocol: 'data:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: ',',
search: '',
hash: '#x',
},
{
input: '#x',
base: 'about:blank',
href: 'about:blank#x',
origin: 'null',
protocol: 'about:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'blank',
search: '',
hash: '#x',
},
{
input: '#',
base: 'test:test?test',
href: 'test:test?test#',
origin: 'null',
protocol: 'test:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'test',
search: '?test',
hash: '',
},
'# multiple @ in authority state',
{
input: 'https://@test@test@example:800/',
base: 'http://doesnotmatter/',
href: 'https://%40test%40test@example:800/',
origin: 'https://example:800',
protocol: 'https:',
username: '%40test%40test',
password: '',
host: 'example:800',
hostname: 'example',
port: '800',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https://@@@example',
base: 'http://doesnotmatter/',
href: 'https://%40%40@example/',
origin: 'https://example',
protocol: 'https:',
username: '%40%40',
password: '',
host: 'example',
hostname: 'example',
port: '',
pathname: '/',
search: '',
hash: '',
},
'non-az-09 characters',
{
input: 'http://`{}:`{}@h/`{}?`{}',
base: 'http://doesnotmatter/',
href: 'http://%60%7B%7D:%60%7B%7D@h/%60%7B%7D?`{}',
origin: 'http://h',
protocol: 'http:',
username: '%60%7B%7D',
password: '%60%7B%7D',
host: 'h',
hostname: 'h',
port: '',
pathname: '/%60%7B%7D',
search: '?`{}',
hash: '',
},
"byte is ' and url is special",
{
input: "http://host/?'",
base: 'about:blank',
href: 'http://host/?%27',
origin: 'http://host',
protocol: 'http:',
username: '',
password: '',
host: 'host',
hostname: 'host',
port: '',
pathname: '/',
search: '?%27',
hash: '',
},
{
input: "notspecial://host/?'",
base: 'about:blank',
href: "notspecial://host/?'",
origin: 'null',
protocol: 'notspecial:',
username: '',
password: '',
host: 'host',
hostname: 'host',
port: '',
pathname: '/',
search: "?'",
hash: '',
},
'# Credentials in base',
{
input: '/some/path',
base: 'http://user@example.org/smth',
href: 'http://user@example.org/some/path',
origin: 'http://example.org',
protocol: 'http:',
username: 'user',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/some/path',
search: '',
hash: '',
},
{
input: '',
base: 'http://user:pass@example.org:21/smth',
href: 'http://user:pass@example.org:21/smth',
origin: 'http://example.org:21',
protocol: 'http:',
username: 'user',
password: 'pass',
host: 'example.org:21',
hostname: 'example.org',
port: '21',
pathname: '/smth',
search: '',
hash: '',
},
{
input: '/some/path',
base: 'http://user:pass@example.org:21/smth',
href: 'http://user:pass@example.org:21/some/path',
origin: 'http://example.org:21',
protocol: 'http:',
username: 'user',
password: 'pass',
host: 'example.org:21',
hostname: 'example.org',
port: '21',
pathname: '/some/path',
search: '',
hash: '',
},
'# a set of tests designed by zcorpan for relative URLs with unknown schemes',
{
input: 'i',
base: 'sc:sd',
failure: true,
},
{
input: 'i',
base: 'sc:sd/sd',
failure: true,
},
{
input: 'i',
base: 'sc:/pa/pa',
href: 'sc:/pa/i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pa/i',
search: '',
hash: '',
},
{
input: 'i',
base: 'sc://ho/pa',
href: 'sc://ho/i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: 'ho',
hostname: 'ho',
port: '',
pathname: '/i',
search: '',
hash: '',
},
{
input: 'i',
base: 'sc:///pa/pa',
href: 'sc:///pa/i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pa/i',
search: '',
hash: '',
},
{
input: '../i',
base: 'sc:sd',
failure: true,
},
{
input: '../i',
base: 'sc:sd/sd',
failure: true,
},
{
input: '../i',
base: 'sc:/pa/pa',
href: 'sc:/i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/i',
search: '',
hash: '',
},
{
input: '../i',
base: 'sc://ho/pa',
href: 'sc://ho/i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: 'ho',
hostname: 'ho',
port: '',
pathname: '/i',
search: '',
hash: '',
},
{
input: '../i',
base: 'sc:///pa/pa',
href: 'sc:///i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/i',
search: '',
hash: '',
},
{
input: '/i',
base: 'sc:sd',
failure: true,
},
{
input: '/i',
base: 'sc:sd/sd',
failure: true,
},
{
input: '/i',
base: 'sc:/pa/pa',
href: 'sc:/i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/i',
search: '',
hash: '',
},
{
input: '/i',
base: 'sc://ho/pa',
href: 'sc://ho/i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: 'ho',
hostname: 'ho',
port: '',
pathname: '/i',
search: '',
hash: '',
},
{
input: '/i',
base: 'sc:///pa/pa',
href: 'sc:///i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/i',
search: '',
hash: '',
},
{
input: '?i',
base: 'sc:sd',
failure: true,
},
{
input: '?i',
base: 'sc:sd/sd',
failure: true,
},
{
input: '?i',
base: 'sc:/pa/pa',
href: 'sc:/pa/pa?i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pa/pa',
search: '?i',
hash: '',
},
{
input: '?i',
base: 'sc://ho/pa',
href: 'sc://ho/pa?i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: 'ho',
hostname: 'ho',
port: '',
pathname: '/pa',
search: '?i',
hash: '',
},
{
input: '?i',
base: 'sc:///pa/pa',
href: 'sc:///pa/pa?i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pa/pa',
search: '?i',
hash: '',
},
{
input: '#i',
base: 'sc:sd',
href: 'sc:sd#i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'sd',
search: '',
hash: '#i',
},
{
input: '#i',
base: 'sc:sd/sd',
href: 'sc:sd/sd#i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'sd/sd',
search: '',
hash: '#i',
},
{
input: '#i',
base: 'sc:/pa/pa',
href: 'sc:/pa/pa#i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pa/pa',
search: '',
hash: '#i',
},
{
input: '#i',
base: 'sc://ho/pa',
href: 'sc://ho/pa#i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: 'ho',
hostname: 'ho',
port: '',
pathname: '/pa',
search: '',
hash: '#i',
},
{
input: '#i',
base: 'sc:///pa/pa',
href: 'sc:///pa/pa#i',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pa/pa',
search: '',
hash: '#i',
},
'# make sure that relative URL logic works on known typically non-relative schemes too',
{
input: 'about:/../',
base: 'about:blank',
href: 'about:/',
origin: 'null',
protocol: 'about:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'data:/../',
base: 'about:blank',
href: 'data:/',
origin: 'null',
protocol: 'data:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'javascript:/../',
base: 'about:blank',
href: 'javascript:/',
origin: 'null',
protocol: 'javascript:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'mailto:/../',
base: 'about:blank',
href: 'mailto:/',
origin: 'null',
protocol: 'mailto:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
'# unknown schemes and their hosts',
{
input: 'sc://ñ.test/',
base: 'about:blank',
href: 'sc://%C3%B1.test/',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '%C3%B1.test',
hostname: '%C3%B1.test',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: "sc://\u001F!\"$&'()*+,-.;<=>^_`{|}~/",
base: 'about:blank',
href: "sc://%1F!\"$&'()*+,-.;<=>^_`{|}~/",
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: "%1F!\"$&'()*+,-.;<=>^_`{|}~",
hostname: "%1F!\"$&'()*+,-.;<=>^_`{|}~",
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'sc://\u0000/',
base: 'about:blank',
failure: true,
},
{
input: 'sc:// /',
base: 'about:blank',
failure: true,
},
/*
{
input: 'sc://%/',
base: 'about:blank',
href: 'sc://%/',
protocol: 'sc:',
username: '',
password: '',
host: '%',
hostname: '%',
port: '',
pathname: '/',
search: '',
hash: '',
},
*/
{
input: 'sc://@/',
base: 'about:blank',
failure: true,
},
{
input: 'sc://te@s:t@/',
base: 'about:blank',
failure: true,
},
{
input: 'sc://:/',
base: 'about:blank',
failure: true,
},
{
input: 'sc://:12/',
base: 'about:blank',
failure: true,
},
{
input: 'sc://[/',
base: 'about:blank',
failure: true,
},
{
input: 'sc://\\/',
base: 'about:blank',
failure: true,
},
{
input: 'sc://]/',
base: 'about:blank',
failure: true,
},
{
input: 'x',
base: 'sc://ñ',
href: 'sc://%C3%B1/x',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '%C3%B1',
hostname: '%C3%B1',
port: '',
pathname: '/x',
search: '',
hash: '',
},
'# unknown schemes and backslashes',
{
input: 'sc:\\../',
base: 'about:blank',
href: 'sc:\\../',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '\\../',
search: '',
hash: '',
},
'# unknown scheme with path looking like a password',
{
input: 'sc::a@example.net',
base: 'about:blank',
href: 'sc::a@example.net',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: ':a@example.net',
search: '',
hash: '',
},
'# unknown scheme with bogus percent-encoding',
{
input: 'wow:%NBD',
base: 'about:blank',
href: 'wow:%NBD',
origin: 'null',
protocol: 'wow:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '%NBD',
search: '',
hash: '',
},
{
input: 'wow:%1G',
base: 'about:blank',
href: 'wow:%1G',
origin: 'null',
protocol: 'wow:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '%1G',
search: '',
hash: '',
},
'# Hosts and percent-encoding',
{
input: 'ftp://example.com%80/',
base: 'about:blank',
failure: true,
},
{
input: 'ftp://example.com%A0/',
base: 'about:blank',
failure: true,
},
{
input: 'https://example.com%80/',
base: 'about:blank',
failure: true,
},
{
input: 'https://example.com%A0/',
base: 'about:blank',
failure: true,
},
/*
{
input: 'ftp://%e2%98%83',
base: 'about:blank',
href: 'ftp://xn--n3h/',
origin: 'ftp://xn--n3h',
protocol: 'ftp:',
username: '',
password: '',
host: 'xn--n3h',
hostname: 'xn--n3h',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https://%e2%98%83',
base: 'about:blank',
href: 'https://xn--n3h/',
origin: 'https://xn--n3h',
protocol: 'https:',
username: '',
password: '',
host: 'xn--n3h',
hostname: 'xn--n3h',
port: '',
pathname: '/',
search: '',
hash: '',
},
*/
'# tests from jsdom/whatwg-url designed for code coverage',
{
input: 'http://127.0.0.1:10100/relative_import.html',
base: 'about:blank',
href: 'http://127.0.0.1:10100/relative_import.html',
origin: 'http://127.0.0.1:10100',
protocol: 'http:',
username: '',
password: '',
host: '127.0.0.1:10100',
hostname: '127.0.0.1',
port: '10100',
pathname: '/relative_import.html',
search: '',
hash: '',
},
{
input: 'http://facebook.com/?foo=%7B%22abc%22',
base: 'about:blank',
href: 'http://facebook.com/?foo=%7B%22abc%22',
origin: 'http://facebook.com',
protocol: 'http:',
username: '',
password: '',
host: 'facebook.com',
hostname: 'facebook.com',
port: '',
pathname: '/',
search: '?foo=%7B%22abc%22',
hash: '',
},
{
input: 'https://localhost:3000/jqueryui@1.2.3',
base: 'about:blank',
href: 'https://localhost:3000/jqueryui@1.2.3',
origin: 'https://localhost:3000',
protocol: 'https:',
username: '',
password: '',
host: 'localhost:3000',
hostname: 'localhost',
port: '3000',
pathname: '/jqueryui@1.2.3',
search: '',
hash: '',
},
'# tab/LF/CR',
{
input: 'h\tt\nt\rp://h\to\ns\rt:9\t0\n0\r0/p\ta\nt\rh?q\tu\ne\rry#f\tr\na\rg',
base: 'about:blank',
href: 'http://host:9000/path?query#frag',
origin: 'http://host:9000',
protocol: 'http:',
username: '',
password: '',
host: 'host:9000',
hostname: 'host',
port: '9000',
pathname: '/path',
search: '?query',
hash: '#frag',
},
'# Stringification of URL.searchParams',
{
input: '?a=b&c=d',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar?a=b&c=d',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '?a=b&c=d',
searchParams: 'a=b&c=d',
hash: '',
},
{
input: '??a=b&c=d',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar??a=b&c=d',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '??a=b&c=d',
searchParams: '%3Fa=b&c=d',
hash: '',
},
'# Scheme only',
{
input: 'http:',
base: 'http://example.org/foo/bar',
href: 'http://example.org/foo/bar',
origin: 'http://example.org',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/foo/bar',
search: '',
searchParams: '',
hash: '',
},
{
input: 'http:',
base: 'https://example.org/foo/bar',
failure: true,
},
{
input: 'sc:',
base: 'https://example.org/foo/bar',
href: 'sc:',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '',
search: '',
searchParams: '',
hash: '',
},
'# Percent encoding of fragments',
{
input: 'http://foo.bar/baz?qux#foo\bbar',
base: 'about:blank',
href: 'http://foo.bar/baz?qux#foo%08bar',
origin: 'http://foo.bar',
protocol: 'http:',
username: '',
password: '',
host: 'foo.bar',
hostname: 'foo.bar',
port: '',
pathname: '/baz',
search: '?qux',
searchParams: 'qux=',
hash: '#foo%08bar',
},
{
input: 'http://foo.bar/baz?qux#foo"bar',
base: 'about:blank',
href: 'http://foo.bar/baz?qux#foo%22bar',
origin: 'http://foo.bar',
protocol: 'http:',
username: '',
password: '',
host: 'foo.bar',
hostname: 'foo.bar',
port: '',
pathname: '/baz',
search: '?qux',
searchParams: 'qux=',
hash: '#foo%22bar',
},
{
input: 'http://foo.bar/baz?qux#foobar',
base: 'about:blank',
href: 'http://foo.bar/baz?qux#foo%3Ebar',
origin: 'http://foo.bar',
protocol: 'http:',
username: '',
password: '',
host: 'foo.bar',
hostname: 'foo.bar',
port: '',
pathname: '/baz',
search: '?qux',
searchParams: 'qux=',
hash: '#foo%3Ebar',
},
{
input: 'http://foo.bar/baz?qux#foo`bar',
base: 'about:blank',
href: 'http://foo.bar/baz?qux#foo%60bar',
origin: 'http://foo.bar',
protocol: 'http:',
username: '',
password: '',
host: 'foo.bar',
hostname: 'foo.bar',
port: '',
pathname: '/baz',
search: '?qux',
searchParams: 'qux=',
hash: '#foo%60bar',
},
'# IPv4 parsing (via https://github.com/nodejs/node/pull/10317)',
{
input: 'http://192.168.257',
base: 'http://other.com/',
href: 'http://192.168.1.1/',
origin: 'http://192.168.1.1',
protocol: 'http:',
username: '',
password: '',
host: '192.168.1.1',
hostname: '192.168.1.1',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://192.168.257.com',
base: 'http://other.com/',
href: 'http://192.168.257.com/',
origin: 'http://192.168.257.com',
protocol: 'http:',
username: '',
password: '',
host: '192.168.257.com',
hostname: '192.168.257.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://256',
base: 'http://other.com/',
href: 'http://0.0.1.0/',
origin: 'http://0.0.1.0',
protocol: 'http:',
username: '',
password: '',
host: '0.0.1.0',
hostname: '0.0.1.0',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://256.com',
base: 'http://other.com/',
href: 'http://256.com/',
origin: 'http://256.com',
protocol: 'http:',
username: '',
password: '',
host: '256.com',
hostname: '256.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://999999999',
base: 'http://other.com/',
href: 'http://59.154.201.255/',
origin: 'http://59.154.201.255',
protocol: 'http:',
username: '',
password: '',
host: '59.154.201.255',
hostname: '59.154.201.255',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://999999999.com',
base: 'http://other.com/',
href: 'http://999999999.com/',
origin: 'http://999999999.com',
protocol: 'http:',
username: '',
password: '',
host: '999999999.com',
hostname: '999999999.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://10000000000',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://10000000000.com',
base: 'http://other.com/',
href: 'http://10000000000.com/',
origin: 'http://10000000000.com',
protocol: 'http:',
username: '',
password: '',
host: '10000000000.com',
hostname: '10000000000.com',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://4294967295',
base: 'http://other.com/',
href: 'http://255.255.255.255/',
origin: 'http://255.255.255.255',
protocol: 'http:',
username: '',
password: '',
host: '255.255.255.255',
hostname: '255.255.255.255',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://4294967296',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://0xffffffff',
base: 'http://other.com/',
href: 'http://255.255.255.255/',
origin: 'http://255.255.255.255',
protocol: 'http:',
username: '',
password: '',
host: '255.255.255.255',
hostname: '255.255.255.255',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://0xffffffff1',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://256.256.256.256',
base: 'http://other.com/',
failure: true,
},
{
input: 'http://256.256.256.256.256',
base: 'http://other.com/',
href: 'http://256.256.256.256.256/',
origin: 'http://256.256.256.256.256',
protocol: 'http:',
username: '',
password: '',
host: '256.256.256.256.256',
hostname: '256.256.256.256.256',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'https://0x.0x.0',
base: 'about:blank',
href: 'https://0.0.0.0/',
origin: 'https://0.0.0.0',
protocol: 'https:',
username: '',
password: '',
host: '0.0.0.0',
hostname: '0.0.0.0',
port: '',
pathname: '/',
search: '',
hash: '',
},
'More IPv4 parsing (via https://github.com/jsdom/whatwg-url/issues/92)',
{
input: 'https://0x100000000/test',
base: 'about:blank',
failure: true,
},
{
input: 'https://256.0.0.1/test',
base: 'about:blank',
failure: true,
},
"# file URLs containing percent-encoded Windows drive letters (shouldn't work)",
{
input: 'file:///C%3A/',
base: 'about:blank',
href: 'file:///C%3A/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C%3A/',
search: '',
hash: '',
},
{
input: 'file:///C%7C/',
base: 'about:blank',
href: 'file:///C%7C/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C%7C/',
search: '',
hash: '',
},
'# file URLs relative to other file URLs (via https://github.com/jsdom/whatwg-url/pull/60)',
{
input: 'pix/submit.gif',
base: 'file:///C:/Users/Domenic/Dropbox/GitHub/tmpvar/jsdom/test/level2/html/files/anchor.html',
href: 'file:///C:/Users/Domenic/Dropbox/GitHub/tmpvar/jsdom/test/level2/html/files/pix/submit.gif',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/Users/Domenic/Dropbox/GitHub/tmpvar/jsdom/test/level2/html/files/pix/submit.gif',
search: '',
hash: '',
},
{
input: '..',
base: 'file:///C:/',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
{
input: '..',
base: 'file:///',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
'# More file URL tests by zcorpan and annevk',
{
input: '/',
base: 'file:///C:/a/b',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
{
input: '//d:',
base: 'file:///C:/a/b',
href: 'file:///d:',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/d:',
search: '',
hash: '',
},
{
input: '//d:/..',
base: 'file:///C:/a/b',
href: 'file:///d:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/d:/',
search: '',
hash: '',
},
{
input: '..',
base: 'file:///ab:/',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '..',
base: 'file:///1:/',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '',
base: 'file:///test?test#test',
href: 'file:///test?test',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test',
search: '?test',
hash: '',
},
{
input: 'file:',
base: 'file:///test?test#test',
href: 'file:///test?test',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test',
search: '?test',
hash: '',
},
{
input: '?x',
base: 'file:///test?test#test',
href: 'file:///test?x',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test',
search: '?x',
hash: '',
},
{
input: 'file:?x',
base: 'file:///test?test#test',
href: 'file:///test?x',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test',
search: '?x',
hash: '',
},
{
input: '#x',
base: 'file:///test?test#test',
href: 'file:///test?test#x',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test',
search: '?test',
hash: '#x',
},
{
input: 'file:#x',
base: 'file:///test?test#test',
href: 'file:///test?test#x',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test',
search: '?test',
hash: '#x',
},
'# File URLs and many (back)slashes',
{
input: 'file:\\\\//',
base: 'about:blank',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file:\\\\\\\\',
base: 'about:blank',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file:\\\\\\\\?fox',
base: 'about:blank',
href: 'file:///?fox',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '?fox',
hash: '',
},
{
input: 'file:\\\\\\\\#guppy',
base: 'about:blank',
href: 'file:///#guppy',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '#guppy',
},
{
input: 'file://spider///',
base: 'about:blank',
href: 'file://spider/',
protocol: 'file:',
username: '',
password: '',
host: 'spider',
hostname: 'spider',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file:\\\\localhost//',
base: 'about:blank',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file:///localhost//cat',
base: 'about:blank',
href: 'file:///localhost//cat',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/localhost//cat',
search: '',
hash: '',
},
{
input: 'file://\\/localhost//cat',
base: 'about:blank',
href: 'file:///localhost//cat',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/localhost//cat',
search: '',
hash: '',
},
{
input: 'file://localhost//a//../..//',
base: 'about:blank',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '/////mouse',
base: 'file:///elephant',
href: 'file:///mouse',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/mouse',
search: '',
hash: '',
},
{
input: '\\//pig',
base: 'file://lion/',
href: 'file:///pig',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pig',
search: '',
hash: '',
},
{
input: '\\/localhost//pig',
base: 'file://lion/',
href: 'file:///pig',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pig',
search: '',
hash: '',
},
{
input: '//localhost//pig',
base: 'file://lion/',
href: 'file:///pig',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/pig',
search: '',
hash: '',
},
{
input: '/..//localhost//pig',
base: 'file://lion/',
href: 'file://lion/localhost//pig',
protocol: 'file:',
username: '',
password: '',
host: 'lion',
hostname: 'lion',
port: '',
pathname: '/localhost//pig',
search: '',
hash: '',
},
{
input: 'file://',
base: 'file://ape/',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
'# File URLs with non-empty hosts',
{
input: '/rooibos',
base: 'file://tea/',
href: 'file://tea/rooibos',
protocol: 'file:',
username: '',
password: '',
host: 'tea',
hostname: 'tea',
port: '',
pathname: '/rooibos',
search: '',
hash: '',
},
{
input: '/?chai',
base: 'file://tea/',
href: 'file://tea/?chai',
protocol: 'file:',
username: '',
password: '',
host: 'tea',
hostname: 'tea',
port: '',
pathname: '/',
search: '?chai',
hash: '',
},
"# Windows drive letter handling with the 'file:' base URL",
{
input: 'C|',
base: 'file://host/dir/file',
href: 'file:///C:',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:',
search: '',
hash: '',
},
{
input: 'C|#',
base: 'file://host/dir/file',
href: 'file:///C:#',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:',
search: '',
hash: '',
},
{
input: 'C|?',
base: 'file://host/dir/file',
href: 'file:///C:?',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:',
search: '',
hash: '',
},
{
input: 'C|/',
base: 'file://host/dir/file',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
{
input: 'C|\n/',
base: 'file://host/dir/file',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
{
input: 'C|\\',
base: 'file://host/dir/file',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
{
input: 'C',
base: 'file://host/dir/file',
href: 'file://host/dir/C',
protocol: 'file:',
username: '',
password: '',
host: 'host',
hostname: 'host',
port: '',
pathname: '/dir/C',
search: '',
hash: '',
},
{
input: 'C|a',
base: 'file://host/dir/file',
href: 'file://host/dir/C|a',
protocol: 'file:',
username: '',
password: '',
host: 'host',
hostname: 'host',
port: '',
pathname: '/dir/C|a',
search: '',
hash: '',
},
'# Windows drive letter quirk in the file slash state',
{
input: '/c:/foo/bar',
base: 'file:///c:/baz/qux',
href: 'file:///c:/foo/bar',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/c:/foo/bar',
search: '',
hash: '',
},
{
input: '/c|/foo/bar',
base: 'file:///c:/baz/qux',
href: 'file:///c:/foo/bar',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/c:/foo/bar',
search: '',
hash: '',
},
{
input: 'file:\\c:\\foo\\bar',
base: 'file:///c:/baz/qux',
href: 'file:///c:/foo/bar',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/c:/foo/bar',
search: '',
hash: '',
},
{
input: '/c:/foo/bar',
base: 'file://host/path',
href: 'file:///c:/foo/bar',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/c:/foo/bar',
search: '',
hash: '',
},
'# Windows drive letter quirk with not empty host',
{
input: 'file://example.net/C:/',
base: 'about:blank',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
{
input: 'file://1.2.3.4/C:/',
base: 'about:blank',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
{
input: 'file://[1::8]/C:/',
base: 'about:blank',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
'# Windows drive letter quirk (no host)',
{
input: 'file:/C|/',
base: 'about:blank',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
{
input: 'file://C|/',
base: 'about:blank',
href: 'file:///C:/',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/C:/',
search: '',
hash: '',
},
'# file URLs without base URL by Rimas Misevičius',
{
input: 'file:',
base: 'about:blank',
href: 'file:///',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'file:?q=v',
base: 'about:blank',
href: 'file:///?q=v',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '?q=v',
hash: '',
},
{
input: 'file:#frag',
base: 'about:blank',
href: 'file:///#frag',
protocol: 'file:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '#frag',
},
'# IPv6 tests',
{
input: 'http://[1:0::]',
base: 'http://example.net/',
href: 'http://[1::]/',
origin: 'http://[1::]',
protocol: 'http:',
username: '',
password: '',
host: '[1::]',
hostname: '[1::]',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://[0:1:2:3:4:5:6:7:8]',
base: 'http://example.net/',
failure: true,
},
{
input: 'https://[0::0::0]',
base: 'about:blank',
failure: true,
},
{
input: 'https://[0:.0]',
base: 'about:blank',
failure: true,
},
{
input: 'https://[0:0:]',
base: 'about:blank',
failure: true,
},
{
input: 'https://[0:1:2:3:4:5:6:7.0.0.0.1]',
base: 'about:blank',
failure: true,
},
{
input: 'https://[0:1.00.0.0.0]',
base: 'about:blank',
failure: true,
},
{
input: 'https://[0:1.290.0.0.0]',
base: 'about:blank',
failure: true,
},
{
input: 'https://[0:1.23.23]',
base: 'about:blank',
failure: true,
},
'# Empty host',
{
input: 'http://?',
base: 'about:blank',
failure: true,
},
{
input: 'http://#',
base: 'about:blank',
failure: true,
},
'Port overflow (2^32 + 81)',
{
input: 'http://f:4294967377/c',
base: 'http://example.org/',
failure: true,
},
'Port overflow (2^64 + 81)',
{
input: 'http://f:18446744073709551697/c',
base: 'http://example.org/',
failure: true,
},
'Port overflow (2^128 + 81)',
{
input: 'http://f:340282366920938463463374607431768211537/c',
base: 'http://example.org/',
failure: true,
},
'# Non-special-URL path tests',
{
input: 'sc://ñ',
base: 'about:blank',
href: 'sc://%C3%B1',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '%C3%B1',
hostname: '%C3%B1',
port: '',
pathname: '',
search: '',
hash: '',
},
{
input: 'sc://ñ?x',
base: 'about:blank',
href: 'sc://%C3%B1?x',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '%C3%B1',
hostname: '%C3%B1',
port: '',
pathname: '',
search: '?x',
hash: '',
},
{
input: 'sc://ñ#x',
base: 'about:blank',
href: 'sc://%C3%B1#x',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '%C3%B1',
hostname: '%C3%B1',
port: '',
pathname: '',
search: '',
hash: '#x',
},
{
input: '#x',
base: 'sc://ñ',
href: 'sc://%C3%B1#x',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '%C3%B1',
hostname: '%C3%B1',
port: '',
pathname: '',
search: '',
hash: '#x',
},
{
input: '?x',
base: 'sc://ñ',
href: 'sc://%C3%B1?x',
origin: 'null',
protocol: 'sc:',
username: '',
password: '',
host: '%C3%B1',
hostname: '%C3%B1',
port: '',
pathname: '',
search: '?x',
hash: '',
},
{
input: 'sc://?',
base: 'about:blank',
href: 'sc://?',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '',
search: '',
hash: '',
},
{
input: 'sc://#',
base: 'about:blank',
href: 'sc://#',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '',
search: '',
hash: '',
},
{
input: '///',
base: 'sc://x/',
href: 'sc:///',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: '////',
base: 'sc://x/',
href: 'sc:////',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '//',
search: '',
hash: '',
},
{
input: '////x/',
base: 'sc://x/',
href: 'sc:////x/',
protocol: 'sc:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '//x/',
search: '',
hash: '',
},
{
input: 'tftp://foobar.com/someconfig;mode=netascii',
base: 'about:blank',
href: 'tftp://foobar.com/someconfig;mode=netascii',
origin: 'null',
protocol: 'tftp:',
username: '',
password: '',
host: 'foobar.com',
hostname: 'foobar.com',
port: '',
pathname: '/someconfig;mode=netascii',
search: '',
hash: '',
},
{
input: 'telnet://user:pass@foobar.com:23/',
base: 'about:blank',
href: 'telnet://user:pass@foobar.com:23/',
origin: 'null',
protocol: 'telnet:',
username: 'user',
password: 'pass',
host: 'foobar.com:23',
hostname: 'foobar.com',
port: '23',
pathname: '/',
search: '',
hash: '',
},
{
input: 'ut2004://10.10.10.10:7777/Index.ut2',
base: 'about:blank',
href: 'ut2004://10.10.10.10:7777/Index.ut2',
origin: 'null',
protocol: 'ut2004:',
username: '',
password: '',
host: '10.10.10.10:7777',
hostname: '10.10.10.10',
port: '7777',
pathname: '/Index.ut2',
search: '',
hash: '',
},
{
input: 'redis://foo:bar@somehost:6379/0?baz=bam&qux=baz',
base: 'about:blank',
href: 'redis://foo:bar@somehost:6379/0?baz=bam&qux=baz',
origin: 'null',
protocol: 'redis:',
username: 'foo',
password: 'bar',
host: 'somehost:6379',
hostname: 'somehost',
port: '6379',
pathname: '/0',
search: '?baz=bam&qux=baz',
hash: '',
},
{
input: 'rsync://foo@host:911/sup',
base: 'about:blank',
href: 'rsync://foo@host:911/sup',
origin: 'null',
protocol: 'rsync:',
username: 'foo',
password: '',
host: 'host:911',
hostname: 'host',
port: '911',
pathname: '/sup',
search: '',
hash: '',
},
{
input: 'git://github.com/foo/bar.git',
base: 'about:blank',
href: 'git://github.com/foo/bar.git',
origin: 'null',
protocol: 'git:',
username: '',
password: '',
host: 'github.com',
hostname: 'github.com',
port: '',
pathname: '/foo/bar.git',
search: '',
hash: '',
},
{
input: 'irc://myserver.com:6999/channel?passwd',
base: 'about:blank',
href: 'irc://myserver.com:6999/channel?passwd',
origin: 'null',
protocol: 'irc:',
username: '',
password: '',
host: 'myserver.com:6999',
hostname: 'myserver.com',
port: '6999',
pathname: '/channel',
search: '?passwd',
hash: '',
},
{
input: 'dns://fw.example.org:9999/foo.bar.org?type=TXT',
base: 'about:blank',
href: 'dns://fw.example.org:9999/foo.bar.org?type=TXT',
origin: 'null',
protocol: 'dns:',
username: '',
password: '',
host: 'fw.example.org:9999',
hostname: 'fw.example.org',
port: '9999',
pathname: '/foo.bar.org',
search: '?type=TXT',
hash: '',
},
{
input: 'ldap://localhost:389/ou=People,o=JNDITutorial',
base: 'about:blank',
href: 'ldap://localhost:389/ou=People,o=JNDITutorial',
origin: 'null',
protocol: 'ldap:',
username: '',
password: '',
host: 'localhost:389',
hostname: 'localhost',
port: '389',
pathname: '/ou=People,o=JNDITutorial',
search: '',
hash: '',
},
{
input: 'git+https://github.com/foo/bar',
base: 'about:blank',
href: 'git+https://github.com/foo/bar',
origin: 'null',
protocol: 'git+https:',
username: '',
password: '',
host: 'github.com',
hostname: 'github.com',
port: '',
pathname: '/foo/bar',
search: '',
hash: '',
},
{
input: 'urn:ietf:rfc:2648',
base: 'about:blank',
href: 'urn:ietf:rfc:2648',
origin: 'null',
protocol: 'urn:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'ietf:rfc:2648',
search: '',
hash: '',
},
{
input: 'tag:joe@example.org,2001:foo/bar',
base: 'about:blank',
href: 'tag:joe@example.org,2001:foo/bar',
origin: 'null',
protocol: 'tag:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'joe@example.org,2001:foo/bar',
search: '',
hash: '',
},
'# percent encoded hosts in non-special-URLs',
{
input: 'non-special://%E2%80%A0/',
base: 'about:blank',
href: 'non-special://%E2%80%A0/',
protocol: 'non-special:',
username: '',
password: '',
host: '%E2%80%A0',
hostname: '%E2%80%A0',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'non-special://H%4fSt/path',
base: 'about:blank',
href: 'non-special://H%4fSt/path',
protocol: 'non-special:',
username: '',
password: '',
host: 'H%4fSt',
hostname: 'H%4fSt',
port: '',
pathname: '/path',
search: '',
hash: '',
},
'# IPv6 in non-special-URLs',
{
input: 'non-special://[1:2:0:0:5:0:0:0]/',
base: 'about:blank',
href: 'non-special://[1:2:0:0:5::]/',
protocol: 'non-special:',
username: '',
password: '',
host: '[1:2:0:0:5::]',
hostname: '[1:2:0:0:5::]',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'non-special://[1:2:0:0:0:0:0:3]/',
base: 'about:blank',
href: 'non-special://[1:2::3]/',
protocol: 'non-special:',
username: '',
password: '',
host: '[1:2::3]',
hostname: '[1:2::3]',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'non-special://[1:2::3]:80/',
base: 'about:blank',
href: 'non-special://[1:2::3]:80/',
protocol: 'non-special:',
username: '',
password: '',
host: '[1:2::3]:80',
hostname: '[1:2::3]',
port: '80',
pathname: '/',
search: '',
hash: '',
},
{
input: 'non-special://[:80/',
base: 'about:blank',
failure: true,
},
{
input: 'blob:https://example.com:443/',
base: 'about:blank',
href: 'blob:https://example.com:443/',
protocol: 'blob:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'https://example.com:443/',
search: '',
hash: '',
},
{
input: 'blob:d3958f5c-0777-0845-9dcf-2cb28783acaf',
base: 'about:blank',
href: 'blob:d3958f5c-0777-0845-9dcf-2cb28783acaf',
protocol: 'blob:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: 'd3958f5c-0777-0845-9dcf-2cb28783acaf',
search: '',
hash: '',
},
'Invalid IPv4 radix digits',
{
input: 'http://0177.0.0.0189',
base: 'about:blank',
href: 'http://0177.0.0.0189/',
protocol: 'http:',
username: '',
password: '',
host: '0177.0.0.0189',
hostname: '0177.0.0.0189',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://0x7f.0.0.0x7g',
base: 'about:blank',
href: 'http://0x7f.0.0.0x7g/',
protocol: 'http:',
username: '',
password: '',
host: '0x7f.0.0.0x7g',
hostname: '0x7f.0.0.0x7g',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://0X7F.0.0.0X7G',
base: 'about:blank',
href: 'http://0x7f.0.0.0x7g/',
protocol: 'http:',
username: '',
password: '',
host: '0x7f.0.0.0x7g',
hostname: '0x7f.0.0.0x7g',
port: '',
pathname: '/',
search: '',
hash: '',
},
'Invalid IPv4 portion of IPv6 address',
{
input: 'http://[::127.0.0.0.1]',
base: 'about:blank',
failure: true,
},
'Uncompressed IPv6 addresses with 0',
{
input: 'http://[0:1:0:1:0:1:0:1]',
base: 'about:blank',
href: 'http://[0:1:0:1:0:1:0:1]/',
protocol: 'http:',
username: '',
password: '',
host: '[0:1:0:1:0:1:0:1]',
hostname: '[0:1:0:1:0:1:0:1]',
port: '',
pathname: '/',
search: '',
hash: '',
},
{
input: 'http://[1:0:1:0:1:0:1:0]',
base: 'about:blank',
href: 'http://[1:0:1:0:1:0:1:0]/',
protocol: 'http:',
username: '',
password: '',
host: '[1:0:1:0:1:0:1:0]',
hostname: '[1:0:1:0:1:0:1:0]',
port: '',
pathname: '/',
search: '',
hash: '',
},
'Percent-encoded query and fragment',
{
input: 'http://example.org/test?\u0022',
base: 'about:blank',
href: 'http://example.org/test?%22',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?%22',
hash: '',
},
{
input: 'http://example.org/test?\u0023',
base: 'about:blank',
href: 'http://example.org/test?#',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '',
hash: '',
},
{
input: 'http://example.org/test?\u003C',
base: 'about:blank',
href: 'http://example.org/test?%3C',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?%3C',
hash: '',
},
{
input: 'http://example.org/test?\u003E',
base: 'about:blank',
href: 'http://example.org/test?%3E',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?%3E',
hash: '',
},
{
input: 'http://example.org/test?\u2323',
base: 'about:blank',
href: 'http://example.org/test?%E2%8C%A3',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?%E2%8C%A3',
hash: '',
},
{
input: 'http://example.org/test?%23%23',
base: 'about:blank',
href: 'http://example.org/test?%23%23',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?%23%23',
hash: '',
},
/*
{
input: 'http://example.org/test?%GH',
base: 'about:blank',
href: 'http://example.org/test?%GH',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?%GH',
hash: '',
},
*/
{
input: 'http://example.org/test?a#%EF',
base: 'about:blank',
href: 'http://example.org/test?a#%EF',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?a',
hash: '#%EF',
},
{
input: 'http://example.org/test?a#%GH',
base: 'about:blank',
href: 'http://example.org/test?a#%GH',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?a',
hash: '#%GH',
},
'URLs that require a non-about:blank base. (Also serve as invalid base tests.)',
{
input: 'a',
base: 'about:blank',
failure: true,
},
{
input: 'a/',
base: 'about:blank',
failure: true,
},
{
input: 'a//',
base: 'about:blank',
failure: true,
},
"Bases that don't fail to parse but fail to be bases",
{
input: 'test-a-colon.html',
base: 'a:',
failure: true,
},
{
input: 'test-a-colon-b.html',
base: 'a:b',
failure: true,
},
'Other base URL tests, that must succeed',
{
input: 'test-a-colon-slash.html',
base: 'a:/',
href: 'a:/test-a-colon-slash.html',
protocol: 'a:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test-a-colon-slash.html',
search: '',
hash: '',
},
{
input: 'test-a-colon-slash-slash.html',
base: 'a://',
href: 'a:///test-a-colon-slash-slash.html',
protocol: 'a:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test-a-colon-slash-slash.html',
search: '',
hash: '',
},
{
input: 'test-a-colon-slash-b.html',
base: 'a:/b',
href: 'a:/test-a-colon-slash-b.html',
protocol: 'a:',
username: '',
password: '',
host: '',
hostname: '',
port: '',
pathname: '/test-a-colon-slash-b.html',
search: '',
hash: '',
},
{
input: 'test-a-colon-slash-slash-b.html',
base: 'a://b',
href: 'a://b/test-a-colon-slash-slash-b.html',
protocol: 'a:',
username: '',
password: '',
host: 'b',
hostname: 'b',
port: '',
pathname: '/test-a-colon-slash-slash-b.html',
search: '',
hash: '',
},
'Null code point in fragment',
{
input: 'http://example.org/test?a#b\u0000c',
base: 'about:blank',
href: 'http://example.org/test?a#bc',
protocol: 'http:',
username: '',
password: '',
host: 'example.org',
hostname: 'example.org',
port: '',
pathname: '/test',
search: '?a',
hash: '#bc',
},
];
---
---
### For enterprise
Available as part of the Tidelift Subscription.
The maintainers of `core-js` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-core-js?utm_source=npm-core-js&utm_medium=referral&utm_campaign=enterprise)
---
[*Example of usage*](http://goo.gl/a2xexl):
```js
import 'core-js'; // <- at the top of your entry point
Array.from(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3]
[1, [2, 3], [4, [5]]].flat(2); // => [1, 2, 3, 4, 5]
Promise.resolve(32).then(x => console.log(x)); // => 32
```
*You can load only required features*:
```js
import 'core-js/features/array/from'; // <- at the top of your entry point
import 'core-js/features/array/flat'; // <- at the top of your entry point
import 'core-js/features/set'; // <- at the top of your entry point
import 'core-js/features/promise'; // <- at the top of your entry point
Array.from(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3]
[1, [2, 3], [4, [5]]].flat(2); // => [1, 2, 3, 4, 5]
Promise.resolve(32).then(x => console.log(x)); // => 32
```
*Or use it without global namespace pollution*:
```js
import from from 'core-js-pure/features/array/from';
import flat from 'core-js-pure/features/array/flat';
import Set from 'core-js-pure/features/set';
import Promise from 'core-js-pure/features/promise';
from(new Set([1, 2, 3, 2, 1])); // => [1, 2, 3]
flat([1, [2, 3], [4, [5]]], 2); // => [1, 2, 3, 4, 5]
Promise.resolve(32).then(x => console.log(x)); // => 32
```
### Index
- [Usage](#usage)
- [Installation](#installation)
- [`postinstall` message](#postinstall-message)
- [CommonJS API](#commonjs-api)
- [Babel](#babel)
- [`@babel/polyfill`](#babelpolyfill)
- [`@babel/preset-env`](#babelpreset-env)
- [`@babel/runtime`](#babelruntime)
- [Configurable level of aggressiveness](#configurable-level-of-aggressiveness)
- [Custom build](#custom-build)
- [Compatibility data](#compatibility-data)
- [Supported engines](#supported-engines)
- [Features](#features)
- [ECMAScript](#ecmascript)
- [ECMAScript: Object](#ecmascript-object)
- [ECMAScript: Function](#ecmascript-function)
- [ECMAScript: Array](#ecmascript-array)
- [ECMAScript: String and RegExp](#ecmascript-string-and-regexp)
- [ECMAScript: Number](#ecmascript-number)
- [ECMAScript: Math](#ecmascript-math)
- [ECMAScript: Date](#ecmascript-date)
- [ECMAScript: Promise](#ecmascript-promise)
- [ECMAScript: Symbol](#ecmascript-symbol)
- [ECMAScript: Collections](#ecmascript-collections)
- [ECMAScript: Typed Arrays](#ecmascript-typed-arrays)
- [ECMAScript: Reflect](#ecmascript-reflect)
- [ECMAScript: JSON](#ecmascript-json)
- [ECMAScript: globalThis](#ecmascript-globalthis)
- [ECMAScript proposals](#ecmascript-proposals)
- [stage 4 proposals](#stage-4-proposals)
- [stage 3 proposals](#stage-3-proposals)
- [stage 2 proposals](#stage-2-proposals)
- [stage 1 proposals](#stage-1-proposals)
- [stage 0 proposals](#stage-0-proposals)
- [pre-stage 0 proposals](#pre-stage-0-proposals)
- [Web standards](#web-standards)
- [`setTimeout` and `setInterval`](#settimeout-and-setinterval)
- [`setImmediate`](#setimmediate)
- [`queueMicrotask`](#queuemicrotask)
- [`URL` and `URLSearchParams`](#url-and-urlsearchparams)
- [iterable DOM collections](#iterable-dom-collections)
- [Iteration helpers](#iteration-helpers)
- [Missing polyfills](#missing-polyfills)
- [Contributing](./CONTRIBUTING.md)
- [Security policy](https://github.com/zloirock/core-js/blob/master/SECURITY.md)
- [Changelog](./CHANGELOG.md)
## Usage
### Installation:
```
// global version
npm install --save core-js@3.6.1
// version without global namespace pollution
npm install --save core-js-pure@3.6.1
// bundled global version
npm install --save core-js-bundle@3.6.1
```
Already bundled version of `core-js` [on CDN](https://unpkg.com/core-js-bundle@3.6.1) ([minified version](https://unpkg.com/core-js-bundle@3.6.1/minified.js)).
### `postinstall` message
The `core-js` project needs your help, so the package shows a message about it after installation. If it causes problems for you, you can disable it:
```
ADBLOCK=true npm install
// or
DISABLE_OPENCOLLECTIVE=true npm install
// or
npm install --loglevel silent
```
### CommonJS API
You can import only-required-for-you polyfills, like in examples at the top of `README.md`. Available CommonJS entry points for all polyfilled methods / constructors and namespaces. Just some examples:
```js
// polyfill all `core-js` features:
import "core-js";
// polyfill only stable `core-js` features - ES and web standards:
import "core-js/stable";
// polyfill only stable ES features:
import "core-js/es";
// if you want to polyfill `Set`:
// all `Set`-related features, with ES proposals:
import "core-js/features/set";
// stable required for `Set` ES features and features from web standards
// (DOM collections iterator in this case):
import "core-js/stable/set";
// only stable ES features required for `Set`:
import "core-js/es/set";
// the same without global namespace pollution:
import Set from "core-js-pure/features/set";
import Set from "core-js-pure/stable/set";
import Set from "core-js-pure/es/set";
// if you want to polyfill just required methods:
import "core-js/features/set/intersection";
import "core-js/stable/queue-microtask";
import "core-js/es/array/from";
// polyfill reflect metadata proposal:
import "core-js/proposals/reflect-metadata";
// polyfill all stage 2+ proposals:
import "core-js/stage/2";
```
##### Caveats when using CommonJS API:
* `modules` path is an internal API, does not inject all required dependencies and can be changed in minor or patch releases. Use it only for a custom build and/or if you know what are you doing.
* If you use `core-js` with the extension of native objects, recommended load all `core-js` modules at the top of the entry point of your application, otherwise, you can have conflicts.
* `core-js` is extremely modular and uses a lot of very tiny modules, because of that for usage in browsers bundle up `core-js` instead of usage loader for each file, otherwise, you will have hundreds of requests.
#### CommonJS and prototype methods without global namespace pollution
In the `pure` version, we can't pollute prototypes of native constructors. Because of that, prototype methods transformed into static methods like in examples above. But with transpilers, we can use one more trick - [bind operator and virtual methods](https://github.com/tc39/proposal-bind-operator). Special for that, available `/virtual/` entry points. Example:
```js
import fill from 'core-js-pure/features/array/virtual/fill';
import findIndex from 'core-js-pure/features/array/virtual/find-index';
Array(10)::fill(0).map((a, b) => b * b)::findIndex(it => it && !(it % 8)); // => 4
// or
import { fill, findIndex } from 'core-js-pure/features/array/virtual';
Array(10)::fill(0).map((a, b) => b * b)::findIndex(it => it && !(it % 8)); // => 4
```
### Babel
`core-js` is integrated with `babel` and is the base for polyfilling-related `babel` features:
#### `@babel/polyfill`
[`@babel/polyfill`](http://babeljs.io/docs/usage/polyfill) [**IS** just the import of stable `core-js` features and `regenerator-runtime`](https://github.com/babel/babel/blob/c8bb4500326700e7dc68ce8c4b90b6482c48d82f/packages/babel-polyfill/src/index.js) for generators and async functions, so if you load `@babel/polyfill` - you load the global version of `core-js` without ES proposals.
Now it's deprecated in favour of separate inclusion of required parts of `core-js` and `regenerator-runtime` and, for preventing breaking changes, left on `core-js@2`.
As a full equal of `@babel/polyfill`, you can use this:
```js
import 'core-js/stable';
import 'regenerator-runtime/runtime';
```
#### `@babel/preset-env`
[`@babel/preset-env`](https://github.com/babel/babel/tree/master/packages/babel-preset-env) has `useBuiltIns` option, which optimizes working with global version of `core-js`. With `useBuiltIns` option, you should also set `corejs` option to used version of `core-js`, like `corejs: '3.6'`.
- `useBuiltIns: 'entry'` replaces imports of `core-js` to import only required for a target environment modules. So, for example,
```js
import 'core-js/stable';
```
with `chrome 71` target will be replaced just to:
```js
import "core-js/modules/es.array.unscopables.flat";
import "core-js/modules/es.array.unscopables.flat-map";
import "core-js/modules/es.object.from-entries";
import "core-js/modules/web.immediate";
```
It works for all entry points of global version of `core-js` and their combinations, for example for
```js
import 'core-js/es';
import 'core-js/proposals/set-methods';
import 'core-js/features/set/map';
```
with `chrome 71` target you will have as a result:
```js
import "core-js/modules/es.array.unscopables.flat";
import "core-js/modules/es.array.unscopables.flat-map";
import "core-js/modules/es.object.from-entries";
import "core-js/modules/esnext.set.difference";
import "core-js/modules/esnext.set.intersection";
import "core-js/modules/esnext.set.is-disjoint-from";
import "core-js/modules/esnext.set.is-subset-of";
import "core-js/modules/esnext.set.is-superset-of";
import "core-js/modules/esnext.set.map";
import "core-js/modules/esnext.set.symmetric-difference";
import "core-js/modules/esnext.set.union";
```
- `useBuiltIns: 'usage'` adds to the top of each file import of polyfills for features used in this file and not supported by target environments, so for:
```js
// first file:
var set = new Set([1, 2, 3]);
// second file:
var array = Array.of(1, 2, 3);
```
if target contains an old environment like `IE 11` we will have something like:
```js
// first file:
import 'core-js/modules/es.array.iterator';
import 'core-js/modules/es.object.to-string';
import 'core-js/modules/es.set';
var set = new Set([1, 2, 3]);
// second file:
import 'core-js/modules/es.array.of';
var array = Array.of(1, 2, 3);
```
By default, `@babel/preset-env` with `useBuiltIns: 'usage'` option only polyfills stable features, but you can enable polyfilling of proposals by `proposals` option, as `corejs: { version: '3.6', proposals: true }`.
#### `@babel/runtime`
[`@babel/runtime`](http://babeljs.io/docs/plugins/transform-runtime/) with `corejs: 3` option simplifies work with `core-js-pure`. It automatically replaces usage of modern features from JS standard library to imports from the version of `core-js` without global namespace pollution, so instead of:
```js
import from from 'core-js-pure/stable/array/from';
import flat from 'core-js-pure/stable/array/flat';
import Set from 'core-js-pure/stable/set';
import Promise from 'core-js-pure/stable/promise';
from(new Set([1, 2, 3, 2, 1]));
flat([1, [2, 3], [4, [5]]], 2);
Promise.resolve(32).then(x => console.log(x));
```
you can write just:
```js
Array.from(new Set([1, 2, 3, 2, 1]));
[1, [2, 3], [4, [5]]].flat(2);
Promise.resolve(32).then(x => console.log(x));
```
By default, `@babel/runtime` only polyfills stable features, but like in `@babel/preset-env`, you can enable polyfilling of proposals by `proposals` option, as `corejs: { version: 3, proposals: true }`.
**Warning!** If you use `@babel/preset-env` and `@babel/runtime` together, use `corejs` option only in one place since it's duplicate functionality and will cause conflicts.
### Configurable level of aggressiveness
By default, `core-js` sets polyfills only when they are required. That means that `core-js` checks if a feature is available and works correctly or not and if it has no problems, `core-js` use native implementation.
But sometimes `core-js` feature detection could be too strict for your case. For example, `Promise` constructor requires the support of unhandled rejection tracking and `@@species`.
Sometimes we could have inverse problem - knowingly broken environment with problems not covered by `core-js` feature detection.
For those cases, we could redefine this behaviour for certain polyfills:
```js
const configurator = require('core-js/configurator');
configurator({
useNative: ['Promise'], // polyfills will be used only if natives completely unavailable
usePolyfill: ['Array.from', 'String.prototype.padEnd'], // polyfills will be used anyway
useFeatureDetection: ['Map', 'Set'], // default behaviour
});
require('core-js');
```
It does not work with some features. Also, if you change the default behaviour, even `core-js` internals may not work correctly.
### Custom build
For some cases could be useful adding a blacklist of features or generation a polyfill for target engines. You could use [`core-js-builder`](/packages/core-js-builder) package for that.
### Compatibility data
[`core-js-compat`](/packages/core-js-compat) package contains data about the necessity of `core-js` modules and API for getting a list of required `core-js` modules by `browserslist` query.
## Supported engines
**Tested in:**
- Chrome 26+
- Firefox 4+
- Safari 5+
- Opera 12+
- Internet Explorer 8+ (sure, IE8 with ES3 limitations; IE7- also should work, but no longer tested)
- Edge
- Android Browser 2.3+
- iOS Safari 5.1+
- PhantomJS 1.9+
- NodeJS 0.8+
...and it doesn't mean `core-js` will not work in other engines, they just have not been tested.
## Features:
[*CommonJS entry points:*](#commonjs-api)
```
core-js(-pure)
```
### ECMAScript
[*CommonJS entry points:*](#commonjs-api)
```
core-js(-pure)/es
```
#### ECMAScript: Object
Modules [`es.object.assign`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.assign.js), [`es.object.is`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.is.js), [`es.object.set-prototype-of`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.set-prototype-of.js), [`es.object.to-string`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.to-string.js), [`es.object.freeze`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.freeze.js), [`es.object.seal`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.seal.js), [`es.object.prevent-extensions`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.prevent-extensions.js), [`es.object.is-frozen`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.is-frozen.js), [`es.object.is-sealed`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.is-sealed.js), [`es.object.is-extensible`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.is-extensible.js), [`es.object.get-own-property-descriptor`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.get-own-property-descriptor.js), [`es.object.get-own-property-descriptors`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.get-own-property-descriptors.js), [`es.object.get-prototype-of`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.get-prototype-of.js), [`es.object.keys`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.keys.js), [`es.object.values`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.values.js), [`es.object.entries`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.entries.js), [`es.object.get-own-property-names`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.get-own-property-names.js) and [`es.object.from-entries`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.from-entries.js).
Just ES5 features: [`es.object.create`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.create.js), [`es.object.define-property`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.define-property.js) and [`es.object.define-properties`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.es.object.define-properties.js).
[ES2017 Annex B](https://tc39.github.io/ecma262/#sec-object.prototype.__defineGetter__) - modules [`es.object.define-setter`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.define-setter.js), [`es.object.define-getter`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.define-getter.js), [`es.object.lookup-setter`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.lookup-setter.js) and [`es.object.lookup-getter`](https://github.com/zloirock/core-js/blob/v3.6.1/packages/core-js/modules/es.object.lookup-getter.js)
```js
class Object {
toString(): string; // ES2015+ fix: @@toStringTag support
__defineGetter__(property: PropertyKey, getter: Function): void;
__defineSetter__(property: PropertyKey, setter: Function): void;
__lookupGetter__(property: PropertyKey): Function | void;
__lookupSetter__(property: PropertyKey): Function | void;
static assign(target: Object, ...sources: Array