@kubb/agent 4.28.1 → 4.29.0

package/.output/server/node_modules/@sec-ant/readable-stream/package.json

@@ -1,98 +0,0 @@
-{
-  "name": "@sec-ant/readable-stream",
-  "description": "A tiny, zero-dependency yet spec-compliant asynchronous iterator polyfill/ponyfill for ReadableStreams.",
-  "private": false,
-  "version": "0.4.1",
-  "type": "module",
-  "files": [
-    "./dist"
-  ],
-  "main": "./dist/index/index.js",
-  "module": "./dist/index/index.js",
-  "exports": {
-    ".": "./dist/index/index.js",
-    "./asyncIterator": "./dist/index/asyncIterator.js",
-    "./fromAnyIterable": "./dist/index/fromAnyIterable.js",
-    "./ponyfill": "./dist/ponyfill/index.js",
-    "./ponyfill/asyncIterator": "./dist/ponyfill/asyncIterator.js",
-    "./ponyfill/fromAnyIterable": "./dist/ponyfill/fromAnyIterable.js",
-    "./polyfill": "./dist/polyfill/index.js",
-    "./polyfill/asyncIterator": "./dist/polyfill/asyncIterator.js",
-    "./polyfill/fromAnyIterable": "./dist/polyfill/fromAnyIterable.js",
-    "./async-iterator": {
-      "types": "./dist/types/async-iterator.d.ts"
-    }
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Sec-ant/readable-stream.git"
-  },
-  "homepage": "https://github.com/Sec-ant/readable-stream",
-  "bugs": {
-    "url": "https://github.com/Sec-ant/readable-stream/issues",
-    "email": "zezhengwu@proton.me"
-  },
-  "keywords": [
-    "stream",
-    "web-streams",
-    "readablestream",
-    "async",
-    "asynchronous",
-    "iterator",
-    "iteration",
-    "async-iterator",
-    "polyfill",
-    "esm",
-    "from-iterable"
-  ],
-  "author": {
-    "name": "Ze-Zheng Wu"
-  },
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "install:ci": "npm ci && npx playwright install --with-deps",
-    "install:codesandbox": "npm ci && ./scripts/prepare.sh",
-    "update-hooks": "simple-git-hooks",
-    "changeset": "changeset",
-    "bump": "changeset version 2>/dev/null | grep . && npm i; exit 0",
-    "type-check": "tsc --noEmit --emitDeclarationOnly false",
-    "format:prettier": "prettier . --write",
-    "format:biome": "biome format . --write",
-    "format": "conc \"npm:format:prettier\" \"npm:format:biome\"",
-    "check:biome": "biome check --apply .",
-    "check": "conc \"npm:format:prettier\" \"npm:check:biome\"",
-    "prebuild": "npm run check && npm run type-check",
-    "build": "vite build",
-    "copy": "copy-files-from-to",
-    "postbuild": "tsc && npm run copy",
-    "test:chromium": "vitest run --browser.name=chromium",
-    "test:firefox": "vitest run --browser.name=firefox",
-    "test": "npm run test:chromium && npm run test:firefox",
-    "test:coverage": "vitest run --coverage",
-    "test:ui": "vitest --ui --coverage",
-    "prepublishOnly": "npm run build",
-    "bump-biome:latest": "npm i -DE @biomejs/biome@latest",
-    "bump-biome:nightly": "npm i -DE @biomejs/biome@nightly"
-  },
-  "devDependencies": {
-    "@biomejs/biome": "1.6.1",
-    "@changesets/cli": "^2.27.1",
-    "@commitlint/cli": "^19.1.0",
-    "@commitlint/config-conventional": "^19.1.0",
-    "@vitest/browser": "^1.3.1",
-    "@vitest/coverage-istanbul": "^1.3.1",
-    "@vitest/ui": "^1.3.1",
-    "concurrently": "^8.2.2",
-    "copy-files-from-to": "^3.9.1",
-    "lint-staged": "^15.2.2",
-    "playwright": "^1.42.1",
-    "prettier": "^3.2.5",
-    "simple-git-hooks": "^2.10.0",
-    "typescript": "^5.4.2",
-    "vite": "^5.1.6",
-    "vitest": "^1.3.1"
-  }
-}

