diff --git a/Redcraft.Utility/Source/Public/Strings/Formatting.h b/Redcraft.Utility/Source/Public/Strings/Formatting.h
new file mode 100644
index 0000000..55faecd
--- /dev/null
+++ b/Redcraft.Utility/Source/Public/Strings/Formatting.h
@@ -0,0 +1,990 @@
+#pragma once
+
+#include "CoreTypes.h"
+#include "TypeTraits/TypeTraits.h"
+#include "Templates/Utility.h"
+#include "Ranges/Utility.h"
+#include "Ranges/View.h"
+#include "Algorithms/Basic.h"
+#include "Containers/StaticArray.h"
+#include "Numerics/Math.h"
+#include "Strings/Char.h"
+#include "Miscellaneous/AssertionMacros.h"
+
+NAMESPACE_REDCRAFT_BEGIN
+NAMESPACE_MODULE_BEGIN(Redcraft)
+NAMESPACE_MODULE_BEGIN(Utility)
+
+/** A concept specifies a type is a format description string context. */
+template <typename T, typename CharType = char>
+concept CFormatStringContext = CInputRange<T> && CCharType<CharType> && CSameAs<TRangeElement<T>, CharType>
+	&& requires(T& Context, TRangeIterator<T> Iter, size_t Index)
+	{
+		/** Set the iterator of the context. */
+		Context.AdvanceTo(MoveTemp(Iter));
+
+		/** @return The next automatic index. */
+		{ Context.GetNextIndex() } -> CSameAs<size_t>;
+
+		/** @return true if the manual index is valid. */
+		{ Context.CheckIndex(Index) } -> CBooleanTestable;
+	};
+
+/** A concept specifies a type is a format output context. */
+template <typename T, typename CharType = char>
+concept CFormatObjectContext = COutputRange<T, CharType> && CCharType<CharType>
+	&& requires(T& Context, TRangeIterator<T> Iter, size_t Index)
+	{
+		/** Set the iterator of the context. */
+		Context.AdvanceTo(MoveTemp(Iter));
+
+		/** Visit the format argument by index, and the argument is always like const&. */
+		{ Context.Visit([](const auto&) { return 0; }, Index) } -> CIntegral;
+
+		/** Visit the format argument by index, and the argument is always like const&. */
+		{ Context.template Visit<int>([](const auto&) { return 0; }, Index) } -> CIntegral;
+	};
+
+/**
+ * A template class that defines the formatting rules for a specific type.
+ *
+ * @tparam T        - The type of object being formatted.
+ * @tparam CharType - The character type of the formatting target.
+ */
+template <typename T, CCharType CharType = char> requires (CSameAs<TRemoveCVRef<T>, T>)
+class TFormatter
+{
+public:
+
+	static_assert(sizeof(T) == -1, "The type is not formattable.");
+
+	FORCEINLINE constexpr TFormatter()                             = delete;
+	FORCEINLINE constexpr TFormatter(const TFormatter&)            = delete;
+	FORCEINLINE constexpr TFormatter(TFormatter&&)                 = delete;
+	FORCEINLINE constexpr TFormatter& operator=(const TFormatter&) = delete;
+	FORCEINLINE constexpr TFormatter& operator=(TFormatter&&)      = delete;
+
+	/**
+	 * Parses the format description string from the context.
+	 * Assert that the format description string is valid.
+	 *
+	 * @return The iterator that points to the first unmatched character.
+	 */
+	template <CFormatStringContext<CharType> CTX>
+	FORCEINLINE constexpr TRangeIterator<CTX> Parse(CTX& Context);
+
+	/**
+	 * Formats the object and writes the result to the context.
+	 * Do not assert that the output range is always large enough, and return directly if it is insufficient.
+	 * Specify, unlike visiting arguments from the context which is always like const&,
+	 * the object argument is a forwarding reference.
+	 *
+	 * @return The iterator that points to the next position of the output.
+	 */
+	template <typename U, CFormatObjectContext<CharType> CTX> requires (CSameAs<TRemoveCVRef<T>, U>)
+	FORCEINLINE constexpr TRangeIterator<CTX> Format(U&& Object, CTX& Context) const;
+
+};
+
+NAMESPACE_PRIVATE_BEGIN
+
+template <typename I, typename S, typename... Ts>
+class TFormatStringContext
+{
+public:
+
+	FORCEINLINE constexpr TFormatStringContext(I InFirst, S InLast) : First(MoveTemp(InFirst)), Last(InLast), AutomaticIndex(0) { }
+
+	NODISCARD FORCEINLINE constexpr I Begin()       requires (!CCopyable<I>) { return MoveTemp(First); }
+	NODISCARD FORCEINLINE constexpr I Begin() const requires ( CCopyable<I>) { return          First;  }
+
+	NODISCARD FORCEINLINE constexpr S End() const { return Last; }
+
+	NODISCARD FORCEINLINE constexpr size_t Num() const requires (CSizedSentinelFor<S, I>) { return Last - First; }
+
+	NODISCARD FORCEINLINE constexpr bool IsEmpty() const { return First == Last; }
+
+	FORCEINLINE constexpr void AdvanceTo(I Iter) { First = MoveTemp(Iter); }
+
+	NODISCARD FORCEINLINE constexpr size_t GetNextIndex()
+	{
+		bool bIsValid = AutomaticIndex < sizeof...(Ts) && AutomaticIndex != INDEX_NONE;
+
+		checkf(bIsValid, TEXT("Illegal automatic indexing. Already entered manual indexing mode."));
+
+		if (!bIsValid) return INDEX_NONE;
+
+		return AutomaticIndex++;
+	}
+
+	NODISCARD FORCEINLINE constexpr bool CheckIndex(size_t Index)
+	{
+		bool bIsValid = AutomaticIndex == 0 || AutomaticIndex == INDEX_NONE;
+
+		checkf(bIsValid, TEXT("Illegal manual indexing. Already entered automatic indexing mode."));
+
+		if (!bIsValid) return false;
+
+		AutomaticIndex = INDEX_NONE;
+
+		return Index < sizeof...(Ts);
+	}
+
+private:
+
+	NO_UNIQUE_ADDRESS I First;
+	NO_UNIQUE_ADDRESS S Last;
+
+	size_t AutomaticIndex = 0;
+};
+
+static_assert(CFormatStringContext<TFormatStringContext<IInputIterator<char>, ISentinelFor<IInputIterator<char>>>>);
+
+template <typename I, typename S, typename... Ts>
+class TFormatObjectContext
+{
+public:
+
+	FORCEINLINE constexpr TFormatObjectContext(I InFirst, S InLast, Ts&... Args) : First(MoveTemp(InFirst)), Last(InLast), ArgsTuple(Args...) { }
+
+	NODISCARD FORCEINLINE constexpr I Begin()       requires (!CCopyable<I>) { return MoveTemp(First); }
+	NODISCARD FORCEINLINE constexpr I Begin() const requires ( CCopyable<I>) { return          First;  }
+
+	NODISCARD FORCEINLINE constexpr S End() const { return Last; }
+
+	NODISCARD FORCEINLINE constexpr size_t Num() const requires (CSizedSentinelFor<S, I>) { return Last - First; }
+
+	NODISCARD FORCEINLINE constexpr bool IsEmpty() const { return First == Last; }
+
+	FORCEINLINE constexpr void AdvanceTo(I Iter) { First = MoveTemp(Iter); }
+
+	template <typename F> requires (((sizeof...(Ts) >= 1) && ... && CInvocable<F&&, Ts&>) && CCommonReference<TInvokeResult<F&&, const Ts&>...>)
+	FORCEINLINE constexpr decltype(auto) Visit(F&& Func, size_t Index) const { return ArgsTuple.Visit(Forward<F>(Func), Index); }
+
+	template <typename Ret, typename F> requires ((sizeof...(Ts) >= 1) && ... && CInvocableResult<Ret, F&&, const Ts&>)
+	FORCEINLINE constexpr Ret Visit(F&& Func, size_t Index) const { return ArgsTuple.template Visit<Ret>(Forward<F>(Func), Index); }
+
+private:
+
+	NO_UNIQUE_ADDRESS I First;
+	NO_UNIQUE_ADDRESS S Last;
+
+	TTuple<Ts&...> ArgsTuple;
+};
+
+static_assert(CFormatObjectContext<TFormatObjectContext<IOutputIterator<char&>, ISentinelFor<IOutputIterator<char&>>, int>>);
+
+NAMESPACE_PRIVATE_END
+
+/** A concept specifies a type is formattable by the 'Algorithms::Format()'. */
+template <typename T, typename CharType = char>
+concept CFormattable = CCharType<CharType> && CSemiregular<TFormatter<TRemoveCVRef<T>, CharType>>
+	&& requires(TFormatter<TRemoveCVRef<T>, CharType>& Formatter, T& Object,
+		NAMESPACE_PRIVATE::TFormatStringContext< IInputIterator<CharType >, ISentinelFor< IInputIterator<CharType >>, T> FormatStringContext,
+		NAMESPACE_PRIVATE::TFormatObjectContext<IOutputIterator<CharType&>, ISentinelFor<IOutputIterator<CharType&>>, T> FormatObjectContext)
+	{
+		{ Formatter.Parse (        FormatStringContext) } -> CSameAs< IInputIterator<CharType >>;
+		{ Formatter.Format(Object, FormatObjectContext) } -> CSameAs<IOutputIterator<CharType&>>;
+	};
+
+NAMESPACE_BEGIN(Algorithms)
+
+/**
+ * Formats the objects and writes the result to the output range.
+ * Assert that the format description string is valid.
+ * If the output range is insufficient, return directly without asserting.
+ *
+ * @param Output - The output range to write the result.
+ * @param Fmt    - The format description string.
+ * @param Args   - The objects to format.
+ *
+ * @return The iterator that points to the next position of the output.
+ */
+template <CInputRange R1, COutputRange<TRangeElement<R1>> R2, CFormattable<TRangeElement<R1>>... Ts> requires (CBorrowedRange<R2>)
+FORCEINLINE constexpr TRangeIterator<R2> Format(R2&& Output, R1&& Fmt, Ts&&... Args)
+{
+	if constexpr (CSizedRange<R1&>)
+	{
+		checkf(Algorithms::Distance(Fmt) >= 0, TEXT("Illegal range. Please check Algorithms::Distance(Fmt)."));
+	}
+
+	if constexpr (CSizedRange<R2&>)
+	{
+		checkf(Algorithms::Distance(Output) >= 0, TEXT("Illegal range. Please check Algorithms::Distance(Output)."));
+	}
+
+	using FCharType   = TRangeElement<R1>;
+	using FCharTraits = TChar<FCharType>;
+
+	using FFormatStringContext = NAMESPACE_PRIVATE::TFormatStringContext<TRangeIterator<R1>, TRangeSentinel<R1>, Ts...>;
+	using FFormatObjectContext = NAMESPACE_PRIVATE::TFormatObjectContext<TRangeIterator<R2>, TRangeSentinel<R2>, Ts...>;
+
+	FFormatStringContext FormatStringContext(Ranges::Begin(Fmt   ), Ranges::End(Fmt   ));
+	FFormatObjectContext FormatObjectContext(Ranges::Begin(Output), Ranges::End(Output), Args...);
+
+	auto FmtIter = Ranges::Begin(FormatStringContext);
+	auto FmtSent = Ranges::End  (FormatStringContext);
+
+	auto OutIter = Ranges::Begin(FormatObjectContext);
+	auto OutSent = Ranges::End  (FormatObjectContext);
+
+	// If the output range is insufficient.
+	if (OutIter == OutSent) UNLIKELY return OutIter;
+
+	TTuple<TFormatter<TRemoveCVRef<Ts>, FCharType>...> Formatters;
+
+	// For each character in the format string.
+	for (FCharType Char; FmtIter != FmtSent; ++FmtIter)
+	{
+		Char = *FmtIter;
+
+		// If the character may be a replacement field.
+		if (Char == LITERAL(FCharType, '{'))
+		{
+			if (++FmtIter == FmtSent) UNLIKELY
+			{
+				checkf(false, TEXT("Illegal format string. Unmatched '{' in format string."));
+
+				break;
+			}
+
+			Char = *FmtIter;
+
+			// If the character just an escaped '{'.
+			if (Char == LITERAL(FCharType, '{'))
+			{
+				if (OutIter == OutSent) UNLIKELY return OutIter;
+
+				*OutIter++ = LITERAL(FCharType, '{');
+
+				continue;
+			}
+
+			// If available replacement fields.
+			if constexpr (sizeof...(Ts) >= 1)
+			{
+				size_t Index;
+
+				// If the replacement field has a manual index.
+				if (Char != LITERAL(FCharType, ':') && Char != LITERAL(FCharType, '}'))
+				{
+					Index = 0;
+
+					bool bIsValid = true;
+
+					do
+					{
+						const uint Digit = FCharTraits::ToDigit(Char);
+
+						if (Digit > 10) bIsValid = false;
+
+						Index = Index * 10 + Digit;
+
+						if (++FmtIter == FmtSent) UNLIKELY break;
+
+						Char = *FmtIter;
+					}
+					while (Char != LITERAL(FCharType, ':') && Char != LITERAL(FCharType, '}'));
+
+					// If the index string contains illegal characters or the index is out of range.
+					if (!bIsValid || !FormatStringContext.CheckIndex(Index)) UNLIKELY
+					{
+						checkf(false, TEXT("Illegal index. Please check the replacement field."));
+
+						break;
+					}
+				}
+
+				// If the replacement field need automatic indexing.
+				else
+				{
+					Index = FormatStringContext.GetNextIndex();
+
+					if (Index == INDEX_NONE)
+					{
+						checkf(false, TEXT("Illegal index. Please check the replacement field."));
+
+						break;
+					}
+				}
+
+				// Jump over the ':' character.
+				if (Char == LITERAL(FCharType, ':')) ++FmtIter;
+
+				FormatStringContext.AdvanceTo(MoveTemp(FmtIter));
+
+				// Parse the format description string.
+				FmtIter = Formatters.Visit([&FormatStringContext](auto& Formatter) -> decltype(FmtIter) { return Formatter.Parse(FormatStringContext); }, Index);
+
+				if (FmtIter == FmtSent || *FmtIter != LITERAL(FCharType, '}')) UNLIKELY
+				{
+					checkf(false, TEXT("Illegal format string. Missing '}' in format string."));
+
+					break;
+				}
+
+				FormatObjectContext.AdvanceTo(MoveTemp(OutIter));
+
+				auto FormatHandler = [&]<size_t... Indices>(TIndexSequence<Indices...>)
+				{
+					TTuple<TConstant<size_t, Indices>...> Visitor;
+
+					return Visitor.Visit([&]<size_t ConstantIndex>(TConstant<size_t, ConstantIndex>)
+					{
+						check(ConstantIndex == Index);
+
+						return Formatters.template GetValue<ConstantIndex>().Format(ForwardAsTuple(Forward<Ts>(Args)...).template GetValue<ConstantIndex>(), FormatObjectContext);
+					}
+					, Index);
+				};
+
+				// Format the object and write the result to the context.
+				OutIter = FormatHandler(TIndexSequenceFor<Ts...>());
+			}
+
+			else
+			{
+				checkf(false, TEXT("Illegal index. Please check the replacement field."));
+
+				break;
+			}
+		}
+
+		// If the character just an escaped '}'.
+		else if (Char == LITERAL(FCharType, '}'))
+		{
+			// Confirm the character is an escaped '}'.
+			if (++FmtIter != FmtSent && *FmtIter == LITERAL(FCharType, '}'))
+			{
+				if (OutIter == OutSent) UNLIKELY return OutIter;
+
+				*OutIter++ = LITERAL(FCharType, '}');
+
+				continue;
+			}
+
+			checkf(false, TEXT("Illegal format string. Missing '{' in format string."));
+
+			break;
+		}
+
+		// If the output range is insufficient.
+		else if (OutIter == OutSent) UNLIKELY return OutIter;
+
+		// If the character is not a replacement field.
+		else *OutIter++ = Char;
+	}
+
+	return OutIter;
+}
+
+/**
+ * Formats the objects and writes the result to the output range.
+ * Assert that the format description string is valid.
+ * If the output range is insufficient, return directly without asserting.
+ *
+ * @param OutputFirst - The iterator of the output range to write the result.
+ * @param OutputLast  - The sentinel of the output range to write the result.
+ * @param FmtFirst    - The iterator of the format description string.
+ * @param FmtLast     - The sentinel of the format description string.
+ * @param Args        - The objects to format.
+ *
+ * @return The iterator that points to the next position of the output.
+ */
+template <CInputIterator I1, CSentinelFor<I1> S1, COutputIterator<TIteratorElement<I1>> I2, CSentinelFor<I2> S2, CFormattable<TIteratorElement<I1>>... Ts>
+FORCEINLINE constexpr I2 Format(I2 OutputFirst, S2 OutputLast, I1 FmtFirst, S1 FmtLast, Ts&&... Args)
+{
+	if constexpr (CSizedSentinelFor<S1, I1>)
+	{
+		checkf(FmtFirst - FmtLast <= 0, TEXT("Illegal range iterator. Please check HaystackFirst <= HaystackLast."));
+	}
+
+	if constexpr (CSizedSentinelFor<S2, I2>)
+	{
+		checkf(OutputFirst - OutputLast <= 0, TEXT("Illegal range iterator. Please check NeedleFirst <= NeedleLast."));
+	}
+
+	return Algorithms::Format(Ranges::View(MoveTemp(OutputFirst), OutputLast), Ranges::View(MoveTemp(FmtFirst), FmtLast), Forward<Ts>(Args)...);
+}
+
+NAMESPACE_END(Algorithms)
+
+/**
+ * A formatter the null-terminated string.
+ *
+ * The syntax of format specifications is:
+ *
+ *	[Fill And Align] [Width] [Precision] [Type]
+ *
+ * 1. The fill and align part:
+ *
+ *	[Fill Character] <Align Option>
+ *
+ *	i.   Fill Character: The character is used to fill width of the object. It is optional and cannot be '{' or '}'.
+ *	                     It should be representable as a single unicode otherwise it is undefined behavior.
+ *
+ *  ii.  Align Option: The character is used to indicate the direction of alignment.
+ *
+ *		- '<': Align the formatted argument to the left of the available space
+ *		       by inserting n fill characters after the formatted argument.
+ *		- '^': Align the formatted argument to the center of the available space
+ *		       by inserting n fill characters around the formatted argument.
+ *		       If cannot absolute centering, offset to the left.
+ *		- '>': Align the formatted argument ro the right of the available space
+ *		       by inserting n fill characters before the formatted argument.
+ *
+ * 2. The width part:
+ *
+ *	- 'N':   The number is used to specify the minimum field width of the object.
+ *	         N should be an unsigned non-zero decimal number.
+ *	- '{N}': Dynamically determine the minimum field width of the object.
+ *	         N should be a valid index of the format integer argument.
+ *	         N is optional, and the default value is automatic indexing.
+ *
+ * 3. The precision part:
+ *
+ *	- '.N':   The number is used to specify the maximum field width of the object.
+ *	          N should be an unsigned non-zero decimal number.
+ *	- '.{N}': Dynamically determine the maximum field width of the object.
+ *	          N should be a valid index of the format integer argument.
+ *	          N is optional, and the default value is automatic indexing.
+ *
+ * 4. The type indicators part:
+ *
+ *	- none: Indicates the as-is formatting.
+ *	- 'S':  Indicates the as-is formatting.
+ *	- '!':  Indicates uppercase formatting.
+ *	- 's':  Indicates lowercase formatting.
+ *	- '?':  Indicates escape formatting.
+ */
+template <CCharType T>
+class TFormatter<T*, T>
+{
+private:
+
+	using FCharType      = T;
+	using FCharTraits    = TChar<FCharType>;
+	using FFillCharacter = TStaticArray<FCharType, FCharTraits::MaxCodeUnitLength>;
+
+public:
+
+	template <CFormatStringContext<FCharType> CTX>
+	constexpr TRangeIterator<CTX> Parse(CTX& Context)
+	{
+		auto Iter = Ranges::Begin(Context);
+		auto Sent = Ranges::End  (Context);
+
+		// Set the default values.
+		{
+			FillUnitLength   = 1;
+			FillCharacter[0] = LITERAL(FCharType, ' ');
+			AlignOption      = LITERAL(FCharType, '<');
+
+			MinFieldWidth =  0;
+			MaxFieldWidth = -1;
+
+			bDynamicMin = false;
+			bDynamicMax = false;
+
+			bLowercase = false;
+			bUppercase = false;
+			bEscape    = false;
+		}
+
+		// If the format description string is empty.
+		if (Iter == Sent || *Iter == LITERAL(FCharType, '}')) return Iter;
+
+		FCharType Char = *Iter; ++Iter;
+
+		// Try to parse the fill and align part.
+		// This code assumes that the format string does not contain multi-unit characters, except for fill character.
+
+		// If the fill character is multi-unit.
+		if (!FCharTraits::IsValid(Char))
+		{
+			FillUnitLength   = 1;
+			FillCharacter[0] = Char;
+
+			while (true)
+			{
+				if (Iter == Sent) UNLIKELY
+				{
+					checkf(false, TEXT("Illegal format string. Missing '}' in format string."));
+
+					return Iter;
+				}
+
+				Char = *Iter; ++Iter;
+
+				// If the fill character ends.
+				if (FillUnitLength == FCharTraits::MaxCodeUnitLength || FCharTraits::IsValid(Char)) break;
+
+				FillCharacter[FillUnitLength++] = Char;
+			}
+
+			if (Char != LITERAL(FCharType, '<') && Char != LITERAL(FCharType, '^') && Char != LITERAL(FCharType, '>')) UNLIKELY
+			{
+				checkf(false, TEXT("Illegal format string. The fill character is not representable as a single unicode."));
+
+				return Iter;
+			}
+
+			AlignOption = Char;
+
+			if (Iter == Sent || *Iter == LITERAL(FCharType, '}')) return Iter;
+
+			Char = *Iter; ++Iter;
+		}
+
+		// If the fill character is single-unit.
+		else do
+		{
+			if (Iter == Sent) break;
+
+			if (*Iter != LITERAL(FCharType, '<') && *Iter != LITERAL(FCharType, '^') && *Iter != LITERAL(FCharType, '>')) break;
+
+			FillUnitLength   = 1;
+			FillCharacter[0] = Char;
+
+			Char = *Iter; ++Iter;
+
+			AlignOption = Char;
+
+			if (Iter == Sent || *Iter == LITERAL(FCharType, '}')) return Iter;
+
+			Char = *Iter; ++Iter;
+		}
+		while (false);
+
+		// Try to parse the width part.
+		{
+			if (Char == LITERAL(FCharType, '{'))
+			{
+				bDynamicMin   = true;
+				MinFieldWidth = INDEX_NONE;
+
+				if (Iter == Sent) UNLIKELY
+				{
+					checkf(false, TEXT("Illegal format string. Missing '}' in format string."));
+
+					return Iter;
+				}
+
+				Char = *Iter; ++Iter;
+			}
+
+			if ((bDynamicMin || Char != LITERAL(FCharType, '0')) && FCharTraits::IsDigit(Char))
+			{
+				MinFieldWidth = FCharTraits::ToDigit(Char);
+
+				while (true)
+				{
+					if (Iter == Sent)
+					{
+						checkf(!bDynamicMin, TEXT("Illegal format string. Missing '}' in format string."));
+
+						return Iter;
+					}
+
+					if (!bDynamicMin && *Iter == LITERAL(FCharType, '}')) return Iter;
+
+					Char = *Iter; ++Iter;
+
+					const uint Digit = FCharTraits::ToDigit(Char);
+
+					if (Digit > 10) break;
+
+					MinFieldWidth = MinFieldWidth * 10 + Digit;
+				}
+			}
+
+			if (bDynamicMin)
+			{
+				if (Char != LITERAL(FCharType, '}')) UNLIKELY
+				{
+					checkf(false, TEXT("Illegal format string. Missing '}' in format string."));
+
+					return Iter;
+				}
+
+				do
+				{
+					// Try to automatic indexing.
+					if (MinFieldWidth == INDEX_NONE)
+					{
+						MinFieldWidth = Context.GetNextIndex();
+
+						if (MinFieldWidth == INDEX_NONE) UNLIKELY
+						{
+							checkf(false, TEXT("Illegal index. Please check the field width."));
+						}
+						else break;
+					}
+
+					// Try to manual indexing.
+					else if (!Context.CheckIndex(MinFieldWidth)) UNLIKELY
+					{
+						checkf(false, TEXT("Illegal index. Please check the field width."));
+					}
+
+					else break;
+
+					bDynamicMin   = false;
+					MinFieldWidth = 0;
+				}
+				while (false);
+
+				if (Iter == Sent || *Iter == LITERAL(FCharType, '}')) return Iter;
+
+				Char = *Iter; ++Iter;
+			}
+		}
+
+		// Try to parse the precision part.
+		if (Char == LITERAL(FCharType, '.'))
+		{
+			if (Iter == Sent) UNLIKELY
+			{
+				checkf(false, TEXT("Illegal format string. Missing precision in format string."));
+
+				return Iter;
+			}
+
+			Char = *Iter; ++Iter;
+
+			if (Char == LITERAL(FCharType, '{'))
+			{
+				bDynamicMax   = true;
+				MaxFieldWidth = INDEX_NONE;
+
+				if (Iter == Sent) UNLIKELY
+				{
+					checkf(false, TEXT("Illegal format string. Missing '}' in format string."));
+
+					return Iter;
+				}
+
+				Char = *Iter; ++Iter;
+			}
+
+			if ((bDynamicMax || Char != LITERAL(FCharType, '0')) && FCharTraits::IsDigit(Char))
+			{
+				MaxFieldWidth = FCharTraits::ToDigit(Char);
+
+				while (true)
+				{
+					if (Iter == Sent)
+					{
+						checkf(!bDynamicMax, TEXT("Illegal format string. Missing '}' in format string."));
+
+						return Iter;
+					}
+
+					if (!bDynamicMax && *Iter == LITERAL(FCharType, '}')) return Iter;
+
+					Char = *Iter; ++Iter;
+
+					const uint Digit = FCharTraits::ToDigit(Char);
+
+					if (Digit > 10) break;
+
+					MaxFieldWidth = MaxFieldWidth * 10 + Digit;
+				}
+			}
+
+			else if (!bDynamicMax)
+			{
+				checkf(false, TEXT("Illegal format string. Missing precision in format string."));
+
+				return Iter;
+			}
+
+			if (bDynamicMax)
+			{
+				if (Char != LITERAL(FCharType, '}')) UNLIKELY
+				{
+					checkf(false, TEXT("Illegal format string. Missing '}' in format string."));
+
+					return Iter;
+				}
+
+				do
+				{
+					// Try to automatic indexing.
+					if (MaxFieldWidth == INDEX_NONE)
+					{
+						MaxFieldWidth = Context.GetNextIndex();
+
+						if (MaxFieldWidth == INDEX_NONE) UNLIKELY
+						{
+							checkf(false, TEXT("Illegal index. Please check the precision."));
+						}
+						else break;
+					}
+
+					// Try to manual indexing.
+					else if (!Context.CheckIndex(MaxFieldWidth)) UNLIKELY
+					{
+						checkf(false, TEXT("Illegal index. Please check the precision."));
+					}
+
+					else break;
+
+					bDynamicMax   = false;
+					MaxFieldWidth = -1;
+				}
+				while (false);
+
+				if (Iter == Sent || *Iter == LITERAL(FCharType, '}')) return Iter;
+
+				Char = *Iter; ++Iter;
+			}
+		}
+
+		// Try to parse the type indicators part.
+		if      (Char == LITERAL(FCharType, 'S')) {                    if (Iter == Sent || *Iter == LITERAL(FCharType, '}')) return Iter; Char = *Iter; ++Iter; }
+		else if (Char == LITERAL(FCharType, '!')) { bUppercase = true; if (Iter == Sent || *Iter == LITERAL(FCharType, '}')) return Iter; Char = *Iter; ++Iter; }
+		else if (Char == LITERAL(FCharType, 's')) { bLowercase = true; if (Iter == Sent || *Iter == LITERAL(FCharType, '}')) return Iter; Char = *Iter; ++Iter; }
+		else if (Char == LITERAL(FCharType, '?')) { bEscape    = true; if (Iter == Sent || *Iter == LITERAL(FCharType, '}')) return Iter; Char = *Iter; ++Iter; }
+
+		checkf(false, TEXT("Illegal format string. Missing '}' in format string."));
+
+		return Iter;
+	}
+
+	template <CFormatObjectContext<FCharType> CTX>
+	constexpr TRangeIterator<CTX> Format(const FCharType* Object, CTX& Context) const
+	{
+		auto Iter = Ranges::Begin(Context);
+		auto Sent = Ranges::End  (Context);
+
+		size_t MinDynamicField = MinFieldWidth;
+		size_t MaxDynamicField = MaxFieldWidth;
+
+		if (bDynamicMin) MinDynamicField = Context.Visit([]<typename U>(U&& Value) -> size_t
+		{
+
+			if constexpr (CIntegral<U>)
+			{
+				checkf(Value > 0, TEXT("Illegal format argument. The dynamic width argument must be a unsigned non-zero number."));
+
+				return Math::Max(Value, 1);
+			}
+			else
+			{
+				checkf(false, TEXT("Illegal format argument. The dynamic width argument must be an integral."));
+
+				return 0;
+			}
+		}
+		, MinFieldWidth);
+
+		if (bDynamicMax) MaxDynamicField = Context.Visit([]<typename U>(U&& Value) -> size_t
+		{
+			if constexpr (CIntegral<U>)
+			{
+				checkf(Value > 0, TEXT("Illegal format argument. The dynamic precision argument must be a unsigned non-zero number."));
+
+				return Math::Max(Value, 1);
+			}
+			else
+			{
+				checkf(false, TEXT("Illegal format argument. The dynamic precision argument must be an integral."));
+
+				return 0;
+			}
+		}
+		, MaxFieldWidth);
+
+		size_t LeftPadding  = 0;
+		size_t RightPadding = 0;
+
+		// Estimate the field width.
+		if (MinDynamicField != 0)
+		{
+			// If escape formatting is enabled, add quotes characters.
+			size_t FieldWidth = bEscape ? 2 : 0;
+
+			for (const FCharType* Ptr = Object; *Ptr != LITERAL(FCharType, '\0'); ++Ptr)
+			{
+				if (bEscape)
+				{
+					switch (const FCharType Char = *Ptr)
+					{
+					case LITERAL(FCharType, '\"'): FieldWidth += 2; break;
+					case LITERAL(FCharType, '\\'): FieldWidth += 2; break;
+					case LITERAL(FCharType, '\a'): FieldWidth += 2; break;
+					case LITERAL(FCharType, '\b'): FieldWidth += 2; break;
+					case LITERAL(FCharType, '\f'): FieldWidth += 2; break;
+					case LITERAL(FCharType, '\n'): FieldWidth += 2; break;
+					case LITERAL(FCharType, '\r'): FieldWidth += 2; break;
+					case LITERAL(FCharType, '\t'): FieldWidth += 2; break;
+					case LITERAL(FCharType, '\v'): FieldWidth += 2; break;
+					default:
+						{
+							// Use '\x00' format for other non-printable characters.
+							if (!FCharTraits::IsASCII(Char) || !FCharTraits::IsPrint(Char))
+							{
+								FieldWidth += 2 + sizeof(FCharType) * 2;
+							}
+
+							else ++FieldWidth;
+						}
+					}
+				}
+
+				else ++FieldWidth;
+			}
+
+			const size_t PaddingWidth = MinDynamicField - Math::Min(FieldWidth, MinDynamicField, MaxDynamicField);
+
+			if      (AlignOption == LITERAL(FCharType, '<')) RightPadding = PaddingWidth;
+			else if (AlignOption == LITERAL(FCharType, '>')) LeftPadding  = PaddingWidth;
+			else if (AlignOption == LITERAL(FCharType, '^'))
+			{
+				LeftPadding  = Math::DivAndFloor(PaddingWidth, 2);
+				RightPadding = PaddingWidth - LeftPadding;
+			}
+		}
+
+		// Write the left padding.
+		for (size_t Index = 0; Index != LeftPadding; ++Index)
+		{
+			for (size_t Jndex = 0; Jndex != FillUnitLength; ++Jndex)
+			{
+				if (Iter == Sent) UNLIKELY return Iter;
+
+				*Iter++ = FillCharacter[Jndex];
+			}
+		}
+
+		// Write the left quote.
+		if (bEscape)
+		{
+			if (Iter == Sent) UNLIKELY return Iter;
+
+			*Iter++ = LITERAL(FCharType, '\"');
+		}
+
+		const FCharType* Ptr = Object - 1;
+
+		// Write the object, include escaped quotes in the counter.
+		for (size_t Index = bEscape ? 1 : 0; Index != MaxDynamicField; ++Index)
+		{
+			FCharType Char = *++Ptr;
+
+			if (Char == LITERAL(FCharType, '\0')) break;
+
+			if (Iter == Sent) UNLIKELY return Iter;
+
+			// Convert the character case.
+			if      (bLowercase) Char = FCharTraits::ToLower(Char);
+			else if (bUppercase) Char = FCharTraits::ToUpper(Char);
+
+			if (bEscape)
+			{
+				switch (Char)
+				{
+				case LITERAL(FCharType, '\"'): *Iter++ = LITERAL(FCharType, '\\'); *Iter++ = LITERAL(FCharType, '\"'); break;
+				case LITERAL(FCharType, '\\'): *Iter++ = LITERAL(FCharType, '\\'); *Iter++ = LITERAL(FCharType, '\\'); break;
+				case LITERAL(FCharType, '\a'): *Iter++ = LITERAL(FCharType, '\\'); *Iter++ = LITERAL(FCharType, 'a');  break;
+				case LITERAL(FCharType, '\b'): *Iter++ = LITERAL(FCharType, '\\'); *Iter++ = LITERAL(FCharType, 'b');  break;
+				case LITERAL(FCharType, '\f'): *Iter++ = LITERAL(FCharType, '\\'); *Iter++ = LITERAL(FCharType, 'f');  break;
+				case LITERAL(FCharType, '\n'): *Iter++ = LITERAL(FCharType, '\\'); *Iter++ = LITERAL(FCharType, 'n');  break;
+				case LITERAL(FCharType, '\r'): *Iter++ = LITERAL(FCharType, '\\'); *Iter++ = LITERAL(FCharType, 'r');  break;
+				case LITERAL(FCharType, '\t'): *Iter++ = LITERAL(FCharType, '\\'); *Iter++ = LITERAL(FCharType, 't');  break;
+				case LITERAL(FCharType, '\v'): *Iter++ = LITERAL(FCharType, '\\'); *Iter++ = LITERAL(FCharType, 'v');  break;
+				default:
+					{
+						// Use '\x00' format for other non-printable characters.
+						if (!FCharTraits::IsASCII(Char) || !FCharTraits::IsPrint(Char))
+						{
+							*Iter++ = LITERAL(FCharType, '\\');
+							*Iter++ = LITERAL(FCharType, 'x' );
+
+							using FUnsignedT = TMakeUnsigned<FCharType>;
+
+							constexpr size_t DigitNum = sizeof(FCharType) * 2;
+
+							FUnsignedT IntValue = static_cast<FUnsignedT>(Char);
+
+							FCharType Buffer[DigitNum];
+
+							for (size_t Jndex = 0; Jndex != DigitNum; ++Jndex)
+							{
+								Buffer[DigitNum - Jndex - 1] = FCharTraits::FromDigit(IntValue & 0xF);
+
+								IntValue >>= 4;
+							}
+
+							check(IntValue == 0);
+
+							for (size_t Jndex = 0; Jndex != DigitNum; ++Jndex)
+							{
+								if (Iter == Sent) UNLIKELY return Iter;
+
+								*Iter++ = Buffer[Jndex];
+							}
+						}
+
+						else *Iter++ = Char;
+					}
+				}
+			}
+
+			else *Iter++ = Char;
+		}
+
+		// Write the right quote, if the field width is enough.
+		if (bEscape && *Ptr == LITERAL(FCharType, '\0'))
+		{
+			if (Iter == Sent) UNLIKELY return Iter;
+
+			*Iter++ = LITERAL(FCharType, '\"');
+		}
+
+		// Write the right padding.
+		for (size_t Index = 0; Index != RightPadding; ++Index)
+		{
+			for (size_t Jndex = 0; Jndex != FillUnitLength; ++Jndex)
+			{
+				if (Iter == Sent) UNLIKELY return Iter;
+
+				*Iter++ = FillCharacter[Jndex];
+			}
+		}
+
+		return Iter;
+	}
+
+private:
+
+	size_t         FillUnitLength = 1;
+	FFillCharacter FillCharacter  = { LITERAL(FCharType, ' ') };
+	FCharType      AlignOption    =   LITERAL(FCharType, '<');
+
+	size_t MinFieldWidth =  0;
+	size_t MaxFieldWidth = -1;
+
+	bool bDynamicMin = false;
+	bool bDynamicMax = false;
+
+	bool bLowercase = false;
+	bool bUppercase = false;
+	bool bEscape    = false;
+
+};
+
+template <CCharType T>           class TFormatter<const T*  , T> : public TFormatter<T*, T> { };
+template <CCharType T, size_t N> class TFormatter<      T[N], T> : public TFormatter<T*, T> { };
+template <CCharType T, size_t N> class TFormatter<const T[N], T> : public TFormatter<T*, T> { };
+
+static_assert(CFormattable<      char*>);
+static_assert(CFormattable<const char*>);
+
+static_assert(CFormattable<      char[256]>);
+static_assert(CFormattable<const char[256]>);
+
+NAMESPACE_MODULE_END(Utility)
+NAMESPACE_MODULE_END(Redcraft)
+NAMESPACE_REDCRAFT_END