This commit is contained in:
Yamozha
2021-04-02 02:24:13 +03:00
parent c23950b545
commit 7256d79e2c
31493 changed files with 3036630 additions and 0 deletions

207
node_modules/es-abstract/test/GetIntrinsic.js generated vendored Normal file
View File

@ -0,0 +1,207 @@
'use strict';
var GetIntrinsic = require('get-intrinsic');
var test = require('tape');
var forEach = require('foreach');
var debug = require('object-inspect');
var generatorFns = require('make-generator-function')();
var asyncFns = require('make-async-function').list();
var asyncGenFns = require('make-async-generator-function')();
var callBound = require('call-bind/callBound');
var v = require('es-value-fixtures');
var $gOPD = require('../helpers/getOwnPropertyDescriptor');
var defineProperty = require('./helpers/defineProperty');
var $isProto = callBound('%Object.prototype.isPrototypeOf%');
test('export', function (t) {
t.equal(typeof GetIntrinsic, 'function', 'it is a function');
t.equal(GetIntrinsic.length, 2, 'function has length of 2');
t.end();
});
test('throws', function (t) {
t['throws'](
function () { GetIntrinsic('not an intrinsic'); },
SyntaxError,
'nonexistent intrinsic throws a syntax error'
);
t['throws'](
function () { GetIntrinsic(''); },
TypeError,
'empty string intrinsic throws a type error'
);
t['throws'](
function () { GetIntrinsic('.'); },
SyntaxError,
'"just a dot" intrinsic throws a syntax error'
);
forEach(v.nonStrings, function (nonString) {
t['throws'](
function () { GetIntrinsic(nonString); },
TypeError,
debug(nonString) + ' is not a String'
);
});
forEach(v.nonBooleans, function (nonBoolean) {
t['throws'](
function () { GetIntrinsic('%', nonBoolean); },
TypeError,
debug(nonBoolean) + ' is not a Boolean'
);
});
forEach([
'toString',
'propertyIsEnumerable',
'hasOwnProperty'
], function (objectProtoMember) {
t['throws'](
function () { GetIntrinsic(objectProtoMember); },
SyntaxError,
debug(objectProtoMember) + ' is not an intrinsic'
);
});
t.end();
});
test('base intrinsics', function (t) {
t.equal(GetIntrinsic('%Object%'), Object, '%Object% yields Object');
t.equal(GetIntrinsic('Object'), Object, 'Object yields Object');
t.equal(GetIntrinsic('%Array%'), Array, '%Array% yields Array');
t.equal(GetIntrinsic('Array'), Array, 'Array yields Array');
t.end();
});
test('dotted paths', function (t) {
t.equal(GetIntrinsic('%Object.prototype.toString%'), Object.prototype.toString, '%Object.prototype.toString% yields Object.prototype.toString');
t.equal(GetIntrinsic('Object.prototype.toString'), Object.prototype.toString, 'Object.prototype.toString yields Object.prototype.toString');
t.equal(GetIntrinsic('%Array.prototype.push%'), Array.prototype.push, '%Array.prototype.push% yields Array.prototype.push');
t.equal(GetIntrinsic('Array.prototype.push'), Array.prototype.push, 'Array.prototype.push yields Array.prototype.push');
test('underscore paths are aliases for dotted paths', { skip: !Object.isFrozen || Object.isFrozen(Object.prototype) }, function (st) {
var original = GetIntrinsic('%ObjProto_toString%');
forEach([
'%Object.prototype.toString%',
'Object.prototype.toString',
'%ObjectPrototype.toString%',
'ObjectPrototype.toString',
'%ObjProto_toString%',
'ObjProto_toString'
], function (name) {
defineProperty(Object.prototype, 'toString', {
value: function toString() {
return original.apply(this, arguments);
}
});
st.equal(GetIntrinsic(name), original, name + ' yields original Object.prototype.toString');
});
defineProperty(Object.prototype, 'toString', { value: original });
st.end();
});
test('dotted paths cache', { skip: !Object.isFrozen || Object.isFrozen(Object.prototype) }, function (st) {
var original = GetIntrinsic('%Object.prototype.propertyIsEnumerable%');
forEach([
'%Object.prototype.propertyIsEnumerable%',
'Object.prototype.propertyIsEnumerable',
'%ObjectPrototype.propertyIsEnumerable%',
'ObjectPrototype.propertyIsEnumerable'
], function (name) {
// eslint-disable-next-line no-extend-native
Object.prototype.propertyIsEnumerable = function propertyIsEnumerable() {
return original.apply(this, arguments);
};
st.equal(GetIntrinsic(name), original, name + ' yields cached Object.prototype.propertyIsEnumerable');
});
// eslint-disable-next-line no-extend-native
Object.prototype.propertyIsEnumerable = original;
st.end();
});
test('dotted path reports correct error', function (st) {
st['throws'](function () {
GetIntrinsic('%NonExistentIntrinsic.prototype.property%');
}, /%NonExistentIntrinsic%/, 'The base intrinsic of %NonExistentIntrinsic.prototype.property% is %NonExistentIntrinsic%');
st['throws'](function () {
GetIntrinsic('%NonExistentIntrinsicPrototype.property%');
}, /%NonExistentIntrinsicPrototype%/, 'The base intrinsic of %NonExistentIntrinsicPrototype.property% is %NonExistentIntrinsicPrototype%');
st.end();
});
t.end();
});
test('accessors', { skip: !$gOPD || typeof Map !== 'function' }, function (t) {
var actual = $gOPD(Map.prototype, 'size');
t.ok(actual, 'Map.prototype.size has a descriptor');
t.equal(typeof actual.get, 'function', 'Map.prototype.size has a getter function');
t.equal(GetIntrinsic('%Map.prototype.size%'), actual.get, '%Map.prototype.size% yields the getter for it');
t.equal(GetIntrinsic('Map.prototype.size'), actual.get, 'Map.prototype.size yields the getter for it');
t.end();
});
test('generator functions', { skip: !generatorFns.length }, function (t) {
var $GeneratorFunction = GetIntrinsic('%GeneratorFunction%');
var $GeneratorFunctionPrototype = GetIntrinsic('%Generator%');
var $GeneratorPrototype = GetIntrinsic('%GeneratorPrototype%');
forEach(generatorFns, function (genFn) {
var fnName = genFn.name;
fnName = fnName ? "'" + fnName + "'" : 'genFn';
t.ok(genFn instanceof $GeneratorFunction, fnName + ' instanceof %GeneratorFunction%');
t.ok($isProto($GeneratorFunctionPrototype, genFn), '%Generator% is prototype of ' + fnName);
t.ok($isProto($GeneratorPrototype, genFn.prototype), '%GeneratorPrototype% is prototype of ' + fnName + '.prototype');
});
t.end();
});
test('async functions', { skip: !asyncFns.length }, function (t) {
var $AsyncFunction = GetIntrinsic('%AsyncFunction%');
var $AsyncFunctionPrototype = GetIntrinsic('%AsyncFunctionPrototype%');
forEach(asyncFns, function (asyncFn) {
var fnName = asyncFn.name;
fnName = fnName ? "'" + fnName + "'" : 'asyncFn';
t.ok(asyncFn instanceof $AsyncFunction, fnName + ' instanceof %AsyncFunction%');
t.ok($isProto($AsyncFunctionPrototype, asyncFn), '%AsyncFunctionPrototype% is prototype of ' + fnName);
});
t.end();
});
test('async generator functions', { skip: !asyncGenFns.length }, function (t) {
var $AsyncGeneratorFunction = GetIntrinsic('%AsyncGeneratorFunction%');
var $AsyncGeneratorFunctionPrototype = GetIntrinsic('%AsyncGenerator%');
var $AsyncGeneratorPrototype = GetIntrinsic('%AsyncGeneratorPrototype%');
forEach(asyncGenFns, function (asyncGenFn) {
var fnName = asyncGenFn.name;
fnName = fnName ? "'" + fnName + "'" : 'asyncGenFn';
t.ok(asyncGenFn instanceof $AsyncGeneratorFunction, fnName + ' instanceof %AsyncGeneratorFunction%');
t.ok($isProto($AsyncGeneratorFunctionPrototype, asyncGenFn), '%AsyncGenerator% is prototype of ' + fnName);
t.ok($isProto($AsyncGeneratorPrototype, asyncGenFn.prototype), '%AsyncGeneratorPrototype% is prototype of ' + fnName + '.prototype');
});
t.end();
});

