@kubb/agent 4.28.1 → 4.29.0

package/.output/server/node_modules/fs-extra/lib/move/move-sync.js

@@ -1,55 +0,0 @@
-'use strict'
-
-const fs = require('graceful-fs')
-const path = require('path')
-const copySync = require('../copy').copySync
-const removeSync = require('../remove').removeSync
-const mkdirpSync = require('../mkdirs').mkdirpSync
-const stat = require('../util/stat')
-
-function moveSync (src, dest, opts) {
-  opts = opts || {}
-  const overwrite = opts.overwrite || opts.clobber || false
-
-  const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, 'move', opts)
-  stat.checkParentPathsSync(src, srcStat, dest, 'move')
-  if (!isParentRoot(dest)) mkdirpSync(path.dirname(dest))
-  return doRename(src, dest, overwrite, isChangingCase)
-}
-
-function isParentRoot (dest) {
-  const parent = path.dirname(dest)
-  const parsedPath = path.parse(parent)
-  return parsedPath.root === parent
-}
-
-function doRename (src, dest, overwrite, isChangingCase) {
-  if (isChangingCase) return rename(src, dest, overwrite)
-  if (overwrite) {
-    removeSync(dest)
-    return rename(src, dest, overwrite)
-  }
-  if (fs.existsSync(dest)) throw new Error('dest already exists.')
-  return rename(src, dest, overwrite)
-}
-
-function rename (src, dest, overwrite) {
-  try {
-    fs.renameSync(src, dest)
-  } catch (err) {
-    if (err.code !== 'EXDEV') throw err
-    return moveAcrossDevice(src, dest, overwrite)
-  }
-}
-
-function moveAcrossDevice (src, dest, overwrite) {
-  const opts = {
-    overwrite,
-    errorOnExist: true,
-    preserveTimestamps: true
-  }
-  copySync(src, dest, opts)
-  return removeSync(src)
-}
-
-module.exports = moveSync

package/.output/server/node_modules/fs-extra/lib/move/move.js

@@ -1,59 +0,0 @@
-'use strict'
-
-const fs = require('../fs')
-const path = require('path')
-const { copy } = require('../copy')
-const { remove } = require('../remove')
-const { mkdirp } = require('../mkdirs')
-const { pathExists } = require('../path-exists')
-const stat = require('../util/stat')
-
-async function move (src, dest, opts = {}) {
-  const overwrite = opts.overwrite || opts.clobber || false
-
-  const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, 'move', opts)
-
-  await stat.checkParentPaths(src, srcStat, dest, 'move')
-
-  // If the parent of dest is not root, make sure it exists before proceeding
-  const destParent = path.dirname(dest)
-  const parsedParentPath = path.parse(destParent)
-  if (parsedParentPath.root !== destParent) {
-    await mkdirp(destParent)
-  }
-
-  return doRename(src, dest, overwrite, isChangingCase)
-}
-
-async function doRename (src, dest, overwrite, isChangingCase) {
-  if (!isChangingCase) {
-    if (overwrite) {
-      await remove(dest)
-    } else if (await pathExists(dest)) {
-      throw new Error('dest already exists.')
-    }
-  }
-
-  try {
-    // Try w/ rename first, and try copy + remove if EXDEV
-    await fs.rename(src, dest)
-  } catch (err) {
-    if (err.code !== 'EXDEV') {
-      throw err
-    }
-    await moveAcrossDevice(src, dest, overwrite)
-  }
-}
-
-async function moveAcrossDevice (src, dest, overwrite) {
-  const opts = {
-    overwrite,
-    errorOnExist: true,
-    preserveTimestamps: true
-  }
-
-  await copy(src, dest, opts)
-  return remove(src)
-}
-
-module.exports = move

package/.output/server/node_modules/fs-extra/lib/output-file/index.js

@@ -1,31 +0,0 @@
-'use strict'
-
-const u = require('universalify').fromPromise
-const fs = require('../fs')
-const path = require('path')
-const mkdir = require('../mkdirs')
-const pathExists = require('../path-exists').pathExists
-
-async function outputFile (file, data, encoding = 'utf-8') {
-  const dir = path.dirname(file)
-
-  if (!(await pathExists(dir))) {
-    await mkdir.mkdirs(dir)
-  }
-
-  return fs.writeFile(file, data, encoding)
-}
-
-function outputFileSync (file, ...args) {
-  const dir = path.dirname(file)
-  if (!fs.existsSync(dir)) {
-    mkdir.mkdirsSync(dir)
-  }
-
-  fs.writeFileSync(file, ...args)
-}
-
-module.exports = {
-  outputFile: u(outputFile),
-  outputFileSync
-}