package/.output/server/node_modules/@sindresorhus/merge-streams/index.js

@@ -1,265 +0,0 @@
-import {on, once} from 'node:events';
-import {PassThrough as PassThroughStream, getDefaultHighWaterMark} from 'node:stream';
-import {finished} from 'node:stream/promises';
-
-export default function mergeStreams(streams) {
-	if (!Array.isArray(streams)) {
-		throw new TypeError(`Expected an array, got \`${typeof streams}\`.`);
-	}
-
-	for (const stream of streams) {
-		validateStream(stream);
-	}
-
-	const objectMode = streams.some(({readableObjectMode}) => readableObjectMode);
-	const highWaterMark = getHighWaterMark(streams, objectMode);
-	const passThroughStream = new MergedStream({
-		objectMode,
-		writableHighWaterMark: highWaterMark,
-		readableHighWaterMark: highWaterMark,
-	});
-
-	for (const stream of streams) {
-		passThroughStream.add(stream);
-	}
-
-	return passThroughStream;
-}
-
-const getHighWaterMark = (streams, objectMode) => {
-	if (streams.length === 0) {
-		return getDefaultHighWaterMark(objectMode);
-	}
-
-	const highWaterMarks = streams
-		.filter(({readableObjectMode}) => readableObjectMode === objectMode)
-		.map(({readableHighWaterMark}) => readableHighWaterMark);
-	return Math.max(...highWaterMarks);
-};
-
-class MergedStream extends PassThroughStream {
-	#streams = new Set([]);
-	#ended = new Set([]);
-	#aborted = new Set([]);
-	#onFinished;
-	#unpipeEvent = Symbol('unpipe');
-	#streamPromises = new WeakMap();
-
-	add(stream) {
-		validateStream(stream);
-
-		if (this.#streams.has(stream)) {
-			return;
-		}
-
-		this.#streams.add(stream);
-
-		this.#onFinished ??= onMergedStreamFinished(this, this.#streams, this.#unpipeEvent);
-		const streamPromise = endWhenStreamsDone({
-			passThroughStream: this,
-			stream,
-			streams: this.#streams,
-			ended: this.#ended,
-			aborted: this.#aborted,
-			onFinished: this.#onFinished,
-			unpipeEvent: this.#unpipeEvent,
-		});
-		this.#streamPromises.set(stream, streamPromise);
-
-		stream.pipe(this, {end: false});
-	}
-
-	async remove(stream) {
-		validateStream(stream);
-
-		if (!this.#streams.has(stream)) {
-			return false;
-		}
-
-		const streamPromise = this.#streamPromises.get(stream);
-		if (streamPromise === undefined) {
-			return false;
-		}
-
-		this.#streamPromises.delete(stream);
-
-		stream.unpipe(this);
-		await streamPromise;
-		return true;
-	}
-}
-
-const onMergedStreamFinished = async (passThroughStream, streams, unpipeEvent) => {
-	updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_COUNT);
-	const controller = new AbortController();
-
-	try {
-		await Promise.race([
-			onMergedStreamEnd(passThroughStream, controller),
-			onInputStreamsUnpipe(passThroughStream, streams, unpipeEvent, controller),
-		]);
-	} finally {
-		controller.abort();
-		updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_COUNT);
-	}
-};
-
-const onMergedStreamEnd = async (passThroughStream, {signal}) => {
-	try {
-		await finished(passThroughStream, {signal, cleanup: true});
-	} catch (error) {
-		errorOrAbortStream(passThroughStream, error);
-		throw error;
-	}
-};
-
-const onInputStreamsUnpipe = async (passThroughStream, streams, unpipeEvent, {signal}) => {
-	for await (const [unpipedStream] of on(passThroughStream, 'unpipe', {signal})) {
-		if (streams.has(unpipedStream)) {
-			unpipedStream.emit(unpipeEvent);
-		}
-	}
-};
-
-const validateStream = stream => {
-	if (typeof stream?.pipe !== 'function') {
-		throw new TypeError(`Expected a readable stream, got: \`${typeof stream}\`.`);
-	}
-};
-
-const endWhenStreamsDone = async ({passThroughStream, stream, streams, ended, aborted, onFinished, unpipeEvent}) => {
-	updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_PER_STREAM);
-	const controller = new AbortController();
-
-	try {
-		await Promise.race([
-			afterMergedStreamFinished(onFinished, stream, controller),
-			onInputStreamEnd({
-				passThroughStream,
-				stream,
-				streams,
-				ended,
-				aborted,
-				controller,
-			}),
-			onInputStreamUnpipe({
-				stream,
-				streams,
-				ended,
-				aborted,
-				unpipeEvent,
-				controller,
-			}),
-		]);
-	} finally {
-		controller.abort();
-		updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_PER_STREAM);
-	}
-
-	if (streams.size > 0 && streams.size === ended.size + aborted.size) {
-		if (ended.size === 0 && aborted.size > 0) {
-			abortStream(passThroughStream);
-		} else {
-			endStream(passThroughStream);
-		}
-	}
-};
-
-const afterMergedStreamFinished = async (onFinished, stream, {signal}) => {
-	try {
-		await onFinished;
-		if (!signal.aborted) {
-			abortStream(stream);
-		}
-	} catch (error) {
-		if (!signal.aborted) {
-			errorOrAbortStream(stream, error);
-		}
-	}
-};
-
-const onInputStreamEnd = async ({passThroughStream, stream, streams, ended, aborted, controller: {signal}}) => {
-	try {
-		await finished(stream, {
-			signal,
-			cleanup: true,
-			readable: true,
-			writable: false,
-		});
-		if (streams.has(stream)) {
-			ended.add(stream);
-		}
-	} catch (error) {
-		if (signal.aborted || !streams.has(stream)) {
-			return;
-		}
-
-		if (isAbortError(error)) {
-			aborted.add(stream);
-		} else {
-			errorStream(passThroughStream, error);
-		}
-	}
-};
-
-const onInputStreamUnpipe = async ({stream, streams, ended, aborted, unpipeEvent, controller: {signal}}) => {
-	await once(stream, unpipeEvent, {signal});
-
-	if (!stream.readable) {
-		return once(signal, 'abort', {signal});
-	}
-
-	streams.delete(stream);
-	ended.delete(stream);
-	aborted.delete(stream);
-};
-
-const endStream = stream => {
-	if (stream.writable) {
-		stream.end();
-	}
-};
-
-const errorOrAbortStream = (stream, error) => {
-	if (isAbortError(error)) {
-		abortStream(stream);
-	} else {
-		errorStream(stream, error);
-	}
-};
-
-// This is the error thrown by `finished()` on `stream.destroy()`
-const isAbortError = error => error?.code === 'ERR_STREAM_PREMATURE_CLOSE';
-
-const abortStream = stream => {
-	if (stream.readable || stream.writable) {
-		stream.destroy();
-	}
-};
-
-// `stream.destroy(error)` crashes the process with `uncaughtException` if no `error` event listener exists on `stream`.
-// We take care of error handling on user behalf, so we do not want this to happen.
-const errorStream = (stream, error) => {
-	if (!stream.destroyed) {
-		stream.once('error', noop);
-		stream.destroy(error);
-	}
-};
-
-const noop = () => {};
-
-const updateMaxListeners = (passThroughStream, increment) => {
-	const maxListeners = passThroughStream.getMaxListeners();
-	if (maxListeners !== 0 && maxListeners !== Number.POSITIVE_INFINITY) {
-		passThroughStream.setMaxListeners(maxListeners + increment);
-	}
-};
-
-// Number of times `passThroughStream.on()` is called regardless of streams:
-//  - once due to `finished(passThroughStream)`
-//  - once due to `on(passThroughStream)`
-const PASSTHROUGH_LISTENERS_COUNT = 2;
-
-// Number of times `passThroughStream.on()` is called per stream:
-//  - once due to `stream.pipe(passThroughStream)`
-const PASSTHROUGH_LISTENERS_PER_STREAM = 1;