58
node_modules/es-abstract/test/diffOps.js generated vendored Normal file
View File

@ -0,0 +1,58 @@
'use strict';
var keys = require('object-keys');
var forEach = require('foreach');
var indexOf = require('array.prototype.indexof');
var has = require('has');
module.exports = function diffOperations(actual, expected, expectedMissing) {
var actualKeys = keys(actual);
var expectedKeys = keys(expected);
var extra = [];
var missing = [];
var extraMissing = [];
forEach(actualKeys, function (op) {
if (!(op in expected)) {
if (actual[op] && typeof actual[op] === 'object') {
forEach(keys(actual[op]), function (nestedOp) {
var fullNestedOp = op + '::' + nestedOp;
if (!(fullNestedOp in expected)) {
extra.push(fullNestedOp);
} else if (indexOf(expectedMissing, fullNestedOp) !== -1) {
extra.push(fullNestedOp);
}
});
} else {
extra.push(op);
}
} else if (indexOf(expectedMissing, op) !== -1) {
extra.push(op);
}
});
var checkMissing = function checkMissing(op, actualValue) {
if (typeof actualValue !== 'function' && indexOf(expectedMissing, op) === -1) {
missing.push(op);
}
};
forEach(expectedKeys, function (op) {
if (op.indexOf('::') > -1) {
var parts = op.split('::');
var value = actual[parts[0]];
if (value && typeof value === 'object' && typeof value[parts[1]] === 'function') {
checkMissing(op, value[parts[1]]);
}
} else {
checkMissing(op, actual[op]);
}
});
forEach(expectedMissing, function (expectedOp) {
if (!has(expected, expectedOp)) {
extraMissing.push(expectedOp);
}
});
return { missing: missing, extra: extra, extraMissing: extraMissing };
};

144
node_modules/es-abstract/test/es2015.js generated vendored Normal file
View File

@ -0,0 +1,144 @@
'use strict';
var ES = require('../').ES2015;
var boundES = require('./helpers/createBoundESNamespace')(ES);
var ops = require('../operations/2015');
var expectedMissing = [
'AddRestrictedFunctionProperties',
'AllocateArrayBuffer',
'AllocateTypedArray',
'BoundFunctionCreate',
'Canonicalize',
'CharacterRange',
'CharacterSetMatcher',
'CloneArrayBuffer',
'Completion',
'Construct',
'CopyDataBlockBytes',
'CreateArrayFromList',
'CreateArrayIterator',
'CreateBuiltinFunction',
'CreateByteDataBlock',
'CreateDynamicFunction',
'CreateIntrinsics',
'CreateListIterator',
'CreateMapIterator',
'CreateMappedArgumentsObject',
'CreatePerIterationEnvironment',
'CreateRealm',
'CreateSetIterator',
'CreateUnmappedArgumentsObject',
'DaylightSavingTA',
'Decode',
'DetachArrayBuffer',
'Encode',
'EnqueueJob',
'EscapeRegExpPattern',
'EvalDeclarationInstantiation',
'EvaluateCall',
'EvaluateDirectCall',
'EvaluateNew',
'ForBodyEvaluation',
'ForIn/OfBodyEvaluation',
'ForIn/OfHeadEvaluation',
'FulfillPromise',
'FunctionAllocate',
'FunctionCreate',
'FunctionInitialize',
'GeneratorFunctionCreate',
'GeneratorResume',
'GeneratorResumeAbrupt',
'GeneratorStart',
'GeneratorValidate',
'GeneratorYield',
'GetBase',
'GetFunctionRealm',
'GetGlobalObject',
'GetIdentifierReference',
'GetModuleNamespace',
'GetNewTarget',
'GetReferencedName',
'GetSuperConstructor',
'GetTemplateObject',
'GetThisEnvironment',
'GetThisValue',
'GetValue',
'GetValueFromBuffer',
'GetViewValue',
'HasPrimitiveBase',
'HostResolveImportedModule',
'ImportedLocalNames',
'InitializeHostDefinedRealm',
'InitializeReferencedBinding',
'IntegerIndexedElementGet',
'IntegerIndexedElementSet',
'IntegerIndexedObjectCreate',
'InternalizeJSONProperty',
'IsAnonymousFunctionDefinition',
'IsCompatiblePropertyDescriptor',
'IsDetachedBuffer',
'IsInTailPosition',
'IsLabelledFunction',
'IsPropertyReference',
'IsStrictReference',
'IsSuperReference',
'IsUnresolvableReference',
'IsWordChar',
'LocalTime',
'LoopContinues',
'MakeArgGetter',
'MakeArgSetter',
'MakeClassConstructor',
'MakeConstructor',
'MakeMethod',
'MakeSuperPropertyReference',
'max',
'min',
'ModuleNamespaceCreate',
'msPerDay', // constant
'NewDeclarativeEnvironment',
'NewFunctionEnvironment',
'NewGlobalEnvironment',
'NewModuleEnvironment',
'NewObjectEnvironment',
'NewPromiseCapability',
'NormalCompletion',
'ObjectDefineProperties',
'OrdinaryCallBindThis',
'OrdinaryCallEvaluateBody',
'ParseModule',
'PerformEval',
'PerformPromiseAll',
'PerformPromiseRace',
'PerformPromiseThen',
'PrepareForOrdinaryCall',
'PrepareForTailCall',
'ProxyCreate',
'PutValue', // takes a Reference
'RegExpAlloc', // creates a regex with uninitialized internal lots
'RegExpBuiltinExec',
'RegExpInitialize', // initializes allocated regex's internal slots
'RejectPromise',
'RepeatMatcher',
'ResolveBinding',
'ResolveThisBinding',
'SerializeJSONArray',
'SerializeJSONObject',
'SerializeJSONProperty',
'SetDefaultGlobalBindings',
'SetRealmGlobalObject',
'SetValueInBuffer',
'SetViewValue',
'sign',
'SortCompare', // mystery access to `comparefn` arg
'TriggerPromiseReactions',
'TypedArrayFrom',
'UpdateEmpty', // completion records
'UTC' // depends on LocalTZA, DaylightSavingTA
];
require('./tests').es2015(boundES, ops, expectedMissing);
require('./helpers/runManifestTest')(require('tape'), ES, 2015);

165
node_modules/es-abstract/test/es2016.js generated vendored Normal file
View File