package/.output/server/node_modules/fs-extra/lib/path-exists/index.js

@@ -1,12 +0,0 @@
-'use strict'
-const u = require('universalify').fromPromise
-const fs = require('../fs')
-
-function pathExists (path) {
-  return fs.access(path).then(() => true).catch(() => false)
-}
-
-module.exports = {
-  pathExists: u(pathExists),
-  pathExistsSync: fs.existsSync
-}

package/.output/server/node_modules/fs-extra/lib/remove/index.js

@@ -1,17 +0,0 @@
-'use strict'
-
-const fs = require('graceful-fs')
-const u = require('universalify').fromCallback
-
-function remove (path, callback) {
-  fs.rm(path, { recursive: true, force: true }, callback)
-}
-
-function removeSync (path) {
-  fs.rmSync(path, { recursive: true, force: true })
-}
-
-module.exports = {
-  remove: u(remove),
-  removeSync
-}

package/.output/server/node_modules/fs-extra/lib/util/async.js

@@ -1,29 +0,0 @@
-'use strict'
-
-// https://github.com/jprichardson/node-fs-extra/issues/1056
-// Performing parallel operations on each item of an async iterator is
-// surprisingly hard; you need to have handlers in place to avoid getting an
-// UnhandledPromiseRejectionWarning.
-// NOTE: This function does not presently handle return values, only errors
-async function asyncIteratorConcurrentProcess (iterator, fn) {
-  const promises = []
-  for await (const item of iterator) {
-    promises.push(
-      fn(item).then(
-        () => null,
-        (err) => err ?? new Error('unknown error')
-      )
-    )
-  }
-  await Promise.all(
-    promises.map((promise) =>
-      promise.then((possibleErr) => {
-        if (possibleErr !== null) throw possibleErr
-      })
-    )
-  )
-}
-
-module.exports = {
-  asyncIteratorConcurrentProcess
-}

package/.output/server/node_modules/fs-extra/lib/util/stat.js

