< Summary

Information
Class: System.Buffers.Text.Base64Url
Assembly: System.Private.CoreLib
File(s): File 1: D:\runner\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Url\Base64UrlDecoder.cs
File 2: D:\runner\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Url\Base64UrlEncoder.cs
File 3: D:\runner\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Url\Base64UrlValidator.cs
Line coverage
64%
Covered lines: 191
Uncovered lines: 107
Coverable lines: 298
Total lines: 1083
Line coverage: 64%
Branch coverage
51%
Covered branches: 37
Total branches: 72
Branch coverage: 51.3%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
File 1: GetMaxDecodedLength(...)100%22100%
File 1: DecodeFromUtf8(...)100%11100%
File 1: DecodeFromUtf8InPlace(...)100%22100%
File 1: DecodeFromUtf8(...)0%440%
File 1: TryDecodeFromUtf8(...)50%4480%
File 1: DecodeFromUtf8(...)0%880%
File 1: DecodeFromChars(...)100%11100%
File 1: DecodeFromChars(...)0%440%
File 1: TryDecodeFromChars(...)0%220%
File 1: DecodeFromChars(...)0%660%
File 1: GetMaxDecodedLength(...)100%11100%
File 1: IsInvalidLength(...)100%11100%
File 1: IsValidPadding(...)100%22100%
File 1: SrcLength(...)100%22100%
File 1: TryDecode128Core(...)100%22100%
File 1: TryDecode256Core(...)100%22100%
File 1: TryLoadVector512(...)100%110%
File 1: TryLoadAvxVector256(...)100%11100%
File 1: TryLoadVector128(...)100%11100%
File 1: TryLoadArmVector128x4(...)100%110%
File 1: DecodeFourElements(...)100%11100%
File 1: DecodeRemaining(...)100%11100%
File 1: IndexOfAnyExceptWhiteSpace(...)100%11100%
File 1: DecodeWithWhiteSpaceBlockwiseWrapper(...)100%11100%
File 1: GetMaxDecodedLength(...)100%11100%
File 1: IsInvalidLength(...)100%110%
File 1: IsValidPadding(...)100%11100%
File 1: SrcLength(...)100%11100%
File 1: TryDecode128Core(...)100%11100%
File 1: TryDecode256Core(...)100%11100%
File 1: TryLoadVector512(...)100%110%
File 1: TryLoadAvxVector256(...)100%11100%
File 1: TryLoadVector128(...)100%11100%
File 1: TryLoadArmVector128x4(...)100%110%
File 1: DecodeFourElements(...)100%11100%
File 1: DecodeRemaining(...)100%11100%
File 1: IndexOfAnyExceptWhiteSpace(...)100%110%
File 1: DecodeWithWhiteSpaceBlockwiseWrapper(...)100%110%
File 2: EncodeToUtf8(...)100%110%
File 2: GetEncodedLength(...)100%22100%
File 2: EncodeToUtf8(...)0%220%
File 2: EncodeToUtf8(...)100%110%
File 2: EncodeToChars(...)100%11100%
File 2: EncodeToChars(...)0%220%
File 2: EncodeToChars(...)100%110%
File 2: EncodeToString(...)50%22100%
File 2: TryEncodeToChars(...)100%110%
File 2: TryEncodeToUtf8(...)100%110%
File 2: TryEncodeToUtf8InPlace(...)100%11100%
File 2: GetMaxSrcLength(...)50%44100%
File 2: GetInPlaceDestinationLength(...)100%22100%
File 2: GetMaxEncodedLength(...)100%11100%
File 2: EncodeOneOptionallyPadTwo(...)100%11100%
File 2: EncodeTwoOptionallyPadOne(...)100%11100%
File 2: StoreVector512ToDestination(...)100%110%
File 2: StoreVector256ToDestination(...)100%110%
File 2: StoreVector128ToDestination(...)100%110%
File 2: StoreArmVector128x4ToDestination(...)100%110%
File 2: EncodeThreeAndWrite(...)100%110%
File 2: GetMaxSrcLength(...)100%11100%
File 2: GetInPlaceDestinationLength(...)100%110%
File 2: GetMaxEncodedLength(...)100%110%
File 2: EncodeOneOptionallyPadTwo(...)100%11100%
File 2: EncodeTwoOptionallyPadOne(...)100%11100%
File 2: StoreVector512ToDestination(...)100%110%
File 2: StoreVector256ToDestination(...)100%11100%
File 2: StoreVector128ToDestination(...)100%11100%
File 2: StoreArmVector128x4ToDestination(...)100%110%
File 2: EncodeThreeAndWrite(...)100%11100%
File 3: IsValid(...)100%110%
File 3: IsValid(...)100%110%
File 3: IsValid(...)100%110%
File 3: IsValid(...)100%11100%
File 3: .cctor()100%110%
File 3: IndexOfAnyExcept(...)100%110%
File 3: IsWhiteSpace(...)100%110%
File 3: IsEncodingPad(...)0%220%
File 3: ValidateAndDecodeLength(...)100%110%
File 3: .cctor()100%11100%
File 3: IndexOfAnyExcept(...)100%11100%
File 3: IsWhiteSpace(...)100%11100%
File 3: IsEncodingPad(...)100%22100%
File 3: ValidateAndDecodeLength(...)100%1414100%

File(s)

