using System;
using System.Buffers;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Management;
using System.Net.Http;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using CliWrap.Builders;
using CliWrap.Exceptions;
using CliWrap.Utils;
using CliWrap.Utils.Extensions;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Tyrrrz")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (C) Oleksii Holub")]
[assembly: AssemblyDescription("Library for interacting with external command-line interfaces")]
[assembly: AssemblyFileVersion("3.6.4.0")]
[assembly: AssemblyInformationalVersion("3.6.4+77a9f6d5692718555f040ad4603916ce0bdb0715")]
[assembly: AssemblyProduct("CliWrap")]
[assembly: AssemblyTitle("CliWrap")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Tyrrrz/CliWrap")]
[assembly: AssemblyVersion("3.6.4.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
internal static class PolyfillExtensions
{
	public static async Task<Stream> GetStreamAsync(this HttpClient httpClient, string requestUri, CancellationToken cancellationToken = default(CancellationToken))
	{
		_ = 1;
		try
		{
			HttpResponseMessage obj = await httpClient.GetAsync(requestUri, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			obj.EnsureSuccessStatusCode();
			return await ReadAsStreamAsync(obj.Content, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		}
		catch (OperationCanceledException ex) when (ex.CancellationToken != cancellationToken && cancellationToken.IsCancellationRequested)
		{
			throw new OperationCanceledException(ex.Message, ex.InnerException, cancellationToken);
		}
	}

	public static async Task<Stream> GetStreamAsync(this HttpClient httpClient, Uri requestUri, CancellationToken cancellationToken = default(CancellationToken))
	{
		return await GetStreamAsync(httpClient, requestUri.ToString(), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task<byte[]> GetByteArrayAsync(this HttpClient httpClient, string requestUri, CancellationToken cancellationToken = default(CancellationToken))
	{
		_ = 1;
		try
		{
			using HttpResponseMessage response = await httpClient.GetAsync(requestUri, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			response.EnsureSuccessStatusCode();
			return await ReadAsByteArrayAsync(response.Content, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		}
		catch (OperationCanceledException ex) when (ex.CancellationToken != cancellationToken && cancellationToken.IsCancellationRequested)
		{
			throw new OperationCanceledException(ex.Message, ex.InnerException, cancellationToken);
		}
	}

	public static async Task<byte[]> GetByteArrayAsync(this HttpClient httpClient, Uri requestUri, CancellationToken cancellationToken = default(CancellationToken))
	{
		return await GetByteArrayAsync(httpClient, requestUri.ToString(), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task<string> GetStringAsync(this HttpClient httpClient, string requestUri, CancellationToken cancellationToken = default(CancellationToken))
	{
		_ = 1;
		try
		{
			using HttpResponseMessage response = await httpClient.GetAsync(requestUri, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			response.EnsureSuccessStatusCode();
			return await ReadAsStringAsync(response.Content, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		}
		catch (OperationCanceledException ex) when (ex.CancellationToken != cancellationToken && cancellationToken.IsCancellationRequested)
		{
			throw new OperationCanceledException(ex.Message, ex.InnerException, cancellationToken);
		}
	}

	public static async Task<string> GetStringAsync(this HttpClient httpClient, Uri requestUri, CancellationToken cancellationToken = default(CancellationToken))
	{
		return await GetStringAsync(httpClient, requestUri.ToString(), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task<Stream> ReadAsStreamAsync(this HttpContent httpContent, CancellationToken cancellationToken = default(CancellationToken))
	{
		cancellationToken.ThrowIfCancellationRequested();
		return await httpContent.ReadAsStreamAsync().ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task<byte[]> ReadAsByteArrayAsync(this HttpContent httpContent, CancellationToken cancellationToken = default(CancellationToken))
	{
		cancellationToken.ThrowIfCancellationRequested();
		return await httpContent.ReadAsByteArrayAsync().ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task<string> ReadAsStringAsync(this HttpContent httpContent, CancellationToken cancellationToken = default(CancellationToken))
	{
		cancellationToken.ThrowIfCancellationRequested();
		return await httpContent.ReadAsStringAsync().ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task WaitForExitAsync(this Process process, CancellationToken cancellationToken = default(CancellationToken))
	{
		TaskCompletionSource<object?> tcs = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
		try
		{
			process.EnableRaisingEvents = true;
		}
		catch when (process.HasExited)
		{
			return;
		}
		process.Exited += HandleExited;
		try
		{
			using (cancellationToken.Register(delegate
			{
				tcs.TrySetCanceled(cancellationToken);
			}))
			{
				await tcs.Task;
			}
		}
		finally
		{
			process.Exited -= HandleExited;
		}
		void HandleExited(object? sender, EventArgs args)
		{
			tcs.TrySetResult(null);
		}
	}

	public static async Task WaitAsync(this Task task, TimeSpan timeout, CancellationToken cancellationToken)
	{
		Task cancellationTask = Task.Delay(timeout, cancellationToken);
		Task finishedTask = await Task.WhenAny(new Task[2] { task, cancellationTask }).ConfigureAwait(continueOnCapturedContext: false);
		await finishedTask.ConfigureAwait(continueOnCapturedContext: false);
		if (finishedTask == cancellationTask)
		{
			throw new TimeoutException("The operation has timed out.");
		}
	}

	public static async Task WaitAsync(this Task task, CancellationToken cancellationToken)
	{
		await WaitAsync(task, Timeout.InfiniteTimeSpan, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task WaitAsync(this Task task, TimeSpan timeout)
	{
		await WaitAsync(task, timeout, CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task<T> WaitAsync<T>(this Task<T> task, TimeSpan timeout, CancellationToken cancellationToken)
	{
		Task cancellationTask = Task.Delay(timeout, cancellationToken);
		Task finishedTask = await Task.WhenAny(new Task[2] { task, cancellationTask }).ConfigureAwait(continueOnCapturedContext: false);
		await finishedTask.ConfigureAwait(continueOnCapturedContext: false);
		if (finishedTask == cancellationTask)
		{
			throw new TimeoutException("The operation has timed out.");
		}
		return task.Result;
	}

	public static async Task<T> WaitAsync<T>(this Task<T> task, CancellationToken cancellationToken)
	{
		return await WaitAsync(task, Timeout.InfiniteTimeSpan, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static async Task<T> WaitAsync<T>(this Task<T> task, TimeSpan timeout)
	{
		return await WaitAsync(task, timeout, CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static int ReadAtLeast(this Stream stream, byte[] buffer, int minimumBytes, bool throwOnEndOfStream = true)
	{
		int i;
		int num;
		for (i = 0; i < buffer.Length; i += num)
		{
			num = stream.Read(buffer, i, Math.Min(minimumBytes, buffer.Length - i));
			if (num <= 0)
			{
				break;
			}
		}
		if (i < minimumBytes && throwOnEndOfStream)
		{
			throw new EndOfStreamException();
		}
		return i;
	}

	public static void ReadExactly(this Stream stream, byte[] buffer, int offset, int count)
	{
		int num;
		for (int i = 0; i < count; i += num)
		{
			num = stream.Read(buffer, offset + i, count - i);
			if (num <= 0)
			{
				throw new EndOfStreamException();
			}
		}
	}

	public static void ReadExactly(this Stream stream, byte[] buffer)
	{
		stream.ReadExactly(buffer, 0, buffer.Length);
	}

	public static async Task<int> ReadAtLeastAsync(this Stream stream, byte[] buffer, int minimumBytes, bool throwOnEndOfStream = true, CancellationToken cancellationToken = default(CancellationToken))
	{
		int totalBytesRead;
		int num;
		for (totalBytesRead = 0; totalBytesRead < buffer.Length; totalBytesRead += num)
		{
			num = await stream.ReadAsync(buffer, totalBytesRead, Math.Min(minimumBytes, buffer.Length - totalBytesRead), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			if (num <= 0)
			{
				break;
			}
		}
		if (totalBytesRead < minimumBytes && throwOnEndOfStream)
		{
			throw new EndOfStreamException();
		}
		return totalBytesRead;
	}

	public static async Task ReadExactlyAsync(this Stream stream, byte[] buffer, int offset, int count, CancellationToken cancellationToken = default(CancellationToken))
	{
		int num;
		for (int totalBytesRead = 0; totalBytesRead < count; totalBytesRead += num)
		{
			num = await stream.ReadAsync(buffer, offset + totalBytesRead, count - totalBytesRead, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			if (num <= 0)
			{
				throw new EndOfStreamException();
			}
		}
	}

	public static async Task ReadExactlyAsync(this Stream stream, byte[] buffer, CancellationToken cancellationToken = default(CancellationToken))
	{
		await stream.ReadExactlyAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
	}

	public static int ReadAtLeast(this Stream stream, Span<byte> buffer, int minimumBytes, bool throwOnEndOfStream = true)
	{
		int i;
		int num;
		for (i = 0; i < buffer.Length; i += num)
		{
			num = stream.Read(buffer.Slice(i));
			if (num <= 0)
			{
				break;
			}
		}
		if (i < minimumBytes && throwOnEndOfStream)
		{
			throw new EndOfStreamException();
		}
		return i;
	}

	public static void ReadExactly(this Stream stream, Span<byte> buffer)
	{
		byte[] array = buffer.ToArray();
		stream.ReadExactly(array, 0, array.Length);
		array.CopyTo(buffer);
	}

	public static async Task<int> ReadAtLeastAsync(this Stream stream, Memory<byte> buffer, int minimumBytes, bool throwOnEndOfStream = true, CancellationToken cancellationToken = default(CancellationToken))
	{
		int totalBytesRead;
		int num;
		for (totalBytesRead = 0; totalBytesRead < buffer.Length; totalBytesRead += num)
		{
			num = await stream.ReadAsync(buffer.Slice(totalBytesRead), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			if (num <= 0)
			{
				break;
			}
		}
		if (totalBytesRead < minimumBytes && throwOnEndOfStream)
		{
			throw new EndOfStreamException();
		}
		return totalBytesRead;
	}

	public static async Task ReadExactlyAsync(this Stream stream, Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
	{
		byte[] bufferArray = buffer.ToArray();
		await stream.ReadExactlyAsync(bufferArray, 0, bufferArray.Length, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		bufferArray.CopyTo(buffer);
	}

	private static void KillProcessTree(int processId)
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Expected O, but got Unknown
		ManagementObjectSearcher val = new ManagementObjectSearcher($"SELECT * FROM Win32_Process WHERE ParentProcessID={processId}");
		try
		{
			ManagementObjectCollection val2 = val.Get();
			try
			{
				try
				{
					using Process process = Process.GetProcessById(processId);
					if (!process.HasExited)
					{
						process.Kill();
					}
				}
				catch
				{
				}
				foreach (ManagementObject item in ((IEnumerable)val2).Cast<ManagementObject>())
				{
					KillProcessTree(Convert.ToInt32(((ManagementBaseObject)item)["ProcessID"]));
				}
			}
			finally
			{
				((IDisposable)val2)?.Dispose();
			}
		}
		finally
		{
			((IDisposable)val)?.Dispose();
		}
	}

	public static void Kill(this Process process, bool entireProcessTree)
	{
		if (!entireProcessTree)
		{
			process.Kill();
		}
		else if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
		{
			process.Kill();
		}
		else
		{
			KillProcessTree(process.Id);
		}
	}
}
namespace CliWrap
{
	public static class Cli
	{
		public static Command Wrap(string targetFilePath)
		{
			return new Command(targetFilePath);
		}
	}
	public class Command : ICommandConfiguration
	{
		public string TargetFilePath { get; }

		public string Arguments { get; }

		public string WorkingDirPath { get; }

		public Credentials Credentials { get; }

		public IReadOnlyDictionary<string, string?> EnvironmentVariables { get; }

		public CommandResultValidation Validation { get; }

		public PipeSource StandardInputPipe { get; }

		public PipeTarget StandardOutputPipe { get; }

		public PipeTarget StandardErrorPipe { get; }

		public Command(string targetFilePath, string arguments, string workingDirPath, Credentials credentials, IReadOnlyDictionary<string, string?> environmentVariables, CommandResultValidation validation, PipeSource standardInputPipe, PipeTarget standardOutputPipe, PipeTarget standardErrorPipe)
		{
			TargetFilePath = targetFilePath;
			Arguments = arguments;
			WorkingDirPath = workingDirPath;
			Credentials = credentials;
			EnvironmentVariables = environmentVariables;
			Validation = validation;
			StandardInputPipe = standardInputPipe;
			StandardOutputPipe = standardOutputPipe;
			StandardErrorPipe = standardErrorPipe;
		}

		public Command(string targetFilePath)
			: this(targetFilePath, string.Empty, Directory.GetCurrentDirectory(), CliWrap.Credentials.Default, new Dictionary<string, string>(), CommandResultValidation.ZeroExitCode, PipeSource.Null, PipeTarget.Null, PipeTarget.Null)
		{
		}

		public Command WithTargetFile(string targetFilePath)
		{
			return new Command(targetFilePath, Arguments, WorkingDirPath, Credentials, EnvironmentVariables, Validation, StandardInputPipe, StandardOutputPipe, StandardErrorPipe);
		}

		public Command WithArguments(string arguments)
		{
			return new Command(TargetFilePath, arguments, WorkingDirPath, Credentials, EnvironmentVariables, Validation, StandardInputPipe, StandardOutputPipe, StandardErrorPipe);
		}

		public Command WithArguments(IEnumerable<string> arguments, bool escape)
		{
			IEnumerable<string> arguments2 = arguments;
			return WithArguments(delegate(ArgumentsBuilder args)
			{
				args.Add(arguments2, escape);
			});
		}

		public Command WithArguments(IEnumerable<string> arguments)
		{
			return WithArguments(arguments, escape: true);
		}

		public Command WithArguments(Action<ArgumentsBuilder> configure)
		{
			ArgumentsBuilder argumentsBuilder = new ArgumentsBuilder();
			configure(argumentsBuilder);
			return WithArguments(argumentsBuilder.Build());
		}

		public Command WithWorkingDirectory(string workingDirPath)
		{
			return new Command(TargetFilePath, Arguments, workingDirPath, Credentials, EnvironmentVariables, Validation, StandardInputPipe, StandardOutputPipe, StandardErrorPipe);
		}

		public Command WithCredentials(Credentials credentials)
		{
			return new Command(TargetFilePath, Arguments, WorkingDirPath, credentials, EnvironmentVariables, Validation, StandardInputPipe, StandardOutputPipe, StandardErrorPipe);
		}

		public Command WithCredentials(Action<CredentialsBuilder> configure)
		{
			CredentialsBuilder credentialsBuilder = new CredentialsBuilder();
			configure(credentialsBuilder);
			return WithCredentials(credentialsBuilder.Build());
		}

		public Command WithEnvironmentVariables(IReadOnlyDictionary<string, string?> environmentVariables)
		{
			return new Command(TargetFilePath, Arguments, WorkingDirPath, Credentials, environmentVariables, Validation, StandardInputPipe, StandardOutputPipe, StandardErrorPipe);
		}

		public Command WithEnvironmentVariables(Action<EnvironmentVariablesBuilder> configure)
		{
			EnvironmentVariablesBuilder environmentVariablesBuilder = new EnvironmentVariablesBuilder();
			configure(environmentVariablesBuilder);
			return WithEnvironmentVariables(environmentVariablesBuilder.Build());
		}

		public Command WithValidation(CommandResultValidation validation)
		{
			return new Command(TargetFilePath, Arguments, WorkingDirPath, Credentials, EnvironmentVariables, validation, StandardInputPipe, StandardOutputPipe, StandardErrorPipe);
		}

		public Command WithStandardInputPipe(PipeSource source)
		{
			return new Command(TargetFilePath, Arguments, WorkingDirPath, Credentials, EnvironmentVariables, Validation, source, StandardOutputPipe, StandardErrorPipe);
		}

		public Command WithStandardOutputPipe(PipeTarget target)
		{
			return new Command(TargetFilePath, Arguments, WorkingDirPath, Credentials, EnvironmentVariables, Validation, StandardInputPipe, target, StandardErrorPipe);
		}

		public Command WithStandardErrorPipe(PipeTarget target)
		{
			return new Command(TargetFilePath, Arguments, WorkingDirPath, Credentials, EnvironmentVariables, Validation, StandardInputPipe, StandardOutputPipe, target);
		}

		[ExcludeFromCodeCoverage]
		public override string ToString()
		{
			return TargetFilePath + " " + Arguments;
		}

		private string GetOptimallyQualifiedTargetFilePath()
		{
			if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
			{
				return TargetFilePath;
			}
			if (Path.IsPathRooted(TargetFilePath) || !string.IsNullOrWhiteSpace(Path.GetExtension(TargetFilePath)))
			{
				return TargetFilePath;
			}
			return (from probeDirPath in GetProbeDirectoryPaths()
				where Directory.Exists(probeDirPath)
				select Path.Combine(probeDirPath, TargetFilePath) into baseFilePath
				from extension in new string[3] { "exe", "cmd", "bat" }
				select Path.ChangeExtension(baseFilePath, extension)).FirstOrDefault(File.Exists) ?? TargetFilePath;
			static IEnumerable<string> GetProbeDirectoryPaths()
			{
				if (!string.IsNullOrWhiteSpace(EnvironmentEx.ProcessPath))
				{
					string directoryName = Path.GetDirectoryName(EnvironmentEx.ProcessPath);
					if (!string.IsNullOrWhiteSpace(directoryName))
					{
						yield return directoryName;
					}
				}
				yield return Directory.GetCurrentDirectory();
				string[] array = Environment.GetEnvironmentVariable("PATH")?.Split(Path.PathSeparator);
				if (array != null)
				{
					string[] array2 = array;
					for (int i = 0; i < array2.Length; i++)
					{
						yield return array2[i];
					}
				}
			}
		}

		private ProcessStartInfo CreateStartInfo()
		{
			ProcessStartInfo processStartInfo = new ProcessStartInfo
			{
				FileName = GetOptimallyQualifiedTargetFilePath(),
				Arguments = Arguments,
				WorkingDirectory = WorkingDirPath,
				RedirectStandardInput = true,
				RedirectStandardOutput = true,
				RedirectStandardError = true,
				UseShellExecute = false,
				CreateNoWindow = true
			};
			try
			{
				if (Credentials.Domain != null)
				{
					processStartInfo.Domain = Credentials.Domain;
				}
				if (Credentials.UserName != null)
				{
					processStartInfo.UserName = Credentials.UserName;
				}
				if (Credentials.Password != null)
				{
					processStartInfo.Password = Credentials.Password.ToSecureString();
				}
				if (Credentials.LoadUserProfile)
				{
					processStartInfo.LoadUserProfile = Credentials.LoadUserProfile;
				}
			}
			catch (NotSupportedException innerException)
			{
				throw new NotSupportedException("Cannot start a process using the provided credentials. Setting custom domain, password, or loading user profile is only supported on Windows.", innerException);
			}
			foreach (var (key, text3) in EnvironmentVariables)
			{
				if (text3 != null)
				{
					processStartInfo.Environment[key] = text3;
				}
				else
				{
					processStartInfo.Environment.Remove(key);
				}
			}
			return processStartInfo;
		}

		private async Task PipeStandardInputAsync(ProcessEx process, CancellationToken cancellationToken = default(CancellationToken))
		{
			await using (process.StandardInput.ToAsyncDisposable())
			{
				try
				{
					await PolyfillExtensions.WaitAsync(StandardInputPipe.CopyToAsync(process.StandardInput, cancellationToken), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}
				catch (IOException ex) when (ex.GetType() == typeof(IOException))
				{
				}
			}
		}

		private async Task PipeStandardOutputAsync(ProcessEx process, CancellationToken cancellationToken = default(CancellationToken))
		{
			await using (process.StandardOutput.ToAsyncDisposable())
			{
				await StandardOutputPipe.CopyFromAsync(process.StandardOutput, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
		}

		private async Task PipeStandardErrorAsync(ProcessEx process, CancellationToken cancellationToken = default(CancellationToken))
		{
			await using (process.StandardError.ToAsyncDisposable())
			{
				await StandardErrorPipe.CopyFromAsync(process.StandardError, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			}
		}

		private async Task<CommandResult> ExecuteAsync(ProcessEx process, CancellationToken forcefulCancellationToken = default(CancellationToken), CancellationToken gracefulCancellationToken = default(CancellationToken))
		{
			using (process)
			{
				CancellationTokenSource waitTimeoutCts = new CancellationTokenSource();
				try
				{
					CommandResult result;
					await using (forcefulCancellationToken.Register(delegate
					{
						waitTimeoutCts.CancelAfter(TimeSpan.FromSeconds(3.0));
					}).ToAsyncDisposable())
					{
						using CancellationTokenSource stdInCts = CancellationTokenSource.CreateLinkedTokenSource(new CancellationToken[1] { forcefulCancellationToken });
						CommandResult commandResult2;
						await using (forcefulCancellationToken.Register(process.Kill).ToAsyncDisposable())
						{
							CommandResult commandResult;
							await using (gracefulCancellationToken.Register(process.Interrupt).ToAsyncDisposable())
							{
								Task pipingTask = Task.WhenAll(PipeStandardInputAsync(process, stdInCts.Token), PipeStandardOutputAsync(process, forcefulCancellationToken), PipeStandardErrorAsync(process, forcefulCancellationToken));
								try
								{
									await process.WaitUntilExitAsync(waitTimeoutCts.Token).ConfigureAwait(continueOnCapturedContext: false);
									stdInCts.Cancel();
									await pipingTask.ConfigureAwait(continueOnCapturedContext: false);
								}
								catch (OperationCanceledException ex) when (ex.CancellationToken == forcefulCancellationToken || ex.CancellationToken == gracefulCancellationToken || ex.CancellationToken == waitTimeoutCts.Token || ex.CancellationToken == stdInCts.Token)
								{
								}
								forcefulCancellationToken.ThrowIfCancellationRequested("Command execution canceled. " + $"Underlying process ({process.Name}#{process.Id}) was forcefully terminated.");
								gracefulCancellationToken.ThrowIfCancellationRequested("Command execution canceled. " + $"Underlying process ({process.Name}#{process.Id}) was gracefully terminated.");
								if (process.ExitCode != 0 && Validation.IsZeroExitCodeValidationEnabled())
								{
									throw new CommandExecutionException(this, process.ExitCode, $"Command execution failed because the underlying process ({process.Name}#{process.Id}) returned a non-zero exit code ({process.ExitCode}).\r\n\r\nCommand:\r\n{TargetFilePath} {Arguments}\r\n\r\nYou can suppress this validation by calling `WithValidation(CommandResultValidation.None)` on the command.");
								}
								commandResult = new CommandResult(process.ExitCode, process.StartTime, process.ExitTime);
							}
							commandResult2 = commandResult;
						}
						result = commandResult2;
					}
					return result;
				}
				finally
				{
					if (waitTimeoutCts != null)
					{
						((IDisposable)waitTimeoutCts).Dispose();
					}
				}
			}
		}

		public CommandTask<CommandResult> ExecuteAsync(CancellationToken forcefulCancellationToken, CancellationToken gracefulCancellationToken)
		{
			ProcessEx processEx = new ProcessEx(CreateStartInfo());
			processEx.Start();
			int id = processEx.Id;
			return new CommandTask<CommandResult>(ExecuteAsync(processEx, forcefulCancellationToken, gracefulCancellationToken), id);
		}

		public CommandTask<CommandResult> ExecuteAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return ExecuteAsync(cancellationToken, CancellationToken.None);
		}

		public static Command operator |(Command source, PipeTarget target)
		{
			return source.WithStandardOutputPipe(target);
		}

		public static Command operator |(Command source, Stream target)
		{
			return source | PipeTarget.ToStream(target);
		}

		public static Command operator |(Command source, StringBuilder target)
		{
			return source | PipeTarget.ToStringBuilder(target);
		}

		public static Command operator |(Command source, Func<string, CancellationToken, Task> target)
		{
			return source | PipeTarget.ToDelegate(target);
		}

		public static Command operator |(Command source, Func<string, Task> target)
		{
			return source | PipeTarget.ToDelegate(target);
		}

		public static Command operator |(Command source, Action<string> target)
		{
			return source | PipeTarget.ToDelegate(target);
		}

		public static Command operator |(Command source, (PipeTarget stdOut, PipeTarget stdErr) targets)
		{
			return source.WithStandardOutputPipe(targets.stdOut).WithStandardErrorPipe(targets.stdErr);
		}

		public static Command operator |(Command source, (Stream stdOut, Stream stdErr) targets)
		{
			return source | (PipeTarget.ToStream(targets.stdOut), PipeTarget.ToStream(targets.stdErr));
		}

		public static Command operator |(Command source, (StringBuilder stdOut, StringBuilder stdErr) targets)
		{
			return source | (PipeTarget.ToStringBuilder(targets.stdOut), PipeTarget.ToStringBuilder(targets.stdErr));
		}

		public static Command operator |(Command source, (Func<string, CancellationToken, Task> stdOut, Func<string, CancellationToken, Task> stdErr) targets)
		{
			return source | (PipeTarget.ToDelegate(targets.stdOut), PipeTarget.ToDelegate(targets.stdErr));
		}

		public static Command operator |(Command source, (Func<string, Task> stdOut, Func<string, Task> stdErr) targets)
		{
			return source | (PipeTarget.ToDelegate(targets.stdOut), PipeTarget.ToDelegate(targets.stdErr));
		}

		public static Command operator |(Command source, (Action<string> stdOut, Action<string> stdErr) targets)
		{
			return source | (PipeTarget.ToDelegate(targets.stdOut), PipeTarget.ToDelegate(targets.stdErr));
		}

		public static Command operator |(PipeSource source, Command target)
		{
			return target.WithStandardInputPipe(source);
		}

		public static Command operator |(Stream source, Command target)
		{
			return PipeSource.FromStream(source) | target;
		}

		public static Command operator |(ReadOnlyMemory<byte> source, Command target)
		{
			return PipeSource.FromBytes(source) | target;
		}

		public static Command operator |(byte[] source, Command target)
		{
			return PipeSource.FromBytes(source) | target;
		}

		public static Command operator |(string source, Command target)
		{
			return PipeSource.FromString(source) | target;
		}

		public static Command operator |(Command source, Command target)
		{
			return PipeSource.FromCommand(source) | target;
		}
	}
	public class CommandResult
	{
		public int ExitCode { get; }

		public DateTimeOffset StartTime { get; }

		public DateTimeOffset ExitTime { get; }

		public TimeSpan RunTime => ExitTime - StartTime;

		public CommandResult(int exitCode, DateTimeOffset startTime, DateTimeOffset exitTime)
		{
			ExitCode = exitCode;
			StartTime = startTime;
			ExitTime = exitTime;
		}
	}
	[Flags]
	public enum CommandResultValidation
	{
		None = 0,
		ZeroExitCode = 1
	}
	internal static class CommandResultValidationExtensions
	{
		public static bool IsZeroExitCodeValidationEnabled(this CommandResultValidation validation)
		{
			return (validation & CommandResultValidation.ZeroExitCode) != 0;
		}
	}
	public class CommandTask<TResult> : IDisposable
	{
		public Task<TResult> Task { get; }

		public int ProcessId { get; }

		public CommandTask(Task<TResult> task, int processId)
		{
			Task = task;
			ProcessId = processId;
		}

		internal CommandTask<T> Bind<T>(Func<Task<TResult>, Task<T>> transform)
		{
			return new CommandTask<T>(transform(Task), ProcessId);
		}

		public CommandTask<T> Select<T>(Func<TResult, T> transform)
		{
			Func<TResult, T> transform2 = transform;
			return Bind((Task<TResult> task) => task.Select(transform2));
		}

		public TaskAwaiter<TResult> GetAwaiter()
		{
			return Task.GetAwaiter();
		}

		public ConfiguredTaskAwaitable<TResult> ConfigureAwait(bool continueOnCapturedContext)
		{
			return Task.ConfigureAwait(continueOnCapturedContext);
		}

		public void Dispose()
		{
			Task.Dispose();
		}

		public static implicit operator Task<TResult>(CommandTask<TResult> commandTask)
		{
			return commandTask.Task;
		}
	}
	public class Credentials
	{
		public string? Domain { get; }

		public string? UserName { get; }

		public string? Password { get; }

		public bool LoadUserProfile { get; }

		public static Credentials Default { get; } = new Credentials();


		public Credentials(string? domain = null, string? userName = null, string? password = null, bool loadUserProfile = false)
		{
			Domain = domain;
			UserName = userName;
			Password = password;
			LoadUserProfile = loadUserProfile;
		}

		[ExcludeFromCodeCoverage]
		public Credentials(string? domain, string? username, string? password)
			: this(domain, username, password, loadUserProfile: false)
		{
		}
	}
	public interface ICommandConfiguration
	{
		string TargetFilePath { get; }

		string Arguments { get; }

		string WorkingDirPath { get; }

		Credentials Credentials { get; }

		IReadOnlyDictionary<string, string?> EnvironmentVariables { get; }

		CommandResultValidation Validation { get; }

		PipeSource StandardInputPipe { get; }

		PipeTarget StandardOutputPipe { get; }

		PipeTarget StandardErrorPipe { get; }
	}
	public abstract class PipeSource
	{
		public static PipeSource Null { get; } = Create((Stream _, CancellationToken cancellationToken) => cancellationToken.IsCancellationRequested ? Task.FromCanceled(cancellationToken) : Task.CompletedTask);


		public abstract Task CopyToAsync(Stream destination, CancellationToken cancellationToken = default(CancellationToken));

		public static PipeSource Create(Func<Stream, CancellationToken, Task> handlePipeAsync)
		{
			return new <PipeSource>F612AD58C26E22862AC9C5A7F308FD80EC164600953573616E18105DA95EAF684__AnonymousPipeSource(handlePipeAsync);
		}

		public static PipeSource Create(Action<Stream> handlePipe)
		{
			Action<Stream> handlePipe2 = handlePipe;
			return Create(delegate(Stream destination, CancellationToken _)
			{
				handlePipe2(destination);
				return Task.CompletedTask;
			});
		}

		public static PipeSource FromStream(Stream stream, bool autoFlush)
		{
			Stream stream2 = stream;
			return Create(async delegate(Stream destination, CancellationToken cancellationToken)
			{
				await stream2.CopyToAsync(destination, autoFlush, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			});
		}

		public static PipeSource FromStream(Stream stream)
		{
			return FromStream(stream, autoFlush: true);
		}

		public static PipeSource FromFile(string filePath)
		{
			string filePath2 = filePath;
			return Create(async delegate(Stream destination, CancellationToken cancellationToken)
			{
				FileStream fileStream = File.OpenRead(filePath2);
				await using (fileStream.ToAsyncDisposable())
				{
					await fileStream.CopyToAsync(destination, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}
			});
		}

		public static PipeSource FromBytes(ReadOnlyMemory<byte> data)
		{
			return Create(async delegate(Stream destination, CancellationToken cancellationToken)
			{
				await destination.WriteAsync(data, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			});
		}

		public static PipeSource FromBytes(byte[] data)
		{
			return FromBytes((ReadOnlyMemory<byte>)data);
		}

		[Obsolete("Use FromBytes(ReadOnlyMemory<byte>) instead")]
		[ExcludeFromCodeCoverage]
		public static PipeSource FromMemory(ReadOnlyMemory<byte> data)
		{
			return FromBytes(data);
		}

		public static PipeSource FromString(string str, Encoding encoding)
		{
			return FromBytes(encoding.GetBytes(str));
		}

		public static PipeSource FromString(string str)
		{
			return FromString(str, Console.InputEncoding);
		}

		public static PipeSource FromCommand(Command command)
		{
			Command command2 = command;
			return Create(async delegate(Stream destination, CancellationToken cancellationToken)
			{
				await command2.WithStandardOutputPipe(PipeTarget.ToStream(destination)).ExecuteAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			});
		}
	}
	internal class <PipeSource>F612AD58C26E22862AC9C5A7F308FD80EC164600953573616E18105DA95EAF684__AnonymousPipeSource : PipeSource
	{
		private readonly Func<Stream, CancellationToken, Task> _copyToAsync;

		public <PipeSource>F612AD58C26E22862AC9C5A7F308FD80EC164600953573616E18105DA95EAF684__AnonymousPipeSource(Func<Stream, CancellationToken, Task> copyToAsync)
		{
			_copyToAsync = copyToAsync;
		}

		public override async Task CopyToAsync(Stream destination, CancellationToken cancellationToken = default(CancellationToken))
		{
			await _copyToAsync(destination, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		}
	}
	public abstract class PipeTarget
	{
		public static PipeTarget Null { get; } = Create((Stream _, CancellationToken cancellationToken) => cancellationToken.IsCancellationRequested ? Task.FromCanceled(cancellationToken) : Task.CompletedTask);


		public abstract Task CopyFromAsync(Stream origin, CancellationToken cancellationToken = default(CancellationToken));

		public static PipeTarget Create(Func<Stream, CancellationToken, Task> handlePipeAsync)
		{
			return new <PipeTarget>F825283E4191C5E3065EA9B63A9E400DE4BF8A70F67D820C9074D40C0E517F81E__AnonymousPipeTarget(handlePipeAsync);
		}

		public static PipeTarget Create(Action<Stream> handlePipe)
		{
			Action<Stream> handlePipe2 = handlePipe;
			return Create(delegate(Stream origin, CancellationToken _)
			{
				handlePipe2(origin);
				return Task.CompletedTask;
			});
		}

		public static PipeTarget ToStream(Stream stream, bool autoFlush)
		{
			Stream stream2 = stream;
			return Create(async delegate(Stream origin, CancellationToken cancellationToken)
			{
				await origin.CopyToAsync(stream2, autoFlush, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			});
		}

		public static PipeTarget ToStream(Stream stream)
		{
			return ToStream(stream, autoFlush: true);
		}

		public static PipeTarget ToFile(string filePath)
		{
			string filePath2 = filePath;
			return Create(async delegate(Stream origin, CancellationToken cancellationToken)
			{
				FileStream fileStream = File.Create(filePath2);
				await using (fileStream.ToAsyncDisposable())
				{
					await origin.CopyToAsync(fileStream, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}
			});
		}

		public static PipeTarget ToStringBuilder(StringBuilder stringBuilder, Encoding encoding)
		{
			Encoding encoding2 = encoding;
			StringBuilder stringBuilder2 = stringBuilder;
			return Create(async delegate(Stream origin, CancellationToken cancellationToken)
			{
				using StreamReader reader = new StreamReader(origin, encoding2, detectEncodingFromByteOrderMarks: false, 1024, leaveOpen: true);
				using IMemoryOwner<char> buffer = MemoryPool<char>.Shared.Rent(1024);
				while (true)
				{
					int num = await reader.ReadAsync(buffer.Memory, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					if (num <= 0)
					{
						break;
					}
					stringBuilder2.Append((object?)buffer.Memory.Slice(0, num));
				}
			});
		}

		public static PipeTarget ToStringBuilder(StringBuilder stringBuilder)
		{
			return ToStringBuilder(stringBuilder, Console.OutputEncoding);
		}

		public static PipeTarget ToDelegate(Func<string, CancellationToken, Task> handleLineAsync, Encoding encoding)
		{
			Encoding encoding2 = encoding;
			Func<string, CancellationToken, Task> handleLineAsync2 = handleLineAsync;
			return Create(async delegate(Stream origin, CancellationToken cancellationToken)
			{
				using StreamReader reader = new StreamReader(origin, encoding2, detectEncodingFromByteOrderMarks: false, 1024, leaveOpen: true);
				await foreach (string item in reader.ReadAllLinesAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false))
				{
					await handleLineAsync2(item, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}
			});
		}

		public static PipeTarget ToDelegate(Func<string, CancellationToken, Task> handleLineAsync)
		{
			return ToDelegate(handleLineAsync, Console.OutputEncoding);
		}

		public static PipeTarget ToDelegate(Func<string, Task> handleLineAsync, Encoding encoding)
		{
			Func<string, Task> handleLineAsync2 = handleLineAsync;
			return ToDelegate(async delegate(string line, CancellationToken _)
			{
				await handleLineAsync2(line).ConfigureAwait(continueOnCapturedContext: false);
			}, encoding);
		}

		public static PipeTarget ToDelegate(Func<string, Task> handleLineAsync)
		{
			return ToDelegate(handleLineAsync, Console.OutputEncoding);
		}

		public static PipeTarget ToDelegate(Action<string> handleLine, Encoding encoding)
		{
			Action<string> handleLine2 = handleLine;
			return ToDelegate(delegate(string line)
			{
				handleLine2(line);
				return Task.CompletedTask;
			}, encoding);
		}

		public static PipeTarget ToDelegate(Action<string> handleLine)
		{
			return ToDelegate(handleLine, Console.OutputEncoding);
		}

		public static PipeTarget Merge(IEnumerable<PipeTarget> targets)
		{
			IReadOnlyList<PipeTarget> readOnlyList = OptimizeTargets(targets);
			if (readOnlyList.Count == 1)
			{
				return readOnlyList.Single();
			}
			if (readOnlyList.Count == 0)
			{
				return Null;
			}
			return new <PipeTarget>F825283E4191C5E3065EA9B63A9E400DE4BF8A70F67D820C9074D40C0E517F81E__AggregatePipeTarget(readOnlyList);
			static void FlattenTargets(IEnumerable<PipeTarget> targets, ICollection<PipeTarget> output)
			{
				foreach (PipeTarget target in targets)
				{
					if (target is <PipeTarget>F825283E4191C5E3065EA9B63A9E400DE4BF8A70F67D820C9074D40C0E517F81E__AggregatePipeTarget <PipeTarget>F825283E4191C5E3065EA9B63A9E400DE4BF8A70F67D820C9074D40C0E517F81E__AggregatePipeTarget2)
					{
						FlattenTargets(<PipeTarget>F825283E4191C5E3065EA9B63A9E400DE4BF8A70F67D820C9074D40C0E517F81E__AggregatePipeTarget2.Targets, output);
					}
					else
					{
						output.Add(target);
					}
				}
			}
			static IReadOnlyList<PipeTarget> OptimizeTargets(IEnumerable<PipeTarget> targets)
			{
				List<PipeTarget> list = new List<PipeTarget>();
				FlattenTargets(targets, list);
				list.RemoveAll((PipeTarget t) => t == Null);
				return list;
			}
		}

		public static PipeTarget Merge(params PipeTarget[] targets)
		{
			return Merge((IEnumerable<PipeTarget>)targets);
		}
	}
	internal class <PipeTarget>F825283E4191C5E3065EA9B63A9E400DE4BF8A70F67D820C9074D40C0E517F81E__AnonymousPipeTarget : PipeTarget
	{
		private readonly Func<Stream, CancellationToken, Task> _copyFromAsync;

		public <PipeTarget>F825283E4191C5E3065EA9B63A9E400DE4BF8A70F67D820C9074D40C0E517F81E__AnonymousPipeTarget(Func<Stream, CancellationToken, Task> copyFromAsync)
		{
			_copyFromAsync = copyFromAsync;
		}

		public override async Task CopyFromAsync(Stream origin, CancellationToken cancellationToken = default(CancellationToken))
		{
			await _copyFromAsync(origin, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		}
	}
	internal class <PipeTarget>F825283E4191C5E3065EA9B63A9E400DE4BF8A70F67D820C9074D40C0E517F81E__AggregatePipeTarget : PipeTarget
	{
		public IReadOnlyList<PipeTarget> Targets { get; }

		public <PipeTarget>F825283E4191C5E3065EA9B63A9E400DE4BF8A70F67D820C9074D40C0E517F81E__AggregatePipeTarget(IReadOnlyList<PipeTarget> targets)
		{
			Targets = targets;
		}

		public override async Task CopyFromAsync(Stream origin, CancellationToken cancellationToken = default(CancellationToken))
		{
			CancellationTokenSource cts = CancellationTokenSource.CreateLinkedTokenSource(new CancellationToken[1] { cancellationToken });
			try
			{
				Dictionary<PipeTarget, SimplexStream> targetSubStreams = new Dictionary<PipeTarget, SimplexStream>();
				foreach (PipeTarget target in Targets)
				{
					targetSubStreams[target] = new SimplexStream();
				}
				PipeTarget key;
				SimplexStream value;
				try
				{
					Task readingTask = Task.WhenAll(targetSubStreams.Select<KeyValuePair<PipeTarget, SimplexStream>, Task>(async delegate(KeyValuePair<PipeTarget, SimplexStream> targetSubStream)
					{
						KeyValuePair<PipeTarget, SimplexStream> keyValuePair = targetSubStream;
						var (pipeTarget2, origin2) = (KeyValuePair<PipeTarget, SimplexStream>)(ref keyValuePair);
						try
						{
							await pipeTarget2.CopyFromAsync(origin2, cts.Token).ConfigureAwait(continueOnCapturedContext: false);
						}
						catch
						{
							cts.Cancel();
							throw;
						}
					}));
					try
					{
						using IMemoryOwner<byte> buffer = MemoryPool<byte>.Shared.Rent(81920);
						while (true)
						{
							int bytesRead = await origin.ReadAsync(buffer.Memory, cts.Token).ConfigureAwait(continueOnCapturedContext: false);
							if (bytesRead <= 0)
							{
								break;
							}
							foreach (KeyValuePair<PipeTarget, SimplexStream> item in targetSubStreams)
							{
								item.Deconstruct(out key, out value);
								await value.WriteAsync(buffer.Memory.Slice(0, bytesRead), cts.Token).ConfigureAwait(continueOnCapturedContext: false);
							}
						}
						foreach (KeyValuePair<PipeTarget, SimplexStream> item2 in targetSubStreams)
						{
							item2.Deconstruct(out key, out value);
							await value.ReportCompletionAsync(cts.Token).ConfigureAwait(continueOnCapturedContext: false);
						}
					}
					finally
					{
						await readingTask.ConfigureAwait(continueOnCapturedContext: false);
					}
				}
				finally
				{
					foreach (KeyValuePair<PipeTarget, SimplexStream> item3 in targetSubStreams)
					{
						item3.Deconstruct(out key, out value);
						await value.ToAsyncDisposable().DisposeAsync().ConfigureAwait(continueOnCapturedContext: false);
					}
				}
			}
			finally
			{
				if (cts != null)
				{
					((IDisposable)cts).Dispose();
				}
			}
		}
	}
}
namespace CliWrap.Utils
{
	internal static class BufferSizes
	{
		public const int Stream = 81920;

		public const int StreamReader = 1024;
	}
	internal class Channel<T> : IDisposable
	{
		private readonly SemaphoreSlim _writeLock = new SemaphoreSlim(1, 1);

		private readonly SemaphoreSlim _readLock = new SemaphoreSlim(0, 1);

		private bool _isItemAvailable;

		private T _item;

		public async Task PublishAsync(T item, CancellationToken cancellationToken = default(CancellationToken))
		{
			await _writeLock.WaitAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			_item = item;
			_isItemAvailable = true;
			_readLock.Release();
		}

		public async IAsyncEnumerable<T> ReceiveAsync([EnumeratorCancellation] CancellationToken cancellationToken = default(CancellationToken))
		{
			while (true)
			{
				await _readLock.WaitAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				if (!_isItemAvailable)
				{
					break;
				}
				yield return _item;
				_isItemAvailable = false;
				_writeLock.Release();
			}
		}

		public async Task ReportCompletionAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			await _writeLock.WaitAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			_item = default(T);
			_isItemAvailable = false;
			_readLock.Release();
		}

		public void Dispose()
		{
			_writeLock.Dispose();
			_readLock.Dispose();
		}
	}
	internal class Disposable : IDisposable
	{
		private readonly Action _dispose;

		public static IDisposable Null { get; } = Create(delegate
		{
		});


		public Disposable(Action dispose)
		{
			_dispose = dispose;
		}

		public void Dispose()
		{
			_dispose();
		}

		public static IDisposable Create(Action dispose)
		{
			return new Disposable(dispose);
		}
	}
	internal static class EnvironmentEx
	{
		private static readonly Lazy<string?> ProcessPathLazy = new Lazy<string>(delegate
		{
			using Process process = Process.GetCurrentProcess();
			return process.MainModule?.FileName;
		});

		public static string? ProcessPath => ProcessPathLazy.Value;
	}
	internal static class NativeMethods
	{
		public static class Unix
		{
			[DllImport("libc", EntryPoint = "kill", SetLastError = true)]
			public static extern int Kill(int pid, int sig);
		}
	}
	internal class <Observable>F9A56BC066C1C55331A426EEC55B608B3C789C113870FC381D9D496607E7DCF71__SynchronizedObserver<T> : IObserver<T>
	{
		private readonly IObserver<T> _observer;

		private readonly object _syncRoot;

		public <Observable>F9A56BC066C1C55331A426EEC55B608B3C789C113870FC381D9D496607E7DCF71__SynchronizedObserver(IObserver<T> observer, object? syncRoot = null)
		{
			_observer = observer;
			_syncRoot = syncRoot ?? new object();
		}

		public void OnCompleted()
		{
			lock (_syncRoot)
			{
				_observer.OnCompleted();
			}
		}

		public void OnError(Exception error)
		{
			lock (_syncRoot)
			{
				_observer.OnError(error);
			}
		}

		public void OnNext(T value)
		{
			lock (_syncRoot)
			{
				_observer.OnNext(value);
			}
		}
	}
	internal class <Observable>F9A56BC066C1C55331A426EEC55B608B3C789C113870FC381D9D496607E7DCF71__Observable<T> : IObservable<T>
	{
		private readonly Func<IObserver<T>, IDisposable> _subscribe;

		public <Observable>F9A56BC066C1C55331A426EEC55B608B3C789C113870FC381D9D496607E7DCF71__Observable(Func<IObserver<T>, IDisposable> subscribe)
		{
			_subscribe = subscribe;
		}

		public IDisposable Subscribe(IObserver<T> observer)
		{
			return _subscribe(new <Observable>F9A56BC066C1C55331A426EEC55B608B3C789C113870FC381D9D496607E7DCF71__SynchronizedObserver<T>(observer));
		}
	}
	internal static class Observable
	{
		public static IObservable<T> Create<T>(Func<IObserver<T>, IDisposable> subscribe)
		{
			return new <Observable>F9A56BC066C1C55331A426EEC55B608B3C789C113870FC381D9D496607E7DCF71__Observable<T>(subscribe);
		}
	}
	internal class ProcessEx : IDisposable
	{
		private readonly Process _nativeProcess;

		private readonly TaskCompletionSource<object?> _exitTcs = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);

		public int Id => _nativeProcess.Id;

		public string Name => Path.GetFileName(_nativeProcess.StartInfo.FileName);

		public Stream StandardInput => _nativeProcess.StandardInput.BaseStream;

		public Stream StandardOutput => _nativeProcess.StandardOutput.BaseStream;

		public Stream StandardError => _nativeProcess.StandardError.BaseStream;

		public DateTimeOffset StartTime { get; private set; }

		public DateTimeOffset ExitTime { get; private set; }

		public int ExitCode => _nativeProcess.ExitCode;

		public ProcessEx(ProcessStartInfo startInfo)
		{
			_nativeProcess = new Process
			{
				StartInfo = startInfo
			};
		}

		public void Start()
		{
			_nativeProcess.EnableRaisingEvents = true;
			_nativeProcess.Exited += delegate
			{
				ExitTime = DateTimeOffset.Now;
				_exitTcs.TrySetResult(null);
			};
			try
			{
				if (!_nativeProcess.Start())
				{
					throw new InvalidOperationException("Failed to start a process with file path '" + _nativeProcess.StartInfo.FileName + "'. Target file is not an executable or lacks execute permissions.");
				}
				StartTime = DateTimeOffset.Now;
			}
			catch (Win32Exception innerException)
			{
				throw new Win32Exception("Failed to start a process with file path '" + _nativeProcess.StartInfo.FileName + "'. Target file or working directory doesn't exist, or the provided credentials are invalid.", innerException);
			}
		}

		public void Interrupt()
		{
			if (!TryInterrupt())
			{
				Kill();
			}
			bool TryInterrupt()
			{
				try
				{
					if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
					{
						using (WindowsSignaler windowsSignaler = WindowsSignaler.Deploy())
						{
							return windowsSignaler.TrySend(_nativeProcess.Id, 0);
						}
					}
					if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) || RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
					{
						return NativeMethods.Unix.Kill(_nativeProcess.Id, 2) == 0;
					}
					return false;
				}
				catch
				{
					return false;
				}
			}
		}

		public void Kill()
		{
			try
			{
				PolyfillExtensions.Kill(_nativeProcess, entireProcessTree: true);
			}
			catch when (_nativeProcess.HasExited)
			{
			}
			catch
			{
			}
		}

		public async Task WaitUntilExitAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			await using (cancellationToken.Register(delegate
			{
				_exitTcs.TrySetCanceled(cancellationToken);
			}).ToAsyncDisposable())
			{
				await _exitTcs.Task.ConfigureAwait(continueOnCapturedContext: false);
			}
		}

		public void Dispose()
		{
			_nativeProcess.Dispose();
		}
	}
	internal class SimplexStream : Stream
	{
		private readonly SemaphoreSlim _writeLock = new SemaphoreSlim(1, 1);

		private readonly SemaphoreSlim _readLock = new SemaphoreSlim(0, 1);

		private IMemoryOwner<byte> _sharedBuffer = MemoryPool<byte>.Shared.Rent(81920);

		private int _sharedBufferBytes;

		private int _sharedBufferBytesRead;

		[ExcludeFromCodeCoverage]
		public override bool CanRead => true;

		[ExcludeFromCodeCoverage]
		public override bool CanSeek => false;

		[ExcludeFromCodeCoverage]
		public override bool CanWrite => true;

		[ExcludeFromCodeCoverage]
		public override long Position { get; set; }

		[ExcludeFromCodeCoverage]
		public override long Length
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			await _writeLock.WaitAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			if (_sharedBuffer.Memory.Length < count)
			{
				_sharedBuffer.Dispose();
				_sharedBuffer = MemoryPool<byte>.Shared.Rent(count);
			}
			buffer.AsSpan(offset, count).CopyTo(_sharedBuffer.Memory.Span);
			_sharedBufferBytes = count;
			_sharedBufferBytesRead = 0;
			_readLock.Release();
		}

		public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
		{
			await _readLock.WaitAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
			int num = Math.Min(count, _sharedBufferBytes - _sharedBufferBytesRead);
			_sharedBuffer.Memory.Slice(_sharedBufferBytesRead, num).CopyTo(buffer.AsMemory(offset, num));
			_sharedBufferBytesRead += num;
			if (_sharedBufferBytesRead >= _sharedBufferBytes)
			{
				_writeLock.Release();
			}
			else
			{
				_readLock.Release();
			}
			return num;
		}

		public async Task ReportCompletionAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			await WriteAsync(Array.Empty<byte>(), 0, 0, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				_readLock.Dispose();
				_writeLock.Dispose();
				_sharedBuffer.Dispose();
			}
			base.Dispose(disposing);
		}

		[ExcludeFromCodeCoverage]
		public override int Read(byte[] buffer, int offset, int count)
		{
			return ReadAsync(buffer, offset, count).GetAwaiter().GetResult();
		}

		[ExcludeFromCodeCoverage]
		public override void Write(byte[] buffer, int offset, int count)
		{
			WriteAsync(buffer, offset, count).GetAwaiter().GetResult();
		}

		[ExcludeFromCodeCoverage]
		public override void Flush()
		{
			throw new NotSupportedException();
		}

		[ExcludeFromCodeCoverage]
		public override long Seek(long offset, SeekOrigin origin)
		{
			throw new NotSupportedException();
		}

		[ExcludeFromCodeCoverage]
		public override void SetLength(long value)
		{
			throw new NotSupportedException();
		}
	}
	internal class WindowsSignaler : IDisposable
	{
		private readonly string _filePath;

		public WindowsSignaler(string filePath)
		{
			_filePath = filePath;
		}

		public bool TrySend(int processId, int signalId)
		{
			Process process = new Process();
			ProcessStartInfo processStartInfo = new ProcessStartInfo();
			processStartInfo.FileName = _filePath;
			processStartInfo.Arguments = processId.ToString(CultureInfo.InvariantCulture) + " " + signalId.ToString(CultureInfo.InvariantCulture);
			processStartInfo.CreateNoWindow = true;
			processStartInfo.UseShellExecute = false;
			processStartInfo.Environment["COMPLUS_OnlyUseLatestCLR"] = "1";
			process.StartInfo = processStartInfo;
			using Process process2 = process;
			if (!process2.Start())
			{
				return false;
			}
			if (!process2.WaitForExit(30000))
			{
				return false;
			}
			return process2.ExitCode == 0;
		}

		public void Dispose()
		{
			try
			{
				File.Delete(_filePath);
			}
			catch
			{
			}
		}

		public static WindowsSignaler Deploy()
		{
			string text = Path.ChangeExtension(Path.GetTempFileName(), "exe");
			Assembly.GetExecutingAssembly().ExtractManifestResource("CliWrap.Signaler.exe", text);
			return new WindowsSignaler(text);
		}
	}
}
namespace CliWrap.Utils.Extensions
{
	internal static class AssemblyExtensions
	{
		public static void ExtractManifestResource(this Assembly assembly, string resourceName, string destFilePath)
		{
			Stream stream = assembly.GetManifestResourceStream(resourceName) ?? throw new MissingManifestResourceException("Could not find resource '" + resourceName + "'.");
			using FileStream destination = File.Create(destFilePath);
			stream.CopyTo(destination);
		}
	}
	internal static class AsyncDisposableExtensions
	{
		private readonly struct AsyncDisposableAdapter : IAsyncDisposable
		{
			private readonly IDisposable _target;

			public AsyncDisposableAdapter(IDisposable target)
			{
				_target = target;
			}

			public async ValueTask DisposeAsync()
			{
				if (_target is IAsyncDisposable asyncDisposable)
				{
					await asyncDisposable.DisposeAsync().ConfigureAwait(continueOnCapturedContext: false);
				}
				else
				{
					_target.Dispose();
				}
			}
		}

		public static IAsyncDisposable ToAsyncDisposable(this IDisposable disposable)
		{
			return new AsyncDisposableAdapter(disposable);
		}
	}
	internal static class CancellationTokenExtensions
	{
		public static void ThrowIfCancellationRequested(this CancellationToken cancellationToken, string message)
		{
			if (!cancellationToken.IsCancellationRequested)
			{
				return;
			}
			throw new OperationCanceledException(message, cancellationToken);
		}
	}
	internal static class ExceptionExtensions
	{
		public static Exception? TryGetSingle(this AggregateException exception)
		{
			ReadOnlyCollection<Exception> innerExceptions = exception.Flatten().InnerExceptions;
			if (innerExceptions.Count != 1)
			{
				return null;
			}
			return innerExceptions.Single();
		}
	}
	internal static class StreamExtensions
	{
		public static async Task CopyToAsync(this Stream source, Stream destination, bool autoFlush, CancellationToken cancellationToken = default(CancellationToken))
		{
			using IMemoryOwner<byte> buffer = MemoryPool<byte>.Shared.Rent(81920);
			while (true)
			{
				int num = await source.ReadAsync(buffer.Memory, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				if (num <= 0)
				{
					break;
				}
				await destination.WriteAsync(buffer.Memory.Slice(0, num), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				if (autoFlush)
				{
					await destination.FlushAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}
			}
		}

		public static async IAsyncEnumerable<string> ReadAllLinesAsync(this StreamReader reader, [EnumeratorCancellation] CancellationToken cancellationToken = default(CancellationToken))
		{
			StringBuilder lineBuffer = new StringBuilder();
			using IMemoryOwner<char> buffer = MemoryPool<char>.Shared.Rent(1024);
			bool isLastCaretReturn = false;
			while (true)
			{
				int charsRead = await reader.ReadAsync(buffer.Memory, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				if (charsRead <= 0)
				{
					break;
				}
				for (int i = 0; i < charsRead; i++)
				{
					char c = buffer.Memory.Span[i];
					if (isLastCaretReturn && c == '\n')
					{
						isLastCaretReturn = false;
						continue;
					}
					char c2 = c;
					if ((c2 == '\n' || c2 == '\r') ? true : false)
					{
						yield return lineBuffer.ToString();
						lineBuffer.Clear();
					}
					else
					{
						lineBuffer.Append(c);
					}
					isLastCaretReturn = c == '\r';
				}
			}
			if (lineBuffer.Length > 0)
			{
				yield return lineBuffer.ToString();
			}
		}
	}
	internal static class StringExtensions
	{
		public static SecureString ToSecureString(this string str)
		{
			SecureString secureString = new SecureString();
			foreach (char c in str)
			{
				secureString.AppendChar(c);
			}
			secureString.MakeReadOnly();
			return secureString;
		}
	}
	internal static class TaskExtensions
	{
		public static async Task<TDestination> Select<TSource, TDestination>(this Task<TSource> task, Func<TSource, TDestination> transform)
		{
			return transform(await task.ConfigureAwait(continueOnCapturedContext: false));
		}
	}
}
namespace CliWrap.Exceptions
{
	public abstract class CliWrapException : Exception
	{
		protected CliWrapException(string message, Exception? innerException)
			: base(message, innerException)
		{
		}

		[ExcludeFromCodeCoverage]
		protected CliWrapException(string message)
			: this(message, null)
		{
		}
	}
	public class CommandExecutionException : CliWrapException
	{
		public ICommandConfiguration Command { get; }

		public int ExitCode { get; }

		public CommandExecutionException(ICommandConfiguration command, int exitCode, string message, Exception? innerException)
			: base(message, innerException)
		{
			Command = command;
			ExitCode = exitCode;
		}

		[ExcludeFromCodeCoverage]
		public CommandExecutionException(ICommandConfiguration command, int exitCode, string message)
			: this(command, exitCode, message, null)
		{
		}
	}
}
namespace CliWrap.EventStream
{
	public abstract class CommandEvent
	{
	}
	public class StartedCommandEvent : CommandEvent
	{
		public int ProcessId { get; }

		public StartedCommandEvent(int processId)
		{
			ProcessId = processId;
		}

		[ExcludeFromCodeCoverage]
		public override string ToString()
		{
			return $"Process ID: {ProcessId}";
		}
	}
	public class StandardOutputCommandEvent : CommandEvent
	{
		public string Text { get; }

		public StandardOutputCommandEvent(string text)
		{
			Text = text;
		}

		[ExcludeFromCodeCoverage]
		public override string ToString()
		{
			return Text;
		}
	}
	public class StandardErrorCommandEvent : CommandEvent
	{
		public string Text { get; }

		public StandardErrorCommandEvent(string text)
		{
			Text = text;
		}

		[ExcludeFromCodeCoverage]
		public override string ToString()
		{
			return Text;
		}
	}
	public class ExitedCommandEvent : CommandEvent
	{
		public int ExitCode { get; }

		public ExitedCommandEvent(int exitCode)
		{
			ExitCode = exitCode;
		}

		[ExcludeFromCodeCoverage]
		public override string ToString()
		{
			return $"Exit code: {ExitCode}";
		}
	}
	public static class EventStreamCommandExtensions
	{
		public static async IAsyncEnumerable<CommandEvent> ListenAsync(this Command command, Encoding standardOutputEncoding, Encoding standardErrorEncoding, [EnumeratorCancellation] CancellationToken forcefulCancellationToken, CancellationToken gracefulCancellationToken)
		{
			Channel<CommandEvent> channel = new Channel<CommandEvent>();
			try
			{
				PipeTarget target = PipeTarget.Merge(command.StandardOutputPipe, PipeTarget.ToDelegate(async delegate(string line, CancellationToken innerCancellationToken)
				{
					await channel.PublishAsync(new StandardOutputCommandEvent(line), innerCancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}, standardOutputEncoding));
				PipeTarget target2 = PipeTarget.Merge(command.StandardErrorPipe, PipeTarget.ToDelegate(async delegate(string line, CancellationToken innerCancellationToken)
				{
					await channel.PublishAsync(new StandardErrorCommandEvent(line), innerCancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}, standardErrorEncoding));
				Command command2 = command.WithStandardOutputPipe(target).WithStandardErrorPipe(target2);
				CommandTask<CommandResult> commandTask = command2.ExecuteAsync(forcefulCancellationToken, gracefulCancellationToken);
				yield return new StartedCommandEvent(commandTask.ProcessId);
				commandTask.Task.ContinueWith((Func<Task<CommandResult>, Task>)async delegate
				{
					await channel.ReportCompletionAsync(forcefulCancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}, TaskContinuationOptions.None);
				await foreach (CommandEvent item in channel.ReceiveAsync(forcefulCancellationToken).ConfigureAwait(continueOnCapturedContext: false))
				{
					yield return item;
				}
				yield return new ExitedCommandEvent(await commandTask.Select((CommandResult r) => r.ExitCode).ConfigureAwait(continueOnCapturedContext: false));
			}
			finally
			{
				if (channel != null)
				{
					((IDisposable)channel).Dispose();
				}
			}
		}

		public static IAsyncEnumerable<CommandEvent> ListenAsync(this Command command, Encoding standardOutputEncoding, Encoding standardErrorEncoding, CancellationToken cancellationToken = default(CancellationToken))
		{
			return command.ListenAsync(standardOutputEncoding, standardErrorEncoding, cancellationToken, CancellationToken.None);
		}

		public static IAsyncEnumerable<CommandEvent> ListenAsync(this Command command, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
		{
			return command.ListenAsync(encoding, encoding, cancellationToken);
		}

		public static IAsyncEnumerable<CommandEvent> ListenAsync(this Command command, CancellationToken cancellationToken = default(CancellationToken))
		{
			return command.ListenAsync(Console.OutputEncoding, cancellationToken);
		}

		public static IObservable<CommandEvent> Observe(this Command command, Encoding standardOutputEncoding, Encoding standardErrorEncoding, CancellationToken forcefulCancellationToken, CancellationToken gracefulCancellationToken)
		{
			Command command2 = command;
			Encoding standardOutputEncoding2 = standardOutputEncoding;
			Encoding standardErrorEncoding2 = standardErrorEncoding;
			return Observable.Create(delegate(IObserver<CommandEvent> observer)
			{
				IObserver<CommandEvent> observer2 = observer;
				PipeTarget target = PipeTarget.Merge(command2.StandardOutputPipe, PipeTarget.ToDelegate(delegate(string line)
				{
					observer2.OnNext(new StandardOutputCommandEvent(line));
				}, standardOutputEncoding2));
				PipeTarget target2 = PipeTarget.Merge(command2.StandardErrorPipe, PipeTarget.ToDelegate(delegate(string line)
				{
					observer2.OnNext(new StandardErrorCommandEvent(line));
				}, standardErrorEncoding2));
				CommandTask<CommandResult> commandTask = command2.WithStandardOutputPipe(target).WithStandardErrorPipe(target2).ExecuteAsync(forcefulCancellationToken, gracefulCancellationToken);
				observer2.OnNext(new StartedCommandEvent(commandTask.ProcessId));
				commandTask.Task.ContinueWith(delegate(Task<CommandResult> t)
				{
					if (t.IsCanceled)
					{
						observer2.OnError(new TaskCanceledException(t));
					}
					else if (t.Exception != null)
					{
						observer2.OnError(t.Exception.TryGetSingle() ?? t.Exception);
					}
					else
					{
						observer2.OnNext(new ExitedCommandEvent(t.Result.ExitCode));
						observer2.OnCompleted();
					}
				}, TaskContinuationOptions.None);
				return Disposable.Null;
			});
		}

		public static IObservable<CommandEvent> Observe(this Command command, Encoding standardOutputEncoding, Encoding standardErrorEncoding, CancellationToken cancellationToken = default(CancellationToken))
		{
			return command.Observe(standardOutputEncoding, standardErrorEncoding, cancellationToken, CancellationToken.None);
		}

		public static IObservable<CommandEvent> Observe(this Command command, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
		{
			return command.Observe(encoding, encoding, cancellationToken);
		}

		public static IObservable<CommandEvent> Observe(this Command command, CancellationToken cancellationToken = default(CancellationToken))
		{
			return command.Observe(Console.OutputEncoding, cancellationToken);
		}
	}
}
namespace CliWrap.Builders
{
	public class ArgumentsBuilder
	{
		private static readonly IFormatProvider DefaultFormatProvider = CultureInfo.InvariantCulture;

		private readonly StringBuilder _buffer = new StringBuilder();

		public ArgumentsBuilder Add(string value, bool escape)
		{
			if (_buffer.Length > 0)
			{
				_buffer.Append(' ');
			}
			_buffer.Append(escape ? Escape(value) : value);
			return this;
		}

		public ArgumentsBuilder Add(string value)
		{
			return Add(value, escape: true);
		}

		public ArgumentsBuilder Add(IEnumerable<string> values, bool escape)
		{
			foreach (string value in values)
			{
				Add(value, escape);
			}
			return this;
		}

		public ArgumentsBuilder Add(IEnumerable<string> values)
		{
			return Add(values, escape: true);
		}

		public ArgumentsBuilder Add(IFormattable value, IFormatProvider formatProvider, bool escape = true)
		{
			return Add(value.ToString(null, formatProvider), escape);
		}

		public ArgumentsBuilder Add(IFormattable value, CultureInfo cultureInfo, bool escape)
		{
			return Add(value, (IFormatProvider)cultureInfo, escape);
		}

		public ArgumentsBuilder Add(IFormattable value, CultureInfo cultureInfo)
		{
			return Add(value, cultureInfo, escape: true);
		}

		public ArgumentsBuilder Add(IFormattable value, bool escape)
		{
			return Add(value, DefaultFormatProvider, escape);
		}

		public ArgumentsBuilder Add(IFormattable value)
		{
			return Add(value, escape: true);
		}

		public ArgumentsBuilder Add(IEnumerable<IFormattable> values, IFormatProvider formatProvider, bool escape = true)
		{
			foreach (IFormattable value in values)
			{
				Add(value, formatProvider, escape);
			}
			return this;
		}

		public ArgumentsBuilder Add(IEnumerable<IFormattable> values, CultureInfo cultureInfo, bool escape)
		{
			return Add(values, (IFormatProvider)cultureInfo, escape);
		}

		public ArgumentsBuilder Add(IEnumerable<IFormattable> values, CultureInfo cultureInfo)
		{
			return Add(values, cultureInfo, escape: true);
		}

		public ArgumentsBuilder Add(IEnumerable<IFormattable> values, bool escape)
		{
			return Add(values, DefaultFormatProvider, escape);
		}

		public ArgumentsBuilder Add(IEnumerable<IFormattable> values)
		{
			return Add(values, escape: true);
		}

		public string Build()
		{
			return _buffer.ToString();
		}

		private static string Escape(string argument)
		{
			if (argument.Length > 0 && argument.All((char c) => !char.IsWhiteSpace(c) && c != '"'))
			{
				return argument;
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append('"');
			int i = 0;
			while (i < argument.Length)
			{
				char c2 = argument[i++];
				switch (c2)
				{
				case '\\':
				{
					int num = 1;
					for (; i < argument.Length && argument[i] == '\\'; i++)
					{
						num++;
					}
					if (i == argument.Length)
					{
						stringBuilder.Append('\\', num * 2);
					}
					else if (argument[i] == '"')
					{
						stringBuilder.Append('\\', num * 2 + 1).Append('"');
						i++;
					}
					else
					{
						stringBuilder.Append('\\', num);
					}
					break;
				}
				case '"':
					stringBuilder.Append('\\').Append('"');
					break;
				default:
					stringBuilder.Append(c2);
					break;
				}
			}
			stringBuilder.Append('"');
			return stringBuilder.ToString();
		}
	}
	public class CredentialsBuilder
	{
		private string? _domain;

		private string? _userName;

		private string? _password;

		private bool _loadUserProfile;

		public CredentialsBuilder SetDomain(string? domain)
		{
			_domain = domain;
			return this;
		}

		public CredentialsBuilder SetUserName(string? userName)
		{
			_userName = userName;
			return this;
		}

		public CredentialsBuilder SetPassword(string? password)
		{
			_password = password;
			return this;
		}

		public CredentialsBuilder LoadUserProfile(bool loadUserProfile = true)
		{
			_loadUserProfile = loadUserProfile;
			return this;
		}

		public Credentials Build()
		{
			return new Credentials(_domain, _userName, _password, _loadUserProfile);
		}
	}
	public class EnvironmentVariablesBuilder
	{
		private readonly Dictionary<string, string?> _envVars = new Dictionary<string, string>(StringComparer.Ordinal);

		public EnvironmentVariablesBuilder Set(string name, string? value)
		{
			_envVars[name] = value;
			return this;
		}

		public EnvironmentVariablesBuilder Set(IEnumerable<KeyValuePair<string, string?>> variables)
		{
			foreach (var (name, value) in variables)
			{
				Set(name, value);
			}
			return this;
		}

		public EnvironmentVariablesBuilder Set(IReadOnlyDictionary<string, string?> variables)
		{
			return Set((IEnumerable<KeyValuePair<string, string?>>)variables);
		}

		public IReadOnlyDictionary<string, string?> Build()
		{
			return new Dictionary<string, string>(_envVars, _envVars.Comparer);
		}
	}
}
namespace CliWrap.Buffered
{
	public static class BufferedCommandExtensions
	{
		public static CommandTask<BufferedCommandResult> ExecuteBufferedAsync(this Command command, Encoding standardOutputEncoding, Encoding standardErrorEncoding, CancellationToken forcefulCancellationToken, CancellationToken gracefulCancellationToken)
		{
			StringBuilder stdOutBuffer = new StringBuilder();
			StringBuilder stdErrBuffer = new StringBuilder();
			PipeTarget target = PipeTarget.Merge(command.StandardOutputPipe, PipeTarget.ToStringBuilder(stdOutBuffer, standardOutputEncoding));
			PipeTarget target2 = PipeTarget.Merge(command.StandardErrorPipe, PipeTarget.ToStringBuilder(stdErrBuffer, standardErrorEncoding));
			return command.WithStandardOutputPipe(target).WithStandardErrorPipe(target2).ExecuteAsync(forcefulCancellationToken, gracefulCancellationToken)
				.Bind(async delegate(Task<CommandResult> task)
				{
					try
					{
						CommandResult commandResult = await task;
						return new BufferedCommandResult(commandResult.ExitCode, commandResult.StartTime, commandResult.ExitTime, stdOutBuffer.ToString(), stdErrBuffer.ToString());
					}
					catch (CommandExecutionException ex)
					{
						throw new CommandExecutionException(ex.Command, ex.ExitCode, "Command execution failed, see the inner exception for details.\r\n\r\nStandard error:\r\n" + stdErrBuffer.ToString().Trim(), ex);
					}
				});
		}

		public static CommandTask<BufferedCommandResult> ExecuteBufferedAsync(this Command command, Encoding standardOutputEncoding, Encoding standardErrorEncoding, CancellationToken cancellationToken = default(CancellationToken))
		{
			return command.ExecuteBufferedAsync(standardOutputEncoding, standardErrorEncoding, cancellationToken, CancellationToken.None);
		}

		public static CommandTask<BufferedCommandResult> ExecuteBufferedAsync(this Command command, Encoding encoding, CancellationToken cancellationToken = default(CancellationToken))
		{
			return command.ExecuteBufferedAsync(encoding, encoding, cancellationToken);
		}

		public static CommandTask<BufferedCommandResult> ExecuteBufferedAsync(this Command command, CancellationToken cancellationToken = default(CancellationToken))
		{
			return command.ExecuteBufferedAsync(Console.OutputEncoding, cancellationToken);
		}
	}
	public class BufferedCommandResult : CommandResult
	{
		public string StandardOutput { get; }

		public string StandardError { get; }

		public BufferedCommandResult(int exitCode, DateTimeOffset startTime, DateTimeOffset exitTime, string standardOutput, string standardError)
			: base(exitCode, startTime, exitTime)
		{
			StandardOutput = standardOutput;
			StandardError = standardError;
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Constructor)]
	[ExcludeFromCodeCoverage]
	internal class SetsRequiredMembersAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter)]
	[ExcludeFromCodeCoverage]
	internal class StringSyntaxAttribute : Attribute
	{
		public const string CompositeFormat = "CompositeFormat";

		public const string DateOnlyFormat = "DateOnlyFormat";

		public const string DateTimeFormat = "DateTimeFormat";

		public const string EnumFormat = "EnumFormat";

		public const string GuidFormat = "GuidFormat";

		public const string Json = "Json";

		public const string NumericFormat = "NumericFormat";

		public const string Regex = "Regex";

		public const string TimeOnlyFormat = "TimeOnlyFormat";

		public const string TimeSpanFormat = "TimeSpanFormat";

		public const string Uri = "Uri";

		public const string Xml = "Xml";

		public string Syntax { get; }

		public object?[] Arguments { get; }

		public StringSyntaxAttribute(string syntax, params object?[] arguments)
		{
			Syntax = syntax;
			Arguments = arguments;
		}

		public StringSyntaxAttribute(string syntax)
			: this(syntax, new object[0])
		{
		}
	}
}
namespace System.Linq
{
	internal static class PolyfillExtensions
	{
		public static T ElementAt<T>(this IEnumerable<T> source, Index index)
		{
			if (index.IsFromEnd)
			{
				ICollection<T> collection = (source as ICollection<T>) ?? source.ToArray();
				return collection.ElementAt(collection.Count - index.Value);
			}
			return source.ElementAt(index.Value);
		}

		public static T? ElementAtOrDefault<T>(this IEnumerable<T> source, Index index)
		{
			if (index.IsFromEnd)
			{
				ICollection<T> collection = (source as ICollection<T>) ?? source.ToArray();
				return collection.ElementAtOrDefault(collection.Count - index.Value);
			}
			return source.ElementAtOrDefault(index.Value);
		}

		public static T FirstOrDefault<T>(this IEnumerable<T> source, T defaultValue)
		{
			using IEnumerator<T> enumerator = source.GetEnumerator();
			if (enumerator.MoveNext())
			{
				return enumerator.Current;
			}
			return defaultValue;
		}

		public static T FirstOrDefault<T>(this IEnumerable<T> source, Func<T, bool> predicate, T defaultValue)
		{
			foreach (T item in source)
			{
				if (predicate(item))
				{
					return item;
				}
			}
			return defaultValue;
		}

		public static T LastOrDefault<T>(this IEnumerable<T> source, T defaultValue)
		{
			T result = defaultValue;
			foreach (T item in source)
			{
				result = item;
			}
			return result;
		}

		public static T LastOrDefault<T>(this IEnumerable<T> source, Func<T, bool> predicate, T defaultValue)
		{
			T result = defaultValue;
			foreach (T item in source)
			{
				if (predicate(item))
				{
					result = item;
				}
			}
			return result;
		}

		public static T SingleOrDefault<T>(this IEnumerable<T> source, T defaultValue)
		{
			T result = defaultValue;
			bool flag = false;
			foreach (T item in source)
			{
				if (flag)
				{
					throw new InvalidOperationException("Sequence contains more than one element.");
				}
				result = item;
				flag = true;
			}
			return result;
		}

		public static T SingleOrDefault<T>(this IEnumerable<T> source, Func<T, bool> predicate, T defaultValue)
		{
			T result = defaultValue;
			bool flag = false;
			foreach (T item in source)
			{
				if (predicate(item))
				{
					if (flag)
					{
						throw new InvalidOperationException("Sequence contains more than one element.");
					}
					result = item;
					flag = true;
				}
			}
			return result;
		}

		public static IEnumerable<T> Take<T>(this IEnumerable<T> source, Range range)
		{
			ICollection<T> collection = (source as ICollection<T>) ?? source.ToArray();
			var (count, count2) = range.GetOffsetAndLength(collection.Count);
			return collection.Skip(count).Take(count2);
		}

		public static T? Min<T>(this IEnumerable<T> source, IComparer<T>? comparer)
		{
			return source.OrderBy((T x) => x, comparer).FirstOrDefault();
		}

		public static T? MinBy<T, TKey>(this IEnumerable<T> source, Func<T, TKey> keySelector, IComparer<TKey>? comparer)
		{
			return source.OrderBy(keySelector, comparer).FirstOrDefault();
		}

		public static T? MinBy<T, TKey>(this IEnumerable<T> source, Func<T, TKey> keySelector)
		{
			return MinBy(source, keySelector, Comparer<TKey>.Default);
		}

		public static T? Max<T>(this IEnumerable<T> source, IComparer<T>? comparer)
		{
			return source.OrderByDescending((T x) => x, comparer).FirstOrDefault();
		}

		public static T? MaxBy<T, TKey>(this IEnumerable<T> source, Func<T, TKey> keySelector, IComparer<TKey>? comparer)
		{
			return source.OrderByDescending(keySelector, comparer).FirstOrDefault();
		}

		public static T? MaxBy<T, TKey>(this IEnumerable<T> source, Func<T, TKey> keySelector)
		{
			return MaxBy(source, keySelector, Comparer<TKey>.Default);
		}

		public static IEnumerable<T> DistinctBy<T, TKey>(this IEnumerable<T> source, Func<T, TKey> keySelector, IEqualityComparer<TKey>? comparer)
		{
			return from x in source.GroupBy(keySelector, comparer)
				select x.First();
		}

		public static IEnumerable<T> DistinctBy<T, TKey>(this IEnumerable<T> source, Func<T, TKey> keySelector)
		{
			return DistinctBy(source, keySelector, EqualityComparer<TKey>.Default);
		}

		public static IEnumerable<T> ExceptBy<T, TKey>(this IEnumerable<T> source, IEnumerable<TKey> other, Func<T, TKey> keySelector, IEqualityComparer<TKey>? comparer)
		{
			HashSet<TKey> set = new HashSet<TKey>(other, comparer);
			foreach (T item in source)
			{
				if (!set.Contains(keySelector(item)))
				{
					yield return item;
				}
			}
		}

		public static IEnumerable<T> ExceptBy<T, TKey>(this IEnumerable<T> source, IEnumerable<TKey> other, Func<T, TKey> keySelector)
		{
			return ExceptBy(source, other, keySelector, EqualityComparer<TKey>.Default);
		}

		public static IEnumerable<T> IntersectBy<T, TKey>(this IEnumerable<T> source, IEnumerable<TKey> other, Func<T, TKey> keySelector, IEqualityComparer<TKey>? comparer)
		{
			HashSet<TKey> set = new HashSet<TKey>(other, comparer);
			foreach (T item in source)
			{
				if (set.Contains(keySelector(item)))
				{
					yield return item;
				}
			}
		}

		public static IEnumerable<T> IntersectBy<T, TKey>(this IEnumerable<T> source, IEnumerable<TKey> other, Func<T, TKey> keySelector)
		{
			return IntersectBy(source, other, keySelector, EqualityComparer<TKey>.Default);
		}

		public static IEnumerable<T> UnionBy<T, TKey>(this IEnumerable<T> source, IEnumerable<T> other, Func<T, TKey> keySelector, IEqualityComparer<TKey>? comparer)
		{
			HashSet<TKey> set = new HashSet<TKey>(comparer);
			foreach (T item in source)
			{
				if (set.Add(keySelector(item)))
				{
					yield return item;
				}
			}
			foreach (T item2 in other)
			{
				if (set.Add(keySelector(item2)))
				{
					yield return item2;
				}
			}
		}

		public static IEnumerable<T> UnionBy<T, TKey>(this IEnumerable<T> source, IEnumerable<T> other, Func<T, TKey> keySelector)
		{
			return UnionBy(source, other, keySelector, EqualityComparer<TKey>.Default);
		}

		public static IEnumerable<T[]> Chunk<T>(this IEnumerable<T> source, int size)
		{
			List<T> chunk = new List<T>(size);
			foreach (T item in source)
			{
				chunk.Add(item);
				if (chunk.Count == size)
				{
					yield return chunk.ToArray();
					chunk.Clear();
				}
			}
			if (chunk.Count > 0)
			{
				yield return chunk.ToArray();
			}
		}

		public static IOrderedEnumerable<T> Order<T>(this IEnumerable<T> source, IComparer<T>? comparer)
		{
			return source.OrderBy((T x) => x, comparer);
		}

		public static IOrderedEnumerable<T> Order<T>(this IEnumerable<T> source)
		{
			return source.Order(Comparer<T>.Default);
		}

		public static IOrderedEnumerable<T> OrderDescending<T>(this IEnumerable<T> source, IComparer<T>? comparer)
		{
			return source.OrderByDescending((T x) => x, comparer);
		}

		public static IOrderedEnumerable<T> OrderDescending<T>(this IEnumerable<T> source)
		{
			return source.OrderDescending(Comparer<T>.Default);
		}

		public static IEnumerable<(TFirst left, TSecond right)> Zip<TFirst, TSecond>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second)
		{
			return first.Zip(second, (TFirst x, TSecond y) => (x, y));
		}
	}
}
namespace System.Runtime.InteropServices
{
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal class LibraryImportAttribute : Attribute
	{
		public string LibraryName { get; }

		public string? EntryPoint { get; init; }

		public bool SetLastError { get; init; }

		public StringMarshalling StringMarshalling { get; init; }

		public Type? StringMarshallingCustomType { get; init; }

		public LibraryImportAttribute(string libraryName)
		{
			LibraryName = libraryName;
		}
	}
	internal enum StringMarshalling
	{
		Custom,
		Utf8,
		Utf16
	}
}
namespace System.Runtime.CompilerServices
{
	[ExcludeFromCodeCoverage]
	internal static class IsExternalInit
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal class ModuleInitializerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal class SkipLocalsInitAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal class CompilerFeatureRequiredAttribute : Attribute
	{
		public const string RefStructs = "RefStructs";

		public const string RequiredMembers = "RequiredMembers";

		public string FeatureName { get; }

		public bool IsOptional { get; init; }

		public CompilerFeatureRequiredAttribute(string featureName)
		{
			FeatureName = featureName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, Inherited = false)]
	[ExcludeFromCodeCoverage]
	internal class RequiredMemberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter)]
	[ExcludeFromCodeCoverage]
	internal class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
}
namespace System.Threading.Tasks
{
	internal static class PolyfillExtensions
	{
	}
}
namespace System.Net.Http
{
	internal static class PolyfillExtensions
	{
	}
}
namespace System.Management
{
	internal static class PolyfillExtensions
	{
	}
}
namespace System.IO
{
	internal static class PolyfillExtensions
	{
	}
}