Diffusion Open Access Compliance Check Tool (OACCT) (paginated-inlines) Browse

rOACCT/node_modules/core-js/internals/async-iterator-iteration.js
f646e1f695a7paginated-inlines

async-iterator-iteration.js
View Options

			'use strict';
			// https://github.com/tc39/proposal-iterator-helpers
			// https://github.com/tc39/proposal-array-from-async
			var call = require('../internals/function-call');
			var aCallable = require('../internals/a-callable');
			var anObject = require('../internals/an-object');
			var isObject = require('../internals/is-object');
			var doesNotExceedSafeInteger = require('../internals/does-not-exceed-safe-integer');
			var getBuiltIn = require('../internals/get-built-in');
			var getIteratorDirect = require('../internals/get-iterator-direct');
			var closeAsyncIteration = require('../internals/async-iterator-close');

			var createMethod = function (TYPE) {
			var IS_TO_ARRAY = TYPE == 0;
			var IS_FOR_EACH = TYPE == 1;
			var IS_EVERY = TYPE == 2;
			var IS_SOME = TYPE == 3;
			return function (object, fn, target) {
			var record = getIteratorDirect(object);
			var Promise = getBuiltIn('Promise');
			var iterator = record.iterator;
			var next = record.next;
			var counter = 0;
			var MAPPING = fn !== undefined;
			if (MAPPING \|\| !IS_TO_ARRAY) aCallable(fn);

			return new Promise(function (resolve, reject) {
			var ifAbruptCloseAsyncIterator = function (error) {
			closeAsyncIteration(iterator, reject, error, reject);
			};

			var loop = function () {
			try {
			if (MAPPING) try {
			doesNotExceedSafeInteger(counter);
			} catch (error5) { ifAbruptCloseAsyncIterator(error5); }
			Promise.resolve(anObject(call(next, iterator))).then(function (step) {
			try {
			if (anObject(step).done) {
			if (IS_TO_ARRAY) {
			target.length = counter;
			resolve(target);
			} else resolve(IS_SOME ? false : IS_EVERY \|\| undefined);
			} else {
			var value = step.value;
			try {
			if (MAPPING) {
			var result = fn(value, counter);

			var handler = function ($result) {
			if (IS_FOR_EACH) {
			loop();
			} else if (IS_EVERY) {
			$result ? loop() : closeAsyncIteration(iterator, resolve, false, reject);
			} else if (IS_TO_ARRAY) {
			try {
			target[counter++] = $result;
			loop();
			} catch (error4) { ifAbruptCloseAsyncIterator(error4); }
			} else {
			$result ? closeAsyncIteration(iterator, resolve, IS_SOME \|\| value, reject) : loop();
			}
			};

			if (isObject(result)) Promise.resolve(result).then(handler, ifAbruptCloseAsyncIterator);
			else handler(result);
			} else {
			target[counter++] = value;
			loop();
			}
			} catch (error3) { ifAbruptCloseAsyncIterator(error3); }
			}
			} catch (error2) { reject(error2); }
			}, reject);
			} catch (error) { reject(error); }
			};

			loop();
			});
			};
			};

			module.exports = {
			toArray: createMethod(0),
			forEach: createMethod(1),
			every: createMethod(2),
			some: createMethod(3),
			find: createMethod(4)
			};