@kubb/agent 0.0.0-canary-20260217115709

package/.output/server/node_modules/npm-run-path/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "npm-run-path",
+  "version": "6.0.0",
+  "description": "Get your PATH prepended with locally installed binaries",
+  "license": "MIT",
+  "repository": "sindresorhus/npm-run-path",
+  "funding": "https://github.com/sponsors/sindresorhus",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "https://sindresorhus.com"
+  },
+  "type": "module",
+  "exports": {
+    "types": "./index.d.ts",
+    "default": "./index.js"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "xo && ava && tsd"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "keywords": [
+    "npm",
+    "run",
+    "path",
+    "package",
+    "bin",
+    "binary",
+    "binaries",
+    "script",
+    "cli",
+    "command-line",
+    "execute",
+    "executable"
+  ],
+  "dependencies": {
+    "path-key": "^4.0.0",
+    "unicorn-magic": "^0.3.0"
+  },
+  "devDependencies": {
+    "ava": "^6.1.3",
+    "tsd": "^0.31.1",
+    "xo": "^0.59.3"
+  }
+}

package/.output/server/node_modules/p-limit/index.js

@@ -0,0 +1,127 @@
+import Queue from 'yocto-queue';
+
+export default function pLimit(concurrency) {
+	let rejectOnClear = false;
+
+	if (typeof concurrency === 'object') {
+		({concurrency, rejectOnClear = false} = concurrency);
+	}
+
+	validateConcurrency(concurrency);
+
+	if (typeof rejectOnClear !== 'boolean') {
+		throw new TypeError('Expected `rejectOnClear` to be a boolean');
+	}
+
+	const queue = new Queue();
+	let activeCount = 0;
+
+	const resumeNext = () => {
+		// Process the next queued function if we're under the concurrency limit
+		if (activeCount < concurrency && queue.size > 0) {
+			activeCount++;
+			queue.dequeue().run();
+		}
+	};
+
+	const next = () => {
+		activeCount--;
+		resumeNext();
+	};
+
+	const run = async (function_, resolve, arguments_) => {
+		// Execute the function and capture the result promise
+		const result = (async () => function_(...arguments_))();
+
+		// Resolve immediately with the promise (don't wait for completion)
+		resolve(result);
+
+		// Wait for the function to complete (success or failure)
+		// We catch errors here to prevent unhandled rejections,
+		// but the original promise rejection is preserved for the caller
+		try {
+			await result;
+		} catch {}
+
+		// Decrement active count and process next queued function
+		next();
+	};
+
+	const enqueue = (function_, resolve, reject, arguments_) => {
+		const queueItem = {reject};
+
+		// Queue the internal resolve function instead of the run function
+		// to preserve the asynchronous execution context.
+		new Promise(internalResolve => { // eslint-disable-line promise/param-names
+			queueItem.run = internalResolve;
+			queue.enqueue(queueItem);
+		}).then(run.bind(undefined, function_, resolve, arguments_)); // eslint-disable-line promise/prefer-await-to-then
+
+		// Start processing immediately if we haven't reached the concurrency limit
+		if (activeCount < concurrency) {
+			resumeNext();
+		}
+	};
+
+	const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
+		enqueue(function_, resolve, reject, arguments_);
+	});
+
+	Object.defineProperties(generator, {
+		activeCount: {
+			get: () => activeCount,
+		},
+		pendingCount: {
+			get: () => queue.size,
+		},
+		clearQueue: {
+			value() {
+				if (!rejectOnClear) {
+					queue.clear();
+					return;
+				}
+
+				const abortError = AbortSignal.abort().reason;
+
+				while (queue.size > 0) {
+					queue.dequeue().reject(abortError);
+				}
+			},
+		},
+		concurrency: {
+			get: () => concurrency,
+
+			set(newConcurrency) {
+				validateConcurrency(newConcurrency);
+				concurrency = newConcurrency;
+
+				queueMicrotask(() => {
+					// eslint-disable-next-line no-unmodified-loop-condition
+					while (activeCount < concurrency && queue.size > 0) {
+						resumeNext();
+					}
+				});
+			},
+		},
+		map: {
+			async value(iterable, function_) {
+				const promises = Array.from(iterable, (value, index) => this(function_, value, index));
+				return Promise.all(promises);
+			},
+		},
+	});
+
+	return generator;
+}
+
+export function limitFunction(function_, options) {
+	const limit = pLimit(options);
+
+	return (...arguments_) => limit(() => function_(...arguments_));
+}
+
+function validateConcurrency(concurrency) {
+	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+		throw new TypeError('Expected `concurrency` to be a number from 1 and up');
+	}
+}

