diff --git a/src/PowerShellRun/Application/InternalEntry.cs b/src/PowerShellRun/Application/InternalEntry.cs
index d51ab30..566165d 100644
--- a/src/PowerShellRun/Application/InternalEntry.cs
+++ b/src/PowerShellRun/Application/InternalEntry.cs
@@ -31,8 +31,10 @@ internal class InternalEntry
     public BackgroundRunspace.Task? PreviewTask { get; set; } = null;
     private int _previewTaskExecutionCount = 0;
     private string[]? _previewLines = null;
-    private readonly object? _previewLinesLock = null;
+    private readonly object? _previewTaskLock = null;
     private bool _previewLinesUpdatedByTask = false;
+    private TextBox.WrappedText? _previewWrappedTextCache = null;
+    private int _previewWrappedTextCacheWidth = 0;
 
     public InternalEntry(SelectorEntry selectorEntry)
     {
@@ -71,7 +73,7 @@ public InternalEntry(SelectorEntry selectorEntry)
 
         if (selectorEntry.PreviewAsyncScript is not null)
         {
-            _previewLinesLock = new object();
+            _previewTaskLock = new object();
         }
     }
 
@@ -89,10 +91,10 @@ public ActionKey[] GetActionKeysMultiSelection()
 
     public void CompletePreviewTask(System.Collections.ObjectModel.Collection<PSObject> taskResult)
     {
-        if (_previewLinesLock is null)
+        if (_previewTaskLock is null)
             return;
 
-        lock (_previewLinesLock)
+        lock (_previewTaskLock)
         {
             if (taskResult.Count > 0 && taskResult[0] is not null)
             {
@@ -106,22 +108,39 @@ public void CompletePreviewTask(System.Collections.ObjectModel.Collection<PSObje
 
     public string[]? GetPreviewLines()
     {
-        if (_previewLinesLock is null)
+        if (_previewTaskLock is null)
             return _previewLines;
 
-        lock (_previewLinesLock)
+        lock (_previewTaskLock)
         {
             return _previewLines;
         }
     }
 
+    public TextBox.WrappedText? GetPreviewWrappedText(int maxWidth)
+    {
+        var previewLines = GetPreviewLines();
+        if (previewLines == null)
+            return null;
+
+        if (_previewWrappedTextCache is not null && _previewWrappedTextCacheWidth == maxWidth)
+        {
+            return _previewWrappedTextCache;
+        }
+
+        _previewWrappedTextCache = new TextBox.WrappedText(previewLines, maxWidth);
+        _previewWrappedTextCacheWidth = maxWidth;
+
+        return _previewWrappedTextCache;
+    }
+
     public void UpdatePreviewTask()
     {
         IsUpdated = false;
-        if (_previewLinesLock is null)
+        if (_previewTaskLock is null)
             return;
 
-        lock (_previewLinesLock)
+        lock (_previewTaskLock)
         {
             if (PreviewTask is null && _previewTaskExecutionCount == 0)
             {
diff --git a/src/PowerShellRun/Application/ResultWindow.cs b/src/PowerShellRun/Application/ResultWindow.cs
index 669316f..b707c57 100644
--- a/src/PowerShellRun/Application/ResultWindow.cs
+++ b/src/PowerShellRun/Application/ResultWindow.cs
@@ -541,13 +541,28 @@ private void BuildUi()
             {
                 if (theme.PreviewEnable)
                 {
-                    var previewLines = internalEntry.GetPreviewLines();
+                    string[]? previewLines = null;
+                    int previewInitialVerticalScroll = 0;
+                    if (theme.PreviewTextWrapMode != TextWrapMode.None)
+                    {
+                        var wrappedPreview = internalEntry.GetPreviewWrappedText(_previewBox.GetInnerLayout().Width);
+                        if (wrappedPreview is not null)
+                        {
+                            previewLines = wrappedPreview.Lines;
+                            previewInitialVerticalScroll = wrappedPreview.GetStartLineIndex(selectorEntry.PreviewInitialVerticalScroll);
+                        }
+                    }
+                    else
+                    {
+                        previewLines = internalEntry.GetPreviewLines();
+                        previewInitialVerticalScroll = selectorEntry.PreviewInitialVerticalScroll;
+                    }
                     int previewLineCount = (previewLines is not null) ? previewLines.Length : 0;
 
                     if (IsFocusedEntryUpdated() || _isFocusedEntryContentUpdated)
                     {
                         _previewBox.ClearAndSetVerticalScroll(
-                            selectorEntry.PreviewInitialVerticalScroll,
+                            previewInitialVerticalScroll,
                             previewLineCount);
                     }
                     else
diff --git a/src/PowerShellRun/Application/Theme.cs b/src/PowerShellRun/Application/Theme.cs
index 2097e8e..114ac72 100644
--- a/src/PowerShellRun/Application/Theme.cs
+++ b/src/PowerShellRun/Application/Theme.cs
@@ -88,6 +88,7 @@ public class Theme
     public FontColor? EntryScrollBarBackgroundColor { get; set; } = null;
 
     public bool PreviewEnable { get; set; } = true;
+    public TextWrapMode PreviewTextWrapMode { get; set; } = TextWrapMode.None;
     public FontColor? PreviewForegroundColor { get; set; } = null;
     public FontColor? PreviewBackgroundColor { get; set; } = null;
     public FontStyle PreviewStyle { get; set; } = FontStyle.Default;
diff --git a/src/PowerShellRun/UI/Canvas.cs b/src/PowerShellRun/UI/Canvas.cs
index e6d40a1..a17dfcb 100644
--- a/src/PowerShellRun/UI/Canvas.cs
+++ b/src/PowerShellRun/UI/Canvas.cs
@@ -303,6 +303,8 @@ public void Write()
                     shouldSetEscapeSequence = true;
                 }
 
+                // Low priority escape sequence is applied here before color and style settings.
+                // e.g. Escape sequences for highlighted characters. The highlight color setting is stronger.
                 if (escapeSequence is not null && shouldSetEscapeSequence && escapeSequenceLowPriority)
                 {
                     builder.Append(escapeSequence);
@@ -337,6 +339,8 @@ public void Write()
                     builder.Append(FontStyleTable.GetEscapeCode(cell.FontStyle));
                 }
 
+                // Normal priority escape sequence is applied here after color and style settings.
+                // It is higher priority than color and style settings.
                 if (escapeSequence is not null && shouldSetEscapeSequence && !escapeSequenceLowPriority)
                 {
                     builder.Append(escapeSequence);
diff --git a/src/PowerShellRun/UI/TextBox.cs b/src/PowerShellRun/UI/TextBox.cs
index dc1d912..70966f5 100644
--- a/src/PowerShellRun/UI/TextBox.cs
+++ b/src/PowerShellRun/UI/TextBox.cs
@@ -1,9 +1,11 @@
 namespace PowerShellRun;
+
 using PowerShellRun.Dependency;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Management.Automation.Language;
+using System.Reflection.PortableExecutable;
 using System.Text;
 
 internal class TextBox : LayoutItem
@@ -163,80 +165,49 @@ void SetCell(Word word, int charIndex, char character = '\0', string? textElemen
                 if (cellIndex >= maxWidth)
                     break;
 
-                bool escaped = false;
-                var textElementIndexes = System.Globalization.StringInfo.ParseCombiningCharacters(word.String);
-                for (int i = 0; i < textElementIndexes.Length; ++i)
+                var textElement = new TextElementEnumerator(word.String);
+                while (textElement.MoveNext())
                 {
                     if (cellIndex >= maxWidth)
                         break;
 
-                    var elementStartIndex = textElementIndexes[i];
-                    var elementStartIndexNext = (i + 1 == textElementIndexes.Length) ? word.String.Length : textElementIndexes[i + 1];
-
-                    var elementCharCount = elementStartIndexNext - elementStartIndex;
-                    bool isBaseCharacter = elementCharCount == 1;
-                    var charIndex = elementStartIndex;
+                    if (textElement.IsEscapeSequence)
+                    {
+                        AddEscapeSequence(textElement.Character);
+                        continue;
+                    }
 
-                    if (isBaseCharacter)
+                    int charIndex = textElement.ElementStartCharIndex;
+                    if (textElement.IsTab)
                     {
-                        // basic 2 byte characters
-                        char character = word.String[charIndex];
-                        if (escaped)
-                        {
-                            if (character == 'm')
-                            {
-                                escaped = false;
-                            }
-                            AddEscapeSequence(character);
-                        }
-                        else
-                        if (character == '\x1b')
-                        {
-                            escaped = true;
-                            AddEscapeSequence(character);
-                        }
-                        else
-                        if (character == '\t')
-                        {
-                            int spaces = tabSize - cellIndex % tabSize;
-                            for (int s = 0; s < spaces; ++s)
-                            {
-                                SetCell(word, charIndex, character: ' ');
-                                if (cellIndex >= maxWidth)
-                                    break;
-                            }
-                        }
-                        else
+                        int spaces = tabSize - cellIndex % tabSize;
+                        for (int s = 0; s < spaces; ++s)
                         {
-                            int displayWidth = Unicode.GetDisplayWidth(character);
-                            if (displayWidth <= 0)
-                                continue;
-
-                            if (cellIndex + displayWidth > maxWidth)
-                                continue;
-
-                            SetCell(word, charIndex, character: character);
-                            if (displayWidth == 2)
-                            {
-                                SetCell(word, charIndex, character: '\0', isSecondCellOfWideCharacter: true);
-                            }
+                            SetCell(word, charIndex, character: ' ');
+                            if (cellIndex >= maxWidth)
+                                break;
                         }
+                        continue;
+                    }
+
+                    if (textElement.DisplayWidth <= 0)
+                        continue;
+
+                    if (cellIndex + textElement.DisplayWidth > maxWidth)
+                        continue;
+
+                    if (textElement.IsBaseCharacter)
+                    {
+                        SetCell(word, charIndex, character: textElement.Character);
                     }
                     else
                     {
-                        int displayWidth = GetDisplayWidthOfComplexTextElement(word.String, elementStartIndex, elementCharCount);
-                        if (displayWidth <= 0)
-                            continue;
-
-                        if (cellIndex + displayWidth > maxWidth)
-                            continue;
+                        SetCell(word, charIndex, textElement: textElement.Element);
+                    }
 
-                        var textElement = word.String.Substring(elementStartIndex, elementCharCount);
-                        SetCell(word, charIndex, textElement: textElement);
-                        if (displayWidth == 2)
-                        {
-                            SetCell(word, charIndex, character: '\0', isSecondCellOfWideCharacter: true);
-                        }
+                    if (textElement.DisplayWidth == 2)
+                    {
+                        SetCell(word, charIndex, character: '\0', isSecondCellOfWideCharacter: true);
                     }
                 }
 
@@ -253,7 +224,110 @@ void SetCell(Word word, int charIndex, char character = '\0', string? textElemen
         }
     }
 
-    public static int GetDisplayWidthOfComplexTextElement(string str, int elementCharOffset, int elementCharCount)
+    public static int GetDisplayWidth(string str)
+    {
+        int tabSize = SelectorOptionHolder.GetInstance().Option.Theme.TabSize;
+        int cellCount = 0;
+
+        var textElement = new TextElementEnumerator(str);
+        while (textElement.MoveNext())
+        {
+            if (textElement.IsTab)
+            {
+                cellCount += tabSize - cellCount % tabSize;
+                continue;
+            }
+
+            if (textElement.DisplayWidth <= 0)
+                continue;
+
+            cellCount += textElement.DisplayWidth;
+        }
+
+        return cellCount;
+    }
+
+    public class TextElementEnumerator
+    {
+        private readonly string _str;
+        private readonly int[] _elementIndexes;
+        private int _currentElementIndex = -1;
+        private bool _isEscaped;
+
+        public bool IsBaseCharacter => ElementCharCount == 1;
+        public bool IsEscapeSequence { get; set; }
+        public bool IsTab { get; set; }
+        public int DisplayWidth { get; set; }
+        public char Character {get; set; } = '\0';
+        public string Element {get; set; } = "";
+        public int ElementStartCharIndex {get; set;}
+        public int ElementCharCount {get; set;}
+
+        public TextElementEnumerator(string str)
+        {
+            _str = str;
+            _elementIndexes = System.Globalization.StringInfo.ParseCombiningCharacters(str);
+        }
+
+        public bool MoveNext()
+        {
+            if (_currentElementIndex >= _elementIndexes.Length)
+                return false;
+
+            ++_currentElementIndex;
+
+            if (_currentElementIndex >= _elementIndexes.Length)
+                return false;
+
+            ElementStartCharIndex = _elementIndexes[_currentElementIndex];
+            var elementStartIndexNext = (_currentElementIndex + 1 == _elementIndexes.Length) ? _str.Length : _elementIndexes[_currentElementIndex + 1];
+            ElementCharCount = elementStartIndexNext - ElementStartCharIndex;
+
+            IsEscapeSequence = false;
+            IsTab = false;
+            DisplayWidth = 0;
+            Character = '\0';
+            Element = "";
+
+            if (IsBaseCharacter)
+            {
+                // basic 2 byte characters
+                Character = _str[ElementStartCharIndex];
+                if (_isEscaped)
+                {
+                    if (Character == 'm')
+                    {
+                        _isEscaped = false;
+                    }
+                    IsEscapeSequence = true;
+                }
+                else
+                if (Character == '\x1b')
+                {
+                    _isEscaped = true;
+                    IsEscapeSequence = true;
+                }
+                else
+                if (Character == '\t')
+                {
+                    IsTab = true;
+                }
+                else
+                {
+                    DisplayWidth = Unicode.GetDisplayWidth(Character);
+                }
+            }
+            else
+            {
+                DisplayWidth = GetDisplayWidthOfComplexTextElement(_str, ElementStartCharIndex, ElementCharCount);
+                Element = _str.Substring(ElementStartCharIndex, ElementCharCount);
+            }
+
+            return true;
+        }
+    }
+
+    private static int GetDisplayWidthOfComplexTextElement(string str, int elementCharOffset, int elementCharCount)
     {
         Debug.Assert(elementCharCount > 1);
 
@@ -285,60 +359,73 @@ public static int GetDisplayWidthOfComplexTextElement(string str, int elementCha
         return displayWidth;
     }
 
-    public static int GetDisplayWidth(string str)
+    public class WrappedText
     {
-        int tabSize = SelectorOptionHolder.GetInstance().Option.Theme.TabSize;
-        int count = 0;
-        bool escaped = false;
+        private int _originalLineCount;
+        private int[] _originalLineIndexes;
+        public string[] Lines;
 
-        var textElementIndexes = System.Globalization.StringInfo.ParseCombiningCharacters(str);
-        for (int i = 0; i < textElementIndexes.Length; ++i)
+        public WrappedText(string[] lines, int maxWidth)
         {
-            var elementStartIndex = textElementIndexes[i];
-            var elementStartIndexNext = (i + 1 == textElementIndexes.Length) ? str.Length : textElementIndexes[i + 1];
+            _originalLineCount = lines.Length;
 
-            var elementCharCount = elementStartIndexNext - elementStartIndex;
-            bool isBaseCharacter = elementCharCount == 1;
-            var charIndex = elementStartIndex;
+            List<string> newLines = new(lines.Length);
+            List<int> originalLineIndexes = new(lines.Length);
+            int tabSize = SelectorOptionHolder.GetInstance().Option.Theme.TabSize;
 
-            if (isBaseCharacter)
+            for (int i = 0; i < lines.Length; ++i)
             {
-                char character = str[charIndex];
-                if (escaped)
+                string line = lines[i];
+                int cellCount = 0;
+                var textElement = new TextElementEnumerator(line);
+
+                int copyStartCharIndex = 0;
+                int copyCharCount = 0;
+                while (textElement.MoveNext())
                 {
-                    if (character == 'm')
+                    int displayWidth = Math.Max(textElement.DisplayWidth, 0);
+                    if (textElement.IsTab)
                     {
-                        escaped = false;
+                        displayWidth = tabSize - cellCount % tabSize;
                     }
+
+                    if (cellCount + displayWidth <= maxWidth || copyCharCount == 0)
+                    {
+                        copyCharCount += textElement.ElementCharCount;
+                    }
+                    else
+                    {
+                        newLines.Add(line.Substring(copyStartCharIndex, copyCharCount));
+                        originalLineIndexes.Add(i);
+
+                        copyStartCharIndex = copyStartCharIndex + copyCharCount;
+                        copyCharCount = textElement.ElementCharCount;
+                        cellCount = 0;
+                    }
+                    cellCount += displayWidth;
                 }
-                else
-                if (character == '\x1b')
-                {
-                    escaped = true;
-                }
-                else
-                if (character == '\t')
-                {
-                    count += tabSize - count % tabSize;
-                }
-                else
-                {
-                    int displayWidth = Unicode.GetDisplayWidth(character);
-                    if (displayWidth <= 0)
-                        continue;
-                    count += displayWidth;
-                }
+
+                newLines.Add(line.Substring(copyStartCharIndex, copyCharCount));
+                originalLineIndexes.Add(i);
             }
-            else
+
+            Lines = newLines.ToArray();
+            _originalLineIndexes = originalLineIndexes.ToArray();
+        }
+
+        // Returns the start line index after wrapping from the original (before wrapping) line index.
+        public int GetStartLineIndex(int originalLineIndex)
+        {
+            originalLineIndex = Math.Min(originalLineIndex, _originalLineCount - 1);
+            for (int i = 0; i < _originalLineIndexes.Length; ++i)
             {
-                int displayWidth = GetDisplayWidthOfComplexTextElement(str, elementStartIndex, elementCharCount);
-                if (displayWidth <= 0)
-                    continue;
-                count += displayWidth;
+                if (_originalLineIndexes[i] == originalLineIndex)
+                {
+                    return i;
+                }
             }
+            return -1;
         }
-
-        return count;
     }
 
     private List<Line> _lines = new List<Line>();
diff --git a/src/PowerShellRun/UI/TextWrapMode.cs b/src/PowerShellRun/UI/TextWrapMode.cs
new file mode 100644
index 0000000..011de59
--- /dev/null
+++ b/src/PowerShellRun/UI/TextWrapMode.cs
@@ -0,0 +1,9 @@
+namespace PowerShellRun;
+
+public enum TextWrapMode
+{
+    None,
+
+    // Wrap anywhere without considering words.
+    Character,
+}