@@ -1,159 +0,0 @@
-'use strict'
-
-const fs = require('../fs')
-const path = require('path')
-const u = require('universalify').fromPromise
-
-function getStats (src, dest, opts) {
-  const statFunc = opts.dereference
-    ? (file) => fs.stat(file, { bigint: true })
-    : (file) => fs.lstat(file, { bigint: true })
-  return Promise.all([
-    statFunc(src),
-    statFunc(dest).catch(err => {
-      if (err.code === 'ENOENT') return null
-      throw err
-    })
-  ]).then(([srcStat, destStat]) => ({ srcStat, destStat }))
-}
-
-function getStatsSync (src, dest, opts) {
-  let destStat
-  const statFunc = opts.dereference
-    ? (file) => fs.statSync(file, { bigint: true })
-    : (file) => fs.lstatSync(file, { bigint: true })
-  const srcStat = statFunc(src)
-  try {
-    destStat = statFunc(dest)
-  } catch (err) {
-    if (err.code === 'ENOENT') return { srcStat, destStat: null }
-    throw err
-  }
-  return { srcStat, destStat }
-}
-
-async function checkPaths (src, dest, funcName, opts) {
-  const { srcStat, destStat } = await getStats(src, dest, opts)
-  if (destStat) {
-    if (areIdentical(srcStat, destStat)) {
-      const srcBaseName = path.basename(src)
-      const destBaseName = path.basename(dest)
-      if (funcName === 'move' &&
-        srcBaseName !== destBaseName &&
-        srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
-        return { srcStat, destStat, isChangingCase: true }
-      }
-      throw new Error('Source and destination must not be the same.')
-    }
-    if (srcStat.isDirectory() && !destStat.isDirectory()) {
-      throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)
-    }
-    if (!srcStat.isDirectory() && destStat.isDirectory()) {
-      throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`)
-    }
-  }
-
-  if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
-    throw new Error(errMsg(src, dest, funcName))
-  }
-
-  return { srcStat, destStat }
-}
-
-function checkPathsSync (src, dest, funcName, opts) {
-  const { srcStat, destStat } = getStatsSync(src, dest, opts)
-
-  if (destStat) {
-    if (areIdentical(srcStat, destStat)) {
-      const srcBaseName = path.basename(src)
-      const destBaseName = path.basename(dest)
-      if (funcName === 'move' &&
-        srcBaseName !== destBaseName &&
-        srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
-        return { srcStat, destStat, isChangingCase: true }
-      }
-      throw new Error('Source and destination must not be the same.')
-    }
-    if (srcStat.isDirectory() && !destStat.isDirectory()) {
-      throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)
-    }
-    if (!srcStat.isDirectory() && destStat.isDirectory()) {
-      throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`)
-    }
-  }
-
-  if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
-    throw new Error(errMsg(src, dest, funcName))
-  }
-  return { srcStat, destStat }
-}
-
-// recursively check if dest parent is a subdirectory of src.
-// It works for all file types including symlinks since it
-// checks the src and dest inodes. It starts from the deepest
-// parent and stops once it reaches the src parent or the root path.
-async function checkParentPaths (src, srcStat, dest, funcName) {
-  const srcParent = path.resolve(path.dirname(src))
-  const destParent = path.resolve(path.dirname(dest))
-  if (destParent === srcParent || destParent === path.parse(destParent).root) return
-
-  let destStat
-  try {
-    destStat = await fs.stat(destParent, { bigint: true })
-  } catch (err) {
-    if (err.code === 'ENOENT') return
-    throw err
-  }
-
-  if (areIdentical(srcStat, destStat)) {
-    throw new Error(errMsg(src, dest, funcName))
-  }
-
-  return checkParentPaths(src, srcStat, destParent, funcName)
-}
-
-function checkParentPathsSync (src, srcStat, dest, funcName) {
-  const srcParent = path.resolve(path.dirname(src))
-  const destParent = path.resolve(path.dirname(dest))
-  if (destParent === srcParent || destParent === path.parse(destParent).root) return
-  let destStat
-  try {
-    destStat = fs.statSync(destParent, { bigint: true })
-  } catch (err) {
-    if (err.code === 'ENOENT') return
-    throw err
-  }
-  if (areIdentical(srcStat, destStat)) {
-    throw new Error(errMsg(src, dest, funcName))
-  }
-  return checkParentPathsSync(src, srcStat, destParent, funcName)
-}
-
-function areIdentical (srcStat, destStat) {
-  // stat.dev can be 0n on windows when node version >= 22.x.x
-  return destStat.ino !== undefined && destStat.dev !== undefined && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev
-}
-
-// return true if dest is a subdir of src, otherwise false.
-// It only checks the path strings.
-function isSrcSubdir (src, dest) {
-  const srcArr = path.resolve(src).split(path.sep).filter(i => i)
-  const destArr = path.resolve(dest).split(path.sep).filter(i => i)
-  return srcArr.every((cur, i) => destArr[i] === cur)
-}
-
-function errMsg (src, dest, funcName) {
-  return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`
-}
-
-module.exports = {
-  // checkPaths
-  checkPaths: u(checkPaths),
-  checkPathsSync,
-  // checkParent
-  checkParentPaths: u(checkParentPaths),
-  checkParentPathsSync,
-  // Misc
-  isSrcSubdir,
-  areIdentical
-}

package/.output/server/node_modules/fs-extra/lib/util/utimes.js

@@ -1,36 +0,0 @@
-'use strict'
-
-const fs = require('../fs')
-const u = require('universalify').fromPromise
-
-async function utimesMillis (path, atime, mtime) {
-  // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)
-  const fd = await fs.open(path, 'r+')
-
-  let closeErr = null
-
-  try {
-    await fs.futimes(fd, atime, mtime)
-  } finally {
-    try {
-      await fs.close(fd)
-    } catch (e) {
-      closeErr = e
-    }
-  }
-
-  if (closeErr) {
-    throw closeErr
-  }
-}
-
-function utimesMillisSync (path, atime, mtime) {
-  const fd = fs.openSync(path, 'r+')
-  fs.futimesSync(fd, atime, mtime)
-  return fs.closeSync(fd)
-}
-
-module.exports = {
-  utimesMillis: u(utimesMillis),
-  utimesMillisSync
-}

package/.output/server/node_modules/fs-extra/package.json

@@ -1,71 +0,0 @@
-{
-  "name": "fs-extra",
-  "version": "11.3.3",
-  "description": "fs-extra contains methods that aren't included in the vanilla Node.js fs package. Such as recursive mkdir, copy, and remove.",
-  "engines": {
-    "node": ">=14.14"
-  },
-  "homepage": "https://github.com/jprichardson/node-fs-extra",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/jprichardson/node-fs-extra"
-  },
-  "keywords": [
-    "fs",
-    "file",
-    "file system",
-    "copy",
-    "directory",
-    "extra",
-    "mkdirp",
-    "mkdir",
-    "mkdirs",
-    "recursive",
-    "json",
-    "read",
-    "write",
-    "extra",
-    "delete",
-    "remove",
-    "touch",
-    "create",
-    "text",
-    "output",
-    "move",
-    "promise"
-  ],
-  "author": "JP Richardson <jprichardson@gmail.com>",
-  "license": "MIT",
-  "dependencies": {
-    "graceful-fs": "^4.2.0",
-    "jsonfile": "^6.0.1",
-    "universalify": "^2.0.0"
-  },
-  "devDependencies": {
-    "klaw": "^2.1.1",
-    "klaw-sync": "^3.0.2",
-    "minimist": "^1.1.1",
-    "mocha": "^10.1.0",
-    "nyc": "^15.0.0",
-    "proxyquire": "^2.0.1",
-    "read-dir-files": "^0.1.1",
-    "standard": "^17.0.0"
-  },
-  "main": "./lib/index.js",
-  "exports": {
-    ".": "./lib/index.js",
-    "./esm": "./lib/esm.mjs"
-  },
-  "files": [
-    "lib/",
-    "!lib/**/__tests__/"
-  ],
-  "scripts": {
-    "lint": "standard",
-    "test-find": "find ./lib/**/__tests__ -name *.test.js | xargs mocha",
-    "test": "npm run lint && npm run unit && npm run unit-esm",
-    "unit": "nyc node test.js",
-    "unit-esm": "node test.mjs"
-  },
-  "sideEffects": false
-}

package/.output/server/node_modules/get-stream/package.json

@@ -1,60 +0,0 @@
-{
-  "name": "get-stream",
-  "version": "9.0.1",
-  "description": "Get a stream as a string, Buffer, ArrayBuffer or array",
-  "license": "MIT",
-  "repository": "sindresorhus/get-stream",
-  "funding": "https://github.com/sponsors/sindresorhus",
-  "author": {
-    "name": "Sindre Sorhus",
-    "email": "sindresorhus@gmail.com",
-    "url": "https://sindresorhus.com"
-  },
-  "type": "module",
-  "exports": {
-    "types": "./source/index.d.ts",
-    "browser": "./source/exports.js",
-    "default": "./source/index.js"
-  },
-  "sideEffects": false,
-  "engines": {
-    "node": ">=18"
-  },
-  "scripts": {
-    "benchmark": "node benchmarks/index.js",
-    "test": "xo && ava && tsd --typings=source/index.d.ts --files=source/index.test-d.ts"
-  },
-  "files": [
-    "source",
-    "!*.test-d.ts"
-  ],
-  "keywords": [
-    "get",
-    "stream",
-    "promise",
-    "concat",
-    "string",
-    "text",
-    "buffer",
-    "read",
-    "data",
-    "consume",
-    "readable",
-    "readablestream",
-    "object",
-    "concat"
-  ],
-  "dependencies": {
-    "@sec-ant/readable-stream": "^0.4.1",
-    "is-stream": "^4.0.1"
-  },
-  "devDependencies": {
-    "@types/node": "^20.8.9",
-    "ava": "^6.1.2",
-    "onetime": "^7.0.0",
-    "precise-now": "^3.0.0",
-    "stream-json": "^1.8.0",
-    "tsd": "^0.29.0",
-    "xo": "^0.58.0"
-  }
-}

package/.output/server/node_modules/get-stream/source/array-buffer.js

@@ -1,84 +0,0 @@
-import {getStreamContents} from './contents.js';
-import {noop, throwObjectStream, getLengthProperty} from './utils.js';
-
-export async function getStreamAsArrayBuffer(stream, options) {
-	return getStreamContents(stream, arrayBufferMethods, options);
-}
-
-const initArrayBuffer = () => ({contents: new ArrayBuffer(0)});
-
-const useTextEncoder = chunk => textEncoder.encode(chunk);
-const textEncoder = new TextEncoder();
-
-const useUint8Array = chunk => new Uint8Array(chunk);
-
-const useUint8ArrayWithOffset = chunk => new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
-
-const truncateArrayBufferChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize);
-
-// `contents` is an increasingly growing `Uint8Array`.
-const addArrayBufferChunk = (convertedChunk, {contents, length: previousLength}, length) => {
-	const newContents = hasArrayBufferResize() ? resizeArrayBuffer(contents, length) : resizeArrayBufferSlow(contents, length);
-	new Uint8Array(newContents).set(convertedChunk, previousLength);
-	return newContents;
-};
-
-// Without `ArrayBuffer.resize()`, `contents` size is always a power of 2.
-// This means its last bytes are zeroes (not stream data), which need to be
-// trimmed at the end with `ArrayBuffer.slice()`.
-const resizeArrayBufferSlow = (contents, length) => {
-	if (length <= contents.byteLength) {
-		return contents;
-	}
-
-	const arrayBuffer = new ArrayBuffer(getNewContentsLength(length));
-	new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
-	return arrayBuffer;
-};
-
-// With `ArrayBuffer.resize()`, `contents` size matches exactly the size of
-// the stream data. It does not include extraneous zeroes to trim at the end.
-// The underlying `ArrayBuffer` does allocate a number of bytes that is a power
-// of 2, but those bytes are only visible after calling `ArrayBuffer.resize()`.
-const resizeArrayBuffer = (contents, length) => {
-	if (length <= contents.maxByteLength) {
-		contents.resize(length);
-		return contents;
-	}
-
-	const arrayBuffer = new ArrayBuffer(length, {maxByteLength: getNewContentsLength(length)});
-	new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
-	return arrayBuffer;
-};
-
-// Retrieve the closest `length` that is both >= and a power of 2
-const getNewContentsLength = length => SCALE_FACTOR ** Math.ceil(Math.log(length) / Math.log(SCALE_FACTOR));
-
-const SCALE_FACTOR = 2;
-
-const finalizeArrayBuffer = ({contents, length}) => hasArrayBufferResize() ? contents : contents.slice(0, length);
-
-// `ArrayBuffer.slice()` is slow. When `ArrayBuffer.resize()` is available
-// (Node >=20.0.0, Safari >=16.4 and Chrome), we can use it instead.
-// eslint-disable-next-line no-warning-comments
-// TODO: remove after dropping support for Node 20.
-// eslint-disable-next-line no-warning-comments
-// TODO: use `ArrayBuffer.transferToFixedLength()` instead once it is available
-const hasArrayBufferResize = () => 'resize' in ArrayBuffer.prototype;
-
-const arrayBufferMethods = {
-	init: initArrayBuffer,
-	convertChunk: {
-		string: useTextEncoder,
-		buffer: useUint8Array,
-		arrayBuffer: useUint8Array,
-		dataView: useUint8ArrayWithOffset,
-		typedArray: useUint8ArrayWithOffset,
-		others: throwObjectStream,
-	},
-	getSize: getLengthProperty,
-	truncateChunk: truncateArrayBufferChunk,
-	addChunk: addArrayBufferChunk,
-	getFinalChunk: noop,
-	finalize: finalizeArrayBuffer,
-};

package/.output/server/node_modules/get-stream/source/array.js

@@ -1,32 +0,0 @@
-import {getStreamContents} from './contents.js';
-import {identity, noop, getContentsProperty} from './utils.js';
-
-export async function getStreamAsArray(stream, options) {
-	return getStreamContents(stream, arrayMethods, options);
-}
-
-const initArray = () => ({contents: []});
-
-const increment = () => 1;
-
-const addArrayChunk = (convertedChunk, {contents}) => {
-	contents.push(convertedChunk);
-	return contents;
-};
-
-const arrayMethods = {
-	init: initArray,
-	convertChunk: {
-		string: identity,
-		buffer: identity,
-		arrayBuffer: identity,
-		dataView: identity,
-		typedArray: identity,
-		others: identity,
-	},
-	getSize: increment,
-	truncateChunk: noop,
-	addChunk: addArrayChunk,
-	getFinalChunk: noop,
-	finalize: getContentsProperty,
-};

package/.output/server/node_modules/get-stream/source/buffer.js

@@ -1,19 +0,0 @@
-import {getStreamAsArrayBuffer} from './array-buffer.js';
-
-export async function getStreamAsBuffer(stream, options) {
-	if (!('Buffer' in globalThis)) {
-		throw new Error('getStreamAsBuffer() is only supported in Node.js');
-	}
-
-	try {
-		return arrayBufferToNodeBuffer(await getStreamAsArrayBuffer(stream, options));
-	} catch (error) {
-		if (error.bufferedData !== undefined) {
-			error.bufferedData = arrayBufferToNodeBuffer(error.bufferedData);
-		}
-
-		throw error;
-	}
-}
-
-const arrayBufferToNodeBuffer = arrayBuffer => globalThis.Buffer.from(arrayBuffer);