@ -0,0 +1,165 @@
'use strict';
var ES = require('../').ES2016;
var boundES = require('./helpers/createBoundESNamespace')(ES);
var ops = require('../operations/2016');
var expectedMissing = [
'AddRestrictedFunctionProperties',
'AllocateArrayBuffer',
'AllocateTypedArray',
'AllocateTypedArrayBuffer',
'BlockDeclarationInstantiation',
'BoundFunctionCreate',
'Canonicalize',
'CharacterRange',
'CharacterRangeOrUnion',
'CharacterSetMatcher',
'CloneArrayBuffer',
'Completion',
'Construct',
'CopyDataBlockBytes',
'CreateArrayFromList',
'CreateArrayIterator',
'CreateBuiltinFunction',
'CreateByteDataBlock',
'CreateDynamicFunction',
'CreateIntrinsics',
'CreateListIterator',
'CreateMapIterator',
'CreateMappedArgumentsObject',
'CreatePerIterationEnvironment',
'CreateRealm',
'CreateResolvingFunctions',
'CreateSetIterator',
'CreateStringIterator',
'CreateUnmappedArgumentsObject',
'DaylightSavingTA',
'Decode',
'DetachArrayBuffer',
'Encode',
'EnqueueJob',
'EnumerateObjectProperties',
'EscapeRegExpPattern',
'EvalDeclarationInstantiation',
'EvaluateCall',
'EvaluateDirectCall',
'EvaluateNew',
'ForBodyEvaluation',
'ForIn/OfBodyEvaluation',
'ForIn/OfHeadEvaluation',
'FulfillPromise',
'FunctionAllocate',
'FunctionCreate',
'FunctionDeclarationInstantiation',
'FunctionInitialize',
'GeneratorFunctionCreate',
'GeneratorResume',
'GeneratorResumeAbrupt',
'GeneratorStart',
'GeneratorValidate',
'GeneratorYield',
'GetActiveScriptOrModule',
'GetFunctionRealm',
'GetGlobalObject',
'GetIdentifierReference',
'GetModuleNamespace',
'GetNewTarget',
'GetSuperConstructor',
'GetTemplateObject',
'GetThisEnvironment',
'GetThisValue',
'GetValue',
'GetValueFromBuffer',
'GetViewValue',
'GlobalDeclarationInstantiation',
'HostPromiseRejectionTracker',
'HostReportErrors',
'HostResolveImportedModule',
'IfAbruptRejectPromise',
'ImportedLocalNames',
'InitializeBoundName',
'InitializeHostDefinedRealm',
'InitializeReferencedBinding',
'IntegerIndexedElementGet',
'IntegerIndexedElementSet',
'IntegerIndexedObjectCreate',
'InternalizeJSONProperty',
'IsAnonymousFunctionDefinition',
'IsCompatiblePropertyDescriptor',
'IsDetachedBuffer',
'IsInTailPosition',
'IsLabelledFunction',
'IsWordChar',
'LocalTime',
'LoopContinues',
'MakeArgGetter',
'MakeArgSetter',
'MakeClassConstructor',
'MakeConstructor',
'MakeMethod',
'MakeSuperPropertyReference',
'max',
'min',
'ModuleNamespaceCreate',
'NewDeclarativeEnvironment',
'NewFunctionEnvironment',
'NewGlobalEnvironment',
'NewModuleEnvironment',
'NewObjectEnvironment',
'NewPromiseCapability',
'NextJob',
'NormalCompletion',
'ObjectDefineProperties',
'OrdinaryCallBindThis',
'OrdinaryCallEvaluateBody',
'OrdinaryDelete',
'OrdinaryGet',
'OrdinaryIsExtensible',
'OrdinaryOwnPropertyKeys',
'OrdinaryPreventExtensions',
'OrdinarySet',
'ParseModule',
'ParseScript',
'PerformEval',
'PerformPromiseAll',
'PerformPromiseRace',
'PerformPromiseThen',
'PrepareForOrdinaryCall',
'PrepareForTailCall',
'PromiseReactionJob',
'PromiseResolveThenableJob',
'ProxyCreate',
'PutValue', // takes a Reference
'RegExpAlloc', // creates a regex with uninitialized internal lots
'RegExpBuiltinExec',
'RegExpInitialize', // initializes allocated regex's internal slots
'RejectPromise',
'RepeatMatcher',
'ResolveBinding',
'ResolveThisBinding',
'ReturnIfAbrupt',
'ScriptEvaluation',
'ScriptEvaluationJob',
'SerializeJSONArray',
'SerializeJSONObject',
'SerializeJSONProperty',
'SetDefaultGlobalBindings',
'SetRealmGlobalObject',
'SetValueInBuffer',
'SetViewValue',
'SortCompare', // mystery access to `comparefn` arg
'TopLevelModuleEvaluationJob',
'ToString Applied to the Number Type',
'TriggerPromiseReactions',
'TypedArrayCreate',
'TypedArraySpeciesCreate',
'UpdateEmpty', // completion records
'UTC', // depends on LocalTZA, DaylightSavingTA
'ValidateTypedArray'
];
require('./tests').es2016(boundES, ops, expectedMissing);
require('./helpers/runManifestTest')(require('tape'), ES, 2016);

211
node_modules/es-abstract/test/es2017.js generated vendored Normal file
View File