package/.output/server/node_modules/@sindresorhus/merge-streams/package.json

@@ -1,49 +0,0 @@
-{
-  "name": "@sindresorhus/merge-streams",
-  "version": "4.0.0",
-  "description": "Merge multiple streams into a unified stream",
-  "license": "MIT",
-  "repository": "sindresorhus/merge-streams",
-  "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 && c8 ava && tsd"
-  },
-  "files": [
-    "index.js",
-    "index.d.ts"
-  ],
-  "keywords": [
-    "merge",
-    "stream",
-    "streams",
-    "readable",
-    "passthrough",
-    "interleave",
-    "interleaved",
-    "unify",
-    "unified"
-  ],
-  "devDependencies": {
-    "@types/node": "^20.8.9",
-    "ava": "^6.1.0",
-    "c8": "^9.1.0",
-    "tempfile": "^5.0.0",
-    "tsd": "^0.31.0",
-    "typescript": "^5.2.2",
-    "xo": "^0.58.0"
-  }
-}

package/.output/server/node_modules/balanced-match/index.js

@@ -1,62 +0,0 @@
-'use strict';
-module.exports = balanced;
-function balanced(a, b, str) {
-  if (a instanceof RegExp) a = maybeMatch(a, str);
-  if (b instanceof RegExp) b = maybeMatch(b, str);
-
-  var r = range(a, b, str);
-
-  return r && {
-    start: r[0],
-    end: r[1],
-    pre: str.slice(0, r[0]),
-    body: str.slice(r[0] + a.length, r[1]),
-    post: str.slice(r[1] + b.length)
-  };
-}
-
-function maybeMatch(reg, str) {
-  var m = str.match(reg);
-  return m ? m[0] : null;
-}
-
-balanced.range = range;
-function range(a, b, str) {
-  var begs, beg, left, right, result;
-  var ai = str.indexOf(a);
-  var bi = str.indexOf(b, ai + 1);
-  var i = ai;
-
-  if (ai >= 0 && bi > 0) {
-    if(a===b) {
-      return [ai, bi];
-    }
-    begs = [];
-    left = str.length;
-
-    while (i >= 0 && !result) {
-      if (i == ai) {
-        begs.push(i);
-        ai = str.indexOf(a, i + 1);
-      } else if (begs.length == 1) {
-        result = [ begs.pop(), bi ];
-      } else {
-        beg = begs.pop();
-        if (beg < left) {
-          left = beg;
-          right = bi;
-        }
-
-        bi = str.indexOf(b, i + 1);
-      }
-
-      i = ai < bi && ai >= 0 ? ai : bi;
-    }
-
-    if (begs.length) {
-      result = [ left, right ];
-    }
-  }
-
-  return result;
-}