package/.output/server/node_modules/p-limit/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "p-limit",
+  "version": "7.3.0",
+  "description": "Run multiple promise-returning & async functions with limited concurrency",
+  "license": "MIT",
+  "repository": "sindresorhus/p-limit",
+  "funding": "https://github.com/sponsors/sindresorhus",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "https://sindresorhus.com"
+  },
+  "type": "module",
+  "exports": {
+    "types": "./index.d.ts",
+    "default": "./index.js"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "xo && ava && tsd",
+    "benchmark": "node benchmark.js"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "keywords": [
+    "promise",
+    "limit",
+    "limited",
+    "concurrency",
+    "throttle",
+    "throat",
+    "rate",
+    "batch",
+    "ratelimit",
+    "task",
+    "queue",
+    "async",
+    "await",
+    "promises",
+    "bluebird"
+  ],
+  "dependencies": {
+    "yocto-queue": "^1.2.1"
+  },
+  "devDependencies": {
+    "ava": "^6.4.1",
+    "in-range": "^3.0.0",
+    "random-int": "^3.0.0",
+    "time-span": "^5.1.0",
+    "tsd": "^0.33.0",
+    "xo": "^1.2.1"
+  }
+}

package/.output/server/node_modules/parse-ms/index.js

@@ -0,0 +1,45 @@
+const toZeroIfInfinity = value => Number.isFinite(value) ? value : 0;
+
+function parseNumber(milliseconds) {
+	return {
+		days: Math.trunc(milliseconds / 86_400_000),
+		hours: Math.trunc(milliseconds / 3_600_000 % 24),
+		minutes: Math.trunc(milliseconds / 60_000 % 60),
+		seconds: Math.trunc(milliseconds / 1000 % 60),
+		milliseconds: Math.trunc(milliseconds % 1000),
+		microseconds: Math.trunc(toZeroIfInfinity(milliseconds * 1000) % 1000),
+		nanoseconds: Math.trunc(toZeroIfInfinity(milliseconds * 1e6) % 1000),
+	};
+}
+
+function parseBigint(milliseconds) {
+	return {
+		days: milliseconds / 86_400_000n,
+		hours: milliseconds / 3_600_000n % 24n,
+		minutes: milliseconds / 60_000n % 60n,
+		seconds: milliseconds / 1000n % 60n,
+		milliseconds: milliseconds % 1000n,
+		microseconds: 0n,
+		nanoseconds: 0n,
+	};
+}
+
+export default function parseMilliseconds(milliseconds) {
+	switch (typeof milliseconds) {
+		case 'number': {
+			if (Number.isFinite(milliseconds)) {
+				return parseNumber(milliseconds);
+			}
+
+			break;
+		}
+
+		case 'bigint': {
+			return parseBigint(milliseconds);
+		}
+
+		// No default
+	}
+
+	throw new TypeError('Expected a finite number or bigint');
+}

package/.output/server/node_modules/parse-ms/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "parse-ms",
+  "version": "4.0.0",
+  "description": "Parse milliseconds into an object",
+  "license": "MIT",
+  "repository": "sindresorhus/parse-ms",
+  "funding": "https://github.com/sponsors/sindresorhus",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "https://sindresorhus.com"
+  },
+  "type": "module",
+  "exports": {
+    "types": "./index.d.ts",
+    "default": "./index.js"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "xo && ava && tsd"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "keywords": [
+    "browser",
+    "parse",
+    "time",
+    "ms",
+    "milliseconds",
+    "microseconds",
+    "nanoseconds",
+    "duration",
+    "period",
+    "range",
+    "interval"
+  ],
+  "devDependencies": {
+    "ava": "^6.0.1",
+    "tsd": "^0.30.3",
+    "xo": "^0.56.0"
+  }
+}

package/.output/server/node_modules/path-is-inside/lib/path-is-inside.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var path = require("path");
+
+module.exports = function (thePath, potentialParent) {
+    // For inside-directory checking, we want to allow trailing slashes, so normalize.
+    thePath = stripTrailingSep(thePath);
+    potentialParent = stripTrailingSep(potentialParent);
+
+    // Node treats only Windows as case-insensitive in its path module; we follow those conventions.
+    if (process.platform === "win32") {
+        thePath = thePath.toLowerCase();
+        potentialParent = potentialParent.toLowerCase();
+    }
+
+    return thePath.lastIndexOf(potentialParent, 0) === 0 &&
+		(
+			thePath[potentialParent.length] === path.sep ||
+			thePath[potentialParent.length] === undefined
+		);
+};
+
+function stripTrailingSep(thePath) {
+    if (thePath[thePath.length - 1] === path.sep) {
+        return thePath.slice(0, -1);
+    }
+    return thePath;
+}

package/.output/server/node_modules/path-is-inside/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "path-is-inside",
+  "description": "Tests whether one path is inside another path",
+  "keywords": [
+    "path",
+    "directory",
+    "folder",
+    "inside",
+    "relative"
+  ],
+  "version": "1.0.2",
+  "author": "Domenic Denicola <d@domenic.me> (https://domenic.me)",
+  "license": "(WTFPL OR MIT)",
+  "repository": "domenic/path-is-inside",
+  "main": "lib/path-is-inside.js",
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "test": "mocha",
+    "lint": "jshint lib"
+  },
+  "devDependencies": {
+    "jshint": "~2.3.0",
+    "mocha": "~1.15.1"
+  }
+}