@ -0,0 +1,211 @@
'use strict';
var ES = require('../').ES2017;
var boundES = require('./helpers/createBoundESNamespace')(ES);
var ops = require('../operations/2017');
var expectedMissing = [
'AddWaiter',
'agent-order',
'AgentCanSuspend',
'AgentSignifier',
'AllocateArrayBuffer',
'AllocateSharedArrayBuffer',
'AllocateTypedArray',
'AllocateTypedArrayBuffer',
'AsyncFunctionAwait',
'AsyncFunctionCreate',
'AsyncFunctionStart',
'AtomicLoad',
'AtomicReadModifyWrite',
'BlockDeclarationInstantiation',
'BoundFunctionCreate',
'Canonicalize',
'CharacterRange',
'CharacterRangeOrUnion',
'CharacterSetMatcher',
'CloneArrayBuffer',
'Completion',
'ComposeWriteEventBytes',
'Construct',
'CopyDataBlockBytes',
'CreateArrayFromList',
'CreateArrayIterator',
'CreateBuiltinFunction',
'CreateByteDataBlock',
'CreateDynamicFunction',
'CreateIntrinsics',
'CreateListIterator',
'CreateMapIterator',
'CreateMappedArgumentsObject',
'CreatePerIterationEnvironment',
'CreateRealm',
'CreateResolvingFunctions',
'CreateSetIterator',
'CreateSharedByteDataBlock',
'CreateStringIterator',
'CreateUnmappedArgumentsObject',
'DaylightSavingTA',
'Decode',
'DetachArrayBuffer',
'Encode',
'EnqueueJob',
'EnterCriticalSection',
'EnumerateObjectProperties',
'EscapeRegExpPattern',
'EvalDeclarationInstantiation',
'EvaluateCall',
'EvaluateDirectCall',
'EvaluateNew',
'EventSet',
'ForBodyEvaluation',
'ForIn/OfBodyEvaluation',
'ForIn/OfHeadEvaluation',
'FulfillPromise',
'FunctionAllocate',
'FunctionCreate',
'FunctionDeclarationInstantiation',
'FunctionInitialize',
'GeneratorFunctionCreate',
'GeneratorResume',
'GeneratorResumeAbrupt',
'GeneratorStart',
'GeneratorValidate',
'GeneratorYield',
'GetActiveScriptOrModule',
'GetBase',
'GetFunctionRealm',
'GetGlobalObject',
'GetIdentifierReference',
'GetModifySetValueInBuffer',
'GetModuleNamespace',
'GetNewTarget',
'GetReferencedName',
'GetSuperConstructor',
'GetTemplateObject',
'GetThisEnvironment',
'GetThisValue',
'GetValue',
'GetValueFromBuffer',
'GetViewValue',
'GetWaiterList',
'GlobalDeclarationInstantiation',
'happens-before',
'HasPrimitiveBase',
'host-synchronizes-with',
'HostEnsureCanCompileStrings',
'HostEventSet',
'HostPromiseRejectionTracker',
'HostReportErrors',
'HostResolveImportedModule',
'IfAbruptRejectPromise',
'ImportedLocalNames',
'InitializeBoundName',
'InitializeHostDefinedRealm',
'InitializeReferencedBinding',
'IntegerIndexedElementGet',
'IntegerIndexedElementSet',
'IntegerIndexedObjectCreate',
'InternalizeJSONProperty',
'IsAnonymousFunctionDefinition',
'IsCompatiblePropertyDescriptor',
'IsDetachedBuffer',
'IsInTailPosition',
'IsLabelledFunction',
'IsPropertyReference',
'IsSharedArrayBuffer',
'IsStrictReference',
'IsSuperReference',
'IsUnresolvableReference',
'IsWordChar',
'LeaveCriticalSection',
'LocalTime',
'LoopContinues',
'MakeArgGetter',
'MakeArgSetter',
'MakeClassConstructor',
'MakeConstructor',
'MakeMethod',
'MakeSuperPropertyReference',
'max',
'memory-order',
'min',
'ModuleNamespaceCreate',
'NewDeclarativeEnvironment',
'NewFunctionEnvironment',
'NewGlobalEnvironment',
'NewModuleEnvironment',
'NewObjectEnvironment',
'NewPromiseCapability',
'NormalCompletion',
'NumberToRawBytes',
'ObjectDefineProperties',
'OrdinaryCallBindThis',
'OrdinaryCallEvaluateBody',
'OrdinaryDelete',
'OrdinaryGet',
'OrdinaryIsExtensible',
'OrdinaryOwnPropertyKeys',
'OrdinaryPreventExtensions',
'OrdinarySet',
'OrdinaryToPrimitive',
'ParseModule',
'ParseScript',
'PerformEval',
'PerformPromiseAll',
'PerformPromiseRace',
'PerformPromiseThen',
'PrepareForOrdinaryCall',
'PrepareForTailCall',
'PromiseReactionJob',
'PromiseResolveThenableJob',
'ProxyCreate',
'PutValue', // takes a Reference
'RawBytesToNumber',
'reads-bytes-from',
'reads-from',
'RegExpAlloc', // creates a regex with uninitialized internal lots
'RegExpBuiltinExec',
'RegExpInitialize', // initializes allocated regex's internal slots
'RejectPromise',
'RemoveWaiter',
'RemoveWaiters',
'RepeatMatcher',
'ResolveBinding',
'ResolveThisBinding',
'ReturnIfAbrupt',
'RunJobs',
'ScriptEvaluation',
'ScriptEvaluationJob',
'SerializeJSONArray',
'SerializeJSONObject',
'SerializeJSONProperty',
'SetDefaultGlobalBindings',
'SetImmutablePrototype',
'SetRealmGlobalObject',
'SetValueInBuffer',
'SetViewValue',
'SharedDataBlockEventSet',
'SortCompare', // mystery access to `comparefn` arg
'Suspend',
'TopLevelModuleEvaluationJob',
'ToString Applied to the Number Type',
'TriggerPromiseReactions',
'TypedArrayCreate',
'TypedArraySpeciesCreate',
'UpdateEmpty', // completion records
'UTC', // depends on LocalTZA, DaylightSavingTA
'ValidateAtomicAccess',
'ValidateSharedIntegerTypedArray',
'ValidateTypedArray',
'ValueOfReadEvent',
'WakeWaiter',
'WordCharacters', // depends on Canonicalize
'AddRestrictedFunctionProperties',
'synchronizes-with'
];
require('./tests').es2017(boundES, ops, expectedMissing);
require('./helpers/runManifestTest')(require('tape'), ES, 2017);

229
node_modules/es-abstract/test/es2018.js generated vendored Normal file
View File

@ -0,0 +1,229 @@
'use strict';
var ES = require('../').ES2018;
var boundES = require('./helpers/createBoundESNamespace')(ES);
var ops = require('../operations/2018');
var expectedMissing = [
'AddRestrictedFunctionProperties',
'AddWaiter',
'agent-order',
'AgentCanSuspend',
'AgentSignifier',
'AllocateArrayBuffer',
'AllocateSharedArrayBuffer',
'AllocateTypedArray',
'AllocateTypedArrayBuffer',
'AsyncFunctionCreate',
'AsyncFunctionStart',
'AsyncGeneratorEnqueue',
'AsyncGeneratorFunctionCreate',
'AsyncGeneratorReject',
'AsyncGeneratorResolve',
'AsyncGeneratorResumeNext',
'AsyncGeneratorStart',
'AsyncGeneratorYield',
'AsyncIteratorClose',
'AtomicLoad',
'AtomicReadModifyWrite',
'Await',
'BackreferenceMatcher',
'BlockDeclarationInstantiation',
'BoundFunctionCreate',
'Canonicalize',
'CaseClauseIsSelected',
'CharacterRange',
'CharacterRangeOrUnion',
'CharacterSetMatcher',
'CloneArrayBuffer',
'Completion',
'ComposeWriteEventBytes',
'Construct',
'CopyDataBlockBytes',
'CreateArrayFromList',
'CreateArrayIterator',
'CreateAsyncFromSyncIterator',
'CreateBuiltinFunction',
'CreateByteDataBlock',
'CreateDynamicFunction',
'CreateIntrinsics',
'CreateListIteratorRecord',
'CreateMapIterator',
'CreateMappedArgumentsObject',
'CreatePerIterationEnvironment',
'CreateRealm',
'CreateResolvingFunctions',
'CreateSetIterator',
'CreateSharedByteDataBlock',
'CreateStringIterator',
'CreateUnmappedArgumentsObject',
'Decode',
'DetachArrayBuffer',
'Encode',
'EnqueueJob',
'EnterCriticalSection',
'EnumerateObjectProperties',
'EscapeRegExpPattern',
'EvalDeclarationInstantiation',
'EvaluateCall',
'EvaluateNew',
'EventSet',
'ForBodyEvaluation',
'ForIn/OfBodyEvaluation',
'ForIn/OfHeadEvaluation',
'FulfillPromise',
'FunctionAllocate',
'FunctionCreate',
'FunctionDeclarationInstantiation',
'FunctionInitialize',
'GeneratorFunctionCreate',
'GeneratorResume',
'GeneratorResumeAbrupt',
'GeneratorStart',
'GeneratorValidate',
'GeneratorYield',
'GetActiveScriptOrModule',
'GetBase',
'GetFunctionRealm',
'GetGeneratorKind',
'GetGlobalObject',
'GetIdentifierReference',
'GetModifySetValueInBuffer',
'GetModuleNamespace',
'GetNewTarget',
'GetReferencedName',
'GetSuperConstructor',
'GetTemplateObject',
'GetThisEnvironment',
'GetThisValue',
'GetValue',
'GetValueFromBuffer',
'GetViewValue',
'GetWaiterList',
'GlobalDeclarationInstantiation',
'happens-before',
'HasPrimitiveBase',
'host-synchronizes-with',
'HostEnsureCanCompileStrings',
'HostEventSet',
'HostPromiseRejectionTracker',
'HostReportErrors',
'HostResolveImportedModule',
'IfAbruptRejectPromise',
'ImportedLocalNames',
'InitializeBoundName',
'InitializeHostDefinedRealm',
'InitializeReferencedBinding',
'InnerModuleEvaluation',
'InnerModuleInstantiation',
'IntegerIndexedElementGet',
'IntegerIndexedElementSet',
'IntegerIndexedObjectCreate',
'InternalizeJSONProperty',
'IsAnonymousFunctionDefinition',
'IsCompatiblePropertyDescriptor',
'IsDetachedBuffer',
'IsInTailPosition',
'IsLabelledFunction',
'IsPropertyReference',
'IsSharedArrayBuffer',
'IsStrictReference',
'IsSuperReference',
'IsUnresolvableReference',
'IsWordChar',
'LeaveCriticalSection',
'LocalTime',
'LoopContinues',
'MakeArgGetter',
'MakeArgSetter',
'MakeClassConstructor',
'MakeConstructor',
'MakeMethod',
'MakeSuperPropertyReference',
'max',
'memory-order',
'min',
'ModuleDeclarationEnvironmentSetup',
'ModuleExecution',
'ModuleNamespaceCreate',
'NewDeclarativeEnvironment',
'NewFunctionEnvironment',
'NewGlobalEnvironment',
'NewModuleEnvironment',
'NewObjectEnvironment',
'NewPromiseCapability',
'NormalCompletion',
'NumberToRawBytes',
'ObjectDefineProperties',
'OrdinaryCallBindThis',
'OrdinaryCallEvaluateBody',
'OrdinaryDelete',
'OrdinaryGet',
'OrdinaryIsExtensible',
'OrdinaryOwnPropertyKeys',
'OrdinaryPreventExtensions',
'OrdinarySet',
'OrdinarySetWithOwnDescriptor',
'OrdinaryToPrimitive',
'ParseModule',
'ParseScript',
'PerformEval',
'PerformPromiseAll',
'PerformPromiseRace',
'PerformPromiseThen',
'PrepareForOrdinaryCall',
'PrepareForTailCall',
'PromiseReactionJob',
'PromiseResolveThenableJob',
'ProxyCreate',
'PutValue', // takes a Reference
'RawBytesToNumber',
'reads-bytes-from',
'reads-from',
'RegExpAlloc', // creates a regex with uninitialized internal lots
'RegExpBuiltinExec',
'RegExpInitialize', // initializes allocated regex's internal slots
'RejectPromise',
'RemoveWaiter',
'RemoveWaiters',
'RepeatMatcher',
'ResolveBinding',
'ResolveThisBinding',
'ReturnIfAbrupt',
'RunJobs',
'ScriptEvaluation',
'ScriptEvaluationJob',
'SerializeJSONArray',
'SerializeJSONObject',
'SerializeJSONProperty',
'SetDefaultGlobalBindings',
'SetImmutablePrototype',
'SetRealmGlobalObject',
'SetValueInBuffer',
'SetViewValue',
'SharedDataBlockEventSet',
'SortCompare', // mystery access to `comparefn` arg
'Suspend',
'synchronizes-with',
'ThrowCompletion',
'TimeZoneString',
'TopLevelModuleEvaluationJob',
'TriggerPromiseReactions',
'TypedArrayCreate',
'TypedArraySpeciesCreate',
'UnicodeMatchProperty',
'UnicodeMatchPropertyValue',
'UpdateEmpty', // completion records
'UTC', // depends on LocalTZA
'ValidateAtomicAccess',
'ValidateSharedIntegerTypedArray',
'ValidateTypedArray',
'ValueOfReadEvent',
'WakeWaiter',
'WordCharacters' // depends on Canonicalize
];
require('./tests').es2018(boundES, ops, expectedMissing);
require('./helpers/runManifestTest')(require('tape'), ES, 2018);

