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 esbuild.
 */
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __esm = (fn, res) => function __init() {
  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// node_modules/.pnpm/p-map@7.0.4/node_modules/p-map/index.js
var p_map_exports = {};
__export(p_map_exports, {
  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 = /* @__PURE__ */ __name(() => {
      reject(signal.reason);
    }, "signalListener");
    const cleanup = /* @__PURE__ */ __name(() => {
      signal?.removeEventListener("abort", signalListener);
    }, "cleanup");
    const resolve = /* @__PURE__ */ __name((value) => {
      resolve_(value);
      cleanup();
    }, "resolve");
    const reject = /* @__PURE__ */ __name((reason) => {
      isRejected = true;
      isResolved = true;
      reject_(reason);
      cleanup();
    }, "reject");
    if (signal) {
      if (signal.aborted) {
        reject(signal.reason);
      }
      signal.addEventListener("abort", signalListener, { once: true });
    }
    const next = /* @__PURE__ */ __name(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 [index2, value] of result.entries()) {
            if (skippedIndexesMap.get(index2) === 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 (error2) {
              reject(error2);
            }
          }
        }
      })();
    }, "next");
    (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 index2 = promises.indexOf(promise);
              if (index2 > 0) {
                promises.splice(index2, 1);
              }
            }
            trySpawn();
            return { done: false, value: returnValue };
          } catch (error) {
            pendingPromisesCount--;
            isDone = true;
            return { error };
          }
        })();
        promises.push(promise);
      }
      __name(trySpawn, "trySpawn");
      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 = __esm({
  "node_modules/.pnpm/p-map@7.0.4/node_modules/p-map/index.js"() {
    __name(pMap, "pMap");
    __name(pMapIterable, "pMapIterable");
    pMapSkip = Symbol("skip");
  }
});

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