@socketsecurity/lib 6.0.3 → 6.0.5

package/dist/external/p-map.js

@@ -8,240 +8,216 @@ const { PromiseCtor: _p_PromiseCtor } = require('../primordials/promise.js')
 "use strict";
 /**
  * Bundled from p-map
- * This is a zero-dependency bundle created by esbuild.
+ * This is a zero-dependency bundle created by rolldown.
  */
-"use strict";
+'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 __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 __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 (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;
+	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) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __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
+//#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 = /* @__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;
-        }
-      }
-    })();
-  });
+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 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;
-      }
-    }
-  };
+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 = __esm({
-  "node_modules/.pnpm/p-map@7.0.4/node_modules/p-map/index.js"() {
-    __name(pMap, "pMap");
-    __name(pMapIterable, "pMapIterable");
-    pMapSkip = Symbol("skip");
-  }
-});
+var init_p_map = __esmMin((() => {
+	pMapSkip = Symbol("skip");
+}));
 
-// src/external/p-map.js
+//#endregion
+//#region src/external/p-map.js
 module.exports = (init_p_map(), __toCommonJS(p_map_exports));
+
+//#endregion
+exports.pMapIterable = pMapIterable;
+exports.pMapSkip = pMapSkip;