231
node_modules/es-abstract/test/es2019.js generated vendored Normal file
View File

@ -0,0 +1,231 @@
'use strict';
var ES = require('../').ES2019;
var boundES = require('./helpers/createBoundESNamespace')(ES);
var ops = require('../operations/2019');
var expectedMissing = [
'AddRestrictedFunctionProperties',
'AddWaiter',
'agent-order',
'AgentCanSuspend',
'AgentSignifier',
'AllocateArrayBuffer',
'AllocateSharedArrayBuffer',
'AllocateTypedArray',
'AllocateTypedArrayBuffer',
'AsyncFromSyncIteratorContinuation',
'AsyncFunctionCreate',
'AsyncFunctionStart',
'AsyncGeneratorEnqueue',
'AsyncGeneratorFunctionCreate',
'AsyncGeneratorReject',
'AsyncGeneratorResolve',
'AsyncGeneratorResumeNext',
'AsyncGeneratorStart',
'AsyncGeneratorYield',
'AsyncIteratorClose',
'AtomicLoad',
'AtomicReadModifyWrite',
'Await',
'BackreferenceMatcher',
'BlockDeclarationInstantiation',
'BoundFunctionCreate',
'Canonicalize',
'CaseClauseIsSelected',
'CharacterRange',
'CharacterRangeOrUnion',
'CharacterSetMatcher',
'CloneArrayBuffer',
'Completion',
'ComposeWriteEventBytes',
'Construct',
'CopyDataBlockBytes',
'CreateArrayFromList',
'CreateArrayIterator',
'CreateAsyncFromSyncIterator',
'CreateBuiltinFunction',
'CreateByteDataBlock',
'CreateDynamicFunction',
'CreateIntrinsics',
'CreateListIteratorRecord',
'CreateMapIterator',
'CreateMappedArgumentsObject',
'CreatePerIterationEnvironment',
'CreateRealm',
'CreateResolvingFunctions',
'CreateSetIterator',
'CreateSharedByteDataBlock',
'CreateStringIterator',
'CreateUnmappedArgumentsObject',
'Decode',
'DetachArrayBuffer',
'Encode',
'EnqueueJob',
'EnterCriticalSection',
'EnumerateObjectProperties',
'EscapeRegExpPattern',
'EvalDeclarationInstantiation',
'EvaluateCall',
'EvaluateNew',
'EventSet',
'ExecuteModule',
'ForBodyEvaluation',
'ForIn/OfBodyEvaluation',
'ForIn/OfHeadEvaluation',
'FulfillPromise',
'FunctionAllocate',
'FunctionCreate',
'FunctionDeclarationInstantiation',
'FunctionInitialize',
'GeneratorFunctionCreate',
'GeneratorResume',
'GeneratorResumeAbrupt',
'GeneratorStart',
'GeneratorValidate',
'GeneratorYield',
'GetActiveScriptOrModule',
'GetBase',
'GetFunctionRealm',
'GetGeneratorKind',
'GetGlobalObject',
'GetIdentifierReference',
'GetModifySetValueInBuffer',
'GetModuleNamespace',
'GetNewTarget',
'GetReferencedName',
'GetSuperConstructor',
'GetTemplateObject',
'GetThisEnvironment',
'GetThisValue',
'GetValue',
'GetValueFromBuffer',
'GetViewValue',
'GetWaiterList',
'GlobalDeclarationInstantiation',
'happens-before',
'HasPrimitiveBase',
'host-synchronizes-with',
'HostEnsureCanCompileStrings',
'HostEventSet',
'HostPromiseRejectionTracker',
'HostReportErrors',
'HostResolveImportedModule',
'IfAbruptRejectPromise',
'ImportedLocalNames',
'InitializeBoundName',
'InitializeEnvironment',
'InitializeHostDefinedRealm',
'InitializeReferencedBinding',
'InnerModuleEvaluation',
'InnerModuleInstantiation',
'IntegerIndexedElementGet',
'IntegerIndexedElementSet',
'IntegerIndexedObjectCreate',
'InternalizeJSONProperty',
'IsAnonymousFunctionDefinition',
'IsCompatiblePropertyDescriptor',
'IsDetachedBuffer',
'IsInTailPosition',
'IsLabelledFunction',
'IsPropertyReference',
'IsSharedArrayBuffer',
'IsStrictReference',
'IsSuperReference',
'IsUnresolvableReference',
'IsWordChar',
'LeaveCriticalSection',
'LocalTime',
'LoopContinues',
'MakeArgGetter',
'MakeArgSetter',
'MakeClassConstructor',
'MakeConstructor',
'MakeMethod',
'MakeSuperPropertyReference',
'max',
'memory-order',
'min',
'ModuleNamespaceCreate',
'NewDeclarativeEnvironment',
'NewFunctionEnvironment',
'NewGlobalEnvironment',
'NewModuleEnvironment',
'NewObjectEnvironment',
'NewPromiseCapability',
'NormalCompletion',
'NotifyWaiter',
'NumberToRawBytes',
'ObjectDefineProperties',
'OrdinaryCallBindThis',
'OrdinaryCallEvaluateBody',
'OrdinaryDelete',
'OrdinaryGet',
'OrdinaryIsExtensible',
'OrdinaryOwnPropertyKeys',
'OrdinaryPreventExtensions',
'OrdinarySet',
'OrdinarySetWithOwnDescriptor',
'OrdinaryToPrimitive',
'ParseModule',
'ParseScript',
'PerformEval',
'PerformPromiseAll',
'PerformPromiseRace',
'PerformPromiseThen',
'PrepareForOrdinaryCall',
'PrepareForTailCall',
'PromiseReactionJob',
'PromiseResolveThenableJob',
'ProxyCreate',
'PutValue', // takes a Reference
'RawBytesToNumber',
'reads-bytes-from',
'reads-from',
'RegExpAlloc', // creates a regex with uninitialized internal lots
'RegExpBuiltinExec',
'RegExpInitialize', // initializes allocated regex's internal slots
'RejectPromise',
'RemoveWaiter',
'RemoveWaiters',
'RepeatMatcher',
'ResolveBinding',
'ResolveThisBinding',
'ReturnIfAbrupt',
'RunJobs',
'ScriptEvaluation',
'ScriptEvaluationJob',
'SerializeJSONArray',
'SerializeJSONObject',
'SerializeJSONProperty',
'SetDefaultGlobalBindings',
'SetImmutablePrototype',
'SetRealmGlobalObject',
'SetValueInBuffer',
'SetViewValue',
'SharedDataBlockEventSet',
'SortCompare', // mystery access to `comparefn` arg
'Suspend',
'SynchronizeEventSet',
'synchronizes-with',
'ThrowCompletion',
'TimeZoneString',
'TopLevelModuleEvaluationJob',
'TriggerPromiseReactions',
'TypedArrayCreate',
'TypedArraySpeciesCreate',
'UnicodeMatchProperty',
'UnicodeMatchPropertyValue',
'UpdateEmpty', // completion records
'UTC', // depends on LocalTZA
'ValidateAtomicAccess',
'ValidateSharedIntegerTypedArray',
'ValidateTypedArray',
'ValueOfReadEvent',
'WordCharacters' // depends on Canonicalize
];
require('./tests').es2019(boundES, ops, expectedMissing);
require('./helpers/runManifestTest')(require('tape'), ES, 2019);