package/.output/server/node_modules/balanced-match/package.json

@@ -1,48 +0,0 @@
-{
-  "name": "balanced-match",
-  "description": "Match balanced character pairs, like \"{\" and \"}\"",
-  "version": "1.0.2",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/juliangruber/balanced-match.git"
-  },
-  "homepage": "https://github.com/juliangruber/balanced-match",
-  "main": "index.js",
-  "scripts": {
-    "test": "tape test/test.js",
-    "bench": "matcha test/bench.js"
-  },
-  "devDependencies": {
-    "matcha": "^0.7.0",
-    "tape": "^4.6.0"
-  },
-  "keywords": [
-    "match",
-    "regexp",
-    "test",
-    "balanced",
-    "parse"
-  ],
-  "author": {
-    "name": "Julian Gruber",
-    "email": "mail@juliangruber.com",
-    "url": "http://juliangruber.com"
-  },
-  "license": "MIT",
-  "testling": {
-    "files": "test/*.js",
-    "browsers": [
-      "ie/8..latest",
-      "firefox/20..latest",
-      "firefox/nightly",
-      "chrome/25..latest",
-      "chrome/canary",
-      "opera/12..latest",
-      "opera/next",
-      "safari/5.1..latest",
-      "ipad/6.0..latest",
-      "iphone/6.0..latest",
-      "android-browser/4.2..latest"
-    ]
-  }
-}