D:\runner\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Url\Base64UrlDecoder.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System.Diagnostics;
 5using System.Diagnostics.CodeAnalysis;
 6using System.Runtime;
 7using System.Runtime.CompilerServices;
 8using System.Runtime.InteropServices;
 9#if NET
 10using System.Runtime.Intrinsics;
 11using System.Runtime.Intrinsics.Arm;
 12using System.Runtime.Intrinsics.Wasm;
 13using System.Runtime.Intrinsics.X86;
 14#endif
 15using static System.Buffers.Text.Base64Helper;
 16
 17namespace System.Buffers.Text
 18{
 19    // AVX2 and Vector128 version based on https://github.com/gfoidl/Base64/blob/5383320e28cac6c7ac6f86502fb05d23a048a21
 20#pragma warning disable 1591 // TODO: Document this API. https://github.com/dotnet/runtime/issues/105974
 21    public static partial class Base64Url
 22#pragma warning restore 1591
 23    {
 24        private const int MaxStackallocThreshold = 256;
 25
 26        /// <summary>
 27        /// Returns the maximum length (in bytes) of the result if you were to decode Base64Url-encoded text from a span
 28        /// </summary>
 29        /// <exception cref="ArgumentOutOfRangeException">The specified <paramref name="base64Length"/> is less than 0.
 30        /// </exception>
 31        public static int GetMaxDecodedLength(int base64Length)
 32        {
 33#if NET
 6953734            ArgumentOutOfRangeException.ThrowIfNegative(base64Length);
 35
 6953736            (uint whole, uint remainder) = uint.DivRem((uint)base64Length, 4);
 37
 6953738            return (int)(whole * 3 + (remainder > 0 ? remainder - 1 : 0));
 39#else
 40            if (base64Length < 0)
 41            {
 42                throw new ArgumentOutOfRangeException(nameof(base64Length));
 43            }
 44
 45            int remainder = (int)((uint)base64Length % 4);
 46
 47            return (base64Length >> 2) * 3 + (remainder > 0 ? remainder - 1 : 0);
 48#endif
 49        }
 50
 51        /// <summary>
 52        /// Decodes the span of UTF-8 encoded text represented as Base64Url into binary data.
 53        /// </summary>
 54        /// <param name="source">The input span which contains UTF-8 encoded text in Base64Url that needs to be decoded.
 55        /// <param name="destination">The output span which contains the result of the operation, i.e. the decoded binar
 56        /// <param name="bytesConsumed">When this method returns, contains the number of input bytes consumed during the
 57        /// <param name="bytesWritten">When this method returns, contains the number of bytes written into the output sp
 58        /// <param name="isFinalBlock"><see langword="true"/> when the input span contains the entirety of data to decod
 59        /// such as when calling in a loop. Calls with <see langword="false"/> should be followed up with another call w
 60        /// <returns>One of the enumeration values that indicates the success or failure of the operation.</returns>
 61        /// <remarks>
 62        /// As padding is optional for Base64Url the <paramref name="source"/> length not required to be a multiple of 4
 63        /// If the <paramref name="source"/> length is not a multiple of 4 and <paramref name="isFinalBlock"/> is <see l
 64        /// - Remainder of 3 bytes - decoded into 2 bytes data, decoding succeeds.
 65        /// - Remainder of 2 bytes - decoded into 1 byte data. decoding succeeds.
 66        /// - Remainder of 1 byte - will cause OperationStatus.InvalidData result.
 67        /// </remarks>
 68        public static OperationStatus DecodeFromUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesCon
 211369            DecodeFrom(default(Base64UrlDecoderByte), source, destination, out bytesConsumed, out bytesWritten, isFinalB
 70
 71        /// <summary>
 72        /// Decodes the span of UTF-8 encoded text in Base64Url into binary data, in-place.
 73        /// The decoded binary output is smaller than the text data contained in the input (the operation deflates the d
 74        /// </summary>
 75        /// <param name="buffer">The input span which contains the Base64Url text data that needs to be decoded.</param>
 76        /// <returns>The number of bytes written into <paramref name="buffer"/>. This can be used to slice the output fo
 77        /// <exception cref="FormatException"><paramref name="buffer"/> contains an invalid Base64Url character,
 78        /// more than two padding characters, or a non white space character among the padding characters.</exception>
 79        /// <remarks>
 80        /// As padding is optional for Base64Url the <paramref name="buffer"/> length not required to be a multiple of 4
 81        /// If the <paramref name="buffer"/> length is not a multiple of 4 the remainders decoded accordingly:
 82        /// - Remainder of 3 bytes - decoded into 2 bytes data, decoding succeeds.
 83        /// - Remainder of 2 bytes - decoded into 1 byte data. decoding succeeds.
 84        /// - Remainder of 1 byte - is invalid input, causes FormatException.
 85        /// </remarks>
 86        public static int DecodeFromUtf8InPlace(Span<byte> buffer)
 87        {
 287088            OperationStatus status = DecodeFromUtf8InPlace<Base64UrlDecoderByte>(default, buffer, out int bytesWritten, 
 89
 90            // Base64.DecodeFromUtf8InPlace returns OperationStatus, therefore doesn't throw.
 91            // For Base64Url, this is not an OperationStatus API and thus throws.
 287092            if (status == OperationStatus.InvalidData)
 93            {
 75794                throw new FormatException(SR.Format_BadBase64Char);
 95            }
 96
 211397            Debug.Assert(status is OperationStatus.Done);
 211398            return bytesWritten;
 99        }
 100
 101        /// <summary>
 102        /// Decodes the span of UTF-8 encoded text represented as Base64Url into binary data.
 103        /// </summary>
 104        /// <param name="source">The input span which contains UTF-8 encoded text in Base64Url that needs to be decoded.
 105        /// <param name="destination">The output span which contains the result of the operation, i.e. the decoded binar
 106        /// <returns>The number of bytes written into <paramref name="destination"/>. This can be used to slice the outp
 107        /// <exception cref="ArgumentException">The buffer in <paramref name="destination"/> is too small to hold the de
 108        /// <exception cref="FormatException"><paramref name="source"/> contains an invalid Base64Url character,
 109        /// more than two padding characters, or a non white space character among the padding characters.</exception>
 110        /// <remarks>
 111        /// As padding is optional for Base64Url the <paramref name="source"/> length not required to be a multiple of 4
 112        /// If the <paramref name="source"/> length is not a multiple of 4 the remainders decoded accordingly:
 113        /// - Remainder of 3 bytes - decoded into 2 bytes data, decoding succeeds.
 114        /// - Remainder of 2 bytes - decoded into 1 byte data. decoding succeeds.
 115        /// - Remainder of 1 byte - is invalid input, causes FormatException.
 116        /// </remarks>
 117        public static int DecodeFromUtf8(ReadOnlySpan<byte> source, Span<byte> destination)
 118        {
 0119            OperationStatus status = DecodeFromUtf8(source, destination, out _, out int bytesWritten);
 120
 0121            if (status == OperationStatus.Done)
 122            {
 0123                return bytesWritten;
 124            }
 125
 0126            if (status == OperationStatus.DestinationTooSmall)
 127            {
 0128                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
 129            }
 130
 0131            Debug.Assert(status is OperationStatus.InvalidData);
 0132            throw new FormatException(SR.Format_BadBase64Char);
 133        }
 134
 135        /// <summary>
 136        /// Decodes the span of UTF-8 encoded text represented as Base64Url into binary data.
 137        /// </summary>
 138        /// <param name="source">The input span which contains UTF-8 encoded text in Base64Url that needs to be decoded.
 139        /// <param name="destination">The output span which contains the result of the operation, i.e. the decoded binar
 140        /// <param name="bytesWritten">When this method returns, contains the number of bytes written into the output sp
 141        /// <returns><see langword="true"/> if bytes decoded successfully, otherwise <see langword="false"/>.</returns>
 142        /// <exception cref="FormatException"><paramref name="source"/> contains an invalid Base64Url character,
 143        /// more than two padding characters, or a non white space character among the padding characters.</exception>
 144        public static bool TryDecodeFromUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten)
 145        {
 678146            OperationStatus status = DecodeFromUtf8(source, destination, out _, out bytesWritten);
 147
 678148            if (status == OperationStatus.InvalidData)
 149            {
 0150                throw new FormatException(SR.Format_BadBase64Char);
 151            }
 152
 678153            Debug.Assert(status is OperationStatus.Done or OperationStatus.DestinationTooSmall);
 678154            return status == OperationStatus.Done;
 155        }
 156
 157        /// <summary>
 158        /// Decodes the span of UTF-8 encoded text represented as Base64Url into binary data.
 159        /// </summary>
 160        /// <param name="source">The input span which contains UTF-8 encoded text in Base64Url that needs to be decoded.
 161        /// <returns>A byte array which contains the result of the decoding operation.</returns>
 162        /// <exception cref="FormatException"><paramref name="source"/> contains an invalid Base64Url character,
 163        /// more than two padding characters, or a non white space character among the padding characters.</exception>
 164        public static unsafe byte[] DecodeFromUtf8(ReadOnlySpan<byte> source)
 165        {
 0166            int upperBound = GetMaxDecodedLength(source.Length);
 0167            byte[]? rented = null;
 168
 0169            Span<byte> destination = (uint)upperBound <= MaxStackallocThreshold
 0170                ? stackalloc byte[MaxStackallocThreshold]
 0171                : (rented = ArrayPool<byte>.Shared.Rent(upperBound));
 172
 0173            OperationStatus status = DecodeFromUtf8(source, destination, out _, out int bytesWritten);
 0174            Debug.Assert(status is OperationStatus.Done or OperationStatus.InvalidData);
 0175            byte[] ret = destination.Slice(0, bytesWritten).ToArray();
 176
 0177            if (rented is not null)
 178            {
 0179                ArrayPool<byte>.Shared.Return(rented);
 180            }
 181
 0182            return status == OperationStatus.Done ? ret : throw new FormatException(SR.Format_BadBase64Char);
 183        }
 184
 185        /// <summary>
 186        /// Decodes the span of unicode ASCII chars represented as Base64Url into binary data.
 187        /// </summary>
 188        /// <param name="source">The input span which contains unicode ASCII chars in Base64Url that needs to be decoded
 189        /// <param name="destination">The output span which contains the result of the operation, i.e. the decoded binar
 190        /// <param name="charsConsumed">When this method returns, contains the number of input chars consumed during the
 191        /// <param name="bytesWritten">When this method returns, contains the number of bytes written into the output sp
 192        /// <param name="isFinalBlock"><see langword="true"/> when the input span contains the entirety of data to decod
 193        /// such as when calling in a loop. Calls with <see langword="false"/> should be followed up with another call w
 194        /// <returns>One of the enumeration values that indicates the success or failure of the operation.</returns>
 195        /// <remarks>
 196        /// As padding is optional for Base64Url the <paramref name="source"/> length not required to be a multiple of 4
 197        /// If the <paramref name="source"/> length is not a multiple of 4 and <paramref name="isFinalBlock"/> is <see l
 198        /// - Remainder of 3 chars - decoded into 2 bytes data, decoding succeeds.
 199        /// - Remainder of 2 chars - decoded into 1 byte data. decoding succeeds.
 200        /// - Remainder of 1 char - will cause OperationStatus.InvalidData result.
 201        /// </remarks>
 202        public static OperationStatus DecodeFromChars(ReadOnlySpan<char> source, Span<byte> destination,
 203            out int charsConsumed, out int bytesWritten, bool isFinalBlock = true) =>
 2870204            DecodeFrom(default(Base64UrlDecoderChar), MemoryMarshal.Cast<char, ushort>(source), destination,
 2870205                out charsConsumed, out bytesWritten, isFinalBlock, ignoreWhiteSpace: true);
 206
 207        /// <summary>
 208        /// Decodes the span of unicode ASCII chars represented as Base64Url into binary data.
 209        /// </summary>
 210        /// <param name="source">The input span which contains ASCII chars in Base64Url that needs to be decoded.</param
 211        /// <param name="destination">The output span which contains the result of the operation, i.e. the decoded binar
 212        /// <returns>The number of bytes written into the output span. This can be used to slice the output for subseque
 213        /// <exception cref="ArgumentException">The buffer in <paramref name="destination"/> is too small to hold the de
 214        /// <exception cref="FormatException"><paramref name="source"/> contains a invalid Base64Url character,
 215        /// more than two padding characters, or a non white space character among the padding characters.</exception>
 216        public static int DecodeFromChars(ReadOnlySpan<char> source, Span<byte> destination)
 217        {
 0218            OperationStatus status = DecodeFromChars(source, destination, out _, out int bytesWritten);
 219
 0220            if (status == OperationStatus.Done)
 221            {
 0222                return bytesWritten;
 223            }
 224
 0225            if (status == OperationStatus.DestinationTooSmall)
 226            {
 0227                throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
 228            }
 229
 0230            Debug.Assert(status == OperationStatus.InvalidData);
 0231            throw new FormatException(SR.Format_BadBase64Char);
 232        }
 233
 234        /// <summary>
 235        /// Decodes the span of unicode ASCII chars represented as Base64Url into binary data.
 236        /// </summary>
 237        /// <param name="source">The input span which contains ASCII chars in Base64Url that needs to be decoded.</param
 238        /// <param name="destination">The output span which contains the result of the operation, i.e. the decoded binar
 239        /// <param name="bytesWritten">When this method returns, contains the number of bytes written into the output sp
 240        /// <returns><see langword="true"/> if bytes decoded successfully, otherwise <see langword="false"/>.</returns>
 241        /// <exception cref="FormatException"><paramref name="source"/> contains an invalid Base64Url character,
 242        /// more than two padding characters, or a non white space character among the padding characters.</exception>
 243        public static bool TryDecodeFromChars(ReadOnlySpan<char> source, Span<byte> destination, out int bytesWritten)
 244        {
 0245            OperationStatus status = DecodeFromChars(source, destination, out _, out bytesWritten);
 246
 0247            if (status == OperationStatus.InvalidData)
 248            {
 0249                throw new FormatException(SR.Format_BadBase64Char);
 250            }
 251
 0252            return status == OperationStatus.Done;
 253        }
 254
 255        /// <summary>
 256        /// Decodes the span of unicode ASCII chars represented as Base64Url into binary data.
 257        /// </summary>
 258        /// <param name="source">The input span which contains ASCII chars in Base64Url that needs to be decoded.</param
 259        /// <returns>A byte array which contains the result of the decoding operation.</returns>
 260        /// <exception cref="FormatException"><paramref name="source"/> contains a invalid Base64Url character,
 261        /// more than two padding characters, or a non white space character among the padding characters.</exception>
 262        public static unsafe byte[] DecodeFromChars(ReadOnlySpan<char> source)
 263        {
 0264            int upperBound = GetMaxDecodedLength(source.Length);
 0265            byte[]? rented = null;
 266
 0267            Span<byte> destination = (uint)upperBound <= MaxStackallocThreshold
 0268                ? stackalloc byte[MaxStackallocThreshold]
 0269                : (rented = ArrayPool<byte>.Shared.Rent(upperBound));
 270
 0271            OperationStatus status = DecodeFromChars(source, destination, out _, out int bytesWritten);
 0272            byte[] ret = destination.Slice(0, bytesWritten).ToArray();
 273
 0274            if (rented is not null)
 275            {
 0276                ArrayPool<byte>.Shared.Return(rented);
 277            }
 278
 0279            return status == OperationStatus.Done ? ret : throw new FormatException(SR.Format_BadBase64Char);
 280        }
 281
 282        private readonly struct Base64UrlDecoderByte : IBase64Decoder<byte>
 283        {
 284            public ReadOnlySpan<sbyte> DecodingMap =>
 127331285                [
 127331286                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 127331287                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 127331288                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1,         //62 is placed at index 45 (
 127331289                    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,         //52-61 are placed at index 
 127331290                    -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
 127331291                    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, 63,         //0-25 are placed at index 6
 127331292                    -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
 127331293                    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,         //26-51 are placed at index 
 127331294                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,         // Bytes over 122 ('z') are 
 127331295                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,         // Hence, padding the map wi
 127331296                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 127331297                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 127331298                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 127331299                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 127331300                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 127331301                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 127331302                ];
 303
 304            public ReadOnlySpan<uint> VbmiLookup0 =>
 0305                [
 0306                    0x80808080, 0x80808080, 0x80808080, 0x80808080,
 0307                    0x80808080, 0x80808080, 0x80808080, 0x80808080,
 0308                    0x80808080, 0x80808080, 0x80808080, 0x80803e80,
 0309                    0x37363534, 0x3b3a3938, 0x80803d3c, 0x80808080
 0310                ];
 311
 312            public ReadOnlySpan<uint> VbmiLookup1 =>
 0313                [
 0314                    0x02010080, 0x06050403, 0x0a090807, 0x0e0d0c0b,
 0315                    0x1211100f, 0x16151413, 0x80191817, 0x3f808080,
 0316                    0x1c1b1a80, 0x201f1e1d, 0x24232221, 0x28272625,
 0317                    0x2c2b2a29, 0x302f2e2d, 0x80333231, 0x80808080
 0318                ];
 319
 320            public ReadOnlySpan<sbyte> Avx2LutHigh =>
 39801321                [
 39801322                    0x00, 0x00, 0x2d, 0x39,
 39801323                    0x4f, 0x5a, 0x6f, 0x7a,
 39801324                    0x00, 0x00, 0x00, 0x00,
 39801325                    0x00, 0x00, 0x00, 0x00,
 39801326                    0x00, 0x00, 0x2d, 0x39,
 39801327                    0x4f, 0x5a, 0x6f, 0x7a,
 39801328                    0x00, 0x00, 0x00, 0x00,
 39801329                    0x00, 0x00, 0x00, 0x00
 39801330                ];
 331
 332            public ReadOnlySpan<sbyte> Avx2LutLow =>
 39801333                [
 39801334                    0x01, 0x01, 0x2d, 0x30,
 39801335                    0x41, 0x50, 0x61, 0x70,
 39801336                    0x01, 0x01, 0x01, 0x01,
 39801337                    0x01, 0x01, 0x01, 0x01,
 39801338                    0x01, 0x01, 0x2d, 0x30,
 39801339                    0x41, 0x50, 0x61, 0x70,
 39801340                    0x01, 0x01, 0x01, 0x01,
 39801341                    0x01, 0x01, 0x01, 0x01
 39801342                ];
 343
 344            public ReadOnlySpan<sbyte> Avx2LutShift =>
 39801345                [
 39801346                    0,   0,  17,   4,
 39801347                  -65, -65, -71, -71,
 39801348                    0,   0,   0,   0,
 39801349                    0,   0,   0,   0,
 39801350                    0,   0,  17,   4,
 39801351                  -65, -65, -71, -71,
 39801352                    0,   0,   0,   0,
 39801353                    0,   0,   0,   0
 39801354                ];
 355
 80868356            public byte MaskSlashOrUnderscore => (byte)'_'; // underscore
 357
 41067358            public ReadOnlySpan<int> Vector128LutHigh => [0x392d0000, 0x7a6f5a4f, 0x00000000, 0x00000000];
 359
 41067360            public ReadOnlySpan<int> Vector128LutLow => [0x302d0101, 0x70615041, 0x01010101, 0x01010101];
 361
 41067362            public ReadOnlySpan<uint> Vector128LutShift => [0x04110000, 0xb9b9bfbf, 0x00000000, 0x00000000];
 363
 0364            public ReadOnlySpan<uint> AdvSimdLutOne3 => [0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFF3EFF];
 365
 0366            public uint AdvSimdLutTwo3Uint1 => 0x1B1AFF3F;
 367
 67424368            public int GetMaxDecodedLength(int sourceLength) => Base64Url.GetMaxDecodedLength(sourceLength);
 369
 59727370            public bool IsInvalidLength(int bufferLength) => (bufferLength & 3) == 1; // One byte cannot be decoded comp
 371
 111251372            public bool IsValidPadding(uint padChar) => padChar is EncodingPad or UrlEncodingPad;
 373
 67424374            public int SrcLength(bool isFinalBlock, int sourceLength) => isFinalBlock ? sourceLength : sourceLength & ~0
 375
 376#if NET
 377            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 378            [CompExactlyDependsOn(typeof(AdvSimd.Arm64))]
 379            [CompExactlyDependsOn(typeof(Ssse3))]
 380            [CompExactlyDependsOn(typeof(PackedSimd))]
 381            public bool TryDecode128Core(
 382                Vector128<byte> str,
 383                Vector128<byte> hiNibbles,
 384                Vector128<byte> maskSlashOrUnderscore,
 385                Vector128<byte> mask8F,
 386                Vector128<byte> lutLow,
 387                Vector128<byte> lutHigh,
 388                Vector128<sbyte> lutShift,
 389                Vector128<byte> shiftForUnderscore,
 390                out Vector128<byte> result)
 391            {
 44250392                Vector128<byte> lowerBound = SimdShuffle(lutLow, hiNibbles, mask8F);
 44250393                Vector128<byte> upperBound = SimdShuffle(lutHigh, hiNibbles, mask8F);
 394
 44250395                Vector128<byte> below = Vector128.LessThan(str, lowerBound);
 44250396                Vector128<byte> above = Vector128.GreaterThan(str, upperBound);
 44250397                Vector128<byte> eq5F = Vector128.Equals(str, maskSlashOrUnderscore);
 398
 399                // Take care as arguments are flipped in order!
 44250400                Vector128<byte> outside = Vector128.AndNot(below | above, eq5F);
 401
 44250402                if (outside != Vector128<byte>.Zero)
 403                {
 38827404                    result = default;
 38827405                    return false;
 406                }
 407
 5423408                Vector128<byte> shift = SimdShuffle(lutShift.AsByte(), hiNibbles, mask8F);
 5423409                str += shift;
 410
 5423411                result = str + (eq5F & shiftForUnderscore);
 5423412                return true;
 413            }
 414
 415            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 416            [CompExactlyDependsOn(typeof(Avx2))]
 417            public bool TryDecode256Core(
 418                Vector256<sbyte> str,
 419                Vector256<sbyte> hiNibbles,
 420                Vector256<sbyte> maskSlashOrUnderscore,
 421                Vector256<sbyte> lutLow,
 422                Vector256<sbyte> lutHigh,
 423                Vector256<sbyte> lutShift,
 424                Vector256<sbyte> shiftForUnderscore,
 425                out Vector256<sbyte> result)
 426            {
 85453427                Vector256<sbyte> lowerBound = Avx2.Shuffle(lutLow, hiNibbles);
 85453428                Vector256<sbyte> upperBound = Avx2.Shuffle(lutHigh, hiNibbles);
 429
 85453430                Vector256<sbyte> below = Vector256.LessThan(str, lowerBound);
 85453431                Vector256<sbyte> above = Vector256.GreaterThan(str, upperBound);
 85453432                Vector256<sbyte> eq5F = Vector256.Equals(str, maskSlashOrUnderscore);
 433
 434                // Take care as arguments are flipped in order!
 85453435                Vector256<sbyte> outside = Vector256.AndNot(below | above, eq5F);
 436
 85453437                if (outside != Vector256<sbyte>.Zero)
 438                {
 37197439                    result = default;
 37197440                    return false;
 441                }
 442
 48256443                Vector256<sbyte> shift = Avx2.Shuffle(lutShift, hiNibbles);
 48256444                str += shift;
 445
 48256446                result = str + (eq5F & shiftForUnderscore);
 48256447                return true;
 448            }
 449
 450            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 451            public unsafe bool TryLoadVector512(byte* src, byte* srcStart, int sourceLength, out Vector512<sbyte> str) =
 0452                default(Base64DecoderByte).TryLoadVector512(src, srcStart, sourceLength, out str);
 453
 454            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 455            [CompExactlyDependsOn(typeof(Avx2))]
 456            public unsafe bool TryLoadAvxVector256(byte* src, byte* srcStart, int sourceLength, out Vector256<sbyte> str
 55135457                default(Base64DecoderByte).TryLoadAvxVector256(src, srcStart, sourceLength, out str);
 458
 459            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 460            public unsafe bool TryLoadVector128(byte* src, byte* srcStart, int sourceLength, out Vector128<byte> str) =>
 42266461                default(Base64DecoderByte).TryLoadVector128(src, srcStart, sourceLength, out str);
 462
 463            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 464            [CompExactlyDependsOn(typeof(AdvSimd.Arm64))]
 465            public unsafe bool TryLoadArmVector128x4(byte* src, byte* srcStart, int sourceLength,
 466                out Vector128<byte> str1, out Vector128<byte> str2, out Vector128<byte> str3, out Vector128<byte> str4) 
 0467                default(Base64DecoderByte).TryLoadArmVector128x4(src, srcStart, sourceLength, out str1, out str2, out st
 468#endif // NET
 469
 470            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 471            public unsafe int DecodeFourElements(byte* source, ref sbyte decodingMap) =>
 106420472                default(Base64DecoderByte).DecodeFourElements(source, ref decodingMap);
 473
 474            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 475            public unsafe int DecodeRemaining(byte* srcEnd, ref sbyte decodingMap, long remaining, out uint t2, out uint
 1986476                default(Base64DecoderByte).DecodeRemaining(srcEnd, ref decodingMap, remaining, out t2, out t3);
 477
 478            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 39833479            public int IndexOfAnyExceptWhiteSpace(ReadOnlySpan<byte> span) => default(Base64DecoderByte).IndexOfAnyExcep
 480
 481            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 482            [SuppressReadyToRunCanonicalRooting]
 483            public OperationStatus DecodeWithWhiteSpaceBlockwiseWrapper<TBase64Decoder>(TBase64Decoder decoder, ReadOnly
 484                ref int bytesConsumed, ref int bytesWritten, bool isFinalBlock = true) where TBase64Decoder : IBase64Dec
 1717485                DecodeWithWhiteSpaceBlockwise(decoder, utf8, bytes, ref bytesConsumed, ref bytesWritten, isFinalBlock);
 486        }
 487
 488        private readonly struct Base64UrlDecoderChar : IBase64Decoder<ushort>
 489        {
 2832490            public ReadOnlySpan<sbyte> DecodingMap => default(Base64UrlDecoderByte).DecodingMap;
 491
 0492            public ReadOnlySpan<uint> VbmiLookup0 => default(Base64UrlDecoderByte).VbmiLookup0;
 493
 0494            public ReadOnlySpan<uint> VbmiLookup1 => default(Base64UrlDecoderByte).VbmiLookup1;
 495
 1632496            public ReadOnlySpan<sbyte> Avx2LutHigh => default(Base64UrlDecoderByte).Avx2LutHigh;
 497
 1632498            public ReadOnlySpan<sbyte> Avx2LutLow => default(Base64UrlDecoderByte).Avx2LutLow;
 499
 1632500            public ReadOnlySpan<sbyte> Avx2LutShift => default(Base64UrlDecoderByte).Avx2LutShift;
 501
 3078502            public byte MaskSlashOrUnderscore => default(Base64UrlDecoderByte).MaskSlashOrUnderscore;
 503
 1446504            public ReadOnlySpan<int> Vector128LutHigh => default(Base64UrlDecoderByte).Vector128LutHigh;
 505
 1446506            public ReadOnlySpan<int> Vector128LutLow => default(Base64UrlDecoderByte).Vector128LutLow;
 507
 1446508            public ReadOnlySpan<uint> Vector128LutShift => default(Base64UrlDecoderByte).Vector128LutShift;
 509
 0510            public ReadOnlySpan<uint> AdvSimdLutOne3 => default(Base64UrlDecoderByte).AdvSimdLutOne3;
 511
 0512            public uint AdvSimdLutTwo3Uint1 => default(Base64UrlDecoderByte).AdvSimdLutTwo3Uint1;
 513
 2832514            public int GetMaxDecodedLength(int sourceLength) => default(Base64UrlDecoderByte).GetMaxDecodedLength(source
 515
 0516            public bool IsInvalidLength(int bufferLength) => default(Base64UrlDecoderByte).IsInvalidLength(bufferLength)
 517
 2321518            public bool IsValidPadding(uint padChar) => default(Base64UrlDecoderByte).IsValidPadding(padChar);
 519
 2832520            public int SrcLength(bool isFinalBlock, int sourceLength) => default(Base64UrlDecoderByte).SrcLength(isFinal
 521
 522#if NET
 523            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 524            [CompExactlyDependsOn(typeof(AdvSimd.Arm64))]
 525            [CompExactlyDependsOn(typeof(Ssse3))]
 526            [CompExactlyDependsOn(typeof(PackedSimd))]
 527            public bool TryDecode128Core(Vector128<byte> str, Vector128<byte> hiNibbles, Vector128<byte> maskSlashOrUnde
 528                Vector128<byte> lutLow, Vector128<byte> lutHigh, Vector128<sbyte> lutShift, Vector128<byte> shiftForUnde
 1984529                default(Base64UrlDecoderByte).TryDecode128Core(str, hiNibbles, maskSlashOrUnderscore, mask8F, lutLow, lu
 530
 531            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 532            [CompExactlyDependsOn(typeof(Avx2))]
 533            public bool TryDecode256Core(Vector256<sbyte> str, Vector256<sbyte> hiNibbles, Vector256<sbyte> maskSlashOrU
 534                Vector256<sbyte> lutHigh, Vector256<sbyte> lutShift, Vector256<sbyte> shiftForUnderscore, out Vector256<
 30318535                default(Base64UrlDecoderByte).TryDecode256Core(str, hiNibbles, maskSlashOrUnderscore, lutLow, lutHigh, l
 536
 537            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 538            public unsafe bool TryLoadVector512(ushort* src, ushort* srcStart, int sourceLength, out Vector512<sbyte> st
 0539                default(Base64DecoderChar).TryLoadVector512(src, srcStart, sourceLength, out str);
 540
 541            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 542            [CompExactlyDependsOn(typeof(Avx2))]
 543            public unsafe bool TryLoadAvxVector256(ushort* src, ushort* srcStart, int sourceLength, out Vector256<sbyte>
 30318544                default(Base64DecoderChar).TryLoadAvxVector256(src, srcStart, sourceLength, out str);
 545
 546            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 547            public unsafe bool TryLoadVector128(ushort* src, ushort* srcStart, int sourceLength, out Vector128<byte> str
 1984548                default(Base64DecoderChar).TryLoadVector128(src, srcStart, sourceLength, out str);
 549
 550            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 551            [CompExactlyDependsOn(typeof(AdvSimd.Arm64))]
 552            public unsafe bool TryLoadArmVector128x4(ushort* src, ushort* srcStart, int sourceLength,
 553                out Vector128<byte> str1, out Vector128<byte> str2, out Vector128<byte> str3, out Vector128<byte> str4) 
 0554                default(Base64DecoderChar).TryLoadArmVector128x4(src, srcStart, sourceLength, out str1, out str2, out st
 555#endif // NET
 556
 557            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 558            public unsafe int DecodeFourElements(ushort* source, ref sbyte decodingMap) =>
 7959559                default(Base64DecoderChar).DecodeFourElements(source, ref decodingMap);
 560
 561            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 562            public unsafe int DecodeRemaining(ushort* srcEnd, ref sbyte decodingMap, long remaining, out uint t2, out ui
 1435563                default(Base64DecoderChar).DecodeRemaining(srcEnd, ref decodingMap, remaining, out t2, out t3);
 564
 565            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 0566            public int IndexOfAnyExceptWhiteSpace(ReadOnlySpan<ushort> span) => default(Base64DecoderChar).IndexOfAnyExc
 567
 568            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 569            [SuppressReadyToRunCanonicalRooting]
 570            public OperationStatus DecodeWithWhiteSpaceBlockwiseWrapper<TBase64Decoder>(TBase64Decoder decoder, ReadOnly
 571                ref int bytesConsumed, ref int bytesWritten, bool isFinalBlock = true) where TBase64Decoder : IBase64Dec
 0572                DecodeWithWhiteSpaceBlockwise(decoder, source, bytes, ref bytesConsumed, ref bytesWritten, isFinalBlock)
 573        }
 574    }
 575}

D:\runner\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Url\Base64UrlEncoder.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System.Diagnostics;
 5using System.Diagnostics.CodeAnalysis;
 6using System.Runtime.CompilerServices;
 7using System.Runtime.InteropServices;
 8#if NET
 9using System.Runtime.Intrinsics;
 10using System.Runtime.Intrinsics.Arm;
 11using System.Runtime.Intrinsics.X86;
 12#endif
 13using static System.Buffers.Text.Base64Helper;
 14
 15namespace System.Buffers.Text
 16{
 17    public static partial class Base64Url
 18    {
 19        /// <summary>
 20        /// Encodes the span of binary data into UTF-8 encoded text represented as Base64Url.
 21        /// </summary>
 22        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 23        /// <param name="destination">The output span which contains the result of the operation, i.e. the UTF-8 encoded
 24        /// <param name="bytesConsumed">When this method returns, contains the number of input bytes consumed during the
 25        /// <param name="bytesWritten">When this method returns, contains the number of bytes written into the output sp
 26        /// <param name="isFinalBlock"><see langword="true"/> when the input span contains the entirety of data to encod
 27        /// such as when calling in a loop, subsequent calls with <see langword="false"/> should end with <see langword=
 28        /// <returns>One of the enumeration values that indicates the success or failure of the operation.</returns>
 29        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 30        public static OperationStatus EncodeToUtf8(ReadOnlySpan<byte> source,
 31            Span<byte> destination, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true) =>
 032            EncodeTo(default(Base64UrlEncoderByte), source, destination, out bytesConsumed, out bytesWritten, isFinalBlo
 33
 34        /// <summary>
 35        /// Returns the number of characters required to encode
 36        /// <paramref name="bytesLength"/> bytes to Base64Url.
 37        /// </summary>
 38        /// <remarks>
 39        /// Because the Base64Url characters are all in the 7-bit ASCII range,
 40        /// the number of characters is equal both to the number of
 41        /// <see cref="char"/> values written by methods like
 42        /// <see cref="EncodeToChars(ReadOnlySpan{byte}, Span{char})"/>
 43        /// and the number of <see cref="byte"/> values written by UTF-8 methods like
 44        /// <see cref="EncodeToUtf8(ReadOnlySpan{byte}, Span{byte})"/>.
 45        /// </remarks>
 46        /// <exception cref="ArgumentOutOfRangeException">
 47        /// <paramref name="bytesLength"/> is less than 0 or greater than 1610612733.
 48        /// </exception>
 49        public static int GetEncodedLength(int bytesLength)
 50        {
 51#if NET
 861052            ArgumentOutOfRangeException.ThrowIfGreaterThan<uint>((uint)bytesLength, MaximumEncodeLength);
 53
 861054            (uint whole, uint remainder) = uint.DivRem((uint)bytesLength, 3);
 55
 861056            return (int)(whole * 4 + (remainder > 0 ? remainder + 1 : 0)); // if remainder is 1 or 2, the encoded length
 57#else
 58            if ((uint)bytesLength > MaximumEncodeLength)
 59            {
 60                throw new ArgumentOutOfRangeException(nameof(bytesLength));
 61            }
 62
 63            int remainder = (int)((uint)bytesLength % 3);
 64
 65            return (bytesLength / 3) * 4 + (remainder > 0 ? remainder + 1 : 0);
 66#endif
 67        }
 68
 69        /// <summary>
 70        /// Encodes the span of binary data into UTF-8 encoded text represented as Base64Url.
 71        /// </summary>
 72        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 73        /// <param name="destination">The output span which contains the result of the operation, i.e. the UTF-8 encoded
 74        /// <returns>The number of bytes written into the destination span. This can be used to slice the output for sub
 75        /// <exception cref="ArgumentException">The buffer in <paramref name="destination"/> is too small to hold the en
 76        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 77        public static int EncodeToUtf8(ReadOnlySpan<byte> source, Span<byte> destination)
 78        {
 079            OperationStatus status = EncodeToUtf8(source, destination, out _, out int bytesWritten);
 80
 081            if (status == OperationStatus.Done)
 82            {
 083                return bytesWritten;
 84            }
 85
 086            Debug.Assert(status == OperationStatus.DestinationTooSmall);
 087            throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
 88        }
 89
 90        /// <summary>
 91        /// Encodes the span of binary data into UTF-8 encoded text represented as Base64Url.
 92        /// </summary>
 93        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 94        /// <returns>The output byte array which contains the result of the operation, i.e. the UTF-8 encoded text in Ba
 95        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 96        public static byte[] EncodeToUtf8(ReadOnlySpan<byte> source)
 97        {
 098            byte[] destination = new byte[GetEncodedLength(source.Length)];
 099            EncodeToUtf8(source, destination, out _, out int bytesWritten);
 0100            Debug.Assert(destination.Length == bytesWritten);
 101
 0102            return destination;
 103        }
 104
 105        /// <summary>
 106        /// Encodes the span of binary data into unicode ASCII chars represented as Base64Url.
 107        /// </summary>
 108        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 109        /// <param name="destination">The output span which contains the result of the operation, i.e. the ASCII chars i
 110        /// <param name="bytesConsumed">When this method returns, contains the number of input bytes consumed during the
 111        /// <param name="charsWritten">When this method returns, contains the number of chars written into the output sp
 112        /// <param name="isFinalBlock"><see langword="true"/> when the input span contains the entirety of data to encod
 113        /// such as when calling in a loop, subsequent calls with <see langword="false"/> should end with <see langword=
 114        /// <returns>One of the enumeration values that indicates the success or failure of the operation.</returns>
 115        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 116        public static OperationStatus EncodeToChars(ReadOnlySpan<byte> source, Span<char> destination,
 117            out int bytesConsumed, out int charsWritten, bool isFinalBlock = true) =>
 4305118            EncodeTo(default(Base64UrlEncoderChar), source, MemoryMarshal.Cast<char, ushort>(destination), out bytesCons
 119
 120        /// <summary>
 121        /// Encodes the span of binary data into unicode ASCII chars represented as Base64Url.
 122        /// </summary>
 123        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 124        /// <param name="destination">The output span which contains the result of the operation, i.e. the ASCII chars i
 125        /// <returns>The number of chars written into the destination span. This can be used to slice the output for sub
 126        /// <exception cref="ArgumentException">The buffer in <paramref name="destination"/> is too small to hold the en
 127        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 128        public static int EncodeToChars(ReadOnlySpan<byte> source, Span<char> destination)
 129        {
 0130            OperationStatus status = EncodeToChars(source, destination, out _, out int charsWritten);
 131
 0132            if (status == OperationStatus.Done)
 133            {
 0134                return charsWritten;
 135            }
 136
 0137            Debug.Assert(status == OperationStatus.DestinationTooSmall);
 0138            throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(destination));
 139        }
 140
 141        /// <summary>
 142        /// Encodes the span of binary data into unicode ASCII chars represented as Base64Url.
 143        /// </summary>
 144        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 145        /// <returns>A char array which contains the result of the operation, i.e. the ASCII chars in Base64Url.</return
 146        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 147        public static char[] EncodeToChars(ReadOnlySpan<byte> source)
 148        {
 0149            char[] destination = new char[GetEncodedLength(source.Length)];
 0150            EncodeToChars(source, destination, out _, out int charsWritten);
 0151            Debug.Assert(destination.Length == charsWritten);
 152
 0153            return destination;
 154        }
 155
 156        /// <summary>
 157        /// Encodes the span of binary data into unicode string represented as Base64Url ASCII chars.
 158        /// </summary>
 159        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 160        /// <returns>A string which contains the result of the operation, i.e. the ASCII string in Base64Url.</returns>
 161        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 162        public static unsafe string EncodeToString(ReadOnlySpan<byte> source)
 163        {
 164#if NET
 1435165            int encodedLength = GetEncodedLength(source.Length);
 166
 1435167            return string.Create(encodedLength, (IntPtr)(&source), static (buffer, spanPtr) =>
 1435168            {
 1435169                ReadOnlySpan<byte> source = *(ReadOnlySpan<byte>*)spanPtr;
 1435170                EncodeToChars(source, buffer, out _, out int charsWritten);
 1435171                Debug.Assert(buffer.Length == charsWritten, $"The source length: {source.Length}, bytes written: {charsW
 2870172            });
 173#else
 174            char[] destination = new char[GetEncodedLength(source.Length)];
 175            EncodeToChars(source, destination, out _, out int charsWritten);
 176            Debug.Assert(destination.Length == charsWritten);
 177
 178            return new string(destination);
 179#endif
 180        }
 181
 182        /// <summary>
 183        /// Encodes the span of binary data into unicode ASCII chars represented as Base64Url.
 184        /// </summary>
 185        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 186        /// <param name="destination">The output span which contains the result of the operation, i.e. the ASCII chars i
 187        /// <param name="charsWritten">When this method returns, contains the number of chars written into the output sp
 188        /// <returns><see langword="true"/> if chars encoded successfully, otherwise <see langword="false"/>.</returns>
 189        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 190        public static bool TryEncodeToChars(ReadOnlySpan<byte> source, Span<char> destination, out int charsWritten)
 191        {
 0192            OperationStatus status = EncodeToChars(source, destination, out _, out charsWritten);
 193
 0194            return status == OperationStatus.Done;
 195        }
 196
 197        /// <summary>
 198        /// Encodes the span of binary data into UTF-8 encoded text represented as Base64Url.
 199        /// </summary>
 200        /// <param name="source">The input span which contains binary data that needs to be encoded.</param>
 201        /// <param name="destination">The output span which contains the result of the operation, i.e. the UTF-8 encoded
 202        /// <param name="bytesWritten">When this method returns, contains the number of bytes written into the output sp
 203        /// <returns><see langword="true"/> if bytes encoded successfully, otherwise <see langword="false"/>.</returns>
 204        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 205        public static bool TryEncodeToUtf8(ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten)
 206        {
 0207            OperationStatus status = EncodeToUtf8(source, destination, out _, out bytesWritten);
 208
 0209            return status == OperationStatus.Done;
 210        }
 211
 212        /// <summary>
 213        /// Encodes the span of binary data (in-place) into UTF-8 encoded text represented as Base64Url.
 214        /// The encoded text output is larger than the binary data contained in the input (the operation inflates the da
 215        /// </summary>
 216        /// <param name="buffer">The input span which contains binary data that needs to be encoded.
 217        /// It needs to be large enough to fit the result of the operation.</param>
 218        /// <param name="dataLength">The amount of binary data contained within the buffer that needs to be encoded
 219        /// (and needs to be smaller than the buffer length).</param>
 220        /// <param name="bytesWritten">When this method returns, contains the number of bytes written into the buffer. T
 221        /// <returns><see langword="true"/> if bytes encoded successfully, otherwise <see langword="false"/>.</returns>
 222        /// <remarks>This implementation of the base64url encoding omits the optional padding characters.</remarks>
 223        public static bool TryEncodeToUtf8InPlace(Span<byte> buffer, int dataLength, out int bytesWritten)
 224        {
 1435225            OperationStatus status = EncodeToUtf8InPlace(default(Base64UrlEncoderByte), buffer, dataLength, out bytesWri
 226
 1435227            return status == OperationStatus.Done;
 228        }
 229
 230        private readonly struct Base64UrlEncoderByte : Base64Helper.IBase64Encoder<byte>
 231        {
 5741232            public ReadOnlySpan<byte> EncodingMap => "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"u
 233
 5082234            public sbyte Avx2LutChar62 => -17;  // char '-' diff
 235
 5082236            public sbyte Avx2LutChar63 => 32;   // char '_' diff
 237
 0238            public ReadOnlySpan<byte> AdvSimdLut4 => "wxyz0123456789-_"u8;
 239
 1506240            public uint Ssse3AdvSimdLutE3 => 0x000020EF;
 241
 1008242            public int IncrementPadTwo => 2;
 243
 764244            public int IncrementPadOne => 3;
 245
 246            public int GetMaxSrcLength(int srcLength, int destLength) =>
 4305247                srcLength <= MaximumEncodeLength && destLength >= GetEncodedLength(srcLength) ?
 4305248                srcLength : GetMaxDecodedLength(destLength);
 249
 250            public uint GetInPlaceDestinationLength(int encodedLength, int leftOver) =>
 1435251                leftOver > 0 ? (uint)(encodedLength - leftOver - 1) : (uint)(encodedLength - 4);
 252
 1435253            public int GetMaxEncodedLength(int srcLength) => GetEncodedLength(srcLength);
 254
 255            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 256            public unsafe void EncodeOneOptionallyPadTwo(byte* oneByte, byte* dest, ref byte encodingMap)
 257            {
 258                uint t0 = oneByte[0];
 259
 504260                uint i = t0 << 8;
 261
 504262                byte i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 10));
 504263                byte i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 4) & 0x3F));
 264
 265                ushort result;
 266
 504267                if (BitConverter.IsLittleEndian)
 268                {
 504269                    result = (ushort)(i0 | (i1 << 8));
 270                }
 271                else
 272                {
 273                    result = (ushort)((i0 << 8) | i1);
 274                }
 275
 504276                Unsafe.WriteUnaligned(dest, result);
 504277            }
 278
 279            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 280            public unsafe void EncodeTwoOptionallyPadOne(byte* twoBytes, byte* dest, ref byte encodingMap)
 281            {
 382282                uint t0 = twoBytes[0];
 382283                uint t1 = twoBytes[1];
 284
 382285                uint i = (t0 << 16) | (t1 << 8);
 286
 382287                byte i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 18));
 382288                byte i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 12) & 0x3F));
 382289                byte i2 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 6) & 0x3F));
 290
 382291                dest[0] = i0;
 382292                dest[1] = i1;
 382293                dest[2] = i2;
 382294            }
 295
 296#if NET
 297            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 298            public unsafe void StoreVector512ToDestination(byte* dest, byte* destStart, int destLength, Vector512<byte> 
 0299                default(Base64EncoderByte).StoreVector512ToDestination(dest, destStart, destLength, str);
 300
 301            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 302            [CompExactlyDependsOn(typeof(Avx2))]
 303            public unsafe void StoreVector256ToDestination(byte* dest, byte* destStart, int destLength, Vector256<byte> 
 0304                default(Base64EncoderByte).StoreVector256ToDestination(dest, destStart, destLength, str);
 305
 306            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 307            public unsafe void StoreVector128ToDestination(byte* dest, byte* destStart, int destLength, Vector128<byte> 
 0308                default(Base64EncoderByte).StoreVector128ToDestination(dest, destStart, destLength, str);
 309
 310            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 311            [CompExactlyDependsOn(typeof(AdvSimd.Arm64))]
 312            public unsafe void StoreArmVector128x4ToDestination(byte* dest, byte* destStart, int destLength,
 313                Vector128<byte> res1, Vector128<byte> res2, Vector128<byte> res3, Vector128<byte> res4) =>
 0314                default(Base64EncoderByte).StoreArmVector128x4ToDestination(dest, destStart, destLength, res1, res2, res
 315#endif // NET
 316
 317            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 318            public unsafe void EncodeThreeAndWrite(byte* threeBytes, byte* destination, ref byte encodingMap) =>
 0319                default(Base64EncoderByte).EncodeThreeAndWrite(threeBytes, destination, ref encodingMap);
 320        }
 321
 322        private readonly struct Base64UrlEncoderChar : IBase64Encoder<ushort>
 323        {
 4305324            public ReadOnlySpan<byte> EncodingMap => default(Base64UrlEncoderByte).EncodingMap;
 325
 5082326            public sbyte Avx2LutChar62 => default(Base64UrlEncoderByte).Avx2LutChar62;
 327
 5082328            public sbyte Avx2LutChar63 => default(Base64UrlEncoderByte).Avx2LutChar63;
 329
 0330            public ReadOnlySpan<byte> AdvSimdLut4 => default(Base64UrlEncoderByte).AdvSimdLut4;
 331
 1506332            public uint Ssse3AdvSimdLutE3 => default(Base64UrlEncoderByte).Ssse3AdvSimdLutE3;
 333
 1008334            public int IncrementPadTwo => default(Base64UrlEncoderByte).IncrementPadTwo;
 335
 764336            public int IncrementPadOne => default(Base64UrlEncoderByte).IncrementPadOne;
 337
 338            public int GetMaxSrcLength(int srcLength, int destLength) =>
 4305339                default(Base64UrlEncoderByte).GetMaxSrcLength(srcLength, destLength);
 340
 0341            public uint GetInPlaceDestinationLength(int encodedLength, int _) => 0; // not used for char encoding
 342
 0343            public int GetMaxEncodedLength(int _) => 0;  // not used for char encoding
 344
 345            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 346            public unsafe void EncodeOneOptionallyPadTwo(byte* oneByte, ushort* dest, ref byte encodingMap) =>
 1008347                Base64Helper.EncodeOneOptionallyPadTwo(oneByte, dest, ref encodingMap);
 348
 349            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 350            public unsafe void EncodeTwoOptionallyPadOne(byte* twoBytes, ushort* dest, ref byte encodingMap) =>
 764351                Base64Helper.EncodeTwoOptionallyPadOne(twoBytes, dest, ref encodingMap);
 352
 353#if NET
 354            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 355            public unsafe void StoreVector512ToDestination(ushort* dest, ushort* destStart, int destLength, Vector512<by
 0356                default(Base64EncoderChar).StoreVector512ToDestination(dest, destStart, destLength, str);
 357
 358            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 359            public unsafe void StoreVector256ToDestination(ushort* dest, ushort* destStart, int destLength, Vector256<by
 46440360                default(Base64EncoderChar).StoreVector256ToDestination(dest, destStart, destLength, str);
 361
 362            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 363            public unsafe void StoreVector128ToDestination(ushort* dest, ushort* destStart, int destLength, Vector128<by
 1608364                default(Base64EncoderChar).StoreVector128ToDestination(dest, destStart, destLength, str);
 365
 366            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 367            [CompExactlyDependsOn(typeof(AdvSimd.Arm64))]
 368            public unsafe void StoreArmVector128x4ToDestination(ushort* dest, ushort* destStart, int destLength,
 369                Vector128<byte> res1, Vector128<byte> res2, Vector128<byte> res3, Vector128<byte> res4) =>
 0370                default(Base64EncoderChar).StoreArmVector128x4ToDestination(dest, destStart, destLength, res1, res2, res
 371#endif // NET
 372
 373            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 374            public unsafe void EncodeThreeAndWrite(byte* threeBytes, ushort* destination, ref byte encodingMap) =>
 10530375                default(Base64EncoderChar).EncodeThreeAndWrite(threeBytes, destination, ref encodingMap);
 376        }
 377    }
 378}

D:\runner\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Url\Base64UrlValidator.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System.Diagnostics;
 5using System.Runtime.CompilerServices;
 6
 7namespace System.Buffers.Text
 8{
 9    public static partial class Base64Url
 10    {
 11        /// <summary>Validates that the specified span of text is comprised of valid Base64Url-encoded data.</summary>
 12        /// <param name="base64UrlText">A span of text to validate.</param>
 13        /// <returns><see langword="true"/> if <paramref name="base64UrlText"/> contains a valid, decodable sequence of 
 14        /// <remarks>
 15        /// If the method returns <see langword="true"/>, the same text passed to <see cref="Base64Url.DecodeFromChars(R
 16        /// <see cref="Base64Url.TryDecodeFromChars(ReadOnlySpan{char}, Span{byte}, out int)"/> would successfully decod
 17        /// of <see cref="Base64Url.TryDecodeFromChars(ReadOnlySpan{char}, Span{byte}, out int)"/> assuming sufficient o
 18        /// Any amount of whitespace is allowed anywhere in the input, where whitespace is defined as the characters ' '
 19        /// </remarks>
 20        public static bool IsValid(ReadOnlySpan<char> base64UrlText) =>
 021            Base64Helper.IsValid(default(Base64UrlCharValidatable), base64UrlText, out _);
 22
 23        /// <summary>Validates that the specified span of text is comprised of valid Base64Url-encoded data.</summary>
 24        /// <param name="base64UrlText">A span of text to validate.</param>
 25        /// <param name="decodedLength">If the method returns true, the number of decoded bytes that will result from de
 26        /// <returns><see langword="true"/> if <paramref name="base64UrlText"/> contains a valid, decodable sequence of 
 27        /// <remarks>
 28        /// If the method returns <see langword="true"/>, the same text passed to <see cref="Base64Url.DecodeFromChars(R
 29        /// <see cref="Base64Url.TryDecodeFromChars(ReadOnlySpan{char}, Span{byte}, out int)"/> would successfully decod
 30        /// of <see cref="Base64Url.TryDecodeFromChars(ReadOnlySpan{char}, Span{byte}, out int)"/> assuming sufficient o
 31        /// Any amount of whitespace is allowed anywhere in the input, where whitespace is defined as the characters ' '
 32        /// </remarks>
 33        public static bool IsValid(ReadOnlySpan<char> base64UrlText, out int decodedLength) =>
 034            Base64Helper.IsValid(default(Base64UrlCharValidatable), base64UrlText, out decodedLength);
 35
 36        /// <summary>Validates that the specified span of UTF-8 text is comprised of valid Base64Url-encoded data.</summ
 37        /// <param name="utf8Base64UrlText">A span of UTF-8 text to validate.</param>
 38        /// <returns><see langword="true"/> if <paramref name="utf8Base64UrlText"/> contains a valid, decodable sequence
 39        /// <remarks>
 40        /// where whitespace is defined as the characters ' ', '\t', '\r', or '\n' (as bytes).
 41        /// </remarks>
 42        public static bool IsValid(ReadOnlySpan<byte> utf8Base64UrlText) =>
 043            Base64Helper.IsValid(default(Base64UrlByteValidatable), utf8Base64UrlText, out _);
 44
 45        /// <summary>Validates that the specified span of UTF-8 text is comprised of valid Base64Url-encoded data.</summ
 46        /// <param name="utf8Base64UrlText">A span of UTF-8 text to validate.</param>
 47        /// <param name="decodedLength">If the method returns true, the number of decoded bytes that will result from de
 48        /// <returns><see langword="true"/> if <paramref name="utf8Base64UrlText"/> contains a valid, decodable sequence
 49        /// <remarks>
 50        /// where whitespace is defined as the characters ' ', '\t', '\r', or '\n' (as bytes).
 51        /// </remarks>
 52        public static bool IsValid(ReadOnlySpan<byte> utf8Base64UrlText, out int decodedLength) =>
 143553            Base64Helper.IsValid(default(Base64UrlByteValidatable), utf8Base64UrlText, out decodedLength);
 54
 55        private const uint UrlEncodingPad = '%'; // allowed for url padding
 56
 57        private readonly struct Base64UrlCharValidatable : Base64Helper.IBase64Validatable<char>
 58        {
 59#if NET
 060            private static readonly SearchValues<char> s_validBase64UrlChars = SearchValues.Create("ABCDEFGHIJKLMNOPQRST
 61
 062            public int IndexOfAnyExcept(ReadOnlySpan<char> span) => span.IndexOfAnyExcept(s_validBase64UrlChars);
 63#else
 64            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 65            public int DecodeValue(char value)
 66            {
 67                if (value > byte.MaxValue)
 68                {
 69                    // Invalid char was found.
 70                    return -2;
 71                }
 72
 73                return default(Base64UrlDecoderByte).DecodingMap[value];
 74            }
 75#endif
 076            public bool IsWhiteSpace(char value) => Base64Helper.IsWhiteSpace(value);
 077            public bool IsEncodingPad(char value) => value == Base64Helper.EncodingPad || value == UrlEncodingPad;
 78            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 79            public bool ValidateAndDecodeLength(char lastChar, int length, int paddingCount, out int decodedLength) =>
 080                default(Base64UrlByteValidatable).ValidateAndDecodeLength((byte)lastChar, length, paddingCount, out deco
 81        }
 82
 83        private readonly struct Base64UrlByteValidatable : Base64Helper.IBase64Validatable<byte>
 84        {
 85#if NET
 186            private static readonly SearchValues<byte> s_validBase64UrlChars = SearchValues.Create(default(Base64UrlEnco
 87
 3121088            public int IndexOfAnyExcept(ReadOnlySpan<byte> span) => span.IndexOfAnyExcept(s_validBase64UrlChars);
 89#else
 90            public int DecodeValue(byte value) => default(Base64UrlDecoderByte).DecodingMap[value];
 91#endif
 9678292            public bool IsWhiteSpace(byte value) => Base64Helper.IsWhiteSpace(value);
 594293            public bool IsEncodingPad(byte value) => value == Base64Helper.EncodingPad || value == UrlEncodingPad;
 94            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 95            public bool ValidateAndDecodeLength(byte lastChar, int length, int paddingCount, out int decodedLength)
 96            {
 97                // Padding is optional for Base64Url, so need to account remainder.
 91798                int remainder = (int)((uint)length % 4);
 99
 917100                if (paddingCount != 0)
 101                {
 147102                    length -= paddingCount;
 147103                    remainder = (int)((uint)length % 4);
 104
 105                    // if there is a padding, there should be remainder and the sum of remainder and padding should not 
 147106                    if (remainder == 0 || remainder + paddingCount > 4)
 107                    {
 69108                        decodedLength = 0;
 69109                        return false;
 110                    }
 111                }
 112
 848113                decodedLength = (length >> 2) * 3 + (remainder > 0 ? remainder - 1 : 0);
 114
 848115                if (remainder > 0)
 116                {
 493117                    int decoded = default(Base64UrlDecoderByte).DecodingMap[lastChar];
 118                    switch (remainder)
 119                    {
 77120                        case 1: return false; // 1 byte is not decodable => invalid.
 174121                        case 2: return ((decoded & 0x0F) == 0); // if unused lower 4 bits are set to 0
 242122                        case 3: return ((decoded & 0x03) == 0); // if unused lower 2 bits are set to 0
 123                    }
 124                }
 125
 355126                return true;
 127            }
 128        }
 129    }
 130}
Generated by: ReportGenerator 5.5.12.0
10/31/2026 - 12:15:09 PM
GitHub | reportgenerator.io

Methods/Properties

GetMaxDecodedLength(System.Int32)
DecodeFromUtf8(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Byte>,System.Int32&,System.Int32&,System.Boolean)
DecodeFromUtf8InPlace(System.Span`1<System.Byte>)
DecodeFromUtf8(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Byte>)
TryDecodeFromUtf8(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Byte>,System.Int32&)
DecodeFromUtf8(System.ReadOnlySpan`1<System.Byte>)
DecodeFromChars(System.ReadOnlySpan`1<System.Char>,System.Span`1<System.Byte>,System.Int32&,System.Int32&,System.Boolean)
DecodeFromChars(System.ReadOnlySpan`1<System.Char>,System.Span`1<System.Byte>)
TryDecodeFromChars(System.ReadOnlySpan`1<System.Char>,System.Span`1<System.Byte>,System.Int32&)
DecodeFromChars(System.ReadOnlySpan`1<System.Char>)
DecodingMap()
VbmiLookup0()
VbmiLookup1()
Avx2LutHigh()
Avx2LutLow()
Avx2LutShift()
MaskSlashOrUnderscore()
Vector128LutHigh()
Vector128LutLow()
Vector128LutShift()
AdvSimdLutOne3()
AdvSimdLutTwo3Uint1()
GetMaxDecodedLength(System.Int32)
IsInvalidLength(System.Int32)
IsValidPadding(System.UInt32)
SrcLength(System.Boolean,System.Int32)
TryDecode128Core(System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.SByte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>&)
TryDecode256Core(System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>&)
TryLoadVector512(System.Byte*,System.Byte*,System.Int32,System.Runtime.Intrinsics.Vector512`1<System.SByte>&)
TryLoadAvxVector256(System.Byte*,System.Byte*,System.Int32,System.Runtime.Intrinsics.Vector256`1<System.SByte>&)
TryLoadVector128(System.Byte*,System.Byte*,System.Int32,System.Runtime.Intrinsics.Vector128`1<System.Byte>&)
TryLoadArmVector128x4(System.Byte*,System.Byte*,System.Int32,System.Runtime.Intrinsics.Vector128`1<System.Byte>&,System.Runtime.Intrinsics.Vector128`1<System.Byte>&,System.Runtime.Intrinsics.Vector128`1<System.Byte>&,System.Runtime.Intrinsics.Vector128`1<System.Byte>&)
DecodeFourElements(System.Byte*,System.SByte&)
DecodeRemaining(System.Byte*,System.SByte&,System.Int64,System.UInt32&,System.UInt32&)
IndexOfAnyExceptWhiteSpace(System.ReadOnlySpan`1<System.Byte>)
DecodeWithWhiteSpaceBlockwiseWrapper(TBase64Decoder,System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Byte>,System.Int32&,System.Int32&,System.Boolean)
DecodingMap()
VbmiLookup0()
VbmiLookup1()
Avx2LutHigh()
Avx2LutLow()
Avx2LutShift()
MaskSlashOrUnderscore()
Vector128LutHigh()
Vector128LutLow()
Vector128LutShift()
AdvSimdLutOne3()
AdvSimdLutTwo3Uint1()
GetMaxDecodedLength(System.Int32)
IsInvalidLength(System.Int32)
IsValidPadding(System.UInt32)
SrcLength(System.Boolean,System.Int32)
TryDecode128Core(System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.SByte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>&)
TryDecode256Core(System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>,System.Runtime.Intrinsics.Vector256`1<System.SByte>&)
TryLoadVector512(System.UInt16*,System.UInt16*,System.Int32,System.Runtime.Intrinsics.Vector512`1<System.SByte>&)
TryLoadAvxVector256(System.UInt16*,System.UInt16*,System.Int32,System.Runtime.Intrinsics.Vector256`1<System.SByte>&)
TryLoadVector128(System.UInt16*,System.UInt16*,System.Int32,System.Runtime.Intrinsics.Vector128`1<System.Byte>&)
TryLoadArmVector128x4(System.UInt16*,System.UInt16*,System.Int32,System.Runtime.Intrinsics.Vector128`1<System.Byte>&,System.Runtime.Intrinsics.Vector128`1<System.Byte>&,System.Runtime.Intrinsics.Vector128`1<System.Byte>&,System.Runtime.Intrinsics.Vector128`1<System.Byte>&)
DecodeFourElements(System.UInt16*,System.SByte&)
DecodeRemaining(System.UInt16*,System.SByte&,System.Int64,System.UInt32&,System.UInt32&)
IndexOfAnyExceptWhiteSpace(System.ReadOnlySpan`1<System.UInt16>)
DecodeWithWhiteSpaceBlockwiseWrapper(TBase64Decoder,System.ReadOnlySpan`1<System.UInt16>,System.Span`1<System.Byte>,System.Int32&,System.Int32&,System.Boolean)
EncodeToUtf8(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Byte>,System.Int32&,System.Int32&,System.Boolean)
GetEncodedLength(System.Int32)
EncodeToUtf8(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Byte>)
EncodeToUtf8(System.ReadOnlySpan`1<System.Byte>)
EncodeToChars(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Char>,System.Int32&,System.Int32&,System.Boolean)
EncodeToChars(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Char>)
EncodeToChars(System.ReadOnlySpan`1<System.Byte>)
EncodeToString(System.ReadOnlySpan`1<System.Byte>)
TryEncodeToChars(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Char>,System.Int32&)
TryEncodeToUtf8(System.ReadOnlySpan`1<System.Byte>,System.Span`1<System.Byte>,System.Int32&)
TryEncodeToUtf8InPlace(System.Span`1<System.Byte>,System.Int32,System.Int32&)
EncodingMap()
Avx2LutChar62()
Avx2LutChar63()
AdvSimdLut4()
Ssse3AdvSimdLutE3()
IncrementPadTwo()
IncrementPadOne()
GetMaxSrcLength(System.Int32,System.Int32)
GetInPlaceDestinationLength(System.Int32,System.Int32)
GetMaxEncodedLength(System.Int32)
EncodeOneOptionallyPadTwo(System.Byte*,System.Byte*,System.Byte&)
EncodeTwoOptionallyPadOne(System.Byte*,System.Byte*,System.Byte&)
StoreVector512ToDestination(System.Byte*,System.Byte*,System.Int32,System.Runtime.Intrinsics.Vector512`1<System.Byte>)
StoreVector256ToDestination(System.Byte*,System.Byte*,System.Int32,System.Runtime.Intrinsics.Vector256`1<System.Byte>)
StoreVector128ToDestination(System.Byte*,System.Byte*,System.Int32,System.Runtime.Intrinsics.Vector128`1<System.Byte>)
StoreArmVector128x4ToDestination(System.Byte*,System.Byte*,System.Int32,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>)
EncodeThreeAndWrite(System.Byte*,System.Byte*,System.Byte&)
EncodingMap()
Avx2LutChar62()
Avx2LutChar63()
AdvSimdLut4()
Ssse3AdvSimdLutE3()
IncrementPadTwo()
IncrementPadOne()
GetMaxSrcLength(System.Int32,System.Int32)
GetInPlaceDestinationLength(System.Int32,System.Int32)
GetMaxEncodedLength(System.Int32)
EncodeOneOptionallyPadTwo(System.Byte*,System.UInt16*,System.Byte&)
EncodeTwoOptionallyPadOne(System.Byte*,System.UInt16*,System.Byte&)
StoreVector512ToDestination(System.UInt16*,System.UInt16*,System.Int32,System.Runtime.Intrinsics.Vector512`1<System.Byte>)
StoreVector256ToDestination(System.UInt16*,System.UInt16*,System.Int32,System.Runtime.Intrinsics.Vector256`1<System.Byte>)
StoreVector128ToDestination(System.UInt16*,System.UInt16*,System.Int32,System.Runtime.Intrinsics.Vector128`1<System.Byte>)
StoreArmVector128x4ToDestination(System.UInt16*,System.UInt16*,System.Int32,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>,System.Runtime.Intrinsics.Vector128`1<System.Byte>)
EncodeThreeAndWrite(System.Byte*,System.UInt16*,System.Byte&)
IsValid(System.ReadOnlySpan`1<System.Char>)
IsValid(System.ReadOnlySpan`1<System.Char>,System.Int32&)
IsValid(System.ReadOnlySpan`1<System.Byte>)
IsValid(System.ReadOnlySpan`1<System.Byte>,System.Int32&)
.cctor()
IndexOfAnyExcept(System.ReadOnlySpan`1<System.Char>)
IsWhiteSpace(System.Char)
IsEncodingPad(System.Char)
ValidateAndDecodeLength(System.Char,System.Int32,System.Int32,System.Int32&)
.cctor()
IndexOfAnyExcept(System.ReadOnlySpan`1<System.Byte>)
IsWhiteSpace(System.Byte)
IsEncodingPad(System.Byte)
ValidateAndDecodeLength(System.Byte,System.Int32,System.Int32,System.Int32&)