240
node_modules/es-abstract/test/es2020.js generated vendored Normal file
View File

@ -0,0 +1,240 @@
'use strict';
var ES = require('../').ES2020;
var boundES = require('./helpers/createBoundESNamespace')(ES);
var ops = require('../operations/2020');
var expectedMissing = [
'AddRestrictedFunctionProperties',
'AddWaiter',
'agent-order',
'AgentCanSuspend',
'AgentSignifier',
'AllocateArrayBuffer',
'AllocateSharedArrayBuffer',
'AllocateTypedArray',
'AllocateTypedArrayBuffer',
'AsyncFromSyncIteratorContinuation',
'AsyncFunctionStart',
'AsyncGeneratorEnqueue',
'AsyncGeneratorReject',
'AsyncGeneratorResolve',
'AsyncGeneratorResumeNext',
'AsyncGeneratorStart',
'AsyncGeneratorYield',
'AsyncIteratorClose',
'AtomicLoad',
'AtomicReadModifyWrite',
'Await',
'BackreferenceMatcher',
'BlockDeclarationInstantiation',
'BoundFunctionCreate',
'Canonicalize',
'CaseClauseIsSelected',
'CharacterRange',
'CharacterRangeOrUnion',
'CharacterSetMatcher',
'CloneArrayBuffer',
'Completion',
'ComposeWriteEventBytes',
'Construct',
'CopyDataBlockBytes',
'CreateArrayFromList',
'CreateArrayIterator',
'CreateAsyncFromSyncIterator',
'CreateBuiltinFunction',
'CreateByteDataBlock',
'CreateDynamicFunction',
'CreateForInIterator',
'CreateIntrinsics',
'CreateListIteratorRecord',
'CreateMapIterator',
'CreateMappedArgumentsObject',
'CreatePerIterationEnvironment',
'CreateRealm',
'CreateRegExpStringIterator',
'CreateResolvingFunctions',
'CreateSetIterator',
'CreateSharedByteDataBlock',
'CreateStringIterator',
'CreateUnmappedArgumentsObject',
'Decode',
'DetachArrayBuffer',
'Encode',
'EnterCriticalSection',
'EnumerateObjectProperties',
'EscapeRegExpPattern',
'EvalDeclarationInstantiation',
'EvaluateCall',
'EvaluateNew',
'EvaluatePropertyAccessWithExpressionKey',
'EvaluatePropertyAccessWithIdentifierKey',
'EventSet',
'ExecuteModule',
'FinishDynamicImport',
'ForBodyEvaluation',
'ForIn/OfBodyEvaluation',
'ForIn/OfHeadEvaluation',
'FulfillPromise',
'FunctionDeclarationInstantiation',
'GeneratorResume',
'GeneratorResumeAbrupt',
'GeneratorStart',
'GeneratorValidate',
'GeneratorYield',
'GetActiveScriptOrModule',
'GetBase',
'GetFunctionRealm',
'GetGeneratorKind',
'GetGlobalObject',
'GetIdentifierReference',
'GetModifySetValueInBuffer',
'GetModuleNamespace',
'GetNewTarget',
'GetReferencedName',
'GetSuperConstructor',
'GetTemplateObject',
'GetThisEnvironment',
'GetThisValue',
'GetValue',
'GetValueFromBuffer',
'GetViewValue',
'GetWaiterList',
'GlobalDeclarationInstantiation',
'happens-before',
'HasPrimitiveBase',
'host-synchronizes-with',
'HostEnqueuePromiseJob',
'HostEnsureCanCompileStrings',
'HostEventSet',
'HostFinalizeImportMeta',
'HostGetImportMetaProperties',
'HostImportModuleDynamically',
'HostPromiseRejectionTracker',
'HostResolveImportedModule',
'IfAbruptRejectPromise',
'ImportedLocalNames',
'InitializeBoundName',
'InitializeEnvironment',
'InitializeHostDefinedRealm',
'InitializeReferencedBinding',
'InnerModuleEvaluation',
'InnerModuleLinking',
'IntegerIndexedElementGet',
'IntegerIndexedElementSet',
'IntegerIndexedObjectCreate',
'InternalizeJSONProperty',
'IsAnonymousFunctionDefinition',
'IsCompatiblePropertyDescriptor',
'IsDetachedBuffer',
'IsInTailPosition',
'IsLabelledFunction',
'IsPropertyReference',
'IsSharedArrayBuffer',
'IsStrictReference',
'IsSuperReference',
'IsUnresolvableReference',
'IsValidIntegerIndex',
'IsValidRegularExpressionLiteral',
'IsWordChar',
'LeaveCriticalSection',
'LocalTime',
'LocalTZA',
'LoopContinues',
'MakeArgGetter',
'MakeArgSetter',
'MakeBasicObject',
'MakeClassConstructor',
'MakeConstructor',
'MakeMethod',
'MakeSuperPropertyReference',
'max',
'memory-order',
'min',
'ModuleNamespaceCreate',
'NewDeclarativeEnvironment',
'NewFunctionEnvironment',
'NewGlobalEnvironment',
'NewModuleEnvironment',
'NewObjectEnvironment',
'NewPromiseCapability',
'NewPromiseReactionJob',
'NewPromiseResolveThenableJob',
'NormalCompletion',
'NotifyWaiter',
'NumericToRawBytes',
'ObjectDefineProperties',
'OrdinaryCallBindThis',
'OrdinaryCallEvaluateBody',
'OrdinaryDelete',
'OrdinaryFunctionCreate',
'OrdinaryGet',
'OrdinaryIsExtensible',
'OrdinaryOwnPropertyKeys',
'OrdinaryPreventExtensions',
'OrdinarySet',
'OrdinarySetWithOwnDescriptor',
'OrdinaryToPrimitive',
'ParseModule',
'ParseScript',
'PerformEval',
'PerformPromiseAll',
'PerformPromiseAllSettled',
'PerformPromiseRace',
'PerformPromiseThen',
'PrepareForOrdinaryCall',
'PrepareForTailCall',
'ProxyCreate',
'PutValue', // takes a Reference
'RawBytesToNumeric',
'reads-bytes-from',
'reads-from',
'RegExpAlloc', // creates a regex with uninitialized internal lots
'RegExpBuiltinExec',
'RegExpInitialize', // initializes allocated regex's internal slots
'RejectPromise',
'RemoveWaiter',
'RemoveWaiters',
'RepeatMatcher',
'RequireInternalSlot',
'ResolveBinding',
'ResolveThisBinding',
'ReturnIfAbrupt',
'ScriptEvaluation',
'SerializeJSONArray',
'SerializeJSONObject',
'SerializeJSONProperty',
'SetDefaultGlobalBindings',
'SetImmutablePrototype',
'SetRealmGlobalObject',
'SetValueInBuffer',
'SetViewValue',
'SharedDataBlockEventSet',
'SortCompare', // mystery access to `comparefn` arg
'StringToBigInt',
'Suspend',
'synchronizes-with',
'ThrowCompletion',
'TimeZoneString',
'ToBigInt',
'ToBigInt64',
'ToBigUint64',
'TriggerPromiseReactions',
'TypedArrayCreate',
'TypedArraySpeciesCreate',
'UnicodeMatchProperty',
'UnicodeMatchPropertyValue',
'UpdateEmpty', // completion records
'UTC', // depends on LocalTZA
'UTF16Encode',
'ValidateAtomicAccess',
'ValidateSharedIntegerTypedArray',
'ValidateTypedArray',
'ValueOfReadEvent',
'WordCharacters' // depends on Canonicalize
];
require('./tests').es2020(boundES, ops, expectedMissing);
require('./helpers/runManifestTest')(require('tape'), ES, 2020);

