const { AggregateErrorCtor: _p_AggregateErrorCtor, TypeErrorCtor: _p_TypeErrorCtor } = require('../primordials/error.js')
const { MapCtor: _p_MapCtor } = require('../primordials/map-set.js')

const { NumberIsSafeInteger: _p_NumberIsSafeInteger } = require('../primordials/number.js')

const { PromiseCtor: _p_PromiseCtor } = require('../primordials/promise.js')

"use strict";
/**
 * Bundled from p-map
 * This is a zero-dependency bundle created by rolldown.
 */
'use strict';

//#region \0rolldown/runtime.js
var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", {
	value,
	configurable: true
});
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
var __exportAll = (all, no_symbols) => {
	let target = {};
	for (var name in all) {
		__defProp(target, name, {
			get: all[name],
			enumerable: true
		});
	}
	if (!no_symbols) {
		__defProp(target, Symbol.toStringTag, { value: "Module" });
	}
	return target;
};
var __copyProps = (to, from, except, desc) => {
	if (from && typeof from === "object" || typeof from === "function") {
		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
			key = keys[i];
			if (!__hasOwnProp.call(to, key) && key !== except) {
				__defProp(to, key, {
					get: ((k) => from[k]).bind(null, key),
					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
				});
			}
		}
	}
	return to;
};
var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);

//#endregion

//#region node_modules/.pnpm/p-map@7.0.4/node_modules/p-map/index.js
var p_map_exports = /* @__PURE__ */ __exportAll({
	default: () => pMap,
	pMapIterable: () => pMapIterable,
	pMapSkip: () => pMapSkip
});
async function pMap(iterable, mapper, { concurrency = Number.POSITIVE_INFINITY, stopOnError = true, signal } = {}) {
	return new _p_PromiseCtor((resolve_, reject_) => {
		if (iterable[Symbol.iterator] === void 0 && iterable[Symbol.asyncIterator] === void 0) throw new _p_TypeErrorCtor(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`);
		if (typeof mapper !== "function") throw new _p_TypeErrorCtor("Mapper function is required");
		if (!(_p_NumberIsSafeInteger(concurrency) && concurrency >= 1 || concurrency === Number.POSITIVE_INFINITY)) throw new _p_TypeErrorCtor(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
		const result = [];
		const errors = [];
		const skippedIndexesMap = /* @__PURE__ */ new _p_MapCtor();
		let isRejected = false;
		let isResolved = false;
		let isIterableDone = false;
		let resolvingCount = 0;
		let currentIndex = 0;
		const iterator = iterable[Symbol.iterator] === void 0 ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
		const signalListener = () => {
			reject(signal.reason);
		};
		const cleanup = () => {
			signal?.removeEventListener("abort", signalListener);
		};
		const resolve = (value) => {
			resolve_(value);
			cleanup();
		};
		const reject = (reason) => {
			isRejected = true;
			isResolved = true;
			reject_(reason);
			cleanup();
		};
		if (signal) {
			if (signal.aborted) reject(signal.reason);
			signal.addEventListener("abort", signalListener, { once: true });
		}
		const next = async () => {
			if (isResolved) return;
			const nextItem = await iterator.next();
			const index = currentIndex;
			currentIndex++;
			if (nextItem.done) {
				isIterableDone = true;
				if (resolvingCount === 0 && !isResolved) {
					if (!stopOnError && errors.length > 0) {
						reject(new _p_AggregateErrorCtor(errors));
						return;
					}
					isResolved = true;
					if (skippedIndexesMap.size === 0) {
						resolve(result);
						return;
					}
					const pureResult = [];
					for (const [index, value] of result.entries()) {
						if (skippedIndexesMap.get(index) === pMapSkip) continue;
						pureResult.push(value);
					}
					resolve(pureResult);
				}
				return;
			}
			resolvingCount++;
			(async () => {
				try {
					const element = await nextItem.value;
					if (isResolved) return;
					const value = await mapper(element, index);
					if (value === pMapSkip) skippedIndexesMap.set(index, value);
					result[index] = value;
					resolvingCount--;
					await next();
				} catch (error) {
					if (stopOnError) reject(error);
					else {
						errors.push(error);
						resolvingCount--;
						try {
							await next();
						} catch (error) {
							reject(error);
						}
					}
				}
			})();
		};
		(async () => {
			for (let index = 0; index < concurrency; index++) {
				try {
					await next();
				} catch (error) {
					reject(error);
					break;
				}
				if (isIterableDone || isRejected) break;
			}
		})();
	});
}
function pMapIterable(iterable, mapper, { concurrency = Number.POSITIVE_INFINITY, backpressure = concurrency } = {}) {
	if (iterable[Symbol.iterator] === void 0 && iterable[Symbol.asyncIterator] === void 0) throw new _p_TypeErrorCtor(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`);
	if (typeof mapper !== "function") throw new _p_TypeErrorCtor("Mapper function is required");
	if (!(_p_NumberIsSafeInteger(concurrency) && concurrency >= 1 || concurrency === Number.POSITIVE_INFINITY)) throw new _p_TypeErrorCtor(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
	if (!(_p_NumberIsSafeInteger(backpressure) && backpressure >= concurrency || backpressure === Number.POSITIVE_INFINITY)) throw new _p_TypeErrorCtor(`Expected \`backpressure\` to be an integer from \`concurrency\` (${concurrency}) and up or \`Infinity\`, got \`${backpressure}\` (${typeof backpressure})`);
	return { async *[Symbol.asyncIterator]() {
		const iterator = iterable[Symbol.asyncIterator] === void 0 ? iterable[Symbol.iterator]() : iterable[Symbol.asyncIterator]();
		const promises = [];
		let pendingPromisesCount = 0;
		let isDone = false;
		let index = 0;
		function trySpawn() {
			if (isDone || !(pendingPromisesCount < concurrency && promises.length < backpressure)) return;
			pendingPromisesCount++;
			const promise = (async () => {
				const { done, value } = await iterator.next();
				if (done) {
					pendingPromisesCount--;
					return { done: true };
				}
				trySpawn();
				try {
					const returnValue = await mapper(await value, index++);
					pendingPromisesCount--;
					if (returnValue === pMapSkip) {
						const index = promises.indexOf(promise);
						if (index > 0) promises.splice(index, 1);
					}
					trySpawn();
					return {
						done: false,
						value: returnValue
					};
				} catch (error) {
					pendingPromisesCount--;
					isDone = true;
					return { error };
				}
			})();
			promises.push(promise);
		}
		trySpawn();
		while (promises.length > 0) {
			const { error, done, value } = await promises[0];
			promises.shift();
			if (error) throw error;
			if (done) return;
			trySpawn();
			if (value === pMapSkip) continue;
			yield value;
		}
	} };
}
var pMapSkip;
var init_p_map = __esmMin((() => {
	pMapSkip = Symbol("skip");
}));

//#endregion
//#region src/external/p-map.js
module.exports = (init_p_map(), __toCommonJS(p_map_exports));

//#endregion
exports.pMapIterable = pMapIterable;
exports.pMapSkip = pMapSkip;