14
node_modules/es-abstract/test/es5.js generated vendored Normal file
View File

@ -0,0 +1,14 @@
'use strict';
var ES = require('../').ES5;
var boundES = require('./helpers/createBoundESNamespace')(ES);
var ops = require('../operations/es5');
var expectedMissing = [
'SplitMatch'
];
require('./tests').es5(boundES, ops, expectedMissing);
require('./helpers/runManifestTest')(require('tape'), ES, 5);

18
node_modules/es-abstract/test/es6.js generated vendored Normal file
View File

@ -0,0 +1,18 @@
'use strict';
var test = require('tape');
var ES = require('../');
var ES6 = ES.ES6;
var ES2015 = ES.ES2015;
var ES6entry = require('../es6');
test('legacy es6 export', function (t) {
t.equal(ES6, ES2015, 'main ES6 === main ES2015');
t.end();
});
test('legacy es6 entry point', function (t) {
t.equal(ES6, ES6entry, 'main ES6 === ES6 entry point');
t.end();
});

18
node_modules/es-abstract/test/es7.js generated vendored Normal file
View File

@ -0,0 +1,18 @@
'use strict';
var test = require('tape');
var ES = require('../');
var ES7 = ES.ES7;
var ES2016 = ES.ES2016;
var ES7entry = require('../es7');
test('legacy es7 export', function (t) {
t.equal(ES7, ES2016, 'main ES7 === main ES2016');
t.end();
});
test('legacy es7 entry point', function (t) {
t.equal(ES7, ES7entry, 'main ES7 === ES7 entry point');
t.end();
});

View File

@ -0,0 +1,42 @@
'use strict';
var test = require('tape');
var hasSymbols = require('has-symbols')();
var OwnPropertyKeys = require('../../helpers/OwnPropertyKeys');
var defineProperty = require('./defineProperty');
test('OwnPropertyKeys', function (t) {
t.deepEqual(OwnPropertyKeys({ a: 1, b: 2 }).sort(), ['a', 'b'].sort(), 'returns own string keys');
t.test('Symbols', { skip: !hasSymbols }, function (st) {
var o = { a: 1 };
var sym = Symbol();
o[sym] = 2;
st.deepEqual(OwnPropertyKeys(o), ['a', sym], 'returns own string and symbol keys');
st.end();
});
t.test('non-enumerables', { skip: !defineProperty.oDP }, function (st) {
var o = { a: 1, b: 42, c: NaN };
defineProperty(o, 'b', { enumerable: false, value: 42 });
defineProperty(o, 'c', { enumerable: false, get: function () { return NaN; } });
if (hasSymbols) {
defineProperty(o, 'd', { enumerable: false, value: true });
defineProperty(o, 'e', { enumerable: false, get: function () { return true; } });
}
st.deepEqual(
OwnPropertyKeys(o).sort(),
(hasSymbols ? ['a', 'b', 'c', 'd', 'e'] : ['a', 'b', 'c']).sort(),
'returns non-enumerable own keys, including accessors and symbols if available'
);
st.end();
});
t.end();
});

60
node_modules/es-abstract/test/helpers/assertRecord.js generated vendored Normal file
View File

@ -0,0 +1,60 @@
'use strict';
var forEach = require('foreach');
var debug = require('object-inspect');
var assertRecord = require('../../helpers/assertRecord');
var v = require('es-value-fixtures');
module.exports = function assertRecordTests(ES, test) {
test('Property Descriptor', function (t) {
var record = 'Property Descriptor';
forEach(v.nonUndefinedPrimitives, function (primitive) {
t['throws'](
function () { assertRecord(ES.Type, record, 'arg', primitive); },
TypeError,
debug(primitive) + ' is not a Property Descriptor'
);
});
t['throws'](
function () { assertRecord(ES.Type, record, 'arg', { invalid: true }); },
TypeError,
'invalid keys not allowed on a Property Descriptor'
);
t.doesNotThrow(
function () { assertRecord(ES.Type, record, 'arg', {}); },
'empty object is an incomplete Property Descriptor'
);
t.doesNotThrow(
function () { assertRecord(ES.Type, record, 'arg', v.accessorDescriptor()); },
'accessor descriptor is a Property Descriptor'
);
t.doesNotThrow(
function () { assertRecord(ES.Type, record, 'arg', v.mutatorDescriptor()); },
'mutator descriptor is a Property Descriptor'
);
t.doesNotThrow(
function () { assertRecord(ES.Type, record, 'arg', v.dataDescriptor()); },
'data descriptor is a Property Descriptor'
);
t.doesNotThrow(
function () { assertRecord(ES.Type, record, 'arg', v.genericDescriptor()); },
'generic descriptor is a Property Descriptor'
);
t['throws'](
function () { assertRecord(ES.Type, record, 'arg', v.bothDescriptor()); },
TypeError,
'a Property Descriptor can not be both a Data and an Accessor Descriptor'
);
t.end();
});
};

View File

@ -0,0 +1,23 @@
'use strict';
var bind = require('function-bind');
var OwnPropertyKeys = require('../../helpers/OwnPropertyKeys');
module.exports = function createBoundESNamespace(ES) {
var keys = OwnPropertyKeys(ES);
var result = {};
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
var prop = ES[key];
if (typeof prop === 'function') {
prop = bind.call(prop, undefined);
} else if (prop && typeof prop === 'object') {
prop = createBoundESNamespace(prop);
}
result[key] = prop;
}
return result;
};

View File

@ -0,0 +1,27 @@
'use strict';
var GetIntrinsic = require('../../GetIntrinsic');
var $defineProperty = GetIntrinsic('%Object.defineProperty%', true);
if ($defineProperty) {
try {
$defineProperty({}, 'a', { value: 1 });
} catch (e) {
// IE 8 has a broken defineProperty
$defineProperty = null;
}
}
module.exports = function defineProperty(O, P, Desc) {
if ($defineProperty) {
return $defineProperty(O, P, Desc);
}
if ((Desc.enumerable && Desc.configurable && Desc.writable) || !(P in O)) {
O[P] = Desc.value; // eslint-disable-line no-param-reassign
return O;
}
throw new SyntaxError('helper does not yet support this configuration');
};
module.exports.oDP = $defineProperty;

View File

@ -0,0 +1,67 @@
'use strict';
var test = require('tape');
var debug = require('object-inspect');
var forEach = require('foreach');
var has = require('has');
var v = require('es-value-fixtures');
var getSymbolDescription = require('../../helpers/getSymbolDescription');
var getInferredName = require('../../helpers/getInferredName');
test('getSymbolDescription', function (t) {
t.test('no symbols', { skip: v.hasSymbols }, function (st) {
st['throws'](
getSymbolDescription,
SyntaxError,
'requires Symbol support'
);
st.end();
});
forEach(v.nonSymbolPrimitives.concat(v.objects), function (nonSymbol) {
t['throws'](
function () { getSymbolDescription(nonSymbol); },
v.hasSymbols ? TypeError : SyntaxError,
debug(nonSymbol) + ' is not a Symbol'
);
});
t.test('with symbols', { skip: !v.hasSymbols }, function (st) {
forEach(
[
[Symbol(), undefined],
[Symbol(undefined), undefined],
[Symbol(null), 'null'],
[Symbol.iterator, 'Symbol.iterator'],
[Symbol('foo'), 'foo']
],
function (pair) {
var sym = pair[0];
var desc = pair[1];
st.equal(getSymbolDescription(sym), desc, debug(sym) + ' description is ' + debug(desc));
}
);
st.test('only possible when inference or native `Symbol.prototype.description` is supported', {
skip: !getInferredName && !has(Symbol.prototype, 'description')
}, function (s2t) {
s2t.equal(getSymbolDescription(Symbol('')), '', 'Symbol("") description is ""');
s2t.end();
});
st.test('only possible when global symbols are supported', {
skip: !has(Symbol, 'for') || !has(Symbol, 'keyFor')
}, function (s2t) {
// eslint-disable-next-line no-restricted-properties
s2t.equal(getSymbolDescription(Symbol['for']('')), '', 'Symbol.for("") description is ""');
s2t.end();
});
st.end();
});
t.end();
});

6
node_modules/es-abstract/test/helpers/index.js generated vendored Normal file
View File

@ -0,0 +1,6 @@
'use strict';
require('./getSymbolDescription');
require('./isByteValue');
require('./isCodePoint');
require('./OwnPropertyKeys');

28
node_modules/es-abstract/test/helpers/isByteValue.js generated vendored Normal file
View File

@ -0,0 +1,28 @@
'use strict';
var test = require('tape');
var forEach = require('foreach');
var debug = require('object-inspect');
var isByteValue = require('../../helpers/isByteValue');
var v = require('es-value-fixtures');
test('isByteValue', function (t) {
forEach([].concat(
v.notNonNegativeIntegers,
-1,
-42,
-Infinity,
Infinity,
v.nonIntegerNumbers
), function (nonByteValue) {
t.equal(isByteValue(nonByteValue), false, debug(nonByteValue) + ' is not a byte value');
});
for (var i = 0; i <= 255; i += 1) {
t.equal(isByteValue(i), true, i + ' is a byte value');
}
t.equal(isByteValue(256), false, '256 is not a byte value');
t.end();
});

20
node_modules/es-abstract/test/helpers/isCodePoint.js generated vendored Normal file
View File

@ -0,0 +1,20 @@
'use strict';
var test = require('tape');
var forEach = require('foreach');
var debug = require('object-inspect');
var isCodePoint = require('../../helpers/isCodePoint');
var v = require('es-value-fixtures');
test('isCodePoint', function (t) {
forEach(v.notNonNegativeIntegers.concat(0x10FFFF + 1), function (nonCodePoints) {
t.equal(isCodePoint(nonCodePoints), false, debug(nonCodePoints) + ' is not a Code Point');
});
forEach([-0, 0, 1, 7, 42, 0x10FFFF], function (codePoint) {
t.equal(isCodePoint(codePoint), true, debug(codePoint) + ' is a Code Point');
});
t.end();
});

View File

@ -0,0 +1,27 @@
'use strict';
var path = require('path');
var fs = require('fs');
var forEach = require('foreach');
var keys = require('object-keys');
module.exports = function runManifestTest(test, ES, edition) {
test('ES' + edition + ' manifest', { skip: !fs.readdirSync }, function (t) {
var files = fs.readdirSync(path.join(__dirname, '../../' + edition), 'utf-8');
var map = {
AbstractEqualityComparison: 'Abstract Equality Comparison',
AbstractRelationalComparison: 'Abstract Relational Comparison',
StrictEqualityComparison: 'Strict Equality Comparison'
};
forEach(files, function (file) {
var name = path.basename(file, path.extname(file));
var actual = ES[map[name] || name];
var expected = require(path.join(__dirname, '../../' + edition + '/', file)); // eslint-disable-line global-require
t.equal(actual, expected, 'ES["' + name + '"] === ' + file);
});
var actualCount = keys(ES).length;
t.equal(actualCount, files.length, 'expected ' + files.length + ' files, got ' + actualCount);
t.end();
});
};

35
node_modules/es-abstract/test/index.js generated vendored Normal file
View File

@ -0,0 +1,35 @@
'use strict';
var ES = require('../');
var test = require('tape');
var keys = require('object-keys');
var forEach = require('foreach');
var ESkeys = keys(ES).sort();
var ES6keys = keys(ES.ES6).sort();
test('exposed properties', function (t) {
t.deepEqual(ESkeys, ES6keys.concat(['ES2020', 'ES2019', 'ES2018', 'ES2017', 'ES7', 'ES2016', 'ES6', 'ES2015', 'ES5']).sort(), 'main ES object keys match ES6 keys');
t.end();
});
test('methods match', function (t) {
forEach(ES6keys, function (key) {
t.equal(ES.ES6[key], ES[key], 'method ' + key + ' on main ES object is ES6 method');
});
t.end();
});
require('./GetIntrinsic');
require('./helpers');
require('./es5');
require('./es6');
require('./es2015');
require('./es7');
require('./es2016');
require('./es2017');
require('./es2018');
require('./es2019');
require('./es2020');

8
node_modules/es-abstract/test/ses-compat.js generated vendored Normal file
View File

@ -0,0 +1,8 @@
'use strict';
/* globals lockdown */
require('ses');
lockdown({ errorTaming: 'unsafe' });
require('.');

6933
node_modules/es-abstract/test/tests.js generated vendored Normal file

File diff suppressed because it is too large Load Diff