diff --git a/PowerEditor/scintilla.original.forUpdating/lexilla542.zip b/PowerEditor/scintilla.original.forUpdating/lexilla543.zip
similarity index 73%
rename from PowerEditor/scintilla.original.forUpdating/lexilla542.zip
rename to PowerEditor/scintilla.original.forUpdating/lexilla543.zip
index 40d76b2b1..ecee8844a 100644
Binary files a/PowerEditor/scintilla.original.forUpdating/lexilla542.zip and b/PowerEditor/scintilla.original.forUpdating/lexilla543.zip differ
diff --git a/PowerEditor/scintilla.original.forUpdating/scintilla554.zip b/PowerEditor/scintilla.original.forUpdating/scintilla555.zip
similarity index 67%
rename from PowerEditor/scintilla.original.forUpdating/scintilla554.zip
rename to PowerEditor/scintilla.original.forUpdating/scintilla555.zip
index 0badd1f17..d9a249ecc 100644
Binary files a/PowerEditor/scintilla.original.forUpdating/scintilla554.zip and b/PowerEditor/scintilla.original.forUpdating/scintilla555.zip differ
diff --git a/boostregex/BoostRegExSearch.cxx b/boostregex/BoostRegExSearch.cxx
index 76607b11a..dc3125f67 100644
--- a/boostregex/BoostRegExSearch.cxx
+++ b/boostregex/BoostRegExSearch.cxx
@@ -1,12 +1,12 @@
 /**
  * Copyright (c) since 2009 Simon Steele - http://untidy.net/
  * Based on the work of Simon Steele for Programmer's Notepad 2 (http://untidy.net)
- * Converted from boost::xpressive to boost::regex and performance improvements 
+ * Converted from boost::xpressive to boost::regex and performance improvements
  * (principally caching the compiled regex), and support for UTF8 encoded text
  * (c) 2012 Dave Brotherstone - Changes for boost::regex
  * (c) 2013 Francois-R.Boyer@PolyMtl.ca - Empty match modes and best match backward search
  * (c) 2019 Don Ho - Adapt for upgrading Scitilla (to version 4.1.4) and boost (to version 1.70)
- * 
+ *
  */
 
 #include <stdlib.h>
@@ -15,6 +15,8 @@
 #include <string_view>
 #include <stdexcept>
 #include <optional>
+#include <map>
+#include <algorithm>
 
 #include "Scintilla.h"
 #include "ScintillaTypes.h"
@@ -54,16 +56,16 @@ class BoostRegexSearch : public RegexSearchBase
 {
 public:
 	BoostRegexSearch() {}
-	
+
 	virtual ~BoostRegexSearch()
 	{
 		delete[] _substituted;
 		_substituted = nullptr;
 	}
-	
+
 	virtual Sci::Position FindText(Document* doc, Sci::Position minPos, Sci::Position maxPos, const char *regex,
                         bool caseSensitive, bool word, bool wordStart, Scintilla::FindOption sciSearchFlags, Sci::Position *lengthRet) override;
-	
+
 	virtual const char *SubstituteByPosition(Document* doc, const char *text, Sci::Position *length) override;
 
 private:
@@ -82,38 +84,38 @@ private:
 			_position = -1;
 			return *this;
 		}
-		
+
 		void set(Document* document = NULL, Sci::Position position = -1, Sci::Position endPosition = -1) {
 			setDocument(document);
 			_position = position;
 			_endPositionForContinuationCheck = _endPosition = endPosition;
 			_documentModified = false;
 		}
-		
+
 		bool isContinuationSearch(Document* document, Sci::Position startPosition, int direction) {
 			if (hasDocumentChanged(document))
 				return false;
-			if (direction > 0) 
+			if (direction > 0)
 				return startPosition == _endPositionForContinuationCheck;
 			else
 				return startPosition == _position;
 		}
-		bool isEmpty() {
+		bool isEmpty() const {
 			return _position == _endPosition;
 		}
-		Sci::Position position() {
+		Sci::Position position() const {
 			return _position;
 		}
-		Sci::Position endPosition() {
+		Sci::Position endPosition() const {
 			return _endPosition;
 		}
-		Sci::Position length() {
+		Sci::Position length() const {
 			return _endPosition - _position;
 		}
-		int found() {
+		int found() const {
 			return _position >= 0;
 		}
-		
+
 	private:
 		bool hasDocumentChanged(Document* currentDocument) {
 			return currentDocument != _document || _documentModified;
@@ -128,7 +130,7 @@ private:
 					_document->AddWatcher(this, NULL);
 			}
 		}
-		
+
 		// DocWatcher, so we can track modifications to know if we should consider a search to be a continuation of last search:
 		virtual void NotifyModified(Document* modifiedDocument, DocModification mh, void* /*userData*/)
 		{
@@ -156,7 +158,7 @@ private:
 		{
 			if (deletedDocument == _document)
 			{
-				// We set the _document here, as we don't want to call the RemoveWatcher on this deleted document. 
+				// We set the _document here, as we don't want to call the RemoveWatcher on this deleted document.
 				// Calling RemoveWatcher inside NotifyDeleted results in a crash, as NotifyDeleted is called whilst
 				// iterating on the watchers list (since Scintilla 3.x).  Before 3.x, it was just a really bad idea.
 				_document = NULL;
@@ -168,13 +170,14 @@ private:
 		virtual void NotifyStyleNeeded(Document* /*document*/, void* /*userData*/, Sci::Position /*endPos*/) {}
 		virtual void NotifyLexerChanged(Document* /*document*/, void* /*userData*/) {}
 		virtual void NotifyErrorOccurred(Document* /*document*/, void* /*userData*/, Scintilla::Status /*status*/) {}
-		
+		virtual void NotifyGroupCompleted(Document* /*document*/, void* /*userData*/) noexcept {}
+
 		Document* _document;
 		bool _documentModified;
 		Sci::Position _position, _endPosition;
 		Sci::Position _endPositionForContinuationCheck;
 	};
-	
+
 	class CharTPtr { // Automatically translatable from utf8 to wchar_t*, if required, with allocation and deallocation on destruction; char* is not deallocated.
 	public:
 		CharTPtr(const char* ptr) : _charPtr(ptr), _wcharPtr(NULL) {}
@@ -209,20 +212,20 @@ private:
 		typedef CharT Char;
 		typedef basic_regex<CharT> Regex;
 		typedef match_results<CharacterIterator> MatchResults;
-		
+
 		MatchResults _match;
 	private:
 		Regex _regex;
 		std::string _lastRegexString;
 		int _lastCompileFlags;
 	};
-	
+
 	class SearchParameters {
 	public:
-		Sci::Position nextCharacter(Sci::Position position);
-		bool isLineStart(Sci::Position position);
-		bool isLineEnd(Sci::Position position);
-		
+		Sci::Position nextCharacter(Sci::Position position) const;
+		bool isLineStart(Sci::Position position) const;
+		bool isLineEnd(Sci::Position position) const;
+
 		Document* _document;
 		const char *_regexString;
 		int _compileFlags;
@@ -234,17 +237,17 @@ private:
 		bool _is_allowed_empty_at_start_position;
 		bool _skip_windows_line_end_as_one_character;
 	};
-	
+
 	static wchar_t *utf8ToWchar(const char *utf8);
 	static char    *wcharToUtf8(const wchar_t *w);
 	static char    *stringToCharPtr(const std::string& str);
 	static char    *stringToCharPtr(const std::wstring& str);
-	
+
 	EncodingDependent<char,    AnsiDocumentIterator> _ansi;
 	EncodingDependent<wchar_t, UTF8DocumentIterator> _utf8;
-	
+
 	char *_substituted = nullptr;
-	
+
 	Match _lastMatch;
 	int _lastDirection = 0;
 };
@@ -272,9 +275,9 @@ Sci::Position BoostRegexSearch::FindText(Document* doc, Sci::Position startPosit
 	g_exceptionMessage.clear();
 	try {
 		SearchParameters search{};
-		
+
 		search._document = doc;
-		
+
 		if (startPosition > endPosition
 			|| (startPosition == endPosition && _lastDirection < 0))  // If we search in an empty region, suppose the direction is the same as last search (this is only important to verify if there can be an empty match in that empty region).
 		{
@@ -293,26 +296,26 @@ Sci::Position BoostRegexSearch::FindText(Document* doc, Sci::Position startPosit
 		// Range endpoints should not be inside DBCS characters, but just in case, move them.
 		search._startPosition = doc->MovePositionOutsideChar(search._startPosition, 1, false);
 		search._endPosition = doc->MovePositionOutsideChar(search._endPosition, 1, false);
-		
+
 		const bool isUtf8 = (doc->CodePage() == SC_CP_UTF8);
-		search._compileFlags = 
+		search._compileFlags =
 			regex_constants::ECMAScript
 			| (caseSensitive ? 0 : regex_constants::icase);
 		search._regexString = regexString;
-		search._boostRegexFlags = 
+		search._boostRegexFlags =
 			((static_cast<int>(sciSearchFlags) & SCFIND_REGEXP_DOTMATCHESNL) ? regex_constants::match_default : regex_constants::match_not_dot_newline);
-		
+
 		const int empty_match_style = static_cast<int>(sciSearchFlags) & SCFIND_REGEXP_EMPTYMATCH_MASK;
 		const int allow_empty_at_start = static_cast<int>(sciSearchFlags) & SCFIND_REGEXP_EMPTYMATCH_ALLOWATSTART;
 
 		search._is_allowed_empty = empty_match_style != SCFIND_REGEXP_EMPTYMATCH_NONE;
-		search._is_allowed_empty_at_start_position = search._is_allowed_empty && 
+		search._is_allowed_empty_at_start_position = search._is_allowed_empty &&
 			(allow_empty_at_start
 			|| !_lastMatch.isContinuationSearch(doc, startPosition, search._direction)
 			|| (empty_match_style == SCFIND_REGEXP_EMPTYMATCH_ALL && !_lastMatch.isEmpty())	// If last match is empty and this is a continuation, then we would have same empty match at start position, if it was allowed.
 			);
 		search._skip_windows_line_end_as_one_character = (static_cast<int>(sciSearchFlags) & SCFIND_REGEXP_SKIPCRLFASONE) != 0;
-		
+
 		Match match =
 			isUtf8 ? _utf8.FindText(search)
 			       : _ansi.FindText(search);
@@ -394,7 +397,7 @@ BoostRegexSearch::Match BoostRegexSearch::EncodingDependent<CharT, CharacterIter
 	search._direction = 1;
 	const bool is_allowed_empty_at_end_position = search._is_allowed_empty_at_start_position;
 	search._is_allowed_empty_at_start_position = search._is_allowed_empty;
-	
+
 	MatchResults bestMatch;
 	Sci::Position bestPosition = -1;
 	Sci::Position bestEnd = -1;
@@ -429,7 +432,7 @@ void BoostRegexSearch::EncodingDependent<CharT, CharacterIterator>::compileRegex
 	}
 }
 
-Sci::Position BoostRegexSearch::SearchParameters::nextCharacter(Sci::Position position)
+Sci::Position BoostRegexSearch::SearchParameters::nextCharacter(Sci::Position position) const
 {
 	if (_skip_windows_line_end_as_one_character && _document->CharAt(position) == '\r' && _document->CharAt(position+1) == '\n')
 		return position + 2;
@@ -437,14 +440,14 @@ Sci::Position BoostRegexSearch::SearchParameters::nextCharacter(Sci::Position po
 		return _document->NextPosition(position, 1);
 }
 
-bool BoostRegexSearch::SearchParameters::isLineStart(Sci::Position position)
+bool BoostRegexSearch::SearchParameters::isLineStart(Sci::Position position) const
 {
 	return (position == 0)
 		|| _document->CharAt(position-1) == '\n'
 		|| (_document->CharAt(position-1) == '\r' && _document->CharAt(position) != '\n');
 }
 
-bool BoostRegexSearch::SearchParameters::isLineEnd(Sci::Position position)
+bool BoostRegexSearch::SearchParameters::isLineEnd(Sci::Position position) const
 {
 	return (position == _document->Length())
 		|| _document->CharAt(position) == '\r'
diff --git a/boostregex/UTF8DocumentIterator.cxx b/boostregex/UTF8DocumentIterator.cxx
index 8e6067ae4..78b5639fa 100644
--- a/boostregex/UTF8DocumentIterator.cxx
+++ b/boostregex/UTF8DocumentIterator.cxx
@@ -18,6 +18,8 @@
 #include <string_view>
 #include <stdexcept>
 #include <optional>
+#include <map>
+#include <algorithm>
 
 #include "ILoader.h"
 #include "ILexer.h"
diff --git a/lexilla/.gitattributes b/lexilla/.gitattributes
index 5bfdda95f..25d651539 100644
--- a/lexilla/.gitattributes
+++ b/lexilla/.gitattributes
@@ -52,6 +52,7 @@
 **.nix text
 **.octave text
 **.p text
+**.pas text
 **.pl text
 **.p6 text
 **.ps1 text
diff --git a/lexilla/cppcheck.suppress b/lexilla/cppcheck.suppress
index 9da560dd7..7ad8796a3 100644
--- a/lexilla/cppcheck.suppress
+++ b/lexilla/cppcheck.suppress
@@ -31,7 +31,6 @@ passedByValue
 missingIncludeSystem
 
 // Passing temporary string into hidden object creator functions: they do not hold the argument
-danglingTemporaryLifetime:lexilla/access/LexillaAccess.cxx
 returnDanglingLifetime:lexilla/access/LexillaAccess.cxx
 
 // cppcheck 2.11 limits checking of complex functions unless --check-level=exhaustive but that
@@ -45,6 +44,9 @@ checkLevelNormal:lexilla/lexers/LexRuby.cxx
 // Physically but not logically const.
 constVariablePointer:lexilla/examples/CheckLexilla/CheckLexilla.c
 
+// cppcheck appears to be incorrectly determining control flow: target_end is used after write
+unreadVariable:lexilla/lexers/LexRuby.cxx
+
 // Suppress most lexer warnings since the lexers are maintained by others
 redundantCondition:lexilla/lexers/LexA68k.cxx
 constParameterReference:lexilla/lexers/LexAbaqus.cxx
@@ -61,6 +63,7 @@ constParameterReference:lexilla/lexers/LexBash.cxx
 knownConditionTrueFalse:lexilla/lexers/LexBash.cxx
 variableScope:lexilla/lexers/LexBash.cxx
 constVariable:lexilla/lexers/LexBasic.cxx
+constParameterReference:lexilla/lexers/LexBullant.cxx
 constParameterReference:lexilla/lexers/LexCLW.cxx
 knownConditionTrueFalse:lexilla/lexers/LexCLW.cxx
 variableScope:lexilla/lexers/LexCmake.cxx
@@ -105,6 +108,7 @@ unreadVariable:lexilla/lexers/LexJulia.cxx
 variableScope:lexilla/lexers/LexJulia.cxx
 variableScope:lexilla/lexers/LexLaTeX.cxx
 constParameterReference:lexilla/lexers/LexLaTeX.cxx
+constParameterReference:lexilla/lexers/LexLisp.cxx
 constParameterPointer:lexilla/lexers/LexMagik.cxx
 constParameterReference:lexilla/lexers/LexMagik.cxx
 constParameterReference:lexilla/lexers/LexMarkdown.cxx
@@ -147,6 +151,8 @@ redundantInitialization:lexilla/lexers/LexRegistry.cxx
 constParameterReference:lexilla/lexers/LexRuby.cxx
 constParameterReference:lexilla/lexers/LexRust.cxx
 knownConditionTrueFalse:lexilla/lexers/LexScriptol.cxx
+constParameterReference:lexilla/lexers/LexScriptol.cxx
+constParameterPointer:lexilla/lexers/LexSmalltalk.cxx
 variableScope:lexilla/lexers/LexSpecman.cxx
 unreadVariable:lexilla/lexers/LexSpice.cxx
 constParameterReference:lexilla/lexers/LexSpice.cxx
@@ -157,6 +163,7 @@ clarifyCalculation:lexilla/lexers/LexTADS3.cxx
 constParameterReference:lexilla/lexers/LexTADS3.cxx
 constParameterReference:lexilla/lexers/LexTAL.cxx
 constVariableReference:lexilla/lexers/LexTCL.cxx
+constParameterPointer:lexilla/lexers/LexTCMD.cxx
 invalidscanf:lexilla/lexers/LexTCMD.cxx
 constParameterReference:lexilla/lexers/LexTeX.cxx
 variableScope:lexilla/lexers/LexTeX.cxx
@@ -166,6 +173,7 @@ constParameterReference:lexilla/lexers/LexVerilog.cxx
 variableScope:lexilla/lexers/LexVerilog.cxx
 badBitmaskCheck:lexilla/lexers/LexVerilog.cxx
 uselessCallsSubstr:lexilla/lexers/LexVerilog.cxx
+duplicateCondition:lexilla/lexers/LexVerilog.cxx
 constParameterReference:lexilla/lexers/LexVHDL.cxx
 constVariable:lexilla/lexers/LexVHDL.cxx
 shadowVariable:lexilla/lexers/LexVHDL.cxx
@@ -191,12 +199,60 @@ constParameterCallback:lexilla/lexers/LexPython.cxx
 constParameterCallback:lexilla/lexers/LexScriptol.cxx
 constParameterCallback:lexilla/lexers/LexVB.cxx
 
+constVariableReference:lexilla/lexers/LexA68k.cxx
+constVariableReference:lexilla/lexers/LexAPDL.cxx
+constVariableReference:lexilla/lexers/LexASY.cxx
+constVariableReference:lexilla/lexers/LexAVE.cxx
+constVariableReference:lexilla/lexers/LexAVS.cxx
+constVariableReference:lexilla/lexers/LexAU3.cxx
+constVariableReference:lexilla/lexers/LexAsn1.cxx
 constVariableReference:lexilla/lexers/LexBibTeX.cxx
+constVariableReference:lexilla/lexers/LexCaml.cxx
+constVariableReference:lexilla/lexers/LexCLW.cxx
+constVariableReference:lexilla/lexers/LexCmake.cxx
+constVariableReference:lexilla/lexers/LexCOBOL.cxx
+constVariableReference:lexilla/lexers/LexCoffeeScript.cxx
+constVariableReference:lexilla/lexers/LexCsound.cxx
 constVariableReference:lexilla/lexers/LexCSS.cxx
 constVariableReference:lexilla/lexers/LexCrontab.cxx
+constVariableReference:lexilla/lexers/LexDataflex.cxx
+constVariableReference:lexilla/lexers/LexDMAP.cxx
+constVariableReference:lexilla/lexers/LexECL.cxx
+constVariableReference:lexilla/lexers/LexEiffel.cxx
+constVariableReference:lexilla/lexers/LexEScript.cxx
+constVariableReference:lexilla/lexers/LexErlang.cxx
+constVariableReference:lexilla/lexers/LexFlagship.cxx
+constVariableReference:lexilla/lexers/LexForth.cxx
+constVariableReference:lexilla/lexers/LexFortran.cxx
+constVariableReference:lexilla/lexers/LexGAP.cxx
 constVariableReference:lexilla/lexers/LexGui4Cli.cxx
+constVariableReference:lexilla/lexers/LexKix.cxx
+constVariableReference:lexilla/lexers/LexKVIrc.cxx
+constVariableReference:lexilla/lexers/LexLout.cxx
+constVariableReference:lexilla/lexers/LexMagik.cxx
+constVariableReference:lexilla/lexers/LexMatlab.cxx
 constVariableReference:lexilla/lexers/LexMetapost.cxx
+constVariableReference:lexilla/lexers/LexMMIXAL.cxx
+constVariableReference:lexilla/lexers/LexMSSQL.cxx
+constVariableReference:lexilla/lexers/LexNsis.cxx
 constVariableReference:lexilla/lexers/LexOpal.cxx
+constVariableReference:lexilla/lexers/LexPOV.cxx
+constVariableReference:lexilla/lexers/LexPascal.cxx
+constVariableReference:lexilla/lexers/LexPB.cxx
+constVariableReference:lexilla/lexers/LexPowerPro.cxx
+constVariableReference:lexilla/lexers/LexPS.cxx
+constVariableReference:lexilla/lexers/LexRebol.cxx
+constVariableReference:lexilla/lexers/LexSAS.cxx
+constVariableReference:lexilla/lexers/LexSML.cxx
+constVariableReference:lexilla/lexers/LexSorcus.cxx
+constVariableReference:lexilla/lexers/LexSpecman.cxx
+constVariableReference:lexilla/lexers/LexStata.cxx
+constVariableReference:lexilla/lexers/LexTACL.cxx
+constVariableReference:lexilla/lexers/LexTADS3.cxx
+constVariableReference:lexilla/lexers/LexTAL.cxx
+constVariableReference:lexilla/lexers/LexTCMD.cxx
+constVariableReference:lexilla/lexers/LexTeX.cxx
+constVariableReference:lexilla/lexers/LexVHDL.cxx
 
 // Suppress everything in test example files
 *:lexilla/test/examples/*
diff --git a/lexilla/doc/Lexilla.html b/lexilla/doc/Lexilla.html
index 35ffbfb98..f8d4f15da 100644
--- a/lexilla/doc/Lexilla.html
+++ b/lexilla/doc/Lexilla.html
@@ -9,7 +9,7 @@
     <meta name="keywords" content="Scintilla, SciTE, Editing Component, Text Editor" />
     <meta name="Description"
     content="www.scintilla.org is the home of the Scintilla editing component and SciTE text editor application." />
-    <meta name="Date.Modified" content="20241218" />
+    <meta name="Date.Modified" content="20250225" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <style type="text/css">
         .logo {
@@ -61,8 +61,8 @@
           <font color="#FFCC99" size="4"> A library of language lexers for use with Scintilla</font>
         </td>
         <td width="40%" align="right">
-          <font color="#FFCC99" size="3">Release version 5.4.2<br />
-           Site last modified December 18 2024</font>
+          <font color="#FFCC99" size="3">Release version 5.4.3<br />
+           Site last modified February 25 2025</font>
         </td>
         <td width="20%">
           &nbsp;
@@ -77,11 +77,11 @@
       </tr>
     </table>
     <ul id="versionlist">
+      <li>Version 5.4.3 improves C++, Modula 3, Pascal, Python, and Ruby.</li>
       <li>Version 5.4.2 adds Nix lexer. Improves JavaScript, PHP, Rust, TOML, and Zig.</li>
       <li>Version 5.4.1 adds Dart, troff, and Zig lexers. Improves C++, F#, HTML, and Smalltalk.</li>
       <li>Version 5.4.0 adds a TOML lexer.</li>
       <li>Version 5.3.3 improves HTML, JavaScript, Lua, PHP, and XML.</li>
-      <li>Version 5.3.2 improves COBOL, HTML, Lua, Ruby, and Rust.</li>
     </ul>
     <ul id="menu">
       <li id="remote1"><a href="https://www.scintilla.org/SciTEImage.html">Screenshot</a></li>
diff --git a/lexilla/doc/LexillaDownload.html b/lexilla/doc/LexillaDownload.html
index e358fdc3c..d8d0307e8 100644
--- a/lexilla/doc/LexillaDownload.html
+++ b/lexilla/doc/LexillaDownload.html
@@ -26,9 +26,9 @@
     <table bgcolor="#CCCCCC" width="100%" cellspacing="0" cellpadding="8" border="0">
       <tr>
         <td>
-          <font size="4"> <a href="https://www.scintilla.org/lexilla542.zip">
+          <font size="4"> <a href="https://www.scintilla.org/lexilla543.zip">
 	Windows</a>&nbsp;&nbsp;
-	<a href="https://www.scintilla.org/lexilla542.tgz">
+	<a href="https://www.scintilla.org/lexilla543.tgz">
           GTK/Linux</a>&nbsp;&nbsp;
 	</font>
         </td>
@@ -42,7 +42,7 @@
       containing very few restrictions.
     </p>
     <h3>
-       Release 5.4.2
+       Release 5.4.3
     </h3>
     <h4>
        Source Code
@@ -50,8 +50,8 @@
        The source code package contains all of the source code for Lexilla but no binary
 	executable code and is available in
        <ul>
-       <li><a href="https://www.scintilla.org/lexilla542.zip">zip format</a> (1.4M) commonly used on Windows</li>
-       <li><a href="https://www.scintilla.org/lexilla542.tgz">tgz format</a> (1.0M) commonly used on Linux and compatible operating systems</li>
+       <li><a href="https://www.scintilla.org/lexilla543.zip">zip format</a> (1.4M) commonly used on Windows</li>
+       <li><a href="https://www.scintilla.org/lexilla543.tgz">tgz format</a> (1.0M) commonly used on Linux and compatible operating systems</li>
        </ul>
        Instructions for building on both Windows and Linux are included in the readme file.
     <h4>
diff --git a/lexilla/doc/LexillaHistory.html b/lexilla/doc/LexillaHistory.html
index 25661247b..be5b34adf 100644
--- a/lexilla/doc/LexillaHistory.html
+++ b/lexilla/doc/LexillaHistory.html
@@ -37,6 +37,7 @@
        Lexilla was originally code that was part of the Scintilla project.
        Thus it shares much of the history and contributors of Scintilla before it was extracted as its own project.
     </p>
+    <a href="#Releases">Releases</a>
     <h2>Contributors</h2>
     <p>
        Thanks to all the people that have contributed patches, bug reports and suggestions.
@@ -588,9 +589,42 @@
       </tr><tr>
 	<td>Henrik S. Johansen</td>
 	<td>Ekopalypse</td>
+	<td>HoTschir</td>
     </tr>
     </table>
-    <h2>Releases</h2>
+    <h2 id="Releases">Releases</h2>
+    <h3>
+       <a href="https://www.scintilla.org/lexilla543.zip">Release 5.4.3</a>
+    </h3>
+    <ul>
+	<li>
+	Released 25 February 2025.
+	</li>
+	<li>
+	C++: Fix evaluation of != in preprocessor condition.
+	<a href="https://github.com/ScintillaOrg/lexilla/issues/299">Issue #299</a>.
+	</li>
+	<li>
+	Modula-3: Allow digits in uppercase identifiers.
+	<a href="https://github.com/ScintillaOrg/lexilla/issues/297">Issue #297</a>.
+	</li>
+	<li>
+	Pascal: Fix asm style extending past end.
+	<a href="https://github.com/ScintillaOrg/lexilla/issues/295">Issue #295</a>.
+	</li>
+	<li>
+	Python: Fix detection of attributes and decorators.
+	<a href="https://github.com/ScintillaOrg/lexilla/issues/294">Issue #294</a>,
+	<a href="https://github.com/ScintillaOrg/lexilla/pull/302">Pull request #302</a>.
+	</li>
+	<li>
+	Ruby: Implement substyles for identifiers SCE_RB_IDENTIFIER.
+	</li>
+	<li>
+	Ruby: Recognize name as SCE_RB_DEFNAME in def when `::` used as well as `.`.
+	<a href="https://github.com/ScintillaOrg/lexilla/issues/300">Issue #300</a>.
+	</li>
+    </ul>
     <h3>
        <a href="https://www.scintilla.org/lexilla542.zip">Release 5.4.2</a>
     </h3>
diff --git a/lexilla/lexers/LexCPP.cxx b/lexilla/lexers/LexCPP.cxx
index 2b1580bf3..7e0ea2ca8 100644
--- a/lexilla/lexers/LexCPP.cxx
+++ b/lexilla/lexers/LexCPP.cxx
@@ -496,7 +496,7 @@ struct OptionSetCPP : public OptionSet<OptionsCPP> {
 
 const char styleSubable[] = {SCE_C_IDENTIFIER, SCE_C_COMMENTDOCKEYWORD, 0};
 
-LexicalClass lexicalClasses[] = {
+const LexicalClass lexicalClasses[] = {
 	// Lexer Cpp SCLEX_CPP SCE_C_:
 	0, "SCE_C_DEFAULT", "default", "White space",
 	1, "SCE_C_COMMENT", "comment", "Comment: /* */.",
@@ -528,7 +528,7 @@ LexicalClass lexicalClasses[] = {
 	27, "SCE_C_ESCAPESEQUENCE", "literal string escapesequence", "Escape sequence",
 };
 
-const int sizeLexicalClasses = static_cast<int>(std::size(lexicalClasses));
+constexpr int sizeLexicalClasses{ std::size(lexicalClasses) };
 
 }
 
@@ -1725,7 +1725,7 @@ void LexerCPP::EvaluateTokens(Tokens &tokens, const SymbolTable &preprocessorDef
 
 	// Evaluate logical negations
 	for (size_t j=0; (j+1)<tokens.size();) {
-		if (setNegationOp.Contains(tokens[j][0])) {
+		if (setNegationOp.Contains(tokens[j][0]) && (tokens[j] != "!=")) {
 			int isTrue = atoi(tokens[j+1].c_str());
 			if (tokens[j] == "!")
 				isTrue = !isTrue;
diff --git a/lexilla/lexers/LexModula.cxx b/lexilla/lexers/LexModula.cxx
index caec8eb3d..10aa6adb2 100644
--- a/lexilla/lexers/LexModula.cxx
+++ b/lexilla/lexers/LexModula.cxx
@@ -366,7 +366,7 @@ static void ColouriseModulaDoc(	Sci_PositionU startPos,
 				if( isupper( sc.ch ) && isupper( sc.chNext ) ) {
 					for( i = 0; i < BUFLEN - 1; i++ ) {
 						buf[i] = sc.GetRelative(i);
-						if( !isalpha( buf[i] ) && !(buf[i] == '_') )
+						if( !(IsAlphaNumeric( buf[i] ) || buf[i] == '_') )
 							break;
 					}
 					kl = i;
diff --git a/lexilla/lexers/LexPascal.cxx b/lexilla/lexers/LexPascal.cxx
index bd6678760..28498346c 100644
--- a/lexilla/lexers/LexPascal.cxx
+++ b/lexilla/lexers/LexPascal.cxx
@@ -133,7 +133,9 @@ contains requires
 
 using namespace Lexilla;
 
-static void GetRangeLowered(Sci_PositionU start,
+namespace {
+
+void GetRangeLowered(Sci_PositionU start,
 		Sci_PositionU end,
 		Accessor &styler,
 		char *s,
@@ -146,7 +148,7 @@ static void GetRangeLowered(Sci_PositionU start,
 	s[i] = '\0';
 }
 
-static void GetForwardRangeLowered(Sci_PositionU start,
+void GetForwardRangeLowered(Sci_PositionU start,
 		CharacterSet &charSet,
 		Accessor &styler,
 		char *s,
@@ -170,7 +172,7 @@ enum {
 	stateFoldMaskAll = 0x0FFF
 };
 
-static void ClassifyPascalWord(WordList *keywordlists[], StyleContext &sc, int &curLineState, bool bSmartHighlighting) {
+void ClassifyPascalWord(WordList *keywordlists[], StyleContext &sc, int &curLineState, bool bSmartHighlighting) {
 	WordList& keywords = *keywordlists[0];
 
 	char s[100];
@@ -215,7 +217,7 @@ static void ClassifyPascalWord(WordList *keywordlists[], StyleContext &sc, int &
 	sc.SetState(SCE_PAS_DEFAULT);
 }
 
-static void ColourisePascalDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
+void ColourisePascalDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
 		Accessor &styler) {
 	bool bSmartHighlighting = styler.GetPropertyInt("lexer.pascal.smart.highlighting", 1) != 0;
 
@@ -225,18 +227,14 @@ static void ColourisePascalDoc(Sci_PositionU startPos, Sci_Position length, int
 	CharacterSet setHexNumber(CharacterSet::setDigits, "abcdefABCDEF");
 	CharacterSet setOperator(CharacterSet::setNone, "#$&'()*+,-./:;<=>@[]^{}");
 
-	Sci_Position curLine = styler.GetLine(startPos);
-	int curLineState = curLine > 0 ? styler.GetLineState(curLine - 1) : 0;
+	int curLineState = 0;
 
 	StyleContext sc(startPos, length, initStyle, styler);
+	if (sc.currentLine > 0) {
+		curLineState = styler.GetLineState(sc.currentLine - 1);
+	}
 
 	for (; sc.More(); sc.Forward()) {
-		if (sc.atLineEnd) {
-			// Update the line state, so it can be seen by next line
-			curLine = styler.GetLine(sc.currentPos);
-			styler.SetLineState(curLine, curLineState);
-		}
-
 		// Determine if the current state should terminate.
 		switch (sc.state) {
 			case SCE_PAS_NUMBER:
@@ -335,6 +333,11 @@ static void ColourisePascalDoc(Sci_PositionU startPos, Sci_Position length, int
 				sc.SetState(SCE_PAS_ASM);
 			}
 		}
+
+		if (sc.atLineEnd) {
+			// Update the line state, so it can be seen by next line
+			styler.SetLineState(sc.currentLine, curLineState);
+		}
 	}
 
 	if (sc.state == SCE_PAS_IDENTIFIER && setWord.Contains(sc.chPrev)) {
@@ -344,11 +347,11 @@ static void ColourisePascalDoc(Sci_PositionU startPos, Sci_Position length, int
 	sc.Complete();
 }
 
-static bool IsStreamCommentStyle(int style) {
+bool IsStreamCommentStyle(int style) {
 	return style == SCE_PAS_COMMENT || style == SCE_PAS_COMMENT2;
 }
 
-static bool IsCommentLine(Sci_Position line, Accessor &styler) {
+bool IsCommentLine(Sci_Position line, Accessor &styler) {
 	Sci_Position pos = styler.LineStart(line);
 	Sci_Position eolPos = styler.LineStart(line + 1) - 1;
 	for (Sci_Position i = pos; i < eolPos; i++) {
@@ -364,16 +367,16 @@ static bool IsCommentLine(Sci_Position line, Accessor &styler) {
 	return false;
 }
 
-static unsigned int GetFoldInPreprocessorLevelFlag(int lineFoldStateCurrent) {
+unsigned int GetFoldInPreprocessorLevelFlag(int lineFoldStateCurrent) {
 	return lineFoldStateCurrent & stateFoldInPreprocessorLevelMask;
 }
 
-static void SetFoldInPreprocessorLevelFlag(int &lineFoldStateCurrent, unsigned int nestLevel) {
+void SetFoldInPreprocessorLevelFlag(int &lineFoldStateCurrent, unsigned int nestLevel) {
 	lineFoldStateCurrent &= ~stateFoldInPreprocessorLevelMask;
 	lineFoldStateCurrent |= nestLevel & stateFoldInPreprocessorLevelMask;
 }
 
-static void ClassifyPascalPreprocessorFoldPoint(int &levelCurrent, int &lineFoldStateCurrent,
+void ClassifyPascalPreprocessorFoldPoint(int &levelCurrent, int &lineFoldStateCurrent,
 		Sci_PositionU startPos, Accessor &styler) {
 	CharacterSet setWord(CharacterSet::setAlpha);
 
@@ -406,7 +409,7 @@ static void ClassifyPascalPreprocessorFoldPoint(int &levelCurrent, int &lineFold
 	}
 }
 
-static Sci_PositionU SkipWhiteSpace(Sci_PositionU currentPos, Sci_PositionU endPos,
+Sci_PositionU SkipWhiteSpace(Sci_PositionU currentPos, Sci_PositionU endPos,
 		Accessor &styler, bool includeChars = false) {
 	CharacterSet setWord(CharacterSet::setAlphaNum, "_");
 	Sci_PositionU j = currentPos + 1;
@@ -419,7 +422,7 @@ static Sci_PositionU SkipWhiteSpace(Sci_PositionU currentPos, Sci_PositionU endP
 	return j;
 }
 
-static void ClassifyPascalWordFoldPoint(int &levelCurrent, int &lineFoldStateCurrent,
+void ClassifyPascalWordFoldPoint(int &levelCurrent, int &lineFoldStateCurrent,
 		Sci_Position startPos, Sci_PositionU endPos,
 		Sci_PositionU lastStart, Sci_PositionU currentPos, Accessor &styler) {
 	char s[100];
@@ -517,7 +520,7 @@ static void ClassifyPascalWordFoldPoint(int &levelCurrent, int &lineFoldStateCur
 	}
 }
 
-static void FoldPascalDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *[],
+void FoldPascalDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *[],
 		Accessor &styler) {
 	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
 	bool foldPreprocessor = styler.GetPropertyInt("fold.preprocessor") != 0;
@@ -608,9 +611,11 @@ static void FoldPascalDoc(Sci_PositionU startPos, Sci_Position length, int initS
 	styler.SetLevel(lineCurrent, lev);
 }
 
-static const char * const pascalWordListDesc[] = {
+const char * const pascalWordListDesc[] = {
 	"Keywords",
 	0
 };
 
+}
+
 extern const LexerModule lmPascal(SCLEX_PASCAL, ColourisePascalDoc, "pascal", FoldPascalDoc, pascalWordListDesc);
diff --git a/lexilla/lexers/LexPython.cxx b/lexilla/lexers/LexPython.cxx
index 28d12154a..19b260400 100644
--- a/lexilla/lexers/LexPython.cxx
+++ b/lexilla/lexers/LexPython.cxx
@@ -714,9 +714,9 @@ void SCI_METHOD LexerPython::Lex(Sci_PositionU startPos, Sci_Position length, in
 							pos--;
 							ch = styler.SafeGetCharAt(pos, '\0');
 						}
-						if (pos < 0 || ch == '.') {
+						if (ch == '.') {
 							// Is this an attribute we could style? if it is, do as asked
-							bool isComment = false;
+							bool isComment = AnyOf(styler.BufferStyleAt(pos), SCE_P_COMMENTLINE, SCE_P_COMMENTBLOCK);
 							bool isDecoratorAttribute = false;
 							const Sci_Position attrLine = styler.GetLine(pos);
 							for (Sci_Position i = styler.LineStart(attrLine); i < pos; i++) {
@@ -726,7 +726,7 @@ void SCI_METHOD LexerPython::Lex(Sci_PositionU startPos, Sci_Position length, in
 								if (attrCh == '#')
 									isComment = true;
 								// Detect if this attribute belongs to a decorator
-								if (!IsASpaceOrTab(ch))
+								if (!IsASpaceOrTab(attrCh))
 									break;
 							}
 							if (((isDecoratorAttribute) && (!isComment)) && (((options.decoratorAttributes == 1)  && (style == SCE_P_IDENTIFIER)) || (options.decoratorAttributes == 2))) {
diff --git a/lexilla/lexers/LexRuby.cxx b/lexilla/lexers/LexRuby.cxx
index eb3bf26e4..54bc2ffde 100644
--- a/lexilla/lexers/LexRuby.cxx
+++ b/lexilla/lexers/LexRuby.cxx
@@ -14,18 +14,25 @@
 
 #include <string>
 #include <string_view>
+#include <vector>
+#include <map>
 
 #include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
 
+#include "InList.h"
 #include "WordList.h"
 #include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
 #include "CharacterSet.h"
 #include "LexerModule.h"
+#include "OptionSet.h"
+#include "SubStyles.h"
+#include "DefaultLexer.h"
 
+using namespace Scintilla;
 using namespace Lexilla;
 
 namespace {
@@ -44,27 +51,27 @@ constexpr bool isHighBitChar(char ch) noexcept {
     return static_cast<unsigned char>(ch) > 127;
 }
 
-inline bool isSafeAlpha(char ch) noexcept {
+bool isSafeAlpha(char ch) noexcept {
     return (isSafeASCII(ch) && isalpha(ch)) || ch == '_';
 }
 
-inline bool isSafeAlphaOrHigh(char ch) noexcept {
+bool isSafeAlphaOrHigh(char ch) noexcept {
 	return isHighBitChar(ch) || isalpha(ch) || ch == '_';
 }
 
-inline bool isSafeAlnum(char ch) noexcept {
+bool isSafeAlnum(char ch) noexcept {
     return (isSafeASCII(ch) && isalnum(ch)) || ch == '_';
 }
 
-inline bool isSafeAlnumOrHigh(char ch) noexcept {
+bool isSafeAlnumOrHigh(char ch) noexcept {
     return isHighBitChar(ch) || isalnum(ch) || ch == '_';
 }
 
-inline bool isSafeDigit(char ch) noexcept {
+bool isSafeDigit(char ch) noexcept {
     return isSafeASCII(ch) && isdigit(ch);
 }
 
-inline bool isSafeWordcharOrHigh(char ch) noexcept {
+bool isSafeWordcharOrHigh(char ch) noexcept {
     // Error: scintilla's KeyWords.h includes '.' as a word-char
     // we want to separate things that can take methods from the
     // methods.
@@ -75,7 +82,7 @@ constexpr bool isWhiteSpace(char ch) noexcept {
     return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n';
 }
 
-inline bool isQestionMarkChar(char chNext, char chNext2) noexcept {
+bool isQuestionMarkChar(char chNext, char chNext2) noexcept {
     // followed by a single character or escape sequence that corresponds to a single codepoint
     if (isSafeAlnum(chNext)) {
         return !isSafeWordcharOrHigh(chNext2);
@@ -84,20 +91,169 @@ inline bool isQestionMarkChar(char chNext, char chNext2) noexcept {
     return !IsASpace(chNext);
 }
 
-#define MAX_KEYWORD_LENGTH 200
+// Options used for LexerRuby
+struct OptionsRuby {
+	bool foldCompact = true;
+	bool foldComment = false;
+};
 
-#define STYLE_MASK 63
-#define actual_style(style) ((style) & STYLE_MASK)
+const char *const rubyWordListDesc[] = {
+    "Keywords",
+    nullptr
+};
+
+struct OptionSetRuby : public OptionSet<OptionsRuby> {
+	OptionSetRuby() {
+		DefineProperty("fold.compact", &OptionsRuby::foldCompact);
+		DefineProperty("fold.comment", &OptionsRuby::foldComment);
+
+		DefineWordListSets(rubyWordListDesc);
+	}
+};
+
+const char styleSubable[] = { SCE_RB_IDENTIFIER, 0 };
+
+const LexicalClass lexicalClasses[] = {
+	// Lexer ruby SCLEX_RUBY SCE_RB_
+	0, "SCE_RB_DEFAULT", "default", "White space",
+	1, "SCE_RB_ERROR", "error", "Error",
+	2, "SCE_RB_COMMENTLINE", "comment", "Comment",
+	3, "SCE_RB_POD", "data", "POD",
+	4, "SCE_RB_NUMBER", "literal numeric", "Number",
+	5, "SCE_RB_WORD", "keyword", "Keyword",
+	6, "SCE_RB_STRING", "literal string", "Quoted string",
+	7, "SCE_RB_CHARACTER", "literal string character", "Quoted string",
+	8, "SCE_RB_CLASSNAME", "identifier", "Class name definition",
+	9, "SCE_RB_DEFNAME", "identifier", "Function or method name definition",
+	10, "SCE_RB_OPERATOR", "operator", "Operator",
+	11, "SCE_RB_IDENTIFIER", "identifier", "Identifiers",
+	12, "SCE_RB_REGEX", "literal regex", "RegEx",
+	13, "SCE_RB_GLOBAL", "identifier", "Global",
+	14, "SCE_RB_SYMBOL", "identifier symbol", "",
+	15, "SCE_RB_MODULE_NAME", "identifier", "Module name",
+	16, "SCE_RB_INSTANCE_VAR", "identifier", "Instance variable",
+	17, "SCE_RB_CLASS_VAR", "identifier", "Class variable",
+	18, "SCE_RB_BACKTICKS", "literal string interpolated", "Back ticks",
+	19, "SCE_RB_DATASECTION", "data", "Data section",
+	20, "SCE_RB_HERE_DELIM", "here-doc literal string", "Here-doc (delimiter)",
+	21, "SCE_RB_HERE_Q", "here-doc literal string", "Here-doc (single quoted, q)",
+	22, "SCE_RB_HERE_QQ", "here-doc literal string", "Here-doc (double quoted, qq)",
+	23, "SCE_RB_HERE_QX", "here-doc literal string", "Here-doc (back ticks, qx)",
+	24, "SCE_RB_STRING_Q", "literal string", "Single quoted string, generic",
+	25, "SCE_RB_STRING_QQ", "literal string interpolated", "qq = double quoted string",
+	26, "SCE_RB_STRING_QX", "literal string interpolated", "qx = back ticks",
+	27, "SCE_RB_STRING_QR", "literal regex", "qr = regex",
+	28, "SCE_RB_STRING_QW", "literal string interpolated", "qw = array",
+	29, "SCE_RB_WORD_DEMOTED", "keyword", "Keyword demoted",
+	30, "SCE_RB_STDIN", "file", "Standard input stream",
+	31, "SCE_RB_STDOUT", "file", "Standard output stream",
+	40, "SCE_RB_STDERR", "file", "Standard error stream",
+	41, "SCE_RB_STRING_W", "literal string", "String array",
+	42, "SCE_RB_STRING_I", "literal string", "Symbol array",
+	43, "SCE_RB_STRING_QI", "literal string interpolated", "Interpolable symbol array",
+	44, "SCE_RB_STRING_QS", "identifier symbol", "Symbol",
+};
+
+class LexerRuby : public DefaultLexer {
+	WordList keywords;
+	OptionsRuby options;
+	OptionSetRuby osRuby;
+	SubStyles subStyles{styleSubable};
+public:
+	LexerRuby() :
+		DefaultLexer("ruby", SCLEX_RUBY, lexicalClasses, std::size(lexicalClasses)) {
+	}
+	// Deleted so LexerRuby objects can not be copied.
+	LexerRuby(const LexerRuby &) = delete;
+	LexerRuby(LexerRuby &&) = delete;
+	void operator=(const LexerRuby &) = delete;
+	void operator=(LexerRuby &&) = delete;
+	~LexerRuby() override = default;
+
+	const char *SCI_METHOD PropertyNames() override {
+		return osRuby.PropertyNames();
+	}
+	int SCI_METHOD PropertyType(const char *name) override {
+		return osRuby.PropertyType(name);
+	}
+	const char *SCI_METHOD DescribeProperty(const char *name) override {
+		return osRuby.DescribeProperty(name);
+	}
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+	const char *SCI_METHOD PropertyGet(const char *key) override {
+		return osRuby.PropertyGet(key);
+	}
+	const char *SCI_METHOD DescribeWordListSets() override {
+		return osRuby.DescribeWordListSets();
+	}
+	Sci_Position SCI_METHOD WordListSet(int n, const char *wl) override;
+
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override;
+	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override;
+
+	int SCI_METHOD AllocateSubStyles(int styleBase, int numberStyles) override {
+		return subStyles.Allocate(styleBase, numberStyles);
+	}
+	int SCI_METHOD SubStylesStart(int styleBase) override {
+		return subStyles.Start(styleBase);
+	}
+	int SCI_METHOD SubStylesLength(int styleBase) override {
+		return subStyles.Length(styleBase);
+	}
+	int SCI_METHOD StyleFromSubStyle(int subStyle) override {
+		const int styleBase = subStyles.BaseStyle(subStyle);
+		return styleBase;
+	}
+	int SCI_METHOD PrimaryStyleFromStyle(int style) override {
+		return style;
+	}
+	void SCI_METHOD FreeSubStyles() override {
+		subStyles.Free();
+	}
+	void SCI_METHOD SetIdentifiers(int style, const char *identifiers) override {
+		subStyles.SetIdentifiers(style, identifiers);
+	}
+	int SCI_METHOD DistanceToSecondaryStyles() override {
+		return 0;
+	}
+	const char *SCI_METHOD GetSubStyleBases() override {
+		return styleSubable;
+	}
+
+	static ILexer5 *LexerFactoryRuby() {
+		return new LexerRuby();
+	}
+};
+
+Sci_Position SCI_METHOD LexerRuby::PropertySet(const char *key, const char *val) {
+	if (osRuby.PropertySet(&options, key, val)) {
+		return 0;
+	}
+	return -1;
+}
+
+Sci_Position SCI_METHOD LexerRuby::WordListSet(int n, const char *wl) {
+	WordList *wordListN = nullptr;
+	switch (n) {
+	case 0:
+		wordListN = &keywords;
+		break;
+	default:
+		break;
+	}
+	Sci_Position firstModification = -1;
+	if (wordListN && wordListN->Set(wl)) {
+		firstModification = 0;
+	}
+	return firstModification;
+}
 
 bool followsDot(Sci_PositionU pos, Accessor &styler) {
-    styler.Flush();
     for (; pos >= 1; --pos) {
-        const int style = actual_style(styler.StyleAt(pos));
-        char ch;
+        const int style = styler.BufferStyleAt(pos);
         switch (style) {
         case SCE_RB_DEFAULT:
-            ch = styler[pos];
-            if (ch == ' ' || ch == '\t') {
+            if (IsASpaceOrTab(styler[pos])) {
                 //continue
             } else {
                 return false;
@@ -114,70 +270,77 @@ bool followsDot(Sci_PositionU pos, Accessor &styler) {
     return false;
 }
 
+constexpr bool IsIdentifierStyle(int style) noexcept {
+    return style == SCE_RB_IDENTIFIER || style >= SubStylesFirst;
+}
+
 // Forward declarations
-bool keywordIsAmbiguous(const char *prevWord) noexcept;
+bool keywordIsAmbiguous(const std::string &prevWord) noexcept;
 bool keywordDoStartsLoop(Sci_Position pos, Accessor &styler);
-bool keywordIsModifier(const char *word, Sci_Position pos, Accessor &styler);
+bool keywordIsModifier(const std::string &word, Sci_Position pos, Accessor &styler);
 
 // pseudo style: prefer regex after identifier
 #define SCE_RB_IDENTIFIER_PREFERRE  SCE_RB_UPPER_BOUND
 
-int ClassifyWordRb(Sci_PositionU start, Sci_PositionU end, char ch, WordList &keywords, Accessor &styler, char *prevWord) {
-    char s[MAX_KEYWORD_LENGTH];
-    Sci_PositionU j = 0;
-    Sci_PositionU lim = end - start + 1; // num chars to copy
-    if (lim >= MAX_KEYWORD_LENGTH) {
-        lim = MAX_KEYWORD_LENGTH - 1;
-    }
-    for (Sci_PositionU i = start; j < lim; i++, j++) {
-        s[j] = styler[i];
-    }
-    s[j] = '\0';
+int ClassifyWordRb(Sci_PositionU end, char ch, char chNext, const WordList &keywords, Accessor &styler, std::string &prevWord, const WordClassifier &idClasser) {
+    const Sci_PositionU start = styler.GetStartSegment();
+    const std::string s = styler.GetRange(start, end);
     int chAttr = SCE_RB_IDENTIFIER;
     int style = SCE_RB_DEFAULT;
-    if (0 == strcmp(prevWord, "class"))
+    if (prevWord == "class")
         chAttr = SCE_RB_CLASSNAME;
-    else if (0 == strcmp(prevWord, "module"))
+    else if (prevWord == "module")
         chAttr = SCE_RB_MODULE_NAME;
-    else if (0 == strcmp(prevWord, "def")) {
+    else if (prevWord == "def") {
         chAttr = SCE_RB_DEFNAME;
-        if (ch == '.') {
-            if (strcmp(s, "self") == 0) {
+        if (ch == '.' || (ch == ':' && chNext == ':')) {
+            if (s == "self") {
                 style = SCE_RB_WORD_DEMOTED;
             } else {
                 style = SCE_RB_IDENTIFIER;
+                const int subStyle = idClasser.ValueFor(s);
+                if (subStyle >= 0) {
+                    style = subStyle;
+                }
             }
         }
-    } else if (keywords.InList(s) && ((start == 0) || !followsDot(start - 1, styler))) {
-        if (keywordIsAmbiguous(s)
+    } else if ((start == 0) || !followsDot(start - 1, styler)) {
+        if (keywords.InList(s)) {
+            if (keywordIsAmbiguous(s)
                 && keywordIsModifier(s, start, styler)) {
 
-            // Demoted keywords are colored as keywords,
-            // but do not affect changes in indentation.
-            //
-            // Consider the word 'if':
-            // 1. <<if test ...>> : normal
-            // 2. <<stmt if test>> : demoted
-            // 3. <<lhs = if ...>> : normal: start a new indent level
-            // 4. <<obj.if = 10>> : color as identifier, since it follows '.'
+                // Demoted keywords are colored as keywords,
+                // but do not affect changes in indentation.
+                //
+                // Consider the word 'if':
+                // 1. <<if test ...>> : normal
+                // 2. <<stmt if test>> : demoted
+                // 3. <<lhs = if ...>> : normal: start a new indent level
+                // 4. <<obj.if = 10>> : color as identifier, since it follows '.'
 
-            chAttr = SCE_RB_WORD_DEMOTED;
+                chAttr = SCE_RB_WORD_DEMOTED;
+            } else {
+                chAttr = SCE_RB_WORD;
+                style = SCE_RB_WORD;
+                prevWord = s;
+            }
         } else {
-            chAttr = SCE_RB_WORD;
-            style = SCE_RB_WORD;
-            strcpy(prevWord, s);
+            const int subStyle = idClasser.ValueFor(s);
+            if (subStyle >= 0) {
+                style = subStyle;
+            }
         }
     }
     if (style == SCE_RB_DEFAULT) {
         style = chAttr;
-        prevWord[0] = 0;
+        prevWord.clear();
     }
-    styler.ColourTo(end, style);
+    styler.ColourTo(end - 1, style);
 
     if (chAttr == SCE_RB_IDENTIFIER) {
         // find heredoc in lib/ruby folder: rg "\w+\s+<<[\w\-~'\"`]"
         // Kernel methods
-        if (!strcmp(s, "puts") || !strcmp(s, "print") || !strcmp(s, "warn") || !strcmp(s, "eval")) {
+        if (InList(s, { "puts", "print", "warn", "eval" } )) {
             chAttr = SCE_RB_IDENTIFIER_PREFERRE;
         }
     }
@@ -232,7 +395,7 @@ constexpr char opposite(char ch) noexcept {
 }
 
 // Null transitions when we see we've reached the end
-// and need to relex the curr char.
+// and need to re-lex the curr char.
 
 void redo_char(Sci_Position &i, char &ch, char &chNext, char &chNext2, int &state) noexcept {
     i--;
@@ -252,20 +415,18 @@ bool currLineContainsHereDelims(Sci_Position &startPos, Accessor &styler) {
     if (startPos <= 1)
         return false;
 
-    Sci_Position pos;
-    for (pos = startPos - 1; pos > 0; pos--) {
+    Sci_Position pos = startPos - 1;
+    for (; pos > 0; pos--) {
         const char ch = styler.SafeGetCharAt(pos);
         if (isEOLChar(ch)) {
             // Leave the pointers where they are -- there are no
-            // here doc delims on the current line, even if
+            // here doc delimiters on the current line, even if
             // the EOL isn't default style
 
             return false;
-        } else {
-            styler.Flush();
-            if (actual_style(styler.StyleAt(pos)) == SCE_RB_HERE_DELIM) {
-                break;
-            }
+        }
+        if (styler.StyleIndexAt(pos) == SCE_RB_HERE_DELIM) {
+            break;
         }
     }
     if (pos == 0) {
@@ -281,12 +442,10 @@ bool currLineContainsHereDelims(Sci_Position &startPos, Accessor &styler) {
 
 class QuoteCls {
 public:
-    int  Count;
-    char Up;
-    char Down;
-    QuoteCls() noexcept {
-        New();
-    }
+    int  Count = 0;
+    char Up = '\0';
+    char Down = '\0';
+    QuoteCls() noexcept = default;
     void New() noexcept {
         Count = 0;
         Up    = '\0';
@@ -319,7 +478,7 @@ constexpr bool isInterpolableLiteral(int state) noexcept {
            && state != SCE_RB_CHARACTER;
 }
 
-inline bool isSingleSpecialVariable(char ch) noexcept {
+bool isSingleSpecialVariable(char ch) noexcept {
     // https://docs.ruby-lang.org/en/master/globals_rdoc.html
     return strchr("~*$?!@/\\;,.=:<>\"&`'+", ch) != nullptr;
 }
@@ -368,25 +527,24 @@ bool isEmptyLine(Sci_Position pos, Accessor &styler) {
     return (indentCurrent & SC_FOLDLEVELWHITEFLAG) != 0;
 }
 
-bool RE_CanFollowKeyword(const char *keyword) noexcept {
-    if (!strcmp(keyword, "and")
-            || !strcmp(keyword, "begin")
-            || !strcmp(keyword, "break")
-            || !strcmp(keyword, "case")
-            || !strcmp(keyword, "do")
-            || !strcmp(keyword, "else")
-            || !strcmp(keyword, "elsif")
-            || !strcmp(keyword, "if")
-            || !strcmp(keyword, "next")
-            || !strcmp(keyword, "return")
-            || !strcmp(keyword, "when")
-            || !strcmp(keyword, "unless")
-            || !strcmp(keyword, "until")
-            || !strcmp(keyword, "not")
-            || !strcmp(keyword, "or")) {
-        return true;
-    }
-    return false;
+bool RE_CanFollowKeyword(const std::string &keyword) noexcept {
+	return InList(keyword, {
+		"and",
+		"begin",
+		"break",
+		"case",
+		"do",
+		"else",
+		"elsif",
+		"if",
+		"next",
+		"return",
+		"when",
+		"unless",
+		"until",
+		"not",
+		"or"
+		});
 }
 
 // Look at chars up to but not including endPos
@@ -407,11 +565,10 @@ Sci_Position skipWhitespace(Sci_Position startPos, Sci_Position endPos, Accessor
 //
 // iPrev points to the start of <<
 
-bool sureThisIsHeredoc(Sci_Position iPrev, Accessor &styler, char *prevWord) {
+bool sureThisIsHeredoc(Sci_Position iPrev, Accessor &styler, std::string &prevWord) {
 
     // Not so fast, since Ruby's so dynamic.  Check the context
     // to make sure we're OK.
-    int prevStyle;
     const Sci_Position lineStart = styler.GetLine(iPrev);
     const Sci_Position lineStartPosn = styler.LineStart(lineStart);
     styler.Flush();
@@ -423,36 +580,29 @@ bool sureThisIsHeredoc(Sci_Position iPrev, Accessor &styler, char *prevWord) {
         //XXX Look at the first previous non-comment non-white line
         // to establish the context.  Not too likely though.
         return true;
-    } else {
-        prevStyle = styler.StyleAt(firstWordPosn);
-        switch (prevStyle) {
-        case SCE_RB_WORD:
-        case SCE_RB_WORD_DEMOTED:
-        case SCE_RB_IDENTIFIER:
-            break;
-        default:
-            return true;
-        }
+    }
+    const int prevStyle = styler.StyleIndexAt(firstWordPosn);
+    switch (prevStyle) {
+    case SCE_RB_WORD:
+    case SCE_RB_WORD_DEMOTED:
+    case SCE_RB_IDENTIFIER:
+        break;
+    default:
+        return true;
     }
     Sci_Position firstWordEndPosn = firstWordPosn;
-    char *dst = prevWord;
+    prevWord.clear();
     for (;;) {
         if (firstWordEndPosn >= iPrev ||
-                styler.StyleAt(firstWordEndPosn) != prevStyle) {
-            *dst = 0;
+                styler.StyleIndexAt(firstWordEndPosn) != prevStyle) {
             break;
         }
-        *dst++ = styler[firstWordEndPosn];
+        prevWord.push_back(styler[firstWordEndPosn]);
         firstWordEndPosn += 1;
     }
     //XXX Write a style-aware thing to regex scintilla buffer objects
-    if (!strcmp(prevWord, "undef")
-            || !strcmp(prevWord, "def")
-            || !strcmp(prevWord, "alias")) {
-        // These keywords are what we were looking for
-        return false;
-    }
-    return true;
+    // These keywords are what we were looking for
+    return !InList(prevWord, { "undef", "def", "alias" });
 }
 
 // Routine that saves us from allocating a buffer for the here-doc target
@@ -476,17 +626,16 @@ bool haveTargetMatch(Sci_Position currPos, Sci_Position lengthDoc, Sci_Position
 Sci_Position findExpressionStart(Sci_Position pos, Sci_Position min_pos, Accessor &styler) {
     int depth = 0;
     for (; pos > min_pos; pos -= 1) {
-        const int style = styler.StyleAt(pos - 1);
+        const int style = styler.StyleIndexAt(pos - 1);
         if (style == SCE_RB_OPERATOR) {
-            const int ch = styler[pos - 1];
+            const char ch = styler[pos - 1];
             if (ch == '}' || ch == ')' || ch == ']') {
                 depth += 1;
             } else if (ch == '{' || ch == '(' || ch == '[') {
                 if (depth == 0) {
                     break;
-                } else {
-                    depth -= 1;
                 }
+                depth -= 1;
             } else if (ch == ';' && depth == 0) {
                 break;
             }
@@ -526,9 +675,9 @@ bool sureThisIsNotHeredoc(Sci_Position lt2StartPos, Accessor &styler) {
     if (firstWordPosn >= lt2StartPos) {
         return definitely_not_a_here_doc;
     }
-    int prevStyle = styler.StyleAt(firstWordPosn);
+    int prevStyle = styler.StyleIndexAt(firstWordPosn);
     // If we have '<<' following a keyword, it's not a heredoc
-    if (prevStyle != SCE_RB_IDENTIFIER
+    if (!IsIdentifierStyle(prevStyle)
             && prevStyle != SCE_RB_GLOBAL       // $stdout and $stderr
             && prevStyle != SCE_RB_SYMBOL
             && prevStyle != SCE_RB_INSTANCE_VAR
@@ -540,7 +689,7 @@ bool sureThisIsNotHeredoc(Sci_Position lt2StartPos, Accessor &styler) {
     for (firstWordPosn += 1; firstWordPosn <= lt2StartPos; firstWordPosn += 1) {
         // Inner loop looks at the name
         for (; firstWordPosn <= lt2StartPos; firstWordPosn += 1) {
-            newStyle = styler.StyleAt(firstWordPosn);
+            newStyle = styler.StyleIndexAt(firstWordPosn);
             if (newStyle != prevStyle) {
                 break;
             }
@@ -551,7 +700,7 @@ bool sureThisIsNotHeredoc(Sci_Position lt2StartPos, Accessor &styler) {
             if (ch == '.') {
                 // yes
             } else if (ch == ':') {
-                if (styler.StyleAt(++firstWordPosn) != SCE_RB_OPERATOR) {
+                if (styler.StyleIndexAt(++firstWordPosn) != SCE_RB_OPERATOR) {
                     return definitely_not_a_here_doc;
                 } else if (styler[firstWordPosn] != ':') {
                     return definitely_not_a_here_doc;
@@ -569,9 +718,9 @@ bool sureThisIsNotHeredoc(Sci_Position lt2StartPos, Accessor &styler) {
     // Skip next batch of white-space
     firstWordPosn = skipWhitespace(firstWordPosn, lt2StartPos, styler);
     // possible symbol for an implicit hash argument
-    if (firstWordPosn < lt2StartPos && styler.StyleAt(firstWordPosn) == SCE_RB_SYMBOL) {
+    if (firstWordPosn < lt2StartPos && styler.StyleIndexAt(firstWordPosn) == SCE_RB_SYMBOL) {
         for (; firstWordPosn <= lt2StartPos; firstWordPosn += 1) {
-            if (styler.StyleAt(firstWordPosn) != SCE_RB_SYMBOL) {
+            if (styler.StyleIndexAt(firstWordPosn) != SCE_RB_SYMBOL) {
                 break;
             }
         }
@@ -584,7 +733,7 @@ bool sureThisIsNotHeredoc(Sci_Position lt2StartPos, Accessor &styler) {
     }
     // OK, now 'j' will point to the current spot moving ahead
     Sci_Position j = firstWordPosn + 1;
-    if (styler.StyleAt(j) != SCE_RB_OPERATOR || styler[j] != '<') {
+    if (styler.StyleIndexAt(j) != SCE_RB_OPERATOR || styler[j] != '<') {
         // This shouldn't happen
         return definitely_not_a_here_doc;
     }
@@ -596,9 +745,9 @@ bool sureThisIsNotHeredoc(Sci_Position lt2StartPos, Accessor &styler) {
     if (j >= lengthDoc) {
         return definitely_not_a_here_doc;
     }
-    bool allow_indent;
-    Sci_Position target_start;
-    Sci_Position target_end;
+    bool allow_indent = false;
+    Sci_Position target_start = 0;
+    Sci_Position target_end = 0;
     // From this point on no more styling, since we're looking ahead
     if (styler[j] == '-' || styler[j] == '~') {
         allow_indent = true;
@@ -618,7 +767,7 @@ bool sureThisIsNotHeredoc(Sci_Position lt2StartPos, Accessor &styler) {
     }
 
     if (isSafeAlnumOrHigh(styler[j])) {
-        // Init target_end because some compilers think it won't
+        // Initialize target_end because some compilers think it won't
         // be initialized by the time it's used
         target_start = target_end = j;
         j++;
@@ -643,15 +792,13 @@ bool sureThisIsNotHeredoc(Sci_Position lt2StartPos, Accessor &styler) {
             j = skipWhitespace(j, lengthDoc, styler);
             if (j >= lengthDoc) {
                 return definitely_not_a_here_doc;
-            } else {
-                const char ch = styler[j];
-                if (ch == '#' || isEOLChar(ch) || ch == '.' || ch == ',' || IsLowerCase(ch)) {
-                    // This is OK, so break and continue;
-                    break;
-                } else {
-                    return definitely_not_a_here_doc;
-                }
             }
+            const char ch = styler[j];
+            if (ch == '#' || isEOLChar(ch) || ch == '.' || ch == ',' || IsLowerCase(ch)) {
+                // This is OK, so break and continue;
+                break;
+            }
+            return definitely_not_a_here_doc;
         }
     }
 
@@ -677,12 +824,18 @@ bool sureThisIsNotHeredoc(Sci_Position lt2StartPos, Accessor &styler) {
 
 //todo: if we aren't looking at a stdio character,
 // move to the start of the first line that is not in a
-// multi-line construct
+// multiline construct
 
 void synchronizeDocStart(Sci_PositionU &startPos, Sci_Position &length, int &initStyle, Accessor &styler, bool skipWhiteSpace=false) {
+    // Retreat one line to match function lexer
+    if (const Sci_Position lineCurrent = styler.GetLine(startPos); lineCurrent > 0) {
+        const Sci_Position endPos = startPos + length;
+        startPos = styler.LineStart(lineCurrent - 1);
+        length = endPos - startPos;
+        initStyle = (startPos > 0) ? styler.StyleIndexAt(startPos - 1) : 0;
+    }
 
-    styler.Flush();
-    const int style = actual_style(styler.StyleAt(startPos));
+    const int style = styler.StyleIndexAt(startPos);
     switch (style) {
     case SCE_RB_STDIN:
     case SCE_RB_STDOUT:
@@ -693,8 +846,8 @@ void synchronizeDocStart(Sci_PositionU &startPos, Sci_Position &length, int &ini
 
     Sci_Position pos = startPos;
     // Quick way to characterize each line
-    Sci_Position lineStart;
-    for (lineStart = styler.GetLine(pos); lineStart > 0; lineStart--) {
+    Sci_Position lineStart = styler.GetLine(pos);
+    for (; lineStart > 0; lineStart--) {
         // Now look at the style before the previous line's EOL
         pos = styler.LineStart(lineStart) - 1;
         if (pos <= 10) {
@@ -708,8 +861,8 @@ void synchronizeDocStart(Sci_PositionU &startPos, Sci_Position &length, int &ini
         }
         if (styler.SafeGetCharAt(pos - 1) == '\\') {
             // Continuation line -- keep going
-        } else if (actual_style(styler.StyleAt(pos)) != SCE_RB_DEFAULT) {
-            // Part of multi-line construct -- keep going
+        } else if (styler.StyleIndexAt(pos) != SCE_RB_DEFAULT) {
+            // Part of multiline construct -- keep going
         } else if (currLineContainsHereDelims(pos, styler)) {
             // Keep going, with pos and length now pointing
             // at the end of the here-doc delimiter
@@ -725,14 +878,14 @@ void synchronizeDocStart(Sci_PositionU &startPos, Sci_Position &length, int &ini
     initStyle = SCE_RB_DEFAULT;
 }
 
-void ColouriseRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[], Accessor &styler) {
+void LexerRuby::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+    Accessor styler(pAccess, nullptr);
+    styler.StartAt(startPos);
 
     // Lexer for Ruby often has to backtrack to start of current style to determine
     // which characters are being used as quotes, how deeply nested is the
     // start position and what the termination string is for here documents
 
-    WordList &keywords = *keywordlists[0];
-
     class HereDocCls {
     public:
         int State = 0;
@@ -753,12 +906,14 @@ void ColouriseRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
 
     synchronizeDocStart(startPos, length, initStyle, styler, false);
 
+    const WordClassifier &idClasser = subStyles.Classifier(SCE_RB_IDENTIFIER);
+
     bool preferRE = true;
     bool afterDef = false;
     int state = initStyle;
     const Sci_Position lengthDoc = startPos + length;
 
-    char prevWord[MAX_KEYWORD_LENGTH + 1] = ""; // 1 byte for zero
+    std::string prevWord;
     if (length == 0)
         return;
 
@@ -810,10 +965,10 @@ void ColouriseRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
     public:
         int brace_counts = 0;   // Number of #{ ... } things within an expression
 
-        bool canEnter() const noexcept {
+        [[nodiscard]] bool canEnter() const noexcept {
             return inner_string_count < INNER_STRINGS_MAX_COUNT;
         }
-        bool canExit() const noexcept {
+        [[nodiscard]] bool canExit() const noexcept {
             return inner_string_count > 0;
         }
         void enter(int &state, const QuoteCls &curr_quote) noexcept {
@@ -858,8 +1013,7 @@ void ColouriseRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
             // Begin of here-doc (the line after the here-doc delimiter):
             HereDoc.State = 2;
             if (state == SCE_RB_WORD) {
-                const Sci_Position wordStartPos = styler.GetStartSegment();
-                ClassifyWordRb(wordStartPos, i - 1, ch, keywords, styler, prevWord);
+                ClassifyWordRb(i, ch, chNext, keywords, styler, prevWord, idClasser);
             } else {
                 styler.ColourTo(i - 1, state);
             }
@@ -1132,7 +1286,7 @@ void ColouriseRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
                         i += width;
                         styler.ColourTo(i, SCE_RB_NUMBER);
                     }
-                } else if (!isQestionMarkChar(chNext, chNext2)) {
+                } else if (!isQuestionMarkChar(chNext, chNext2)) {
                     styler.ColourTo(i, SCE_RB_OPERATOR);
                     preferRE = chNext <= ' ';
                 } else {
@@ -1159,7 +1313,7 @@ void ColouriseRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
                 // constructs are binary operators
                 //
                 // So if we don't have one of these chars,
-                // we aren't ending an object exp'n, and ops
+                // we aren't ending an object expression, and ops
                 // like : << / are unary operators.
 
                 if (ch == '{') {
@@ -1198,9 +1352,9 @@ void ColouriseRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
                         && isSafeWordcharOrHigh(chPrev)
                         && (chNext == '('
                             || isWhiteSpace(chNext))
-                        && (!strcmp(prevWord, "def")
+                        && ((prevWord == "def")
                             || followsDot(styler.GetStartSegment(), styler))) {
-                    // <name>= is a name only when being def'd -- Get it the next time
+                    // <name>= is a name only when being defined -- Get it the next time
                     // This means that <name>=<name> is always lexed as
                     // <name>, (op, =), <name>
                 } else if (ch == ':'
@@ -1225,11 +1379,10 @@ void ColouriseRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
                     // No need to handle this state -- we'll just move to the end
                     preferRE = false;
                 } else {
-                    const Sci_Position wordStartPos = styler.GetStartSegment();
-                    const int word_style = ClassifyWordRb(wordStartPos, i - 1, ch, keywords, styler, prevWord);
+                    const int word_style = ClassifyWordRb(i, ch, chNext, keywords, styler, prevWord, idClasser);
                     switch (word_style) {
                     case SCE_RB_WORD:
-                        afterDef = strcmp(prevWord, "def") == 0;
+                        afterDef = prevWord == "def";
                         preferRE = RE_CanFollowKeyword(prevWord);
                         break;
 
@@ -1565,57 +1718,45 @@ void ColouriseRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
     if (state == SCE_RB_WORD) {
         // We've ended on a word, possibly at EOF, and need to
         // classify it.
-        ClassifyWordRb(styler.GetStartSegment(), lengthDoc - 1, '\0', keywords, styler, prevWord);
+        ClassifyWordRb(lengthDoc, '\0', '\0', keywords, styler, prevWord, idClasser);
     } else {
         styler.ColourTo(lengthDoc - 1, state);
     }
+    styler.Flush();
 }
 
 // Helper functions for folding, disambiguation keywords
 // Assert that there are no high-bit chars
 
-void getPrevWord(Sci_Position pos, char *prevWord, Accessor &styler, int word_state) {
-    Sci_Position i;
-    styler.Flush();
-    for (i = pos - 1; i > 0; i--) {
-        if (actual_style(styler.StyleAt(i)) != word_state) {
+std::string getPrevWord(Sci_Position pos, Accessor &styler, int word_state) {
+    Sci_Position i = pos - 1;
+    for (; i > 0; i--) {
+        if (styler.StyleIndexAt(i) != word_state) {
             i++;
             break;
         }
     }
-    if (i < pos - MAX_KEYWORD_LENGTH) // overflow
-        i = pos - MAX_KEYWORD_LENGTH;
-    char *dst = prevWord;
+    std::string prevWord;
     for (; i <= pos; i++) {
-        *dst++ = styler[i];
+        prevWord.push_back(styler[i]);
     }
-    *dst = 0;
+    return prevWord;
 }
 
-bool keywordIsAmbiguous(const char *prevWord) noexcept {
+bool keywordIsAmbiguous(const std::string &prevWord) noexcept {
     // Order from most likely used to least likely
     // Lots of ways to do a loop in Ruby besides 'while/until'
-    if (!strcmp(prevWord, "if")
-            || !strcmp(prevWord, "do")
-            || !strcmp(prevWord, "while")
-            || !strcmp(prevWord, "unless")
-            || !strcmp(prevWord, "until")
-            || !strcmp(prevWord, "for")) {
-        return true;
-    } else {
-        return false;
-    }
+    return InList(prevWord, { "if", "do", "while", "unless", "until", "for" });
 }
 
 // Demote keywords in the following conditions:
 // if, while, unless, until modify a statement
 // do after a while or until, as a noise word (like then after if)
 
-bool keywordIsModifier(const char *word, Sci_Position pos, Accessor &styler) {
+bool keywordIsModifier(const std::string &word, Sci_Position pos, Accessor &styler) {
     if (word[0] == 'd' && word[1] == 'o' && !word[2]) {
         return keywordDoStartsLoop(pos, styler);
     }
-    char ch;
     int style = SCE_RB_DEFAULT;
     Sci_Position lineStart = styler.GetLine(pos);
     Sci_Position lineStartPosn = styler.LineStart(lineStart);
@@ -1623,7 +1764,7 @@ bool keywordIsModifier(const char *word, Sci_Position pos, Accessor &styler) {
     // position. But first move lineStartPosn back behind any
     // continuations immediately above word.
     while (lineStartPosn > 0) {
-        ch = styler[lineStartPosn-1];
+        const char ch = styler[lineStartPosn-1];
         if (ch == '\n' || ch == '\r') {
             const char chPrev  = styler.SafeGetCharAt(lineStartPosn-2);
             const char chPrev2 = styler.SafeGetCharAt(lineStartPosn-3);
@@ -1643,9 +1784,9 @@ bool keywordIsModifier(const char *word, Sci_Position pos, Accessor &styler) {
 
     styler.Flush();
     while (--pos >= lineStartPosn) {
-        style = actual_style(styler.StyleAt(pos));
+        style = styler.StyleIndexAt(pos);
         if (style == SCE_RB_DEFAULT) {
-            ch = styler[pos];
+            const char ch = styler[pos];
             if (IsASpaceOrTab(ch)) {
                 //continue
             } else if (ch == '\r' || ch == '\n') {
@@ -1690,10 +1831,9 @@ bool keywordIsModifier(const char *word, Sci_Position pos, Accessor &styler) {
         //XXX: Make a list of other keywords where 'if' isn't a modifier
         //     and can appear legitimately
         // Formulate this to avoid warnings from most compilers
-        if (strcmp(word, "if") == 0) {
-            char prevWord[MAX_KEYWORD_LENGTH + 1];
-            getPrevWord(pos, prevWord, styler, SCE_RB_WORD);
-            return strcmp(prevWord, "else") != 0;
+        if (word == "if") {
+            const std::string prevWord = getPrevWord(pos, styler, SCE_RB_WORD);
+            return prevWord != "else";
         }
         return true;
     default:
@@ -1703,8 +1843,7 @@ bool keywordIsModifier(const char *word, Sci_Position pos, Accessor &styler) {
     // usually it's a block assignment, like
     // a << if x then y else z
 
-    ch = styler[pos];
-    switch (ch) {
+    switch (styler[pos]) {
     case ')':
     case ']':
     case '}':
@@ -1726,7 +1865,7 @@ bool keywordDoStartsLoop(Sci_Position pos, Accessor &styler) {
     const Sci_Position lineStartPosn = styler.LineStart(lineStart);
     styler.Flush();
     while (--pos >= lineStartPosn) {
-        const int style = actual_style(styler.StyleAt(pos));
+        const int style = styler.StyleIndexAt(pos);
         if (style == SCE_RB_DEFAULT) {
             const char ch = styler[pos];
             if (ch == '\r' || ch == '\n') {
@@ -1737,22 +1876,15 @@ bool keywordDoStartsLoop(Sci_Position pos, Accessor &styler) {
             }
         } else if (style == SCE_RB_WORD) {
             // Check for while or until, but write the word in backwards
-            char prevWord[MAX_KEYWORD_LENGTH + 1]; // 1 byte for zero
-            char *dst = prevWord;
-            int wordLen = 0;
-            Sci_Position start_word;
-            for (start_word = pos;
-                    start_word >= lineStartPosn && actual_style(styler.StyleAt(start_word)) == SCE_RB_WORD;
+            std::string prevWord;
+            Sci_Position start_word = pos;
+            for (;
+                    start_word >= lineStartPosn && styler.StyleIndexAt(start_word) == SCE_RB_WORD;
                     start_word--) {
-                if (++wordLen < MAX_KEYWORD_LENGTH) {
-                    *dst++ = styler[start_word];
-                }
+                prevWord.push_back(styler[start_word]);
             }
-            *dst = 0;
             // Did we see our keyword?
-            if (!strcmp(prevWord, WHILE_BACKWARDS)
-                    || !strcmp(prevWord, UNTIL_BACKWARDS)
-                    || !strcmp(prevWord, FOR_BACKWARDS)) {
+            if (InList(prevWord, { WHILE_BACKWARDS, UNTIL_BACKWARDS, FOR_BACKWARDS } )) {
                 return true;
             }
             // We can move pos to the beginning of the keyword, and then
@@ -1837,9 +1969,8 @@ bool IsCommentLine(Sci_Position line, Accessor &styler) {
  *  Later offer to fold POD, here-docs, strings, and blocks of comments
  */
 
-void FoldRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *[], Accessor &styler) {
-    const bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-    const bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
+void LexerRuby::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+    Accessor styler(pAccess, nullptr);
 
     synchronizeDocStart(startPos, length, initStyle, styler, false);
     const Sci_PositionU endPos = startPos + length;
@@ -1851,8 +1982,8 @@ void FoldRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordL
     int levelCurrent = levelPrev;
     char chPrev = '\0';
     char chNext = styler[startPos];
-    int styleNext = styler.StyleAt(startPos);
-    int stylePrev = startPos <= 1 ? SCE_RB_DEFAULT : styler.StyleAt(startPos - 1);
+    int styleNext = styler.StyleIndexAt(startPos);
+    int stylePrev = startPos <= 1 ? SCE_RB_DEFAULT : styler.StyleIndexAt(startPos - 1);
     // detect endless method definition to fix up code folding
     enum class MethodDefinition {
         None,
@@ -1869,11 +2000,11 @@ void FoldRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordL
         const char ch = chNext;
         chNext = styler.SafeGetCharAt(i + 1);
         const int style = styleNext;
-        styleNext = styler.StyleAt(i + 1);
+        styleNext = styler.StyleIndexAt(i + 1);
         const bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
 
-        /*Mutiline comment patch*/
-        if (foldComment && atEOL && IsCommentLine(lineCurrent, styler)) {
+        /* Multiline comment patch */
+        if (options.foldComment && atEOL && IsCommentLine(lineCurrent, styler)) {
             if (!IsCommentLine(lineCurrent - 1, styler)
                     && IsCommentLine(lineCurrent + 1, styler))
                 levelCurrent++;
@@ -1883,7 +2014,7 @@ void FoldRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordL
         }
 
         if (style == SCE_RB_COMMENTLINE) {
-            if (foldComment && stylePrev != SCE_RB_COMMENTLINE) {
+            if (options.foldComment && stylePrev != SCE_RB_COMMENTLINE) {
                 if (chNext == '{') {
                     levelCurrent++;
                 } else if (chNext == '}' && levelCurrent > 0) {
@@ -1900,29 +2031,28 @@ void FoldRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordL
             }
         } else if (style == SCE_RB_WORD && styleNext != SCE_RB_WORD) {
             // Look at the keyword on the left and decide what to do
-            char prevWord[MAX_KEYWORD_LENGTH + 1]; // 1 byte for zero
-            prevWord[0] = 0;
-            getPrevWord(i, prevWord, styler, SCE_RB_WORD);
-            if (!strcmp(prevWord, "end")) {
+            const std::string prevWord = getPrevWord(i, styler, SCE_RB_WORD);
+            if (prevWord == "end") {
                 // Don't decrement below 0
                 if (levelCurrent > 0)
                     levelCurrent--;
-            } else if (!strcmp(prevWord, "def")) {
+            } else if (prevWord == "def") {
                 levelCurrent++;
                 method_definition = MethodDefinition::Define;
-            } else if (!strcmp(prevWord, "if")
-                       || !strcmp(prevWord, "class")
-                       || !strcmp(prevWord, "module")
-                       || !strcmp(prevWord, "begin")
-                       || !strcmp(prevWord, "case")
-                       || !strcmp(prevWord, "do")
-                       || !strcmp(prevWord, "while")
-                       || !strcmp(prevWord, "unless")
-                       || !strcmp(prevWord, "until")
-                       || !strcmp(prevWord, "for")
-                      ) {
-                levelCurrent++;
-            }
+			} else if (InList(prevWord, {
+                    "if",
+                    "class",
+                    "module",
+                    "begin",
+                    "case",
+                    "do",
+                    "while",
+                    "unless",
+                    "until",
+                    "for"
+				})) {
+				levelCurrent++;
+			}
         } else if (style == SCE_RB_HERE_DELIM && !heredocOpen) {
             if (stylePrev == SCE_RB_OPERATOR && chPrev == '<' && styler.SafeGetCharAt(i - 2) == '<') {
                 levelCurrent++;
@@ -1943,7 +2073,7 @@ void FoldRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordL
             case MethodDefinition::Define:
                 if (style == SCE_RB_OPERATOR) {
                     method_definition = MethodDefinition::Operator;
-                } else if (style == SCE_RB_DEFNAME || style == SCE_RB_WORD_DEMOTED || style == SCE_RB_CLASSNAME || style == SCE_RB_IDENTIFIER) {
+                } else if (style == SCE_RB_DEFNAME || style == SCE_RB_WORD_DEMOTED || style == SCE_RB_CLASSNAME || IsIdentifierStyle(style)) {
                     method_definition = MethodDefinition::Name;
                 } else if (!(style == SCE_RB_WORD || IsASpaceOrTab(ch))) {
                     method_definition = MethodDefinition::None;
@@ -1990,7 +2120,7 @@ void FoldRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordL
         }
         if (atEOL || (i == endPos - 1)) {
             int lev = levelPrev;
-            if (visibleChars == 0 && foldCompact)
+            if (visibleChars == 0 && options.foldCompact)
                 lev |= SC_FOLDLEVELWHITEFLAG;
             if ((levelCurrent > levelPrev) && (visibleChars > 0))
                 lev |= SC_FOLDLEVELHEADERFLAG;
@@ -2009,11 +2139,6 @@ void FoldRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordL
     }
 }
 
-const char *const rubyWordListDesc[] = {
-    "Keywords",
-    nullptr
-};
-
 }
 
-extern const LexerModule lmRuby(SCLEX_RUBY, ColouriseRbDoc, "ruby", FoldRbDoc, rubyWordListDesc);
+extern const LexerModule lmRuby(SCLEX_RUBY, LexerRuby::LexerFactoryRuby, "ruby", rubyWordListDesc);
diff --git a/lexilla/lexlib/StyleContext.cxx b/lexilla/lexlib/StyleContext.cxx
index 031884090..5a64288db 100644
--- a/lexilla/lexlib/StyleContext.cxx
+++ b/lexilla/lexlib/StyleContext.cxx
@@ -54,6 +54,8 @@ bool StyleContext::MatchIgnoreCase(const char *s) {
 	if (MakeLowerCase(ch) != static_cast<unsigned char>(*s))
 		return false;
 	s++;
+	if (!*s)
+		return true;
 	if (MakeLowerCase(chNext) != static_cast<unsigned char>(*s))
 		return false;
 	s++;
diff --git a/lexilla/src/Lexilla/Info.plist b/lexilla/src/Lexilla/Info.plist
index c7533ddc3..a1d0470fc 100644
--- a/lexilla/src/Lexilla/Info.plist
+++ b/lexilla/src/Lexilla/Info.plist
@@ -15,7 +15,7 @@
 	<key>CFBundlePackageType</key>
 	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
 	<key>CFBundleShortVersionString</key>
-	<string>5.4.2</string>
+	<string>5.4.3</string>
 	<key>CFBundleVersion</key>
 	<string>$(CURRENT_PROJECT_VERSION)</string>
 	<key>NSHumanReadableCopyright</key>
diff --git a/lexilla/src/Lexilla/Lexilla.xcodeproj/project.pbxproj b/lexilla/src/Lexilla/Lexilla.xcodeproj/project.pbxproj
index 2670ac025..9f612513f 100644
--- a/lexilla/src/Lexilla/Lexilla.xcodeproj/project.pbxproj
+++ b/lexilla/src/Lexilla/Lexilla.xcodeproj/project.pbxproj
@@ -876,7 +876,7 @@
 			buildSettings = {
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++17";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 5.4.2;
+				CURRENT_PROJECT_VERSION = 5.4.3;
 				DEAD_CODE_STRIPPING = YES;
 				DEVELOPMENT_TEAM = 4F446KW87E;
 				DYLIB_COMPATIBILITY_VERSION = 1;
@@ -904,7 +904,7 @@
 			buildSettings = {
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++17";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 5.4.2;
+				CURRENT_PROJECT_VERSION = 5.4.3;
 				DEAD_CODE_STRIPPING = YES;
 				DEVELOPMENT_TEAM = 4F446KW87E;
 				DYLIB_COMPATIBILITY_VERSION = 1;
diff --git a/lexilla/src/LexillaVersion.rc b/lexilla/src/LexillaVersion.rc
index fff730f27..14864f191 100644
--- a/lexilla/src/LexillaVersion.rc
+++ b/lexilla/src/LexillaVersion.rc
@@ -4,8 +4,8 @@
 
 #include <windows.h>
 
-#define VERSION_LEXILLA "5.4.2"
-#define VERSION_WORDS 5, 4, 2, 0
+#define VERSION_LEXILLA "5.4.3"
+#define VERSION_WORDS 5, 4, 3, 0
 
 VS_VERSION_INFO VERSIONINFO
 FILEVERSION	VERSION_WORDS
diff --git a/lexilla/src/deps.mak b/lexilla/src/deps.mak
index 7baceabb8..38d54455c 100644
--- a/lexilla/src/deps.mak
+++ b/lexilla/src/deps.mak
@@ -1304,12 +1304,16 @@ $(DIR_O)/LexRuby.o: \
 	../../scintilla/include/Sci_Position.h \
 	../../scintilla/include/Scintilla.h \
 	../include/SciLexer.h \
+	../lexlib/InList.h \
 	../lexlib/WordList.h \
 	../lexlib/LexAccessor.h \
 	../lexlib/Accessor.h \
 	../lexlib/StyleContext.h \
 	../lexlib/CharacterSet.h \
-	../lexlib/LexerModule.h
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/SubStyles.h \
+	../lexlib/DefaultLexer.h
 $(DIR_O)/LexRust.o: \
 	../lexers/LexRust.cxx \
 	../../scintilla/include/ILexer.h \
diff --git a/lexilla/src/nmdeps.mak b/lexilla/src/nmdeps.mak
index c7f1eb58b..02cb58b76 100644
--- a/lexilla/src/nmdeps.mak
+++ b/lexilla/src/nmdeps.mak
@@ -1304,12 +1304,16 @@ $(DIR_O)/LexRuby.obj: \
 	../../scintilla/include/Sci_Position.h \
 	../../scintilla/include/Scintilla.h \
 	../include/SciLexer.h \
+	../lexlib/InList.h \
 	../lexlib/WordList.h \
 	../lexlib/LexAccessor.h \
 	../lexlib/Accessor.h \
 	../lexlib/StyleContext.h \
 	../lexlib/CharacterSet.h \
-	../lexlib/LexerModule.h
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/SubStyles.h \
+	../lexlib/DefaultLexer.h
 $(DIR_O)/LexRust.obj: \
 	../lexers/LexRust.cxx \
 	../../scintilla/include/ILexer.h \
diff --git a/lexilla/test/examples/cpp/x.cxx b/lexilla/test/examples/cpp/x.cxx
index c65da9c8f..4c60528ad 100644
--- a/lexilla/test/examples/cpp/x.cxx
+++ b/lexilla/test/examples/cpp/x.cxx
@@ -66,6 +66,11 @@ b
 // Active
 #endif
 
+#define ONE 1
+#if ONE != 1
+// Inactive
+#endif
+
 int main() {
 	double x[] = {3.14159,6.02e23,1.6e-19,1.0+1};
 	int y[] = {75,0113,0x4b};
diff --git a/lexilla/test/examples/cpp/x.cxx.folded b/lexilla/test/examples/cpp/x.cxx.folded
index 0126e2449..23b14b56f 100644
--- a/lexilla/test/examples/cpp/x.cxx.folded
+++ b/lexilla/test/examples/cpp/x.cxx.folded
@@ -66,6 +66,11 @@
  0 401 401 | // Active
  0 401 400 | #endif
  1 400 400   
+ 0 400 400   #define ONE 1
+ 2 400 401 + #if ONE != 1
+ 0 401 401 | // Inactive
+ 0 401 400 | #endif
+ 1 400 400   
  2 400 401 + int main() {
  0 401 401 | 	double x[] = {3.14159,6.02e23,1.6e-19,1.0+1};
  0 401 401 | 	int y[] = {75,0113,0x4b};
diff --git a/lexilla/test/examples/cpp/x.cxx.styled b/lexilla/test/examples/cpp/x.cxx.styled
index f037ac4d8..06334fd8b 100644
--- a/lexilla/test/examples/cpp/x.cxx.styled
+++ b/lexilla/test/examples/cpp/x.cxx.styled
@@ -66,6 +66,11 @@
 {2}// Active
 {9}#endif
 {0}
+{9}#define ONE 1
+#if ONE != 1
+{66}// Inactive
+{9}#endif
+{0}
 {5}int{0} {11}main{10}(){0} {10}{{0}
 	{11}double{0} {11}x{10}[]{0} {10}={0} {10}{{4}3.14159{10},{4}6.02e23{10},{4}1.6e-19{10},{4}1.0{10}+{4}1{10}};{0}
 	{5}int{0} {11}y{10}[]{0} {10}={0} {10}{{4}75{10},{4}0113{10},{4}0x4b{10}};{0}
diff --git a/lexilla/test/examples/modula/Issue297.m3 b/lexilla/test/examples/modula/Issue297.m3
new file mode 100644
index 000000000..9c0c802d6
--- /dev/null
+++ b/lexilla/test/examples/modula/Issue297.m3
@@ -0,0 +1,6 @@
+INTERFACE Issue297;
+
+TYPE
+  INTEGER32 = [-16_7fffffff-1 .. 16_7fffffff];
+
+END Issue297.
diff --git a/lexilla/test/examples/modula/Issue297.m3.folded b/lexilla/test/examples/modula/Issue297.m3.folded
new file mode 100644
index 000000000..80b55701c
--- /dev/null
+++ b/lexilla/test/examples/modula/Issue297.m3.folded
@@ -0,0 +1,7 @@
+ 0 400 400   INTERFACE Issue297;
+ 1 400 400   
+ 0 400 400   TYPE
+ 0 400 400     INTEGER32 = [-16_7fffffff-1 .. 16_7fffffff];
+ 1 400 400   
+ 0 400 3ff   END Issue297.
+ 1 3ff 3ff   
\ No newline at end of file
diff --git a/lexilla/test/examples/modula/Issue297.m3.styled b/lexilla/test/examples/modula/Issue297.m3.styled
new file mode 100644
index 000000000..0461cea48
--- /dev/null
+++ b/lexilla/test/examples/modula/Issue297.m3.styled
@@ -0,0 +1,6 @@
+{4}INTERFACE{0} Issue297{16};{0}
+
+{4}TYPE{0}
+  INTEGER32 {16}={0} {16}[-{7}16_7fffffff{16}-{6}1{0} {16}..{0} {7}16_7fffffff{16}];{0}
+
+{4}END{0} Issue297{16}.{0}
diff --git a/lexilla/test/examples/pascal/AllStyles.pas b/lexilla/test/examples/pascal/AllStyles.pas
new file mode 100644
index 000000000..d1115cace
--- /dev/null
+++ b/lexilla/test/examples/pascal/AllStyles.pas
@@ -0,0 +1,82 @@
+// Enumerate all primary styles: 0 to 14
+
+{
+  SCE_PAS_DEFAULT=0
+  SCE_PAS_IDENTIFIER=1
+  SCE_PAS_COMMENT=2
+  SCE_PAS_COMMENT2=3
+  SCE_PAS_COMMENTLINE=4
+  SCE_PAS_PREPROCESSOR=5
+  SCE_PAS_PREPROCESSOR2=6
+  SCE_PAS_NUMBER=7
+  SCE_PAS_HEXNUMBER=8
+  SCE_PAS_WORD=9
+  SCE_PAS_STRING=10
+  SCE_PAS_STRINGEOL=11
+  SCE_PAS_CHARACTER=12
+  SCE_PAS_OPERATOR=13
+  SCE_PAS_ASM=14
+}
+
+// default=0
+   
+// identifier=1
+function functionname(var paramerter1: type1):result1;
+procedure procedurename(const parameter2: type2);
+
+// comment=2
+{comment text}
+
+// comment2=3
+(* comment text *)
+
+// commentline=4 
+// example line
+
+// preprocessor=5
+{$DEFINE xyz}
+
+{$IFDEF xyz}
+   codeblock 1
+{$else}
+   codeblock 2
+{$endif}
+
+// preprocessor2=6
+(*$DEFINE xyz*)
+
+// number=7
+123
+1.23
+-123
+-12.3
++123
+123
+1.23e2
+-1.23E2
+
+// hexnumber=8
+$123
+$123ABCDEF
+$ABCDEF123
+
+// word=9
+absolute abstract and array as 
+
+// string=10
+'string'
+
+// stringeol=11
+'string
+
+// character=12
+#65
+
+// operator=13 
+$ & * + / < = > ^  
+
+// asm
+asm 
+  this is 
+  inside assembler
+end
diff --git a/lexilla/test/examples/pascal/AllStyles.pas.folded b/lexilla/test/examples/pascal/AllStyles.pas.folded
new file mode 100644
index 000000000..c5d275a3e
--- /dev/null
+++ b/lexilla/test/examples/pascal/AllStyles.pas.folded
@@ -0,0 +1,83 @@
+ 0 400   0   // Enumerate all primary styles: 0 to 14
+ 1 400   0   
+ 2 400   0 + {
+ 0 401   0 |   SCE_PAS_DEFAULT=0
+ 0 401   0 |   SCE_PAS_IDENTIFIER=1
+ 0 401   0 |   SCE_PAS_COMMENT=2
+ 0 401   0 |   SCE_PAS_COMMENT2=3
+ 0 401   0 |   SCE_PAS_COMMENTLINE=4
+ 0 401   0 |   SCE_PAS_PREPROCESSOR=5
+ 0 401   0 |   SCE_PAS_PREPROCESSOR2=6
+ 0 401   0 |   SCE_PAS_NUMBER=7
+ 0 401   0 |   SCE_PAS_HEXNUMBER=8
+ 0 401   0 |   SCE_PAS_WORD=9
+ 0 401   0 |   SCE_PAS_STRING=10
+ 0 401   0 |   SCE_PAS_STRINGEOL=11
+ 0 401   0 |   SCE_PAS_CHARACTER=12
+ 0 401   0 |   SCE_PAS_OPERATOR=13
+ 0 401   0 |   SCE_PAS_ASM=14
+ 0 401   0 | }
+ 1 400   0   
+ 0 400   0   // default=0
+ 1 400   0      
+ 0 400   0   // identifier=1
+ 0 400   0   function functionname(var paramerter1: type1):result1;
+ 0 400   0   procedure procedurename(const parameter2: type2);
+ 1 400   0   
+ 0 400   0   // comment=2
+ 0 400   0   {comment text}
+ 1 400   0   
+ 0 400   0   // comment2=3
+ 0 400   0   (* comment text *)
+ 1 400   0   
+ 2 400   0 + // commentline=4 
+ 0 401   0 | // example line
+ 1 400   0   
+ 0 400   0   // preprocessor=5
+ 0 400   0   {$DEFINE xyz}
+ 1 400   0   
+ 2 400   0 + {$IFDEF xyz}
+ 0 401   0 |    codeblock 1
+ 0 401   0 | {$else}
+ 0 401   0 |    codeblock 2
+ 0 401   0 | {$endif}
+ 1 400   0   
+ 0 400   0   // preprocessor2=6
+ 0 400   0   (*$DEFINE xyz*)
+ 1 400   0   
+ 0 400   0   // number=7
+ 0 400   0   123
+ 0 400   0   1.23
+ 0 400   0   -123
+ 0 400   0   -12.3
+ 0 400   0   +123
+ 0 400   0   123
+ 0 400   0   1.23e2
+ 0 400   0   -1.23E2
+ 1 400   0   
+ 0 400   0   // hexnumber=8
+ 0 400   0   $123
+ 0 400   0   $123ABCDEF
+ 0 400   0   $ABCDEF123
+ 1 400   0   
+ 0 400   0   // word=9
+ 0 400   0   absolute abstract and array as 
+ 1 400   0   
+ 0 400   0   // string=10
+ 0 400   0   'string'
+ 1 400   0   
+ 0 400   0   // stringeol=11
+ 0 400   0   'string
+ 1 400   0   
+ 0 400   0   // character=12
+ 0 400   0   #65
+ 1 400   0   
+ 0 400   0   // operator=13 
+ 0 400   0   $ & * + / < = > ^  
+ 1 400   0   
+ 0 400   0   // asm
+ 2 400   0 + asm 
+ 0 401   0 |   this is 
+ 0 401   0 |   inside assembler
+ 0 401   0 | end
+ 1 400   0   
\ No newline at end of file
diff --git a/lexilla/test/examples/pascal/AllStyles.pas.styled b/lexilla/test/examples/pascal/AllStyles.pas.styled
new file mode 100644
index 000000000..1907e6ba9
--- /dev/null
+++ b/lexilla/test/examples/pascal/AllStyles.pas.styled
@@ -0,0 +1,82 @@
+{4}// Enumerate all primary styles: 0 to 14
+{0}
+{2}{
+  SCE_PAS_DEFAULT=0
+  SCE_PAS_IDENTIFIER=1
+  SCE_PAS_COMMENT=2
+  SCE_PAS_COMMENT2=3
+  SCE_PAS_COMMENTLINE=4
+  SCE_PAS_PREPROCESSOR=5
+  SCE_PAS_PREPROCESSOR2=6
+  SCE_PAS_NUMBER=7
+  SCE_PAS_HEXNUMBER=8
+  SCE_PAS_WORD=9
+  SCE_PAS_STRING=10
+  SCE_PAS_STRINGEOL=11
+  SCE_PAS_CHARACTER=12
+  SCE_PAS_OPERATOR=13
+  SCE_PAS_ASM=14
+}{0}
+
+{4}// default=0
+{0}   
+{4}// identifier=1
+{9}function{0} {1}functionname{13}({9}var{0} {1}paramerter1{13}:{0} {1}type1{13}):{1}result1{13};{0}
+{9}procedure{0} {1}procedurename{13}({9}const{0} {1}parameter2{13}:{0} {1}type2{13});{0}
+
+{4}// comment=2
+{2}{comment text}{0}
+
+{4}// comment2=3
+{3}(* comment text *){0}
+
+{4}// commentline=4 
+// example line
+{0}
+{4}// preprocessor=5
+{5}{$DEFINE xyz}{0}
+
+{5}{$IFDEF xyz}{0}
+   {1}codeblock{0} {7}1{0}
+{5}{$else}{0}
+   {1}codeblock{0} {7}2{0}
+{5}{$endif}{0}
+
+{4}// preprocessor2=6
+{6}(*$DEFINE xyz*){0}
+
+{4}// number=7
+{7}123{0}
+{7}1.23{0}
+{13}-{7}123{0}
+{13}-{7}12.3{0}
+{13}+{7}123{0}
+{7}123{0}
+{7}1.23e2{0}
+{13}-{7}1.23E2{0}
+
+{4}// hexnumber=8
+{8}$123{0}
+{8}$123ABCDEF{0}
+{8}$ABCDEF123{0}
+
+{4}// word=9
+{9}absolute{0} {9}abstract{0} {9}and{0} {9}array{0} {9}as{0} 
+
+{4}// string=10
+{10}'string'{0}
+
+{4}// stringeol=11
+{11}'string
+{0}
+{4}// character=12
+{12}#65{0}
+
+{4}// operator=13 
+{8}${0} {13}&{0} {13}*{0} {13}+{0} {13}/{0} {13}<{0} {13}={0} {13}>{0} {13}^{0}  
+
+{4}// asm
+{9}asm{14} 
+  this is 
+  inside assembler
+{9}end{0}
diff --git a/lexilla/test/examples/pascal/CodeFolding.pas b/lexilla/test/examples/pascal/CodeFolding.pas
new file mode 100644
index 000000000..55f3e358a
--- /dev/null
+++ b/lexilla/test/examples/pascal/CodeFolding.pas
@@ -0,0 +1,80 @@
+// tests for code folding
+
+// multi line comments
+{ 
+line1
+line2
+}
+
+// begin .. end
+begin
+some commands
+end;
+
+record test
+  var1: type1;
+  var2: type2;
+  end; //record
+  
+//asm
+asm
+  some statement
+  end; //asm
+  
+//try (from https://wiki.freepascal.org/Try)
+try
+  // code that might generate an exception
+except
+  // will only be executed in case of an exception
+  on E: EDatabaseError do
+    ShowMessage( 'Database error: '+ E.ClassName + #13#10 + E.Message );
+  on E: Exception do
+    ShowMessage( 'Error: '+ E.ClassName + #13#10 + E.Message );
+end;
+  
+//try nested (from https://wiki.freepascal.org/Try)
+try
+  try
+    // code dealing with database that might generate an exception
+  except
+    // will only be executed in case of an exception
+    on E: EDatabaseError do
+      ShowMessage( 'Database error: '+ E.ClassName + #13#10 + E.Message );
+    on E: Exception do
+      ShowMessage( 'Error: '+ E.ClassName + #13#10 + E.Message );
+  end;
+finally
+  // clean up database-related resources
+end;
+
+//case
+case x of
+  1: do something;
+  2: do some other thing;
+else
+  do default;
+  end; //case
+  
+//if then else  
+if x=y then 
+  do something;
+else
+  do some other thing;
+  
+//for loop  
+for i:=1 to 10 do
+  writeln(i)
+
+//do until
+repeat
+  write(a);
+  i:=i+1;
+until i>10;
+
+//preprocessor if, else, endif
+{$DEFINE label}
+{$IFDEF label}
+  command 1
+{$ELSE}
+  command 2
+{$ENDIF}
diff --git a/lexilla/test/examples/pascal/CodeFolding.pas.folded b/lexilla/test/examples/pascal/CodeFolding.pas.folded
new file mode 100644
index 000000000..bd785d07c
--- /dev/null
+++ b/lexilla/test/examples/pascal/CodeFolding.pas.folded
@@ -0,0 +1,81 @@
+ 0 400   0   // tests for code folding
+ 1 400   0   
+ 0 400   0   // multi line comments
+ 2 400   0 + { 
+ 0 401   0 | line1
+ 0 401   0 | line2
+ 0 401   0 | }
+ 1 400   0   
+ 0 400   0   // begin .. end
+ 2 400   0 + begin
+ 0 401   0 | some commands
+ 0 401   0 | end;
+ 1 400   0   
+ 2 400   0 + record test
+ 0 401   0 |   var1: type1;
+ 0 401   0 |   var2: type2;
+ 0 401   0 |   end; //record
+ 1 400   0     
+ 0 400   0   //asm
+ 2 400   0 + asm
+ 0 401   0 |   some statement
+ 0 401   0 |   end; //asm
+ 1 400   0     
+ 0 400   0   //try (from https://wiki.freepascal.org/Try)
+ 2 400   0 + try
+ 0 401   0 |   // code that might generate an exception
+ 0 401   0 | except
+ 0 401   0 |   // will only be executed in case of an exception
+ 0 401   0 |   on E: EDatabaseError do
+ 0 401   0 |     ShowMessage( 'Database error: '+ E.ClassName + #13#10 + E.Message );
+ 0 401   0 |   on E: Exception do
+ 0 401   0 |     ShowMessage( 'Error: '+ E.ClassName + #13#10 + E.Message );
+ 0 401   0 | end;
+ 1 400   0     
+ 0 400   0   //try nested (from https://wiki.freepascal.org/Try)
+ 2 400   0 + try
+ 2 401   0 +   try
+ 0 402   0 |     // code dealing with database that might generate an exception
+ 0 402   0 |   except
+ 0 402   0 |     // will only be executed in case of an exception
+ 0 402   0 |     on E: EDatabaseError do
+ 0 402   0 |       ShowMessage( 'Database error: '+ E.ClassName + #13#10 + E.Message );
+ 0 402   0 |     on E: Exception do
+ 0 402   0 |       ShowMessage( 'Error: '+ E.ClassName + #13#10 + E.Message );
+ 0 402   0 |   end;
+ 0 401   0 | finally
+ 0 401   0 |   // clean up database-related resources
+ 0 401   0 | end;
+ 1 400   0   
+ 0 400   0   //case
+ 2 400   0 + case x of
+ 0 401   0 |   1: do something;
+ 0 401   0 |   2: do some other thing;
+ 0 401   0 | else
+ 0 401   0 |   do default;
+ 0 401   0 |   end; //case
+ 1 400   0     
+ 0 400   0   //if then else  
+ 0 400   0   if x=y then 
+ 0 400   0     do something;
+ 0 400   0   else
+ 0 400   0     do some other thing;
+ 1 400   0     
+ 0 400   0   //for loop  
+ 0 400   0   for i:=1 to 10 do
+ 0 400   0     writeln(i)
+ 1 400   0   
+ 0 400   0   //do until
+ 0 400   0   repeat
+ 0 400   0     write(a);
+ 0 400   0     i:=i+1;
+ 0 400   0   until i>10;
+ 1 400   0   
+ 0 400   0   //preprocessor if, else, endif
+ 0 400   0   {$DEFINE label}
+ 2 400   0 + {$IFDEF label}
+ 0 401   0 |   command 1
+ 0 401   0 | {$ELSE}
+ 0 401   0 |   command 2
+ 0 401   0 | {$ENDIF}
+ 1 400   0   
\ No newline at end of file
diff --git a/lexilla/test/examples/pascal/CodeFolding.pas.styled b/lexilla/test/examples/pascal/CodeFolding.pas.styled
new file mode 100644
index 000000000..99f9d892c
--- /dev/null
+++ b/lexilla/test/examples/pascal/CodeFolding.pas.styled
@@ -0,0 +1,80 @@
+{4}// tests for code folding
+{0}
+{4}// multi line comments
+{2}{ 
+line1
+line2
+}{0}
+
+{4}// begin .. end
+{9}begin{0}
+{1}some{0} {1}commands{0}
+{9}end{13};{0}
+
+{9}record{0} {1}test{0}
+  {1}var1{13}:{0} {1}type1{13};{0}
+  {1}var2{13}:{0} {1}type2{13};{0}
+  {9}end{13};{0} {4}//record
+{0}  
+{4}//asm
+{9}asm{14}
+  some statement
+  {9}end{13};{0} {4}//asm
+{0}  
+{4}//try (from https://wiki.freepascal.org/Try)
+{9}try{0}
+  {4}// code that might generate an exception
+{9}except{0}
+  {4}// will only be executed in case of an exception
+{0}  {9}on{0} {1}E{13}:{0} {1}EDatabaseError{0} {9}do{0}
+    {1}ShowMessage{13}({0} {10}'Database error: '{13}+{0} {1}E{13}.{1}ClassName{0} {13}+{0} {12}#13#10{0} {13}+{0} {1}E{13}.{9}Message{0} {13});{0}
+  {9}on{0} {1}E{13}:{0} {1}Exception{0} {9}do{0}
+    {1}ShowMessage{13}({0} {10}'Error: '{13}+{0} {1}E{13}.{1}ClassName{0} {13}+{0} {12}#13#10{0} {13}+{0} {1}E{13}.{9}Message{0} {13});{0}
+{9}end{13};{0}
+  
+{4}//try nested (from https://wiki.freepascal.org/Try)
+{9}try{0}
+  {9}try{0}
+    {4}// code dealing with database that might generate an exception
+{0}  {9}except{0}
+    {4}// will only be executed in case of an exception
+{0}    {9}on{0} {1}E{13}:{0} {1}EDatabaseError{0} {9}do{0}
+      {1}ShowMessage{13}({0} {10}'Database error: '{13}+{0} {1}E{13}.{1}ClassName{0} {13}+{0} {12}#13#10{0} {13}+{0} {1}E{13}.{9}Message{0} {13});{0}
+    {9}on{0} {1}E{13}:{0} {1}Exception{0} {9}do{0}
+      {1}ShowMessage{13}({0} {10}'Error: '{13}+{0} {1}E{13}.{1}ClassName{0} {13}+{0} {12}#13#10{0} {13}+{0} {1}E{13}.{9}Message{0} {13});{0}
+  {9}end{13};{0}
+{9}finally{0}
+  {4}// clean up database-related resources
+{9}end{13};{0}
+
+{4}//case
+{9}case{0} {1}x{0} {9}of{0}
+  {7}1{13}:{0} {9}do{0} {1}something{13};{0}
+  {7}2{13}:{0} {9}do{0} {1}some{0} {1}other{0} {1}thing{13};{0}
+{9}else{0}
+  {9}do{0} {1}default{13};{0}
+  {9}end{13};{0} {4}//case
+{0}  
+{4}//if then else  
+{9}if{0} {1}x{13}={1}y{0} {9}then{0} 
+  {9}do{0} {1}something{13};{0}
+{9}else{0}
+  {9}do{0} {1}some{0} {1}other{0} {1}thing{13};{0}
+  
+{4}//for loop  
+{9}for{0} {1}i{13}:={7}1{0} {9}to{0} {7}10{0} {9}do{0}
+  {1}writeln{13}({1}i{13}){0}
+
+{4}//do until
+{9}repeat{0}
+  {1}write{13}({1}a{13});{0}
+  {1}i{13}:={1}i{13}+{7}1{13};{0}
+{9}until{0} {1}i{13}>{7}10{13};{0}
+
+{4}//preprocessor if, else, endif
+{5}{$DEFINE label}{0}
+{5}{$IFDEF label}{0}
+  {1}command{0} {7}1{0}
+{5}{$ELSE}{0}
+  {1}command{0} {7}2{0}
+{5}{$ENDIF}{0}
diff --git a/lexilla/test/examples/pascal/SciTE.properties b/lexilla/test/examples/pascal/SciTE.properties
new file mode 100644
index 000000000..a302e23ab
--- /dev/null
+++ b/lexilla/test/examples/pascal/SciTE.properties
@@ -0,0 +1,20 @@
+# coding: utf-8
+lexer.*.pas=pascal
+keywords.*.pas=absolute abstract and array as asm assembler automated begin case \
+cdecl class const constructor delayed deprecated destructor dispid dispinterface \
+div do downto dynamic else end except experimental export exports external far \
+file final finalization finally for forward function goto helper if \
+implementation in inherited initialization inline interface is label library \
+message mod near nil not object of on operator or out overload override packed \
+pascal platform private procedure program property protected public published \
+raise record reference register reintroduce repeat resourcestring safecall \
+sealed set shl shr static stdcall strict string then threadvar to try type unit \
+unsafe until uses var varargs virtual while winapi with xor
+
+
+lexer.pascal.smart.highlighting=1
+
+fold=1
+fold.preprocessor=1
+fold.comment=1
+fold.compact=1
diff --git a/lexilla/test/examples/pascal/SomeExample.pas b/lexilla/test/examples/pascal/SomeExample.pas
new file mode 100644
index 000000000..d59cdad70
--- /dev/null
+++ b/lexilla/test/examples/pascal/SomeExample.pas
@@ -0,0 +1,41 @@
+// some example source code
+
+{
+  SCE_PAS_DEFAULT=0
+  SCE_PAS_IDENTIFIER=1
+  SCE_PAS_COMMENT=2
+  SCE_PAS_COMMENT2=3
+  SCE_PAS_COMMENTLINE=4
+  SCE_PAS_PREPROCESSOR=5
+  SCE_PAS_PREPROCESSOR2=6
+  SCE_PAS_NUMBER=7
+  SCE_PAS_HEXNUMBER=8
+  SCE_PAS_WORD=9
+  SCE_PAS_STRING=10
+  SCE_PAS_STRINGEOL=11
+  SCE_PAS_CHARACTER=12
+  SCE_PAS_OPERATOR=13
+  SCE_PAS_ASM=14
+}
+
+{ --------------------------------------------------------------------------- }
+function functionname(paramerter1: type1):result1;
+  var
+    i: LongInt;
+  begin
+  for i:=1 to 10 do
+    begin
+    writeln(i)
+    end;
+  result:=true;
+  end;
+{ --------------------------------------------------------------------------- }
+procedure procedurename(parameter2: type2);
+  var
+    i: LongInt;
+  begin
+  for i:=1 to 10 do
+    begin
+    writeln(i)
+    end;
+  end;
diff --git a/lexilla/test/examples/pascal/SomeExample.pas.folded b/lexilla/test/examples/pascal/SomeExample.pas.folded
new file mode 100644
index 000000000..9d78a588a
--- /dev/null
+++ b/lexilla/test/examples/pascal/SomeExample.pas.folded
@@ -0,0 +1,42 @@
+ 0 400   0   // some example source code
+ 1 400   0   
+ 2 400   0 + {
+ 0 401   0 |   SCE_PAS_DEFAULT=0
+ 0 401   0 |   SCE_PAS_IDENTIFIER=1
+ 0 401   0 |   SCE_PAS_COMMENT=2
+ 0 401   0 |   SCE_PAS_COMMENT2=3
+ 0 401   0 |   SCE_PAS_COMMENTLINE=4
+ 0 401   0 |   SCE_PAS_PREPROCESSOR=5
+ 0 401   0 |   SCE_PAS_PREPROCESSOR2=6
+ 0 401   0 |   SCE_PAS_NUMBER=7
+ 0 401   0 |   SCE_PAS_HEXNUMBER=8
+ 0 401   0 |   SCE_PAS_WORD=9
+ 0 401   0 |   SCE_PAS_STRING=10
+ 0 401   0 |   SCE_PAS_STRINGEOL=11
+ 0 401   0 |   SCE_PAS_CHARACTER=12
+ 0 401   0 |   SCE_PAS_OPERATOR=13
+ 0 401   0 |   SCE_PAS_ASM=14
+ 0 401   0 | }
+ 1 400   0   
+ 0 400   0   { --------------------------------------------------------------------------- }
+ 0 400   0   function functionname(paramerter1: type1):result1;
+ 0 400   0     var
+ 0 400   0       i: LongInt;
+ 2 400   0 +   begin
+ 0 401   0 |   for i:=1 to 10 do
+ 2 401   0 +     begin
+ 0 402   0 |     writeln(i)
+ 0 402   0 |     end;
+ 0 401   0 |   result:=true;
+ 0 401   0 |   end;
+ 0 400   0   { --------------------------------------------------------------------------- }
+ 0 400   0   procedure procedurename(parameter2: type2);
+ 0 400   0     var
+ 0 400   0       i: LongInt;
+ 2 400   0 +   begin
+ 0 401   0 |   for i:=1 to 10 do
+ 2 401   0 +     begin
+ 0 402   0 |     writeln(i)
+ 0 402   0 |     end;
+ 0 401   0 |   end;
+ 1 400   0   
\ No newline at end of file
diff --git a/lexilla/test/examples/pascal/SomeExample.pas.styled b/lexilla/test/examples/pascal/SomeExample.pas.styled
new file mode 100644
index 000000000..d0476325d
--- /dev/null
+++ b/lexilla/test/examples/pascal/SomeExample.pas.styled
@@ -0,0 +1,41 @@
+{4}// some example source code
+{0}
+{2}{
+  SCE_PAS_DEFAULT=0
+  SCE_PAS_IDENTIFIER=1
+  SCE_PAS_COMMENT=2
+  SCE_PAS_COMMENT2=3
+  SCE_PAS_COMMENTLINE=4
+  SCE_PAS_PREPROCESSOR=5
+  SCE_PAS_PREPROCESSOR2=6
+  SCE_PAS_NUMBER=7
+  SCE_PAS_HEXNUMBER=8
+  SCE_PAS_WORD=9
+  SCE_PAS_STRING=10
+  SCE_PAS_STRINGEOL=11
+  SCE_PAS_CHARACTER=12
+  SCE_PAS_OPERATOR=13
+  SCE_PAS_ASM=14
+}{0}
+
+{2}{ --------------------------------------------------------------------------- }{0}
+{9}function{0} {1}functionname{13}({1}paramerter1{13}:{0} {1}type1{13}):{1}result1{13};{0}
+  {9}var{0}
+    {1}i{13}:{0} {1}LongInt{13};{0}
+  {9}begin{0}
+  {9}for{0} {1}i{13}:={7}1{0} {9}to{0} {7}10{0} {9}do{0}
+    {9}begin{0}
+    {1}writeln{13}({1}i{13}){0}
+    {9}end{13};{0}
+  {1}result{13}:={1}true{13};{0}
+  {9}end{13};{0}
+{2}{ --------------------------------------------------------------------------- }{0}
+{9}procedure{0} {1}procedurename{13}({1}parameter2{13}:{0} {1}type2{13});{0}
+  {9}var{0}
+    {1}i{13}:{0} {1}LongInt{13};{0}
+  {9}begin{0}
+  {9}for{0} {1}i{13}:={7}1{0} {9}to{0} {7}10{0} {9}do{0}
+    {9}begin{0}
+    {1}writeln{13}({1}i{13}){0}
+    {9}end{13};{0}
+  {9}end{13};{0}
diff --git a/lexilla/test/examples/python/attributes/attrib-decorator.py b/lexilla/test/examples/python/attributes/attrib-decorator.py
new file mode 100644
index 000000000..8917172f9
--- /dev/null
+++ b/lexilla/test/examples/python/attributes/attrib-decorator.py
@@ -0,0 +1,9 @@
+# issue#294 also pointed out that decorator attributes behaved differently
+#   for left-justified decorators vs indented decorators
+
+@decorator.attribute
+def foo():
+    @decorator.attribute
+    def bar():
+        pass
+    bar()
diff --git a/lexilla/test/examples/python/attributes/attrib-decorator.py.folded b/lexilla/test/examples/python/attributes/attrib-decorator.py.folded
new file mode 100644
index 000000000..814d34122
--- /dev/null
+++ b/lexilla/test/examples/python/attributes/attrib-decorator.py.folded
@@ -0,0 +1,10 @@
+ 0 400   0   # issue#294 also pointed out that decorator attributes behaved differently
+ 0 400   0   #   for left-justified decorators vs indented decorators
+ 1 400   0   
+ 0 400   0   @decorator.attribute
+ 2 400   0 + def foo():
+ 0 404   0 |     @decorator.attribute
+ 2 404   0 +     def bar():
+ 0 408   0 |         pass
+ 0 404   0 |     bar()
+ 1 404   0 | 
\ No newline at end of file
diff --git a/lexilla/test/examples/python/attributes/attrib-decorator.py.styled b/lexilla/test/examples/python/attributes/attrib-decorator.py.styled
new file mode 100644
index 000000000..420543a72
--- /dev/null
+++ b/lexilla/test/examples/python/attributes/attrib-decorator.py.styled
@@ -0,0 +1,9 @@
+{1}# issue#294 also pointed out that decorator attributes behaved differently{0}
+{1}#   for left-justified decorators vs indented decorators{0}
+
+{15}@decorator{10}.{15}attribute{0}
+{5}def{0} {9}foo{10}():{0}
+    {15}@decorator{10}.{15}attribute{0}
+    {5}def{0} {9}bar{10}():{0}
+        {5}pass{0}
+    {11}bar{10}(){0}
diff --git a/lexilla/test/examples/python/attributes/attrib-id.py b/lexilla/test/examples/python/attributes/attrib-id.py
new file mode 100644
index 000000000..beb07a000
--- /dev/null
+++ b/lexilla/test/examples/python/attributes/attrib-id.py
@@ -0,0 +1,18 @@
+varname = 1
+# identifier in first line was mis-styled as attribute when bug existed
+
+# left comment ends with period.  this was okay before bug.
+varname = 2
+
+x = 1 # comment after code ends with period. this failed when bug existed.
+varname = 3
+
+def dummy():
+    # indented comment ends with period.this failed when bug existed.
+    varname = 4
+
+x = 2 ## comment block is the same.
+varname = 5
+
+# per issue#294, identifiers were mis-styled as attributes when at beginning of file
+# and when after a non-left-justifed comment
diff --git a/lexilla/test/examples/python/attributes/attrib-id.py.folded b/lexilla/test/examples/python/attributes/attrib-id.py.folded
new file mode 100644
index 000000000..ef328df72
--- /dev/null
+++ b/lexilla/test/examples/python/attributes/attrib-id.py.folded
@@ -0,0 +1,19 @@
+ 0 400   0   varname = 1
+ 0 400   0   # identifier in first line was mis-styled as attribute when bug existed
+ 1 400   0   
+ 0 400   0   # left comment ends with period.  this was okay before bug.
+ 0 400   0   varname = 2
+ 1 400   0   
+ 0 400   0   x = 1 # comment after code ends with period. this failed when bug existed.
+ 0 400   0   varname = 3
+ 1 400   0   
+ 2 400   0 + def dummy():
+ 0 404   0 |     # indented comment ends with period.this failed when bug existed.
+ 0 404   0 |     varname = 4
+ 1 400   0   
+ 0 400   0   x = 2 ## comment block is the same.
+ 0 400   0   varname = 5
+ 1 400   0   
+ 0 400   0   # per issue#294, identifiers were mis-styled as attributes when at beginning of file
+ 0 400   0   # and when after a non-left-justifed comment
+ 1 400   0   
\ No newline at end of file
diff --git a/lexilla/test/examples/python/attributes/attrib-id.py.styled b/lexilla/test/examples/python/attributes/attrib-id.py.styled
new file mode 100644
index 000000000..f31f09c9f
--- /dev/null
+++ b/lexilla/test/examples/python/attributes/attrib-id.py.styled
@@ -0,0 +1,18 @@
+{11}varname{0} {10}={0} {2}1{0}
+{1}# identifier in first line was mis-styled as attribute when bug existed{0}
+
+{1}# left comment ends with period.  this was okay before bug.{0}
+{11}varname{0} {10}={0} {2}2{0}
+
+{11}x{0} {10}={0} {2}1{0} {1}# comment after code ends with period. this failed when bug existed.{0}
+{11}varname{0} {10}={0} {2}3{0}
+
+{5}def{0} {9}dummy{10}():{0}
+    {1}# indented comment ends with period.this failed when bug existed.{0}
+    {11}varname{0} {10}={0} {2}4{0}
+
+{11}x{0} {10}={0} {2}2{0} {12}## comment block is the same.{0}
+{11}varname{0} {10}={0} {2}5{0}
+
+{1}# per issue#294, identifiers were mis-styled as attributes when at beginning of file{0}
+{1}# and when after a non-left-justifed comment{0}
diff --git a/lexilla/test/examples/ruby/234HereDoc.rb b/lexilla/test/examples/ruby/234HereDoc.rb
index 17bc8e11b..f80b96edb 100644
--- a/lexilla/test/examples/ruby/234HereDoc.rb
+++ b/lexilla/test/examples/ruby/234HereDoc.rb
@@ -6,3 +6,10 @@ A中
 puts <<中
 #{1+2}
 中
+
+def STDERR::error(x) = puts(x)
+def STDERR.error(x) = puts(x)
+
+STDERR.error <<EOF
+STDERR heredoc
+EOF
diff --git a/lexilla/test/examples/ruby/234HereDoc.rb.folded b/lexilla/test/examples/ruby/234HereDoc.rb.folded
index 815c8d124..cc23c67ae 100644
--- a/lexilla/test/examples/ruby/234HereDoc.rb.folded
+++ b/lexilla/test/examples/ruby/234HereDoc.rb.folded
@@ -6,4 +6,11 @@
  2 400   0 + puts <<中
  0 401   0 | #{1+2}
  0 401   0 | 中
+ 1 400   0   
+ 0 400   0   def STDERR::error(x) = puts(x)
+ 0 400   0   def STDERR.error(x) = puts(x)
+ 1 400   0   
+ 2 400   0 + STDERR.error <<EOF
+ 0 401   0 | STDERR heredoc
+ 0 401   0 | EOF
  0 400   0   
\ No newline at end of file
diff --git a/lexilla/test/examples/ruby/234HereDoc.rb.styled b/lexilla/test/examples/ruby/234HereDoc.rb.styled
index 930d57f3e..0cd519631 100644
--- a/lexilla/test/examples/ruby/234HereDoc.rb.styled
+++ b/lexilla/test/examples/ruby/234HereDoc.rb.styled
@@ -6,3 +6,10 @@
 {11}puts{0} {10}<<{20}中{22}
 {10}#{{4}1{10}+{4}2{10}}{22}
 {20}中{0}
+
+{5}def{0} {128}STDERR{10}::{9}error{10}({11}x{10}){0} {10}={0} {11}puts{10}({11}x{10}){0}
+{5}def{0} {128}STDERR{10}.{9}error{10}({11}x{10}){0} {10}={0} {11}puts{10}({11}x{10}){0}
+
+{128}STDERR{10}.{11}error{0} {10}<<{20}EOF{22}
+STDERR heredoc
+{20}EOF{0}
diff --git a/lexilla/test/examples/ruby/AllStyles.rb b/lexilla/test/examples/ruby/AllStyles.rb
index 2828c4941..e6e479d6f 100644
--- a/lexilla/test/examples/ruby/AllStyles.rb
+++ b/lexilla/test/examples/ruby/AllStyles.rb
@@ -113,6 +113,12 @@ while 1 do end
 #44:symbol
 %s(#{1 + 1})
 
+#128:user keywords 1
+decrypt
+
+#129:user keywords 2
+encrypt
+
 #19:data section
 __END__
 
diff --git a/lexilla/test/examples/ruby/AllStyles.rb.folded b/lexilla/test/examples/ruby/AllStyles.rb.folded
index 16677afe7..22172f03c 100644
--- a/lexilla/test/examples/ruby/AllStyles.rb.folded
+++ b/lexilla/test/examples/ruby/AllStyles.rb.folded
@@ -113,6 +113,12 @@
  0 400   0   #44:symbol
  0 400   0   %s(#{1 + 1})
  1 400   0   
+ 0 400   0   #128:user keywords 1
+ 0 400   0   decrypt
+ 1 400   0   
+ 0 400   0   #129:user keywords 2
+ 0 400   0   encrypt
+ 1 400   0   
  0 400   0   #19:data section
  0 400   0   __END__
  1 400   0   
diff --git a/lexilla/test/examples/ruby/AllStyles.rb.styled b/lexilla/test/examples/ruby/AllStyles.rb.styled
index 8e208bd10..279d9dfb6 100644
--- a/lexilla/test/examples/ruby/AllStyles.rb.styled
+++ b/lexilla/test/examples/ruby/AllStyles.rb.styled
@@ -113,6 +113,12 @@
 {2}#44:symbol{0}
 {44}%s(#{1 + 1}){0}
 
+{2}#128:user keywords 1{0}
+{128}decrypt{0}
+
+{2}#129:user keywords 2{0}
+{129}encrypt{0}
+
 {2}#19:data section{0}
 {19}__END__
 
diff --git a/lexilla/test/examples/ruby/Issue65.rb b/lexilla/test/examples/ruby/Issue65.rb
index 2b2ec459a..2ba56dc4f 100644
--- a/lexilla/test/examples/ruby/Issue65.rb
+++ b/lexilla/test/examples/ruby/Issue65.rb
@@ -41,6 +41,7 @@ class A
 	# array decomposition
 	def dec(((a, b), c)) = puts(a + b + c)
 	# class method
+	def self::say(*s) = puts(s)
 	def self.say(*s) = puts(s)
 	# test short method name
 	def a = 1
diff --git a/lexilla/test/examples/ruby/Issue65.rb.folded b/lexilla/test/examples/ruby/Issue65.rb.folded
index 745764f82..933298c5e 100644
--- a/lexilla/test/examples/ruby/Issue65.rb.folded
+++ b/lexilla/test/examples/ruby/Issue65.rb.folded
@@ -41,6 +41,7 @@
  0 401   0 | 	# array decomposition
  0 401   0 | 	def dec(((a, b), c)) = puts(a + b + c)
  0 401   0 | 	# class method
+ 0 401   0 | 	def self::say(*s) = puts(s)
  0 401   0 | 	def self.say(*s) = puts(s)
  0 401   0 | 	# test short method name
  0 401   0 | 	def a = 1
diff --git a/lexilla/test/examples/ruby/Issue65.rb.styled b/lexilla/test/examples/ruby/Issue65.rb.styled
index ff8db026e..50da455cb 100644
--- a/lexilla/test/examples/ruby/Issue65.rb.styled
+++ b/lexilla/test/examples/ruby/Issue65.rb.styled
@@ -41,6 +41,7 @@
 	{2}# array decomposition{0}
 	{5}def{0} {9}dec{10}((({11}a{10},{0} {11}b{10}),{0} {11}c{10})){0} {10}={0} {11}puts{10}({11}a{0} {10}+{0} {11}b{0} {10}+{0} {11}c{10}){0}
 	{2}# class method{0}
+	{5}def{0} {29}self{10}::{9}say{10}(*{11}s{10}){0} {10}={0} {11}puts{10}({11}s{10}){0}
 	{5}def{0} {29}self{10}.{9}say{10}(*{11}s{10}){0} {10}={0} {11}puts{10}({11}s{10}){0}
 	{2}# test short method name{0}
 	{5}def{0} {9}a{0} {10}={0} {4}1{0}
diff --git a/lexilla/test/examples/ruby/SciTE.properties b/lexilla/test/examples/ruby/SciTE.properties
index 5693c0efb..83cb91b4e 100644
--- a/lexilla/test/examples/ruby/SciTE.properties
+++ b/lexilla/test/examples/ruby/SciTE.properties
@@ -1,4 +1,8 @@
 lexer.*.rb=ruby
-keywords.*.rb=begin class def do end false if module return self super true unless until while \
+keywords.*.rb=begin class def do else end false if module return self super true unless until while \
 __FILE__ __LINE__
 fold=1
+
+substyles.ruby.11=2
+substylewords.11.1.*=decrypt STDERR
+substylewords.11.2.*=encrypt
diff --git a/lexilla/version.txt b/lexilla/version.txt
index 28621d35a..878b70634 100644
--- a/lexilla/version.txt
+++ b/lexilla/version.txt
@@ -1 +1 @@
-542
\ No newline at end of file
+543
\ No newline at end of file
diff --git a/scintilla/call/ScintillaCall.cxx b/scintilla/call/ScintillaCall.cxx
index 64c9728e2..57b050805 100644
--- a/scintilla/call/ScintillaCall.cxx
+++ b/scintilla/call/ScintillaCall.cxx
@@ -1259,6 +1259,26 @@ ChangeHistoryOption ScintillaCall::ChangeHistory() {
 	return static_cast<Scintilla::ChangeHistoryOption>(Call(Message::GetChangeHistory));
 }
 
+void ScintillaCall::SetUndoSelectionHistory(Scintilla::UndoSelectionHistoryOption undoSelectionHistory) {
+	Call(Message::SetUndoSelectionHistory, static_cast<uintptr_t>(undoSelectionHistory));
+}
+
+UndoSelectionHistoryOption ScintillaCall::UndoSelectionHistory() {
+	return static_cast<Scintilla::UndoSelectionHistoryOption>(Call(Message::GetUndoSelectionHistory));
+}
+
+void ScintillaCall::SetSelectionSerialized(const char *selectionString) {
+	CallString(Message::SetSelectionSerialized, 0, selectionString);
+}
+
+Position ScintillaCall::SelectionSerialized(char *selectionString) {
+	return CallPointer(Message::GetSelectionSerialized, 0, selectionString);
+}
+
+std::string ScintillaCall::SelectionSerialized() {
+	return CallReturnString(Message::GetSelectionSerialized, 0);
+}
+
 Line ScintillaCall::FirstVisibleLine() {
 	return Call(Message::GetFirstVisibleLine);
 }
diff --git a/scintilla/cocoa/Scintilla/Info.plist b/scintilla/cocoa/Scintilla/Info.plist
index 0b38cedfc..d78450e75 100644
--- a/scintilla/cocoa/Scintilla/Info.plist
+++ b/scintilla/cocoa/Scintilla/Info.plist
@@ -15,7 +15,7 @@
 	<key>CFBundlePackageType</key>
 	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
 	<key>CFBundleShortVersionString</key>
-	<string>5.5.4</string>
+	<string>5.5.5</string>
 	<key>CFBundleVersion</key>
 	<string>$(CURRENT_PROJECT_VERSION)</string>
 	<key>NSHumanReadableCopyright</key>
diff --git a/scintilla/cocoa/Scintilla/Scintilla.xcodeproj/project.pbxproj b/scintilla/cocoa/Scintilla/Scintilla.xcodeproj/project.pbxproj
index 31316e909..1edacf787 100644
--- a/scintilla/cocoa/Scintilla/Scintilla.xcodeproj/project.pbxproj
+++ b/scintilla/cocoa/Scintilla/Scintilla.xcodeproj/project.pbxproj
@@ -586,7 +586,7 @@
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 5.5.4;
+				CURRENT_PROJECT_VERSION = 5.5.5;
 				DEAD_CODE_STRIPPING = YES;
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
@@ -650,7 +650,7 @@
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
 				COPY_PHASE_STRIP = NO;
-				CURRENT_PROJECT_VERSION = 5.5.4;
+				CURRENT_PROJECT_VERSION = 5.5.5;
 				DEAD_CODE_STRIPPING = YES;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				ENABLE_NS_ASSERTIONS = NO;
@@ -682,7 +682,7 @@
 				CODE_SIGN_IDENTITY = "-";
 				CODE_SIGN_STYLE = Manual;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 5.5.4;
+				CURRENT_PROJECT_VERSION = 5.5.5;
 				DEAD_CODE_STRIPPING = YES;
 				DEFINES_MODULE = YES;
 				DEVELOPMENT_TEAM = "";
@@ -717,7 +717,7 @@
 				CODE_SIGN_IDENTITY = "-";
 				CODE_SIGN_STYLE = Manual;
 				COMBINE_HIDPI_IMAGES = YES;
-				CURRENT_PROJECT_VERSION = 5.5.4;
+				CURRENT_PROJECT_VERSION = 5.5.5;
 				DEAD_CODE_STRIPPING = YES;
 				DEFINES_MODULE = YES;
 				DEVELOPMENT_TEAM = "";
diff --git a/scintilla/doc/ScintillaDoc.html b/scintilla/doc/ScintillaDoc.html
index aa5e1f9a0..b436d2620 100644
--- a/scintilla/doc/ScintillaDoc.html
+++ b/scintilla/doc/ScintillaDoc.html
@@ -130,7 +130,7 @@
 
     <h1>Scintilla Documentation</h1>
 
-    <p>Last edited 26 October 2024 NH</p>
+    <p>Last edited 12 February 2025 NH</p>
 
     <p style="background:#90F0C0">Scintilla 5 has moved the lexers from Scintilla into a new
     <a href="Lexilla.html">Lexilla</a> project.<br />
@@ -1121,7 +1121,7 @@ struct Sci_TextRangeFull {
     If the text argument is NULL(0) then the length that should be allocated
     to store the entire current line is returned.</p>
 
-    <p>See also: <code
+    <p>See also: <code>
     <a class="seealso" href="#SCI_GETSELTEXT">SCI_GETSELTEXT</a>,
     <a class="seealso" href="#SCI_GETLINE">SCI_GETLINE</a>,
     <a class="seealso" href="#SCI_GETTEXT">SCI_GETTEXT</a>,
@@ -1239,6 +1239,10 @@ struct Sci_TextRangeFull {
      <a class="message" href="#SCI_GETRECTANGULARSELECTIONANCHORVIRTUALSPACE">SCI_GETRECTANGULARSELECTIONANCHORVIRTUALSPACE &rarr; position</a><br />
      <br />
 
+     <a class="message" href="#SCI_SETSELECTIONSERIALIZED">SCI_SETSELECTIONSERIALIZED(&lt;unused&gt;, const char *selectionString)</a><br />
+     <a class="message" href="#SCI_GETSELECTIONSERIALIZED">SCI_GETSELECTIONSERIALIZED(&lt;unused&gt;, char *selectionString) &rarr; position</a><br />
+     <br />
+
      <a class="element" href="#SC_ELEMENT_SELECTION_ADDITIONAL_TEXT">SC_ELEMENT_SELECTION_ADDITIONAL_TEXT : colouralpha</a><br />
      <a class="element" href="#SC_ELEMENT_SELECTION_ADDITIONAL_BACK">SC_ELEMENT_SELECTION_ADDITIONAL_BACK : colouralpha</a><br />
      <a class="discouraged message" href="#SCI_SETADDITIONALSELALPHA">SCI_SETADDITIONALSELALPHA(alpha alpha)</a><br />
@@ -1404,6 +1408,12 @@ struct Sci_TextRangeFull {
      Set or query the position and amount of virtual space for the caret and anchor of the rectangular selection.
      After setting the rectangular selection, this is broken down into multiple selections, one for each line.</p>
 
+    <p>
+     <b id="SCI_SETSELECTIONSERIALIZED">SCI_SETSELECTIONSERIALIZED(&lt;unused&gt;, const char *selectionString)</b><br />
+     <b id="SCI_GETSELECTIONSERIALIZED">SCI_GETSELECTIONSERIALIZED(&lt;unused&gt;, char *selectionString) &rarr; position</b><br />
+     Set or query the selection type and positions as a serialized string.
+     The format of this string may change in future versions so should not be persisted beyond the current session.</p>
+
     <p>
      <b id="SC_ELEMENT_SELECTION_ADDITIONAL_TEXT">SC_ELEMENT_SELECTION_ADDITIONAL_TEXT : colouralpha</b><br />
      <b id="SC_ELEMENT_SELECTION_ADDITIONAL_BACK">SC_ELEMENT_SELECTION_ADDITIONAL_BACK : colouralpha</b><br />
@@ -1938,6 +1948,8 @@ struct Sci_TextToFindFull {
      <a class="message" href="#SCI_ENDUNDOACTION">SCI_ENDUNDOACTION</a><br />
      <a class="message" href="#SCI_GETUNDOSEQUENCE">SCI_GETUNDOSEQUENCE &rarr; int</a><br />
      <a class="message" href="#SCI_ADDUNDOACTION">SCI_ADDUNDOACTION(int token, int flags)</a><br />
+     <a class="message" href="#SCI_SETUNDOSELECTIONHISTORY">SCI_SETUNDOSELECTIONHISTORY(int undoSelectionHistory)</a><br />
+     <a class="message" href="#SCI_GETUNDOSELECTIONHISTORY">SCI_GETUNDOSELECTIONHISTORY &rarr; int</a><br />
     </code>
 
     <p><b id="SCI_UNDO">SCI_UNDO</b><br />
@@ -2016,6 +2028,35 @@ struct Sci_TextToFindFull {
      look like typing or deletions that look like multiple uses of the Backspace or Delete keys.
      </p>
 
+    <p><b id="SCI_SETUNDOSELECTIONHISTORY">SCI_SETUNDOSELECTIONHISTORY(int undoSelectionHistory)</b><br />
+     <b id="SCI_GETUNDOSELECTIONHISTORY">SCI_GETUNDOSELECTIONHISTORY &rarr; int</b><br />
+     The selection for each action can be saved and then restored when undo or redo is performed.
+      <code>SCI_SETUNDOSELECTIONHISTORY</code> controls this.
+      There is a memory cost for this feature with a minimum of 150 bytes for each of undo and redo for each recorded action.
+      Recording may be turned on at any time.</p>
+
+    <p>The <code class="parameter">undoSelectionHistory</code> argument can be:</p>
+    <table class="standard" summary="Undo selection history state">
+      <tbody valign="top">
+        <tr>
+          <th align="left"><code>SC_UNDO_SELECTION_HISTORY_DISABLED</code></th>
+
+          <td>0</td>
+
+          <td>The default: undo selection history turned off.</td>
+        </tr>
+
+        <tr>
+          <th align="left"><code>SC_UNDO_SELECTION_HISTORY_ENABLED</code></th>
+
+          <td>1</td>
+
+          <td>Restore selection for each undo and redo.</td>
+        </tr>
+
+      </tbody>
+    </table>
+
     <h2 id="UndoSaveRestore">Undo Save and Restore</h2>
 
     <p>This feature is unfinished and has limitations.
@@ -5024,16 +5065,55 @@ struct Sci_TextToFindFull {
      <b id="SCI_GETTECHNOLOGY">SCI_GETTECHNOLOGY &rarr; int</b><br />
     The technology property allows choosing between different drawing APIs and options.
     On most platforms, the only choice is <code>SC_TECHNOLOGY_DEFAULT</code> (0).
-    On Windows Vista or later, <code>SC_TECHNOLOGY_DIRECTWRITE</code> (1),
-    <code>SC_TECHNOLOGY_DIRECTWRITERETAIN</code> (2), or
-    <code>SC_TECHNOLOGY_DIRECTWRITEDC</code> (3)
-    can be chosen to use the Direct2D and DirectWrite APIs for higher quality antialiased drawing.
-    <code>SC_TECHNOLOGY_DIRECTWRITERETAIN</code> differs from
-    <code>SC_TECHNOLOGY_DIRECTWRITE</code> by requesting that the frame
-    is retained after being presented which may prevent drawing failures on some cards and drivers.
-    <code>SC_TECHNOLOGY_DIRECTWRITEDC</code> differs from
-    <code>SC_TECHNOLOGY_DIRECTWRITE</code> by using DirectWrite to draw into a GDI DC.
+    On Windows 7 or later, <code>SC_TECHNOLOGY_DIRECTWRITE</code> (1) performs higher quality antialiased drawing.
+    The other choices in the following table are similar to <code>SC_TECHNOLOGY_DIRECTWRITE</code>
+    but may work or be more efficient in some situations where <code>SC_TECHNOLOGY_DIRECTWRITE</code> fails or is slow.
     </p>
+    <table class="standard" summary="Technology choice">
+      <tbody valign="top">
+        <tr>
+          <th align="left"><code>SC_TECHNOLOGY_DEFAULT</code></th>
+
+          <td>0</td>
+
+          <td>Use older GDI API which is compatible with all versions of Windows including Windows Vista and XP.</td>
+        </tr>
+
+        <tr>
+          <th align="left"><code>SC_TECHNOLOGY_DIRECTWRITE</code></th>
+
+          <td>1</td>
+
+          <td>Use the Direct2D and DirectWrite APIs for higher quality antialiased drawing.</td>
+        </tr>
+
+        <tr>
+          <th align="left"><code>SC_TECHNOLOGY_DIRECTWRITERETAIN</code></th>
+
+          <td>2</td>
+
+          <td>Request that the frame is retained after being presented which may prevent drawing failures on some cards and drivers.</td>
+        </tr>
+
+        <tr>
+          <th align="left"><code>SC_TECHNOLOGY_DIRECTWRITEDC</code></th>
+
+          <td>3</td>
+
+          <td>Use DirectWrite to draw into a GDI DC. This mode may work for remote access sessions.</td>
+        </tr>
+
+        <tr>
+          <th align="left"><code>SC_TECHNOLOGY_DIRECT_WRITE_1</code></th>
+
+          <td>4</td>
+
+          <td>Use DirectWrite in a lower level way that manages graphics state more explicitly.</td>
+        </tr>
+
+      </tbody>
+    </table>
+
     <p>
     On Win32, buffered drawing is set to a reasonable value for the technology: on for GDI and off for Direct2D
     as Direct2D performs its own buffering.
@@ -5216,7 +5296,7 @@ struct Sci_TextToFindFull {
           <td><code>SC_SUPPORTS_LINE_DRAWS_FINAL</code></td>
           <td>0</td>
           <td>Whether drawing a line draws its final position.<br />
-          Only false on Win32 GDI.</div></td>
+          Only false on Win32 GDI.</td>
         </tr>
 
         <tr>
@@ -7523,7 +7603,7 @@ sptr_t CallScintilla(unsigned int iMessage, uptr_t wParam, sptr_t lParam){
     <p>For many applications lexing documents larger than 4GB will be too sluggish so
     <code>SC_DOCUMENTOPTION_STYLES_NONE</code>
     and the null lexer <code>"null"</code> can be used. Another approach is to turn on idle styling with
-    <code><a class="seealso" href="#SCI_SETIDLESTYLING">SCI_SETIDLESTYLING</code></a>.
+    <a class="seealso" href="#SCI_SETIDLESTYLING"><code>SCI_SETIDLESTYLING</code></a>.
     </p>
 
     <table class="standard" summary="Document options">
diff --git a/scintilla/doc/ScintillaDownload.html b/scintilla/doc/ScintillaDownload.html
index 3295fab01..5f041a01f 100644
--- a/scintilla/doc/ScintillaDownload.html
+++ b/scintilla/doc/ScintillaDownload.html
@@ -26,9 +26,9 @@
     <table bgcolor="#CCCCCC" width="100%" cellspacing="0" cellpadding="8" border="0">
       <tr>
         <td>
-          <font size="4"> <a href="https://www.scintilla.org/scintilla554.zip">
+          <font size="4"> <a href="https://www.scintilla.org/scintilla555.zip">
 	Windows</a>&nbsp;&nbsp;
-	<a href="https://www.scintilla.org/scintilla554.tgz">
+	<a href="https://www.scintilla.org/scintilla555.tgz">
           GTK/Linux</a>&nbsp;&nbsp;
 	</font>
         </td>
@@ -42,7 +42,7 @@
       containing very few restrictions.
     </p>
     <h3>
-       Release 5.5.4
+       Release 5.5.5
     </h3>
     <h4>
        Source Code
@@ -50,8 +50,8 @@
        The source code package contains all of the source code for Scintilla but no binary
 	executable code and is available in
        <ul>
-       <li><a href="https://www.scintilla.org/scintilla554.zip">zip format</a> (1.8M) commonly used on Windows</li>
-       <li><a href="https://www.scintilla.org/scintilla554.tgz">tgz format</a> (1.7M) commonly used on Linux and compatible operating systems</li>
+       <li><a href="https://www.scintilla.org/scintilla555.zip">zip format</a> (1.8M) commonly used on Windows</li>
+       <li><a href="https://www.scintilla.org/scintilla555.tgz">tgz format</a> (1.7M) commonly used on Linux and compatible operating systems</li>
        </ul>
        Instructions for building on both Windows and Linux are included in the readme file.
     <h4>
diff --git a/scintilla/doc/ScintillaHistory.html b/scintilla/doc/ScintillaHistory.html
index 2f31311e0..f4b400965 100644
--- a/scintilla/doc/ScintillaHistory.html
+++ b/scintilla/doc/ScintillaHistory.html
@@ -34,6 +34,7 @@
       </tr>
     </table>
     <h1>History of Scintilla</h1>
+    <a href="#Releases">Releases</a>
     <h2>Contributors</h2>
     <p>
        Thanks to all the people that have contributed patches, bug reports and suggestions.
@@ -586,7 +587,41 @@
 	<td>Pawel Z Wronek</td>
     </tr>
     </table>
-    <h2>Releases</h2>
+    <h2 id="Releases">Releases</h2>
+    <h3>
+       <a href="https://www.scintilla.org/scintilla555.zip">Release 5.5.5</a>
+    </h3>
+    <ul>
+	<li>
+	Released 25 February 2025.
+	</li>
+	<li>
+	Remember selection with undo and redo. Controlled with SCI_SETUNDOSELECTIONHISTORY.
+	<a href="https://sourceforge.net/p/scintilla/feature-requests/1273/">Feature #1273</a>,
+	<a href="https://sourceforge.net/p/scintilla/bugs/1479/">Bug #1479</a>,
+	<a href="https://sourceforge.net/p/scintilla/bugs/1224/">Bug #1224</a>.
+	</li>
+	<li>
+	Serialize selection type and ranges with SCI_GETSELECTIONSERIALIZED and SCI_SETSELECTIONSERIALIZED.
+	</li>
+	<li>
+	For Win32, update Direct2D and DirectWrite interfaces used to 1.1 and add a lower-level approach to calling DirectWrite 1.1
+	by specifying SC_TECHNOLOGY_DIRECT_WRITE_1.
+	Since Windows Vista does not support these API versions, Scintilla o longer supports DirectWrite on Windows Vista and will
+	fall back to using GDI.
+	</li>
+	<li>
+	Fix segmentation of long lexemes to avoid breaking before modifiers like accents that must be drawn with their base letters.
+	For wrapping, try to break lines without separating letters from modifiers.
+	</li>
+	<li>
+	For GTK on Windows, replace reverse arrow cursor with hand as reverse arrow was small in scaled modes.
+	<a href="https://sourceforge.net/p/scintilla/bugs/2460/">Bug #2460</a>.
+	</li>
+	<li>
+	Fix bug on Qt where double-click stopped working when Scintilla instance had been running for weeks.
+	</li>
+    </ul>
     <h3>
        <a href="https://www.scintilla.org/scintilla554.zip">Release 5.5.4</a>
     </h3>
diff --git a/scintilla/doc/index.html b/scintilla/doc/index.html
index 1854eccf2..99a16d8c3 100644
--- a/scintilla/doc/index.html
+++ b/scintilla/doc/index.html
@@ -9,7 +9,7 @@
     <meta name="keywords" content="Scintilla, SciTE, Editing Component, Text Editor" />
     <meta name="Description"
     content="www.scintilla.org is the home of the Scintilla editing component and SciTE text editor application." />
-    <meta name="Date.Modified" content="20241218" />
+    <meta name="Date.Modified" content="20250225" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <style type="text/css">
         .logo {
@@ -61,8 +61,8 @@
           GTK, and macOS</font>
         </td>
         <td width="40%" align="right">
-          <font color="#FFCC99" size="3"> Release version 5.5.4<br />
-           Site last modified December 18 2024</font>
+          <font color="#FFCC99" size="3"> Release version 5.5.5<br />
+           Site last modified February 25 2025</font>
         </td>
         <td width="20%">
           &nbsp;
@@ -77,11 +77,11 @@
       </tr>
     </table>
     <ul id="versionlist">
+      <li>Version 5.5.5 can remember selection with undo and redo. Update to use DirectWrite 1.1.</li>
       <li>Version 5.5.4 fixes wrapping of removed lines and edge cases for moving lines. On GTK, middle click can be repeated with one value.</li>
       <li>Version 5.5.3 fixes horizontal scrolling with a touchpad on Win32.</li>
       <li>Version 5.5.2 adds multiple selection copy with separator, a font stretch setting, and access to whether an undo sequence is active.</li>
       <li>Version 5.5.1 adds SCI_CUTALLOWLINE and fixes a Win32 bug that caused the cursor to flicker.</li>
-      <li>Version 5.5.0 adds elements for inactive additional selections.</li>
     </ul>
     <ul id="menu">
       <li id="remote1"><a href="https://www.scintilla.org/SciTEImage.html">Screenshot</a></li>
diff --git a/scintilla/gtk/PlatGTK.cxx b/scintilla/gtk/PlatGTK.cxx
index d4e77a735..65073a5a6 100644
--- a/scintilla/gtk/PlatGTK.cxx
+++ b/scintilla/gtk/PlatGTK.cxx
@@ -1346,7 +1346,13 @@ void Window::SetCursor(Cursor curs) {
 		gdkCurs = gdk_cursor_new_for_display(pdisplay, GDK_HAND2);
 		break;
 	case Cursor::reverseArrow:
+#ifdef G_OS_WIN32
+		// GDK_RIGHT_PTR is scaled incorrectly under Windows with HiDPI screens (GTK 3.24);
+		// GDK_HAND2 is mapped to a native Windows cursor by GTK
+		gdkCurs = gdk_cursor_new_for_display(pdisplay, GDK_HAND2);
+#else
 		gdkCurs = gdk_cursor_new_for_display(pdisplay, GDK_RIGHT_PTR);
+#endif
 		break;
 	default:
 		gdkCurs = gdk_cursor_new_for_display(pdisplay, GDK_LEFT_PTR);
diff --git a/scintilla/include/Scintilla.h b/scintilla/include/Scintilla.h
index 49664614e..4a98d5640 100644
--- a/scintilla/include/Scintilla.h
+++ b/scintilla/include/Scintilla.h
@@ -533,6 +533,12 @@ typedef sptr_t (*SciFnDirectStatus)(sptr_t ptr, unsigned int iMessage, uptr_t wP
 #define SC_CHANGE_HISTORY_INDICATORS 4
 #define SCI_SETCHANGEHISTORY 2780
 #define SCI_GETCHANGEHISTORY 2781
+#define SC_UNDO_SELECTION_HISTORY_DISABLED 0
+#define SC_UNDO_SELECTION_HISTORY_ENABLED 1
+#define SCI_SETUNDOSELECTIONHISTORY 2782
+#define SCI_GETUNDOSELECTIONHISTORY 2783
+#define SCI_SETSELECTIONSERIALIZED 2784
+#define SCI_GETSELECTIONSERIALIZED 2785
 #define SCI_GETFIRSTVISIBLELINE 2152
 #define SCI_GETLINE 2153
 #define SCI_GETLINECOUNT 2154
@@ -1122,6 +1128,7 @@ typedef sptr_t (*SciFnDirectStatus)(sptr_t ptr, unsigned int iMessage, uptr_t wP
 #define SC_TECHNOLOGY_DIRECTWRITE 1
 #define SC_TECHNOLOGY_DIRECTWRITERETAIN 2
 #define SC_TECHNOLOGY_DIRECTWRITEDC 3
+#define SC_TECHNOLOGY_DIRECT_WRITE_1 4
 #define SCI_SETTECHNOLOGY 2630
 #define SCI_GETTECHNOLOGY 2631
 #define SCI_CREATELOADER 2632
diff --git a/scintilla/include/Scintilla.iface b/scintilla/include/Scintilla.iface
index c00890c95..0493d4149 100644
--- a/scintilla/include/Scintilla.iface
+++ b/scintilla/include/Scintilla.iface
@@ -1334,6 +1334,22 @@ set void SetChangeHistory=2780(ChangeHistoryOption changeHistory,)
 # Report change history status.
 get ChangeHistoryOption GetChangeHistory=2781(,)
 
+enu UndoSelectionHistoryOption=SC_UNDO_SELECTION_HISTORY_
+val SC_UNDO_SELECTION_HISTORY_DISABLED=0
+val SC_UNDO_SELECTION_HISTORY_ENABLED=1
+
+# Enable or disable undo selection history.
+set void SetUndoSelectionHistory=2782(UndoSelectionHistoryOption undoSelectionHistory,)
+
+# Report undo selection history status.
+get UndoSelectionHistoryOption GetUndoSelectionHistory=2783(,)
+
+# Set selection from serialized form.
+set void SetSelectionSerialized=2784(, string selectionString)
+
+# Retrieve serialized form of selection.
+get position GetSelectionSerialized=2785(, stringresult selectionString)
+
 # Retrieve the display line at the top of the display.
 get line GetFirstVisibleLine=2152(,)
 
@@ -3076,6 +3092,7 @@ val SC_TECHNOLOGY_DEFAULT=0
 val SC_TECHNOLOGY_DIRECTWRITE=1
 val SC_TECHNOLOGY_DIRECTWRITERETAIN=2
 val SC_TECHNOLOGY_DIRECTWRITEDC=3
+val SC_TECHNOLOGY_DIRECT_WRITE_1=4
 
 ali SC_TECHNOLOGY_DIRECTWRITE=DIRECT_WRITE
 ali SC_TECHNOLOGY_DIRECTWRITERETAIN=DIRECT_WRITE_RETAIN
diff --git a/scintilla/include/ScintillaCall.h b/scintilla/include/ScintillaCall.h
index c1f35571f..345d15612 100644
--- a/scintilla/include/ScintillaCall.h
+++ b/scintilla/include/ScintillaCall.h
@@ -360,6 +360,11 @@ public:
 	Position FormatRangeFull(bool draw, RangeToFormatFull *fr);
 	void SetChangeHistory(Scintilla::ChangeHistoryOption changeHistory);
 	Scintilla::ChangeHistoryOption ChangeHistory();
+	void SetUndoSelectionHistory(Scintilla::UndoSelectionHistoryOption undoSelectionHistory);
+	Scintilla::UndoSelectionHistoryOption UndoSelectionHistory();
+	void SetSelectionSerialized(const char *selectionString);
+	Position SelectionSerialized(char *selectionString);
+	std::string SelectionSerialized();
 	Line FirstVisibleLine();
 	Position GetLine(Line line, char *text);
 	std::string GetLine(Line line);
diff --git a/scintilla/include/ScintillaMessages.h b/scintilla/include/ScintillaMessages.h
index 898c79948..0aa7362ec 100644
--- a/scintilla/include/ScintillaMessages.h
+++ b/scintilla/include/ScintillaMessages.h
@@ -285,6 +285,10 @@ enum class Message {
 	FormatRangeFull = 2777,
 	SetChangeHistory = 2780,
 	GetChangeHistory = 2781,
+	SetUndoSelectionHistory = 2782,
+	GetUndoSelectionHistory = 2783,
+	SetSelectionSerialized = 2784,
+	GetSelectionSerialized = 2785,
 	GetFirstVisibleLine = 2152,
 	GetLine = 2153,
 	GetLineCount = 2154,
diff --git a/scintilla/include/ScintillaTypes.h b/scintilla/include/ScintillaTypes.h
index a11626942..9ddab5397 100644
--- a/scintilla/include/ScintillaTypes.h
+++ b/scintilla/include/ScintillaTypes.h
@@ -300,6 +300,11 @@ enum class ChangeHistoryOption {
 	Indicators = 4,
 };
 
+enum class UndoSelectionHistoryOption {
+	Disabled = 0,
+	Enabled = 1,
+};
+
 enum class FoldLevel {
 	None = 0x0,
 	Base = 0x400,
@@ -511,6 +516,7 @@ enum class Technology {
 	DirectWrite = 1,
 	DirectWriteRetain = 2,
 	DirectWriteDC = 3,
+	DirectWrite1 = 4,
 };
 
 enum class LineEndType {
diff --git a/scintilla/qt/ScintillaEdit/ScintillaDocument.cpp b/scintilla/qt/ScintillaEdit/ScintillaDocument.cpp
index 2e29def38..384e8c212 100644
--- a/scintilla/qt/ScintillaEdit/ScintillaDocument.cpp
+++ b/scintilla/qt/ScintillaEdit/ScintillaDocument.cpp
@@ -55,6 +55,7 @@ public:
     void NotifyDeleted(Document *doc, void *userData) noexcept override;
     void NotifyStyleNeeded(Document *doc, void *userData, Sci::Position endPos) override;
     void NotifyErrorOccurred(Document *doc, void *userData, Status status) override;
+    void NotifyGroupCompleted(Document *doc, void *userData) noexcept override;
 };
 
 WatcherHelper::WatcherHelper(ScintillaDocument *owner_) : owner(owner_) {
@@ -88,6 +89,10 @@ void WatcherHelper::NotifyErrorOccurred(Document *, void *, Status status) {
     emit owner->error_occurred(static_cast<int>(status));
 }
 
+void WatcherHelper::NotifyGroupCompleted(Document *, void *) noexcept {
+    // Needed to satisfy protocol. May implement an event in future.
+}
+
 ScintillaDocument::ScintillaDocument(QObject *parent, void *pdoc_) :
     QObject(parent), pdoc(static_cast<Scintilla::IDocumentEditable *>(pdoc_)), docWatcher(nullptr) {
     if (!pdoc) {
diff --git a/scintilla/qt/ScintillaEdit/ScintillaEdit.pro b/scintilla/qt/ScintillaEdit/ScintillaEdit.pro
index 7a7fcab6f..97d7f4dda 100644
--- a/scintilla/qt/ScintillaEdit/ScintillaEdit.pro
+++ b/scintilla/qt/ScintillaEdit/ScintillaEdit.pro
@@ -13,7 +13,7 @@ TEMPLATE = lib
 CONFIG += lib_bundle
 CONFIG += c++1z
 
-VERSION = 5.5.4
+VERSION = 5.5.5
 
 SOURCES += \
     ScintillaEdit.cpp \
diff --git a/scintilla/qt/ScintillaEditBase/ScintillaEditBase.cpp b/scintilla/qt/ScintillaEditBase/ScintillaEditBase.cpp
index 202f0d94a..12ac0b16d 100644
--- a/scintilla/qt/ScintillaEditBase/ScintillaEditBase.cpp
+++ b/scintilla/qt/ScintillaEditBase/ScintillaEditBase.cpp
@@ -241,12 +241,12 @@ void ScintillaEditBase::keyPressEvent(QKeyEvent *event)
 		default:                    key = event->key(); break;
 	}
 
-	bool shift = QApplication::keyboardModifiers() & Qt::ShiftModifier;
-	bool ctrl  = QApplication::keyboardModifiers() & Qt::ControlModifier;
-	bool alt   = QApplication::keyboardModifiers() & Qt::AltModifier;
+	const bool shift = QApplication::keyboardModifiers() & Qt::ShiftModifier;
+	const bool ctrl  = QApplication::keyboardModifiers() & Qt::ControlModifier;
+	const bool alt   = QApplication::keyboardModifiers() & Qt::AltModifier;
 
 	bool consumed = false;
-	bool added = sqt->KeyDownWithModifiers(static_cast<Keys>(key),
+	const bool added = sqt->KeyDownWithModifiers(static_cast<Keys>(key),
 					       ModifierFlags(shift, ctrl, alt),
 					       &consumed) != 0;
 	if (!consumed)
@@ -283,7 +283,9 @@ void ScintillaEditBase::keyPressEvent(QKeyEvent *event)
 	emit keyPressed(event);
 }
 
-static int modifierTranslated(int sciModifier)
+namespace {
+
+int modifierTranslated(int sciModifier)
 {
 	switch (sciModifier) {
 		case SCMOD_SHIFT:
@@ -299,15 +301,25 @@ static int modifierTranslated(int sciModifier)
 	}
 }
 
+// Convert QElapsedTimer timestamp qint64 into unsigned int milliseconds wanted by Editor methods.
+unsigned int TimeOfEvent(const QElapsedTimer &timer)
+{
+	// Wrap every 2 billion milliseconds -> 24 days
+	constexpr qint64 maxTime = 2'000'000'000;
+	return static_cast<unsigned int>(timer.elapsed() % maxTime);
+}
+
+}
+
 void ScintillaEditBase::mousePressEvent(QMouseEvent *event)
 {
-	Point pos = PointFromQPoint(event->pos());
+	const Point pos = PointFromQPoint(event->pos());
 
 	emit buttonPressed(event);
 
 	if (event->button() == Qt::MiddleButton &&
 	    QApplication::clipboard()->supportsSelection()) {
-		SelectionPosition selPos = sqt->SPositionFromLocation(
+		const SelectionPosition selPos = sqt->SPositionFromLocation(
 					pos, false, false, sqt->UserVirtualSpace());
 		sqt->sel.Clear();
 		sqt->SetSelection(selPos, selPos);
@@ -316,15 +328,15 @@ void ScintillaEditBase::mousePressEvent(QMouseEvent *event)
 	}
 
 	if (event->button() == Qt::LeftButton) {
-		bool shift = QApplication::keyboardModifiers() & Qt::ShiftModifier;
-		bool ctrl  = QApplication::keyboardModifiers() & Qt::ControlModifier;
-		bool alt   = QApplication::keyboardModifiers() & modifierTranslated(sqt->rectangularSelectionModifier);
+		const bool shift = QApplication::keyboardModifiers() & Qt::ShiftModifier;
+		const bool ctrl  = QApplication::keyboardModifiers() & Qt::ControlModifier;
+		const bool alt   = QApplication::keyboardModifiers() & modifierTranslated(sqt->rectangularSelectionModifier);
 
-		sqt->ButtonDownWithModifiers(pos, time.elapsed(), ModifierFlags(shift, ctrl, alt));
+		sqt->ButtonDownWithModifiers(pos, TimeOfEvent(time), ModifierFlags(shift, ctrl, alt));
 	}
 
 	if (event->button() == Qt::RightButton) {
-		sqt->RightButtonDownWithModifiers(pos, time.elapsed(), ModifiersOfKeyboard());
+		sqt->RightButtonDownWithModifiers(pos, TimeOfEvent(time), ModifiersOfKeyboard());
 	}
 }
 
@@ -332,11 +344,11 @@ void ScintillaEditBase::mouseReleaseEvent(QMouseEvent *event)
 {
 	const QPoint point = event->pos();
 	if (event->button() == Qt::LeftButton)
-		sqt->ButtonUpWithModifiers(PointFromQPoint(point), time.elapsed(), ModifiersOfKeyboard());
+		sqt->ButtonUpWithModifiers(PointFromQPoint(point), TimeOfEvent(time), ModifiersOfKeyboard());
 
 	const sptr_t pos = send(SCI_POSITIONFROMPOINT, point.x(), point.y());
 	const sptr_t line = send(SCI_LINEFROMPOSITION, pos);
-	int modifiers = QApplication::keyboardModifiers();
+	const int modifiers = QApplication::keyboardModifiers();
 
 	emit textAreaClicked(line, modifiers);
 	emit buttonReleased(event);
@@ -350,21 +362,21 @@ void ScintillaEditBase::mouseDoubleClickEvent(QMouseEvent *event)
 
 void ScintillaEditBase::mouseMoveEvent(QMouseEvent *event)
 {
-	Point pos = PointFromQPoint(event->pos());
+	const Point pos = PointFromQPoint(event->pos());
 
-	bool shift = QApplication::keyboardModifiers() & Qt::ShiftModifier;
-	bool ctrl  = QApplication::keyboardModifiers() & Qt::ControlModifier;
-	bool alt   = QApplication::keyboardModifiers() & modifierTranslated(sqt->rectangularSelectionModifier);
+	const bool shift = QApplication::keyboardModifiers() & Qt::ShiftModifier;
+	const bool ctrl  = QApplication::keyboardModifiers() & Qt::ControlModifier;
+	const bool alt   = QApplication::keyboardModifiers() & modifierTranslated(sqt->rectangularSelectionModifier);
 
 	const KeyMod modifiers = ModifierFlags(shift, ctrl, alt);
 
-	sqt->ButtonMoveWithModifiers(pos, time.elapsed(), modifiers);
+	sqt->ButtonMoveWithModifiers(pos, TimeOfEvent(time), modifiers);
 }
 
 void ScintillaEditBase::contextMenuEvent(QContextMenuEvent *event)
 {
-	Point pos = PointFromQPoint(event->globalPos());
-	Point pt = PointFromQPoint(event->pos());
+	const Point pos = PointFromQPoint(event->globalPos());
+	const Point pt = PointFromQPoint(event->pos());
 	if (!sqt->PointInSelection(pt)) {
 		sqt->SetEmptySelection(sqt->PositionFromLocation(pt));
 	}
@@ -383,7 +395,7 @@ void ScintillaEditBase::dragEnterEvent(QDragEnterEvent *event)
 	} else if (event->mimeData()->hasText()) {
 		event->acceptProposedAction();
 
-		Point point = PointFromQPoint(event->pos());
+		const Point point = PointFromQPoint(event->pos());
 		sqt->DragEnter(point);
 	} else {
 		event->ignore();
@@ -402,7 +414,7 @@ void ScintillaEditBase::dragMoveEvent(QDragMoveEvent *event)
 	} else if (event->mimeData()->hasText()) {
 		event->acceptProposedAction();
 
-		Point point = PointFromQPoint(event->pos());
+		const Point point = PointFromQPoint(event->pos());
 		sqt->DragMove(point);
 	} else {
 		event->ignore();
@@ -417,8 +429,8 @@ void ScintillaEditBase::dropEvent(QDropEvent *event)
 	} else if (event->mimeData()->hasText()) {
 		event->acceptProposedAction();
 
-		Point point = PointFromQPoint(event->pos());
-		bool move = (event->source() == this &&
+		const Point point = PointFromQPoint(event->pos());
+		const bool move = (event->source() == this &&
                  event->proposedAction() == Qt::MoveAction);
 		sqt->Drop(point, event->mimeData(), move);
 	} else {
@@ -428,7 +440,7 @@ void ScintillaEditBase::dropEvent(QDropEvent *event)
 
 bool ScintillaEditBase::IsHangul(const QChar qchar)
 {
-	unsigned int unicode = qchar.unicode();
+	const unsigned int unicode = qchar.unicode();
 	// Korean character ranges used for preedit chars.
 	// http://www.programminginkorean.com/programming/hangul-in-unicode/
 	const bool HangulJamo = (0x1100 <= unicode && unicode <= 0x11FF);
@@ -465,22 +477,24 @@ void ScintillaEditBase::DrawImeIndicator(int indicator, int len)
 	}
 }
 
-static int GetImeCaretPos(QInputMethodEvent *event)
+namespace {
+
+int GetImeCaretPos(QInputMethodEvent *event)
 {
-	foreach (QInputMethodEvent::Attribute attr, event->attributes()) {
+	foreach (const QInputMethodEvent::Attribute attr, event->attributes()) {
 		if (attr.type == QInputMethodEvent::Cursor)
 			return attr.start;
 	}
 	return 0;
 }
 
-static std::vector<int> MapImeIndicators(QInputMethodEvent *event)
+std::vector<int> MapImeIndicators(QInputMethodEvent *event)
 {
 	std::vector<int> imeIndicator(event->preeditString().size(), IndicatorUnknown);
-	foreach (QInputMethodEvent::Attribute attr, event->attributes()) {
+	foreach (const QInputMethodEvent::Attribute attr, event->attributes()) {
 		if (attr.type == QInputMethodEvent::TextFormat) {
-			QTextFormat format = attr.value.value<QTextFormat>();
-			QTextCharFormat charFormat = format.toCharFormat();
+			const QTextFormat format = attr.value.value<QTextFormat>();
+			const QTextCharFormat charFormat = format.toCharFormat();
 
 			int indicator = IndicatorUnknown;
 			switch (charFormat.underlineStyle()) {
@@ -520,6 +534,8 @@ static std::vector<int> MapImeIndicators(QInputMethodEvent *event)
 	return imeIndicator;
 }
 
+}
+
 void ScintillaEditBase::inputMethodEvent(QInputMethodEvent *event)
 {
 	// Copy & paste by johnsonj with a lot of helps of Neil
@@ -596,8 +612,8 @@ void ScintillaEditBase::inputMethodEvent(QInputMethodEvent *event)
 		}
 
 		// Move IME carets.
-		int imeCaretPos = GetImeCaretPos(event);
-		int imeEndToImeCaretU16 = imeCaretPos - preeditStrLen;
+		const int imeCaretPos = GetImeCaretPos(event);
+		const int imeEndToImeCaretU16 = imeCaretPos - preeditStrLen;
 		const Sci::Position imeCaretPosDoc = sqt->pdoc->GetRelativePositionUTF16(sqt->CurrentPosition(), imeEndToImeCaretU16);
 
 		MoveImeCarets(- sqt->CurrentPosition() + imeCaretPosDoc);
@@ -671,7 +687,9 @@ QVariant ScintillaEditBase::inputMethodQuery(Qt::InputMethodQuery query) const
 
 		case Qt::ImCurrentSelection:
 		{
-			QVarLengthArray<char,1024> buffer(send(SCI_GETSELTEXT)+1);
+			// Most of the time selection is small so can be stack allocated
+			constexpr int reasonableSelectionLength = 1024;
+			QVarLengthArray<char,reasonableSelectionLength> buffer(send(SCI_GETSELTEXT)+1);
 			sends(SCI_GETSELTEXT, 0, buffer.data());
 
 			return sqt->StringFromDocument(buffer.constData());
@@ -727,7 +745,7 @@ void ScintillaEditBase::notifyParent(NotificationData scn)
 			const bool deleted = FlagSet(scn.modificationType, ModificationFlags::DeleteText);
 
 			const Scintilla::Position length = send(SCI_GETTEXTLENGTH);
-			bool firstLineAdded = (added && length == 1) ||
+			const bool firstLineAdded = (added && length == 1) ||
 			                      (deleted && length == 0);
 
 			if (scn.linesAdded != 0) {
diff --git a/scintilla/qt/ScintillaEditBase/ScintillaEditBase.pro b/scintilla/qt/ScintillaEditBase/ScintillaEditBase.pro
index 883147aff..66f17762b 100644
--- a/scintilla/qt/ScintillaEditBase/ScintillaEditBase.pro
+++ b/scintilla/qt/ScintillaEditBase/ScintillaEditBase.pro
@@ -13,7 +13,7 @@ TEMPLATE = lib
 CONFIG += lib_bundle
 CONFIG += c++1z
 
-VERSION = 5.5.4
+VERSION = 5.5.5
 
 SOURCES += \
     PlatQt.cpp \
diff --git a/scintilla/scripts/HeaderOrder.txt b/scintilla/scripts/HeaderOrder.txt
index 79cf0fa7a..7274299b5 100644
--- a/scintilla/scripts/HeaderOrder.txt
+++ b/scintilla/scripts/HeaderOrder.txt
@@ -52,6 +52,7 @@
 #include <memory>
 #include <numeric>
 #include <chrono>
+#include <charconv>
 #include <regex>
 #include <iostream>
 #include <sstream>
@@ -79,8 +80,10 @@
 #include <shellscalingapi.h>
 #include <zmouse.h>
 #include <ole2.h>
-#include <d2d1.h>
-#include <dwrite.h>
+#include <wrl.h>
+#include <d2d1_1.h>
+#include <d3d11_1.h>
+#include <dwrite_1.h>
 
 // Cocoa headers
 #include <Cocoa/Cocoa.h>
diff --git a/scintilla/src/CaseConvert.cxx b/scintilla/src/CaseConvert.cxx
index 67b6f199b..7fe0515b2 100644
--- a/scintilla/src/CaseConvert.cxx
+++ b/scintilla/src/CaseConvert.cxx
@@ -749,7 +749,7 @@ void CaseConverter::SetupConversions(CaseConversion conversion) {
 			break;
 		}
 		if (!converted.empty()) {
-			const int character = UnicodeFromUTF8(reinterpret_cast<const unsigned char *>(originUTF8.data()));
+			const int character = UnicodeFromUTF8(originUTF8);
 			Add(character, converted);
 		}
 	}
diff --git a/scintilla/src/CellBuffer.cxx b/scintilla/src/CellBuffer.cxx
index 081791dc4..96604146d 100644
--- a/scintilla/src/CellBuffer.cxx
+++ b/scintilla/src/CellBuffer.cxx
@@ -1075,6 +1075,10 @@ int CellBuffer::UndoSequenceDepth() const noexcept {
 	return uh->UndoSequenceDepth();
 }
 
+bool CellBuffer::AfterUndoSequenceStart() const noexcept {
+	return uh->AfterUndoSequenceStart();
+}
+
 void CellBuffer::AddUndoAction(Sci::Position token, bool mayCoalesce) {
 	bool startSequence = false;
 	uh->AppendAction(ActionType::container, token, nullptr, 0, startSequence, mayCoalesce);
diff --git a/scintilla/src/CellBuffer.h b/scintilla/src/CellBuffer.h
index 76f475484..7c670a5d2 100644
--- a/scintilla/src/CellBuffer.h
+++ b/scintilla/src/CellBuffer.h
@@ -167,6 +167,7 @@ public:
 	void BeginUndoAction(bool mayCoalesce=false) noexcept;
 	void EndUndoAction() noexcept;
 	int UndoSequenceDepth() const noexcept;
+	bool AfterUndoSequenceStart() const noexcept;
 	void AddUndoAction(Sci::Position token, bool mayCoalesce);
 	void DeleteUndoHistory() noexcept;
 
diff --git a/scintilla/src/Document.cxx b/scintilla/src/Document.cxx
index 61220e21a..3066c9691 100644
--- a/scintilla/src/Document.cxx
+++ b/scintilla/src/Document.cxx
@@ -18,6 +18,7 @@
 #include <string_view>
 #include <vector>
 #include <array>
+#include <map>
 #include <forward_list>
 #include <optional>
 #include <algorithm>
@@ -132,6 +133,9 @@ size_t ActionDuration::ActionsInAllowedTime(double secondsAllowed) const noexcep
 	return std::lround(secondsAllowed / Duration());
 }
 
+const CharacterExtracted characterEmpty(unicodeReplacementChar, 0);
+const CharacterExtracted characterBadByte(unicodeReplacementChar, 1);
+
 CharacterExtracted::CharacterExtracted(const unsigned char *charBytes, size_t widthCharBytes) noexcept {
 	const int utf8status = UTF8Classify(charBytes, widthCharBytes);
 	if (utf8status & UTF8MaskInvalid) {
@@ -959,7 +963,7 @@ bool Document::NextCharacter(Sci::Position &pos, int moveDir) const noexcept {
 
 CharacterExtracted Document::CharacterAfter(Sci::Position position) const noexcept {
 	if (position >= LengthNoExcept()) {
-		return CharacterExtracted(unicodeReplacementChar, 0);
+		return characterEmpty;
 	}
 	const unsigned char leadByte = cb.UCharAt(position);
 	if (!dbcsCodePage || UTF8IsAscii(leadByte)) {
@@ -985,7 +989,7 @@ CharacterExtracted Document::CharacterAfter(Sci::Position position) const noexce
 
 CharacterExtracted Document::CharacterBefore(Sci::Position position) const noexcept {
 	if (position <= 0) {
-		return CharacterExtracted(unicodeReplacementChar, 0);
+		return characterEmpty;
 	}
 	const unsigned char previousByte = cb.UCharAt(position - 1);
 	if (0 == dbcsCodePage) {
@@ -1010,7 +1014,7 @@ CharacterExtracted Document::CharacterBefore(Sci::Position position) const noexc
 			}
 			// Else invalid UTF-8 so return position of isolated trail byte
 		}
-		return CharacterExtracted(unicodeReplacementChar, 1);
+		return characterBadByte;
 	} else {
 		// Moving backwards in DBCS is complex so use NextPosition
 		const Sci::Position posStartCharacter = NextPosition(position, -1);
@@ -1201,6 +1205,104 @@ bool Document::IsDBCSDualByteAt(Sci::Position pos) const noexcept {
 		&& IsDBCSTrailByteNoExcept(cb.CharAt(pos + 1));
 }
 
+namespace {
+
+// Remove any extra bytes after the last valid character.
+void DiscardEndFragment(std::string_view &text) noexcept {
+	if (!text.empty()) {
+		if (UTF8IsFirstByte(text.back())) {
+			// Ending with start of character byte is invalid
+			text.remove_suffix(1);
+		} else if (UTF8IsTrailByte(text.back())) {
+			// go back to the start of last character.
+			const size_t maxTrail = std::max<size_t>(UTF8MaxBytes - 1, text.length());
+			size_t trail = 1;
+			while (trail < maxTrail && UTF8IsTrailByte(text[text.length() - trail])) {
+				trail++;
+			}
+			const std::string_view endPortion = text.substr(text.length() - trail);
+			if (!UTF8IsValid(endPortion)) {
+				text.remove_suffix(trail);
+			}
+		}
+	}
+}
+
+constexpr bool IsBaseOfGrapheme(CharacterCategory cc) {
+	// \p{L}\p{N}\p{P}\p{Sm}\p{Sc}\p{So}\p{Zs}
+	switch (cc) {
+	case ccLu:
+	case ccLl:
+	case ccLt:
+	case ccLm:
+	case ccLo:
+	case ccNd:
+	case ccNl:
+	case ccNo:
+	case ccPc:
+	case ccPd:
+	case ccPs:
+	case ccPe:
+	case ccPi:
+	case ccPf:
+	case ccPo:
+	case ccSm:
+	case ccSc:
+	case ccSo:
+	case ccZs:
+		return true;
+	default:
+		// ccMn, ccMc, ccMe,
+		// ccSk,
+		// ccZl, ccZp,
+		// ccCc, ccCf, ccCs, ccCo, ccCn
+		return false;
+	}
+}
+
+CharacterExtracted LastCharacter(std::string_view text) noexcept {
+	if (text.empty())
+		return characterEmpty;
+	const size_t length = text.length();
+	size_t trail = length;
+	while ((trail > 0) && (length - trail < UTF8MaxBytes) && UTF8IsTrailByte(text[trail - 1]))
+		trail--;
+	const size_t start = (trail > 0) ? trail - 1 : trail;
+	const int utf8status = UTF8Classify(text.substr(start));
+	if (utf8status & UTF8MaskInvalid) {
+		return characterBadByte;
+	}
+	return { static_cast<unsigned int>(UnicodeFromUTF8(text.substr(start))),
+		static_cast<unsigned int>(utf8status & UTF8MaskWidth) };
+}
+
+}
+
+bool Scintilla::Internal::DiscardLastCombinedCharacter(std::string_view &text) noexcept {
+	// Handle the simple common case where a base character may be followed by
+	// accents and similar marks by discarding until start of base character.
+	// 
+	// From Grapheme_Cluster_Boundaries
+	// combining character sequence = ccs-base? ccs-extend+
+	// ccs-base := [\p{L}\p{N}\p{P}\p{S}\p{Zs}]
+	// ccs-extend := [\p{M}\p{Join_Control}]
+	// Modified to move Sk (Symbol Modifier) from ccs-base to ccs-extend to preserve modified emoji
+
+	std::string_view truncated = text;
+	while (truncated.length() > UTF8MaxBytes) {
+		// Give up when short
+		const CharacterExtracted ce = LastCharacter(truncated);
+		const CharacterCategory cc = CategoriseCharacter(static_cast<int>(ce.character));
+		truncated.remove_suffix(ce.widthBytes);
+		if (IsBaseOfGrapheme(cc)) {
+			text = truncated;
+			return true;
+		}
+	}
+	// No base character found so just leave as is
+	return false;
+}
+
 // Need to break text into segments near end but taking into account the
 // encoding to not break inside a UTF-8 or DBCS character and also trying
 // to avoid breaking inside a pair of combining characters, or inside
@@ -1214,7 +1316,8 @@ bool Document::IsDBCSDualByteAt(Sci::Position pos) const noexcept {
 // In preference order from best to worst:
 //   1) Break before or after spaces or controls
 //   2) Break at word and punctuation boundary for better kerning and ligature support
-//   3) Break after whole character, this may break combining characters
+//   3) Break before letter in UTF-8 to avoid breaking combining characters
+//   4) Break after whole character, this may break combining characters
 
 size_t Document::SafeSegment(std::string_view text) const noexcept {
 	// check space first as most written language use spaces.
@@ -1225,6 +1328,13 @@ size_t Document::SafeSegment(std::string_view text) const noexcept {
 	}
 
 	if (!dbcsCodePage || dbcsCodePage == CpUtf8) {
+		if (dbcsCodePage) {
+			// UTF-8
+			DiscardEndFragment(text);
+			if (DiscardLastCombinedCharacter(text)) {
+				return text.length();
+			}
+		}
 		// backward iterate for UTF-8 and single byte encoding to find word and punctuation boundary.
 		std::string_view::iterator it = text.end() - 1;
 		const bool punctuation = IsPunctuation(*it);
@@ -1235,14 +1345,7 @@ size_t Document::SafeSegment(std::string_view text) const noexcept {
 			}
 		} while (it != text.begin());
 
-		it = text.end() - 1;
-		if (dbcsCodePage) {
-			// for UTF-8 go back to the start of last character.
-			for (int trail = 0; trail < UTF8MaxBytes - 1 && UTF8IsTrailByte(*it); trail++) {
-				--it;
-			}
-		}
-		return it - text.begin();
+		return text.length() - 1;
 	}
 
 	{
@@ -1320,6 +1423,10 @@ bool Document::DeleteChars(Sci::Position pos, Sci::Position len) {
 	} else {
 		enteredModification++;
 		if (!cb.IsReadOnly()) {
+			if (cb.IsCollectingUndo() && cb.CanRedo()) {
+				// Abandoning some undo actions so truncate any later selections
+				TruncateUndoComments(cb.UndoCurrent());
+			}
 			NotifyModified(
 			    DocModification(
 			        ModificationFlags::BeforeDelete | ModificationFlags::User,
@@ -1373,6 +1480,10 @@ Sci::Position Document::InsertString(Sci::Position position, const char *s, Sci:
 		s = insertion.c_str();
 		insertLength = insertion.length();
 	}
+	if (cb.IsCollectingUndo() && cb.CanRedo()) {
+		// Abandoning some undo actions so truncate any later selections
+		TruncateUndoComments(cb.UndoCurrent());
+	}
 	NotifyModified(
 		DocModification(
 			ModificationFlags::BeforeInsert | ModificationFlags::User,
@@ -1556,6 +1667,20 @@ Sci::Position Document::Redo() {
 	return newPos;
 }
 
+void Document::EndUndoAction() noexcept {
+	cb.EndUndoAction();
+	if (UndoSequenceDepth() == 0) {
+		// Broadcast notification to views to allow end of group processing.
+		// NotifyGroupCompleted may throw (for memory exhaustion) but this method
+		// may not as it is called in UndoGroup destructor so ignore exception.
+		try {
+			NotifyGroupCompleted();
+		} catch (...) {
+			// Ignore any exception
+		}
+	}
+}
+
 int Document::UndoSequenceDepth() const noexcept {
 	return cb.UndoSequenceDepth();
 }
@@ -2389,11 +2514,11 @@ LineCharacterIndexType Document::LineCharacterIndex() const noexcept {
 }
 
 void Document::AllocateLineCharacterIndex(LineCharacterIndexType lineCharacterIndex) {
-	return cb.AllocateLineCharacterIndex(lineCharacterIndex);
+	cb.AllocateLineCharacterIndex(lineCharacterIndex);
 }
 
 void Document::ReleaseLineCharacterIndex(LineCharacterIndexType lineCharacterIndex) {
-	return cb.ReleaseLineCharacterIndex(lineCharacterIndex);
+	cb.ReleaseLineCharacterIndex(lineCharacterIndex);
 }
 
 Sci::Line Document::LinesTotal() const noexcept {
@@ -2504,6 +2629,32 @@ void Document::SetLexInterface(std::unique_ptr<LexInterface> pLexInterface) noex
 	pli = std::move(pLexInterface);
 }
 
+void Document::SetViewState(void *view, ViewStateShared pVSS) {
+	if (pVSS) {
+		viewData[view] = pVSS;
+	} else {
+		viewData.erase(view);
+	}
+}
+
+ViewStateShared Document::GetViewState(void *view) const noexcept {
+	try {
+		const std::map<void *, ViewStateShared>::const_iterator it = viewData.find(view);
+
+		if (it != viewData.end()) {
+			return it->second;
+		}
+	} catch (...) {
+	}
+	return {};
+}
+
+void Document::TruncateUndoComments(int action) {
+	for (auto &[key, value] : viewData) {
+		value->TruncateUndo(action);
+	}
+}
+
 int SCI_METHOD Document::SetLineState(Sci_Position line, int state) {
 	const int statePrevious = States()->SetLineState(line, state, LinesTotal());
 	if (state != statePrevious) {
@@ -2700,6 +2851,12 @@ void Document::NotifySavePoint(bool atSavePoint) {
 	}
 }
 
+void Document::NotifyGroupCompleted() noexcept {
+	for (const WatcherWithUserData &watcher : watchers) {
+		watcher.watcher->NotifyGroupCompleted(this, watcher.userData);
+	}
+}
+
 void Document::NotifyModified(DocModification mh) {
 	if (FlagSet(mh.modificationType, ModificationFlags::InsertText)) {
 		decorations->InsertSpace(mh.position, mh.length);
@@ -3206,8 +3363,8 @@ bool MatchOnLines(const Document *doc, const Regex &regexp, const RESearchRange
 		const Sci::Position lineStartPos = doc->LineStart(line);
 		const Sci::Position lineEndPos = doc->LineEnd(line);
 		const Range lineRange = resr.LineRange(line, lineStartPos, lineEndPos);
-		Iterator itStart(doc, lineRange.start);
-		Iterator itEnd(doc, lineRange.end);
+		const Iterator itStart(doc, lineRange.start);
+		const Iterator itEnd(doc, lineRange.end);
 		const std::regex_constants::match_flag_type flagsMatch = MatchFlags(doc, lineRange.start, lineRange.end, lineStartPos, lineEndPos);
 		std::regex_iterator<Iterator> it(itStart, itEnd, regexp, flagsMatch);
 		for (const std::regex_iterator<Iterator> last; it != last; ++it) {
diff --git a/scintilla/src/Document.h b/scintilla/src/Document.h
index 091cf856c..ccc90edbc 100644
--- a/scintilla/src/Document.h
+++ b/scintilla/src/Document.h
@@ -172,6 +172,22 @@ public:
 	bool isEnabled;
 };
 
+// Base class for view state that can be held and transferred without understanding the contents.
+// Declared here but real implementation subclass declared in EditModel 
+struct ViewState {
+	ViewState() noexcept = default;
+	// Deleted so ViewState objects can not be copied
+	ViewState(const ViewState &) = delete;
+	ViewState(ViewState &&) = delete;
+	ViewState &operator=(const ViewState &) = delete;
+	ViewState &operator=(ViewState &&) = delete;
+	virtual ~ViewState() noexcept = default;
+
+	virtual void TruncateUndo(int index)=0;
+};
+
+using ViewStateShared = std::shared_ptr<ViewState>;
+
 struct LexerReleaser {
 	// Called by unique_ptr to destroy/free the Resource
 	void operator()(Scintilla::ILexer5 *pLexer) noexcept {
@@ -257,6 +273,8 @@ struct CharacterExtracted {
 	}
 };
 
+bool DiscardLastCombinedCharacter(std::string_view &text) noexcept;
+
 /**
  */
 class Document : PerLine, public Scintilla::IDocument, public Scintilla::ILoader, public Scintilla::IDocumentEditable {
@@ -304,6 +322,8 @@ private:
 	std::unique_ptr<RegexSearchBase> regex;
 	std::unique_ptr<LexInterface> pli;
 
+	std::map<void *, ViewStateShared>viewData;
+
 public:
 
 	Scintilla::EndOfLine eolMode;
@@ -396,8 +416,9 @@ public:
 	}
 	bool IsCollectingUndo() const noexcept { return cb.IsCollectingUndo(); }
 	void BeginUndoAction(bool coalesceWithPrior=false) noexcept { cb.BeginUndoAction(coalesceWithPrior); }
-	void EndUndoAction() noexcept { cb.EndUndoAction(); }
+	void EndUndoAction() noexcept;
 	int UndoSequenceDepth() const noexcept;
+	bool AfterUndoSequenceStart() const noexcept { return cb.AfterUndoSequenceStart(); }
 	void AddUndoAction(Sci::Position token, bool mayCoalesce) { cb.AddUndoAction(token, mayCoalesce); }
 	void SetSavePoint();
 	bool IsSavePoint() const noexcept { return cb.IsSavePoint(); }
@@ -534,6 +555,10 @@ public:
 	LexInterface *GetLexInterface() const noexcept;
 	void SetLexInterface(std::unique_ptr<LexInterface> pLexInterface) noexcept;
 
+	void SetViewState(void *view, ViewStateShared pVSS);
+	ViewStateShared GetViewState(void *view) const noexcept;
+	void TruncateUndoComments(int action);
+
 	int SCI_METHOD SetLineState(Sci_Position line, int state) override;
 	int SCI_METHOD GetLineState(Sci_Position line) const override;
 	Sci::Line GetMaxLineState() const noexcept;
@@ -574,6 +599,7 @@ public:
 private:
 	void NotifyModifyAttempt();
 	void NotifySavePoint(bool atSavePoint);
+	void NotifyGroupCompleted() noexcept;
 	void NotifyModified(DocModification mh);
 };
 
@@ -664,6 +690,7 @@ public:
 	virtual void NotifyDeleted(Document *doc, void *userData) noexcept = 0;
 	virtual void NotifyStyleNeeded(Document *doc, void *userData, Sci::Position endPos) = 0;
 	virtual void NotifyErrorOccurred(Document *doc, void *userData, Scintilla::Status status) = 0;
+	virtual void NotifyGroupCompleted(Document *doc, void *userData) noexcept = 0;
 };
 
 }
diff --git a/scintilla/src/EditModel.cxx b/scintilla/src/EditModel.cxx
index 13b3da5b0..e12aab38e 100644
--- a/scintilla/src/EditModel.cxx
+++ b/scintilla/src/EditModel.cxx
@@ -58,6 +58,42 @@ using namespace Scintilla::Internal;
 Caret::Caret() noexcept :
 	active(false), on(false), period(500) {}
 
+void ModelState::RememberSelectionForUndo(int index, const Selection &sel) {
+	historyForUndo.indexCurrent = index;
+	historyForUndo.ssCurrent = sel.ToString();
+}
+
+void ModelState::ForgetSelectionForUndo() noexcept {
+	historyForUndo.indexCurrent = -1;
+}
+
+void ModelState::RememberSelectionOntoStack(int index, Sci::Line topLine) {
+	if ((historyForUndo.indexCurrent >= 0) && (index == historyForUndo.indexCurrent + 1)) {
+		// Don't overwrite initial selection save if most recent action was coalesced
+		historyForUndo.stack[index] = { historyForUndo.ssCurrent, topLine };
+	}
+}
+
+void ModelState::RememberSelectionForRedoOntoStack(int index, const Selection &sel, Sci::Line topLine) {
+	historyForRedo.stack[index] = { sel.ToString(), topLine };
+}
+
+SelectionWithScroll ModelState::SelectionFromStack(int index, UndoRedo history) const {
+	const SelectionHistory &sh = history == UndoRedo::undo ? historyForUndo : historyForRedo;
+	const SelectionStack::const_iterator it = sh.stack.find(index);
+	if (it != sh.stack.end()) {
+		return it->second;
+	}
+	return {};
+}
+
+void ModelState::TruncateUndo(int index) {
+	const SelectionStack::const_iterator itUndo = historyForUndo.stack.find(index);
+	historyForUndo.stack.erase(itUndo, historyForUndo.stack.end());
+	const SelectionStack::const_iterator itRedo = historyForRedo.stack.find(index);
+	historyForRedo.stack.erase(itRedo, historyForRedo.stack.end());
+}
+
 EditModel::EditModel() : braces{} {
 	inOverstrike = false;
 	xOffset = 0;
@@ -85,6 +121,9 @@ EditModel::EditModel() : braces{} {
 
 EditModel::~EditModel() {
 	try {
+		// Erasing the view state won't throw even though SetViewState
+		// and the resulting map::erase aren't marked noexcept.
+		pdoc->SetViewState(this, {});
 		// This never throws but isn't marked noexcept for compatibility
 		pdoc->Release();
 	} catch (...) {
@@ -131,3 +170,22 @@ InSelection EditModel::LineEndInSelection(Sci::Line lineDoc) const {
 int EditModel::GetMark(Sci::Line line) const {
 	return pdoc->GetMark(line, FlagSet(changeHistoryOption, ChangeHistoryOption::Markers));
 }
+
+void EditModel::EnsureModelState() {
+	if (!modelState && (undoSelectionHistoryOption == UndoSelectionHistoryOption::Enabled)) {
+		if (ViewStateShared vss = pdoc->GetViewState(this)) {
+			modelState = std::dynamic_pointer_cast<ModelState>(vss);
+		} else {
+			modelState = std::make_shared<ModelState>();
+			pdoc->SetViewState(this, std::static_pointer_cast<ViewState>(modelState));
+		}
+	}
+}
+
+void EditModel::ChangeUndoSelectionHistory(Scintilla::UndoSelectionHistoryOption undoSelectionHistoryOptionNew) {
+	undoSelectionHistoryOption = undoSelectionHistoryOptionNew;
+	if (undoSelectionHistoryOption == UndoSelectionHistoryOption::Disabled) {
+		modelState.reset();
+		pdoc->SetViewState(this, {});
+	}
+}
diff --git a/scintilla/src/EditModel.h b/scintilla/src/EditModel.h
index e36d26fb1..dcaf99613 100644
--- a/scintilla/src/EditModel.h
+++ b/scintilla/src/EditModel.h
@@ -21,6 +21,36 @@ public:
 	Caret() noexcept;
 };
 
+enum class UndoRedo { undo, redo };
+
+// Selection stack is sparse so use a map
+
+struct SelectionWithScroll {
+	std::string selection;
+	Sci::Line topLine = 0;
+};
+
+using SelectionStack = std::map<int, SelectionWithScroll>;
+
+struct SelectionHistory {
+	int indexCurrent = 0;
+	std::string ssCurrent;
+	SelectionStack stack;
+};
+
+struct ModelState : ViewState {
+	SelectionHistory historyForUndo;
+	SelectionHistory historyForRedo;
+	void RememberSelectionForUndo(int index, const Selection &sel);
+	void ForgetSelectionForUndo() noexcept;
+	void RememberSelectionOntoStack(int index, Sci::Line topLine);
+	void RememberSelectionForRedoOntoStack(int index, const Selection &sel, Sci::Line topLine);
+	SelectionWithScroll SelectionFromStack(int index, UndoRedo history) const;
+	virtual void TruncateUndo(int index) final;
+};
+
+using ModelStateShared = std::shared_ptr<ModelState>;
+
 class EditModel {
 public:
 	bool inOverstrike;
@@ -57,6 +87,10 @@ public:
 
 	Document *pdoc;
 
+	Scintilla::UndoSelectionHistoryOption undoSelectionHistoryOption = UndoSelectionHistoryOption::Disabled;
+	bool needRedoRemembered = false;
+	ModelStateShared modelState;
+
 	EditModel();
 	// Deleted so EditModel objects can not be copied.
 	EditModel(const EditModel &) = delete;
@@ -75,6 +109,9 @@ public:
 	const char *GetFoldDisplayText(Sci::Line lineDoc) const noexcept;
 	InSelection LineEndInSelection(Sci::Line lineDoc) const;
 	[[nodiscard]] int GetMark(Sci::Line line) const;
+
+	void EnsureModelState();
+	void ChangeUndoSelectionHistory(Scintilla::UndoSelectionHistoryOption undoSelectionHistoryOptionNew);
 };
 
 }
diff --git a/scintilla/src/EditView.cxx b/scintilla/src/EditView.cxx
index c84fa9249..bc52e676e 100644
--- a/scintilla/src/EditView.cxx
+++ b/scintilla/src/EditView.cxx
@@ -2530,19 +2530,13 @@ void EditView::PaintText(Surface *surfaceWindow, const EditModel &model, const V
 
 		Sci::Line lineDocPrevious = -1;	// Used to avoid laying out one document line multiple times
 		std::shared_ptr<LineLayout> ll;
-		std::vector<DrawPhase> phases;
+		DrawPhase phase = DrawPhase::all;
 		if ((phasesDraw == PhasesDraw::Multiple) && !bufferedDraw) {
-			for (DrawPhase phase = DrawPhase::back; phase <= DrawPhase::carets; phase = static_cast<DrawPhase>(static_cast<int>(phase) * 2)) {
-				phases.push_back(phase);
-			}
-		} else {
-			phases.push_back(DrawPhase::all);
+			phase = DrawPhase::back;
 		}
-		for (const DrawPhase &phase : phases) {
-			int ypos = 0;
-			if (!bufferedDraw)
-				ypos += screenLinePaintFirst * vsDraw.lineHeight;
+		for (;;) {
 			int yposScreen = screenLinePaintFirst * vsDraw.lineHeight;
+			int ypos = bufferedDraw ? 0 : yposScreen;
 			Sci::Line visibleLine = model.TopLineOfMain() + screenLinePaintFirst;
 			while (visibleLine < model.pcs->LinesDisplayed() && yposScreen < rcArea.bottom) {
 
@@ -2561,6 +2555,10 @@ void EditView::PaintText(Surface *surfaceWindow, const EditModel &model, const V
 					ll = RetrieveLineLayout(lineDoc, model);
 					LayoutLine(model, surface, vsDraw, ll.get(), model.wrapWidth);
 					lineDocPrevious = lineDoc;
+					if (ll && model.BidirectionalEnabled()) {
+						// Fill the line bidi data
+						UpdateBidiData(model, vsDraw, ll.get());
+					}
 				}
 #if defined(TIME_PAINTING)
 				durLayout += ep.Duration(true);
@@ -2588,11 +2586,6 @@ void EditView::PaintText(Surface *surfaceWindow, const EditModel &model, const V
 						surface->FillRectangleAligned(rcSpacer, Fill(vsDraw.styles[StyleDefault].back));
 					}
 
-					if (model.BidirectionalEnabled()) {
-						// Fill the line bidi data
-						UpdateBidiData(model, vsDraw, ll.get());
-					}
-
 					DrawLine(surface, model, vsDraw, ll.get(), lineDoc, visibleLine, xStart, rcLine, subLine, phase);
 #if defined(TIME_PAINTING)
 					durPaint += ep.Duration(true);
@@ -2631,6 +2624,11 @@ void EditView::PaintText(Surface *surfaceWindow, const EditModel &model, const V
 				yposScreen += vsDraw.lineHeight;
 				visibleLine++;
 			}
+
+			if (phase >= DrawPhase::carets) {
+				break;
+			}
+			phase = static_cast<DrawPhase>(static_cast<int>(phase) * 2);
 		}
 		ll.reset();
 #if defined(TIME_PAINTING)
diff --git a/scintilla/src/Editor.cxx b/scintilla/src/Editor.cxx
index a97aec962..847259076 100644
--- a/scintilla/src/Editor.cxx
+++ b/scintilla/src/Editor.cxx
@@ -711,6 +711,15 @@ void Editor::SetEmptySelection(Sci::Position currentPos_) {
 	SetEmptySelection(SelectionPosition(currentPos_));
 }
 
+void Editor::SetSelectionFromSerialized(const char *serialized) {
+	if (serialized) {
+		sel = Selection(serialized);
+		sel.Truncate(pdoc->Length());
+		SetRectangularRange();
+		InvalidateStyleRedraw();
+	}
+}
+
 void Editor::MultipleSelectAdd(AddNumber addNumber) {
 	if (SelectionEmpty() || !multipleSelection) {
 		// Select word at caret
@@ -926,6 +935,37 @@ void Editor::SetLastXChosen() {
 	lastXChosen = static_cast<int>(pt.x) + xOffset;
 }
 
+void Editor::RememberSelectionForUndo(int index) {
+	EnsureModelState();
+	if (modelState) {
+		modelState->RememberSelectionForUndo(index, sel);
+		needRedoRemembered = true;
+		// Remember selection at end of processing current message
+	}
+}
+
+void Editor::RememberSelectionOntoStack(int index) {
+	EnsureModelState();
+	if (modelState) {
+		// Is undo currently inside a group?
+		if (!pdoc->AfterUndoSequenceStart()) {
+			// Don't remember selections inside a grouped sequence as can only
+			// unto or redo to the start and end of the group.
+			modelState->RememberSelectionOntoStack(index, topLine);
+		}
+	}
+}
+
+void Editor::RememberCurrentSelectionForRedoOntoStack() {
+	if (needRedoRemembered && (pdoc->UndoSequenceDepth() == 0)) {
+		EnsureModelState();
+		if (modelState) {
+			modelState->RememberSelectionForRedoOntoStack(pdoc->UndoCurrent(), sel, topLine);
+			needRedoRemembered = false;
+		}
+	}
+}
+
 void Editor::ScrollTo(Sci::Line line, bool moveThumb) {
 	const Sci::Line topLineNew = std::clamp<Sci::Line>(line, 0, MaxScrollPos());
 	if (topLineNew != topLine) {
@@ -2085,13 +2125,13 @@ void Editor::InsertCharacter(std::string_view sv, CharacterSource charSource) {
 				}
 			}
 		}
+		ThinRectangularRange();
 	}
 	if (wrapOccurred) {
 		SetScrollBars();
 		SetVerticalScrollPos();
 		Redraw();
 	}
-	ThinRectangularRange();
 	// If in wrap mode rewrap current line so EnsureCaretVisible has accurate information
 	EnsureCaretVisible();
 	// Avoid blinking during rapid typing:
@@ -2367,22 +2407,44 @@ void Editor::SelectAll() {
 	Redraw();
 }
 
+void Editor::RestoreSelection(Sci::Position newPos, UndoRedo history) {
+	EnsureModelState();
+	if ((undoSelectionHistoryOption == UndoSelectionHistoryOption::Enabled) && modelState) {
+		// Undo wants the element after the current as it just undid it
+		const int index = pdoc->UndoCurrent() + (history == UndoRedo::undo ? 1 : 0);
+		const SelectionWithScroll selAndLine = modelState->SelectionFromStack(index, history);
+		if (!selAndLine.selection.empty()) {
+			ScrollTo(selAndLine.topLine);
+			sel = Selection(selAndLine.selection);
+			if (sel.IsRectangular()) {
+				const size_t mainForRectangular = sel.Main();
+				// Reconstitute ranges from rectangular range
+				SetRectangularRange();
+				// Restore main if possible.
+				if (mainForRectangular < sel.Count()) {
+					sel.SetMain(mainForRectangular);
+				}
+			}
+			newPos = -1; // Used selection from stack so don't use position returned from undo/redo.
+		}
+	}
+	if (newPos >= 0)
+		SetEmptySelection(newPos);
+	EnsureCaretVisible();
+}
+
 void Editor::Undo() {
 	if (pdoc->CanUndo()) {
 		InvalidateCaret();
 		const Sci::Position newPos = pdoc->Undo();
-		if (newPos >= 0)
-			SetEmptySelection(newPos);
-		EnsureCaretVisible();
+		RestoreSelection(newPos, UndoRedo::undo);
 	}
 }
 
 void Editor::Redo() {
 	if (pdoc->CanRedo()) {
 		const Sci::Position newPos = pdoc->Redo();
-		if (newPos >= 0)
-			SetEmptySelection(newPos);
-		EnsureCaretVisible();
+		RestoreSelection(newPos, UndoRedo::redo);
 	}
 }
 
@@ -2458,6 +2520,17 @@ void Editor::NotifyErrorOccurred(Document *, void *, Status status) {
 	errorStatus = status;
 }
 
+void Editor::NotifyGroupCompleted(Document *, void *) noexcept {
+	// RememberCurrentSelectionForRedoOntoStack may throw (for memory exhaustion)
+	// but this method may not as it is called in UndoGroup destructor so ignore
+	// exception.
+	try {
+		RememberCurrentSelectionForRedoOntoStack();
+	} catch (...) {
+		// Ignore any exception
+	}
+}
+
 void Editor::NotifyChar(int ch, CharacterSource charSource) {
 	NotificationData scn = {};
 	scn.nmhdr.code = Notification::CharAdded;
@@ -2726,6 +2799,15 @@ void Editor::NotifyModified(Document *, DocModification mh, void *) {
 			view.llc.Invalidate(LineLayout::ValidLevel::checkTextAndStyle);
 		}
 	} else {
+		if ((undoSelectionHistoryOption == UndoSelectionHistoryOption::Enabled) &&
+			FlagSet(mh.modificationType, ModificationFlags::User)) {
+			if (FlagSet(mh.modificationType, ModificationFlags::BeforeInsert | ModificationFlags::BeforeDelete)) {
+				RememberSelectionForUndo(pdoc->UndoCurrent());
+			}
+			if (FlagSet(mh.modificationType, ModificationFlags::InsertText | ModificationFlags::DeleteText)) {
+				RememberSelectionOntoStack(pdoc->UndoCurrent());
+			}
+		}
 		// Move selection and brace highlights
 		if (FlagSet(mh.modificationType, ModificationFlags::InsertText)) {
 			sel.MovePositions(true, mh.position, mh.length);
@@ -5460,6 +5542,7 @@ void Editor::SetDocPointer(Document *document) {
 		pdoc = document;
 	}
 	pdoc->AddRef();
+	modelState.reset();
 	pcs = ContractionStateCreate(pdoc->IsLarge());
 
 	// Ensure all positions within document
@@ -8421,8 +8504,8 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 	case Message::GetLineSelStartPosition:
 	case Message::GetLineSelEndPosition: {
 			const SelectionSegment segmentLine(
-				SelectionPosition(pdoc->LineStart(LineFromUPtr(wParam))),
-				SelectionPosition(pdoc->LineEnd(LineFromUPtr(wParam))));
+				pdoc->LineStart(LineFromUPtr(wParam)),
+				pdoc->LineEnd(LineFromUPtr(wParam)));
 			for (size_t r=0; r<sel.Count(); r++) {
 				const SelectionSegment portion = sel.Range(r).Intersect(segmentLine);
 				if (portion.start.IsValid()) {
@@ -8615,6 +8698,22 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 	case Message::GetChangeHistory:
 		return static_cast<sptr_t>(changeHistoryOption);
 
+	case Message::SetUndoSelectionHistory:
+		ChangeUndoSelectionHistory(static_cast<UndoSelectionHistoryOption>(wParam));
+		break;
+
+	case Message::GetUndoSelectionHistory:
+		return static_cast<sptr_t>(undoSelectionHistoryOption);
+
+	case Message::SetSelectionSerialized:
+		SetSelectionFromSerialized(ConstCharPtrFromSPtr(lParam));
+		break;
+
+	case Message::GetSelectionSerialized: {
+		const std::string serialized = sel.ToString();
+		return BytesResult(lParam, serialized);
+	}
+
 	case Message::SetExtraAscent:
 		vs.extraAscent = static_cast<int>(wParam);
 		InvalidateStyleRedraw();
@@ -9024,6 +9123,11 @@ sptr_t Editor::WndProc(Message iMessage, uptr_t wParam, sptr_t lParam) {
 	default:
 		return DefWndProc(iMessage, wParam, lParam);
 	}
+
+	// If there was a change that needs its selection saved and it wasn't explicity saved
+	// then do that here.
+	RememberCurrentSelectionForRedoOntoStack();
+
 	//Platform::DebugPrintf("end wnd proc\n");
 	return 0;
 }
diff --git a/scintilla/src/Editor.h b/scintilla/src/Editor.h
index c932e27dc..df4e59bbc 100644
--- a/scintilla/src/Editor.h
+++ b/scintilla/src/Editor.h
@@ -352,6 +352,7 @@ protected:	// ScintillaBase subclass needs access to much of Editor
 	void SetSelection(SelectionPosition currentPos_);
 	void SetEmptySelection(SelectionPosition currentPos_);
 	void SetEmptySelection(Sci::Position currentPos_);
+	void SetSelectionFromSerialized(const char *serialized);
 	enum class AddNumber { one, each };
 	void MultipleSelectAdd(AddNumber addNumber);
 	bool RangeContainsProtected(Sci::Position start, Sci::Position end) const noexcept;
@@ -367,6 +368,9 @@ protected:	// ScintillaBase subclass needs access to much of Editor
 	SelectionPosition MovePositionSoVisible(Sci::Position pos, int moveDir);
 	Point PointMainCaret();
 	void SetLastXChosen();
+	void RememberSelectionForUndo(int index);
+	void RememberSelectionOntoStack(int index);
+	void RememberCurrentSelectionForRedoOntoStack();
 
 	void ScrollTo(Sci::Line line, bool moveThumb=true);
 	virtual void ScrollText(Sci::Line linesToMove);
@@ -443,6 +447,7 @@ protected:	// ScintillaBase subclass needs access to much of Editor
 	virtual void Paste() = 0;
 	void Clear();
 	virtual void SelectAll();
+	void RestoreSelection(Sci::Position newPos, UndoRedo history);
 	virtual void Undo();
 	virtual void Redo();
 	void DelCharBack(bool allowLineStartDeletion);
@@ -477,6 +482,7 @@ protected:	// ScintillaBase subclass needs access to much of Editor
 	void NotifyDeleted(Document *document, void *userData) noexcept override;
 	void NotifyStyleNeeded(Document *doc, void *userData, Sci::Position endStyleNeeded) override;
 	void NotifyErrorOccurred(Document *doc, void *userData, Scintilla::Status status) override;
+	void NotifyGroupCompleted(Document *, void *) noexcept override;
 	void NotifyMacroRecord(Scintilla::Message iMessage, Scintilla::uptr_t wParam, Scintilla::sptr_t lParam);
 
 	void ContainerNeedsUpdate(Scintilla::Update flags) noexcept;
diff --git a/scintilla/src/Platform.h b/scintilla/src/Platform.h
index 585ddd14c..77464945e 100644
--- a/scintilla/src/Platform.h
+++ b/scintilla/src/Platform.h
@@ -194,8 +194,8 @@ public:
 	virtual ~Surface() noexcept = default;
 	static std::unique_ptr<Surface> Allocate(Scintilla::Technology technology);
 
-	virtual void Init(WindowID wid)=0;
-	virtual void Init(SurfaceID sid, WindowID wid)=0;
+	virtual void Init(WindowID wid)=0;	// For measuring text
+	virtual void Init(SurfaceID sid, WindowID wid)=0;	// For drawing
 	virtual std::unique_ptr<Surface> AllocatePixMap(int width, int height)=0;
 
 	virtual void SetMode(SurfaceMode mode)=0;
diff --git a/scintilla/src/PositionCache.cxx b/scintilla/src/PositionCache.cxx
index b1ada52af..5cdaf43b2 100644
--- a/scintilla/src/PositionCache.cxx
+++ b/scintilla/src/PositionCache.cxx
@@ -155,7 +155,7 @@ int LineLayout::LineStart(int line) const noexcept {
 int LineLayout::LineLength(int line) const noexcept {
 	if (!lineStarts) {
 		return numCharsInLine;
-	} if (line >= lines - 1) {
+	} else if (line >= lines - 1) {
 		return numCharsInLine - lineStarts[line];
 	} else {
 		return lineStarts[line + 1] - lineStarts[line];
@@ -356,6 +356,7 @@ void LineLayout::WrapLine(const Document *pdoc, Sci::Position posLineStart, Wrap
 			if (p > 0) {
 				lastGoodBreak = CharacterBoundary(p, -1);
 			}
+			bool foundBreak = false;
 			if (wrapState != Wrap::Char) {
 				Sci::Position pos = lastGoodBreak;
 				while (pos > lastLineStart) {
@@ -370,12 +371,23 @@ void LineLayout::WrapLine(const Document *pdoc, Sci::Position posLineStart, Wrap
 				}
 				if (pos > lastLineStart) {
 					lastGoodBreak = pos;
+					foundBreak = true;
 				}
 			}
-			if (lastGoodBreak == lastLineStart) {
-				// Try moving to start of last character
-				if (p > 0) {
-					lastGoodBreak = CharacterBoundary(p, -1);
+			if (!foundBreak) {
+				if (CpUtf8 == pdoc->dbcsCodePage) {
+					// Go back before a base character, commonly a letter as modifiers are after the letter they modify
+					std::string_view svWithoutLast(&chars[lastLineStart], CharacterBoundary(p + 1, 1) - lastLineStart);
+					if (DiscardLastCombinedCharacter(svWithoutLast) && !svWithoutLast.empty()) {
+						lastGoodBreak = lastLineStart + static_cast<Sci::Position>(svWithoutLast.length());
+						foundBreak = true;
+					}
+				}
+				if (!foundBreak) {
+					// Try moving to start of last character
+					if (p > 0) {
+						lastGoodBreak = CharacterBoundary(p, -1);
+					}
 				}
 				if (lastGoodBreak == lastLineStart) {
 					// Ensure at least one character on line.
@@ -409,8 +421,7 @@ ScreenLine::ScreenLine(
 	tabWidthMinimumPixels(tabWidthMinimumPixels_) {
 }
 
-ScreenLine::~ScreenLine() {
-}
+ScreenLine::~ScreenLine() = default;
 
 std::string_view ScreenLine::Text() const {
 	return std::string_view(&ll->chars[start], len);
@@ -498,7 +509,6 @@ bool AllGraphicASCII(std::string_view text) {
 size_t LineLayoutCache::EntryForLine(Sci::Line line) const noexcept {
 	switch (level) {
 	case LineCache::None:
-		return 0;
 	case LineCache::Caret:
 		return 0;
 	case LineCache::Page:
@@ -652,9 +662,10 @@ namespace {
 // Simply pack the (maximum 4) character bytes into an int
 constexpr unsigned int KeyFromString(std::string_view charBytes) noexcept {
 	PLATFORM_ASSERT(charBytes.length() <= 4);
+	constexpr int byteMultiplier = 0x100;
 	unsigned int k=0;
 	for (const unsigned char uc : charBytes) {
-		k = k * 0x100 + uc;
+		k = k * byteMultiplier + uc;
 	}
 	return k;
 }
@@ -682,16 +693,16 @@ namespace Scintilla::Internal {
 const char *ControlCharacterString(unsigned char ch) noexcept {
 	if (ch < std::size(repsC0)) {
 		return repsC0[ch];
-	} else {
-		return "BAD";
 	}
+	return "BAD";
 }
 
 
 void Hexits(char *hexits, int ch) noexcept {
+	constexpr int hexDivisor = 0x10;
 	hexits[0] = 'x';
-	hexits[1] = "0123456789ABCDEF"[ch / 0x10];
-	hexits[2] = "0123456789ABCDEF"[ch % 0x10];
+	hexits[1] = "0123456789ABCDEF"[ch / hexDivisor];
+	hexits[2] = "0123456789ABCDEF"[ch % hexDivisor];
 	hexits[3] = 0;
 }
 
@@ -856,16 +867,12 @@ BreakFinder::BreakFinder(const LineLayout *ll_, const Selection *psel, Range lin
 	}
 
 	if (FlagSet(breakFor, BreakFor::Selection)) {
-		const SelectionPosition posStart(posLineStart);
-		const SelectionPosition posEnd(posLineStart + lineRange.end);
-		const SelectionSegment segmentLine(posStart, posEnd);
+		const SelectionSegment segmentLine(posLineStart, posLineStart + lineRange.end);
 		for (size_t r=0; r<psel->Count(); r++) {
 			const SelectionSegment portion = psel->Range(r).Intersect(segmentLine);
-			if (!(portion.start == portion.end)) {
-				if (portion.start.IsValid())
-					Insert(portion.start.Position() - posLineStart);
-				if (portion.end.IsValid())
-					Insert(portion.end.Position() - posLineStart);
+			if (!portion.Empty()) {
+				Insert(portion.start.Position() - posLineStart);
+				Insert(portion.end.Position() - posLineStart);
 			}
 		}
 		// On the curses platform, the terminal is drawing its own caret, so add breaks around the
@@ -988,10 +995,10 @@ bool BreakFinder::More() const noexcept {
 }
 
 class PositionCacheEntry {
-	uint16_t styleNumber;
-	uint16_t len;
-	uint16_t clock;
-	bool unicode;
+	uint16_t styleNumber = 0;
+	uint16_t len = 0;
+	uint16_t clock = 0;
+	bool unicode = false;
 	std::unique_ptr<XYPOSITION[]> positions;
 public:
 	PositionCacheEntry() noexcept;
@@ -1006,15 +1013,16 @@ public:
 	void Clear() noexcept;
 	bool Retrieve(unsigned int styleNumber_, bool unicode_, std::string_view sv, XYPOSITION *positions_) const noexcept;
 	static size_t Hash(unsigned int styleNumber_, bool unicode_, std::string_view sv) noexcept;
-	bool NewerThan(const PositionCacheEntry &other) const noexcept;
+	[[nodiscard]] bool NewerThan(const PositionCacheEntry &other) const noexcept;
 	void ResetClock() noexcept;
 };
 
 class PositionCache : public IPositionCache {
-	std::vector<PositionCacheEntry> pces;
+	static constexpr size_t defaultCacheSize = 0x400;
+	std::vector<PositionCacheEntry> pces{ defaultCacheSize };
 	std::mutex mutex;
-	uint16_t clock;
-	bool allClear;
+	uint16_t clock = 1;
+	bool allClear = true;
 public:
 	PositionCache();
 	// Deleted so LineAnnotation objects can not be copied.
@@ -1026,14 +1034,12 @@ public:
 
 	void Clear() noexcept override;
 	void SetSize(size_t size_) override;
-	size_t GetSize() const noexcept override;
+	[[nodiscard]] size_t GetSize() const noexcept override;
 	void MeasureWidths(Surface *surface, const ViewStyle &vstyle, unsigned int styleNumber,
 		bool unicode, std::string_view sv, XYPOSITION *positions, bool needsLocking) override;
 };
 
-PositionCacheEntry::PositionCacheEntry() noexcept :
-	styleNumber(0), len(0), clock(0), unicode(false) {
-}
+PositionCacheEntry::PositionCacheEntry() noexcept = default;
 
 // Copy constructor not currently used, but needed for being element in std::vector.
 PositionCacheEntry::PositionCacheEntry(const PositionCacheEntry &other) :
@@ -1079,9 +1085,8 @@ bool PositionCacheEntry::Retrieve(unsigned int styleNumber_, bool unicode_, std:
 			positions_[i] = positions[i];
 		}
 		return true;
-	} else {
-		return false;
 	}
+	return false;
 }
 
 size_t PositionCacheEntry::Hash(unsigned int styleNumber_, bool unicode_, std::string_view sv) noexcept {
@@ -1100,11 +1105,7 @@ void PositionCacheEntry::ResetClock() noexcept {
 	}
 }
 
-PositionCache::PositionCache() {
-	clock = 1;
-	pces.resize(0x400);
-	allClear = true;
-}
+PositionCache::PositionCache() = default;
 
 void PositionCache::Clear() noexcept {
 	if (!allClear) {
diff --git a/scintilla/src/Selection.cxx b/scintilla/src/Selection.cxx
index 3865622f4..ff42ef778 100644
--- a/scintilla/src/Selection.cxx
+++ b/scintilla/src/Selection.cxx
@@ -9,11 +9,13 @@
 #include <cstdlib>
 
 #include <stdexcept>
+#include <string>
 #include <string_view>
 #include <vector>
 #include <optional>
 #include <algorithm>
 #include <memory>
+#include <charconv>
 
 #include "Debugging.h"
 
@@ -22,6 +24,30 @@
 
 using namespace Scintilla::Internal;
 
+namespace {
+
+// Generically convert a string to a integer value throwing if the conversion failed.
+// Failures include values that are out of range for the destination variable.
+template <typename T>
+void ValueFromString(std::string_view sv, T &value) {
+	const std::from_chars_result res = std::from_chars(sv.data(), sv.data() + sv.size(), value);
+	if (res.ec != std::errc{}) {
+		if (res.ec == std::errc::result_out_of_range)
+			throw std::runtime_error("from_chars out of range.");
+		throw std::runtime_error("from_chars failed.");
+	}
+}
+
+}
+
+SelectionPosition::SelectionPosition(std::string_view sv) : position(0) {
+	if (const size_t v = sv.find('v'); v != std::string_view::npos) {
+		ValueFromString(sv.substr(v + 1), virtualSpace);
+		sv = sv.substr(0, v);
+	}
+	ValueFromString(sv, position);
+}
+
 void SelectionPosition::MoveForInsertDelete(bool insertion, Sci::Position startChange, Sci::Position length, bool moveForEqual) noexcept {
 	if (insertion) {
 		if (position == startChange) {
@@ -52,32 +78,42 @@ void SelectionPosition::MoveForInsertDelete(bool insertion, Sci::Position startC
 	}
 }
 
-bool SelectionPosition::operator <(const SelectionPosition &other) const noexcept {
-	if (position == other.position)
-		return virtualSpace < other.virtualSpace;
-	else
-		return position < other.position;
-}
-
 bool SelectionPosition::operator >(const SelectionPosition &other) const noexcept {
 	if (position == other.position)
 		return virtualSpace > other.virtualSpace;
-	else
-		return position > other.position;
+	return position > other.position;
 }
 
 bool SelectionPosition::operator <=(const SelectionPosition &other) const noexcept {
-	if (position == other.position && virtualSpace == other.virtualSpace)
+	if (other == *this)
 		return true;
-	else
-		return other > *this;
+	return other > *this;
 }
 
 bool SelectionPosition::operator >=(const SelectionPosition &other) const noexcept {
-	if (position == other.position && virtualSpace == other.virtualSpace)
+	if (other == *this)
 		return true;
-	else
-		return *this > other;
+	return *this > other;
+}
+
+std::string SelectionPosition::ToString() const {
+	std::string result = std::to_string(position);
+	if (virtualSpace) {
+		result += 'v';
+		result += std::to_string(virtualSpace);
+	}
+	return result;
+}
+
+SelectionRange::SelectionRange(std::string_view sv) {
+	const size_t dash = sv.find('-');
+	if (dash == std::string_view::npos) {
+		anchor = SelectionPosition(sv);
+		caret = anchor;
+	} else {
+		anchor = SelectionPosition(sv.substr(0, dash));
+		caret = SelectionPosition(sv.substr(dash + 1));
+	}
 }
 
 Sci::Position SelectionRange::Length() const noexcept {
@@ -131,20 +167,15 @@ bool SelectionRange::ContainsCharacter(SelectionPosition spCharacter) const noex
 }
 
 SelectionSegment SelectionRange::Intersect(SelectionSegment check) const noexcept {
-	const SelectionSegment inOrder(caret, anchor);
-	if ((inOrder.start <= check.end) || (inOrder.end >= check.start)) {
-		SelectionSegment portion = check;
-		if (portion.start < inOrder.start)
-			portion.start = inOrder.start;
-		if (portion.end > inOrder.end)
-			portion.end = inOrder.end;
-		if (portion.start > portion.end)
-			return SelectionSegment();
-		else
-			return portion;
-	} else {
-		return SelectionSegment();
+	const SelectionSegment inOrder = AsSegment();
+	if ((inOrder.start > check.end) || (inOrder.end < check.start)) {
+		// Nothing in common, not even touching so return empty *invalid* segment
+		return {};
 	}
+	return {
+		std::max(check.start, inOrder.start),
+		std::min(check.end, inOrder.end)
+	};
 }
 
 void SelectionRange::Swap() noexcept {
@@ -181,9 +212,15 @@ bool SelectionRange::Trim(SelectionRange range) noexcept {
 			caret = end;
 		}
 		return Empty();
-	} else {
-		return false;
 	}
+	return false;
+}
+
+void SelectionRange::Truncate(Sci::Position length) noexcept {
+	if (anchor.Position() > length)
+		anchor.SetPosition(length);
+	if (caret.Position() > length)
+		caret.SetPosition(length);
 }
 
 // If range is all virtual collapse to start of virtual space
@@ -197,10 +234,73 @@ void SelectionRange::MinimizeVirtualSpace() noexcept {
 	}
 }
 
+std::string SelectionRange::ToString() const {
+	std::string result = anchor.ToString();
+	if (!(caret == anchor)) {
+		result += '-';
+		result += caret.ToString();
+	}
+	return result;
+}
+
 Selection::Selection() : mainRange(0), moveExtends(false), tentativeMain(false), selType(SelTypes::stream) {
 	AddSelection(SelectionRange(SelectionPosition(0)));
 }
 
+Selection::Selection(std::string_view sv) : mainRange(0), moveExtends(false), tentativeMain(false), selType(SelTypes::stream) {
+	if (sv.empty()) {
+		return;
+	}
+	try {
+		// Decode initial letter prefix if any
+		switch (sv.front()) {
+		case 'R':
+			selType = SelTypes::rectangle;
+			break;
+		case 'L':
+			selType = SelTypes::lines;
+			break;
+		case 'T':
+			selType = SelTypes::thin;
+			break;
+		default:
+			break;
+		}
+		if (selType != SelTypes::stream) {
+			sv.remove_prefix(1);
+		}
+
+		// Non-zero main index at end after '#'
+		if (const size_t hash = sv.find('#'); hash != std::string_view::npos) {
+			ValueFromString(sv.substr(hash + 1), mainRange);
+			sv = sv.substr(0, hash);
+		}
+
+		// Remainder is list of ranges
+		if (selType == SelTypes::rectangle || selType == SelTypes::thin) {
+			rangeRectangular = SelectionRange(sv);
+			// Ensure enough ranges exist for mainRange to be in bounds
+			for (size_t i = 0; i <= mainRange; i++) {
+				ranges.emplace_back(SelectionPosition(0));
+			}
+		} else {
+			size_t comma = sv.find(',');
+			while (comma != std::string_view::npos) {
+				ranges.emplace_back(sv.substr(0, comma));
+				sv.remove_prefix(comma + 1);
+				comma = sv.find(',');
+			}
+			ranges.emplace_back(sv);
+			if (mainRange >= ranges.size()) {
+				mainRange = ranges.size() - 1;
+			}
+		}
+	} catch (std::runtime_error &) {
+		// On failure, produce an empty selection.
+		Clear();
+	}
+}
+
 bool Selection::IsRectangular() const noexcept {
 	return (selType == SelTypes::rectangle) || (selType == SelTypes::thin);
 }
@@ -217,9 +317,13 @@ SelectionRange &Selection::Rectangular() noexcept {
 	return rangeRectangular;
 }
 
+SelectionRange Selection::RectangularCopy() const noexcept {
+	return rangeRectangular;
+}
+
 SelectionSegment Selection::Limits() const noexcept {
 	PLATFORM_ASSERT(!ranges.empty());
-	SelectionSegment sr(ranges[0].anchor, ranges[0].caret);
+	SelectionSegment sr = ranges[0].AsSegment();
 	for (size_t i=1; i<ranges.size(); i++) {
 		sr.Extend(ranges[i].anchor);
 		sr.Extend(ranges[i].caret);
@@ -230,9 +334,8 @@ SelectionSegment Selection::Limits() const noexcept {
 SelectionSegment Selection::LimitsForRectangularElseMain() const noexcept {
 	if (IsRectangular()) {
 		return Limits();
-	} else {
-		return SelectionSegment(ranges[mainRange].caret, ranges[mainRange].anchor);
 	}
+	return ranges[mainRange].AsSegment();
 }
 
 size_t Selection::Count() const noexcept {
@@ -267,9 +370,8 @@ const SelectionRange &Selection::RangeMain() const noexcept {
 SelectionPosition Selection::Start() const noexcept {
 	if (IsRectangular()) {
 		return rangeRectangular.Start();
-	} else {
-		return ranges[mainRange].Start();
 	}
+	return ranges[mainRange].Start();
 }
 
 bool Selection::MoveExtends() const noexcept {
@@ -428,11 +530,13 @@ void Selection::Clear() noexcept {
 	if (ranges.size() > 1) {
 		ranges.erase(ranges.begin() + 1, ranges.end());
 	}
-	mainRange = 0;
-	selType = SelTypes::stream;
-	moveExtends = false;
-	ranges[mainRange].Reset();
+	ranges[0].Reset();
+	rangesSaved.clear();
 	rangeRectangular.Reset();
+	mainRange = 0;
+	moveExtends = false;
+	tentativeMain = false;
+	selType = SelTypes::stream;
 }
 
 void Selection::RemoveDuplicates() noexcept {
@@ -456,3 +560,52 @@ void Selection::RotateMain() noexcept {
 	mainRange = (mainRange + 1) % ranges.size();
 }
 
+void Selection::SetRanges(const Ranges &rangesToSet) {
+	ranges = rangesToSet;
+}
+
+void Selection::Truncate(Sci::Position length) noexcept {
+	// This may be needed when applying a persisted selection onto a document that has been shortened.
+	for (SelectionRange &range : ranges) {
+		range.Truncate(length);
+	}
+	// Above may have made some non-unique empty ranges.
+	RemoveDuplicates();
+	rangeRectangular.Truncate(length);
+}
+
+std::string Selection::ToString() const {
+	std::string result;
+	switch (selType) {
+	case SelTypes::rectangle:
+		result += 'R';
+		break;
+	case SelTypes::lines:
+		result += 'L';
+		break;
+	case SelTypes::thin:
+		result += 'T';
+		break;
+	default:
+		// No handling of none as not a real value of enumeration, just used for empty arguments
+		// No prefix.
+		break;
+	}
+	if (selType == SelTypes::rectangle || selType == SelTypes::thin) {
+		result += rangeRectangular.ToString();
+	} else {
+		for (size_t r = 0; r < ranges.size(); r++) {
+			if (r > 0) {
+				result += ',';
+			}
+			result += ranges[r].ToString();
+		}
+	}
+
+	if (mainRange > 0) {
+		result += '#';
+		result += std::to_string(mainRange);
+	}
+
+	return result;
+}
diff --git a/scintilla/src/Selection.h b/scintilla/src/Selection.h
index 9d54f2193..8b5c3f63e 100644
--- a/scintilla/src/Selection.h
+++ b/scintilla/src/Selection.h
@@ -11,26 +11,35 @@
 namespace Scintilla::Internal {
 
 class SelectionPosition {
-	Sci::Position position;
-	Sci::Position virtualSpace;
+	Sci::Position position = Sci::invalidPosition;
+	Sci::Position virtualSpace = 0;
 public:
-	explicit SelectionPosition(Sci::Position position_= Sci::invalidPosition, Sci::Position virtualSpace_=0) noexcept : position(position_), virtualSpace(virtualSpace_) {
+	constexpr SelectionPosition() noexcept = default;
+	constexpr explicit SelectionPosition(Sci::Position position_, Sci::Position virtualSpace_=0) noexcept : position(position_), virtualSpace(virtualSpace_) {
 		PLATFORM_ASSERT(virtualSpace < 800000000);
 		if (virtualSpace < 0)
 			virtualSpace = 0;
 	}
+	explicit SelectionPosition(std::string_view sv);
 	void Reset() noexcept {
 		position = 0;
 		virtualSpace = 0;
 	}
 	void MoveForInsertDelete(bool insertion, Sci::Position startChange, Sci::Position length, bool moveForEqual) noexcept;
-	bool operator ==(const SelectionPosition &other) const noexcept {
-		return position == other.position && virtualSpace == other.virtualSpace;
+	[[nodiscard]] constexpr bool operator ==(const SelectionPosition &other) const noexcept {
+		return (position == other.position) && (virtualSpace == other.virtualSpace);
 	}
-	bool operator <(const SelectionPosition &other) const noexcept;
-	bool operator >(const SelectionPosition &other) const noexcept;
-	bool operator <=(const SelectionPosition &other) const noexcept;
-	bool operator >=(const SelectionPosition &other) const noexcept;
+	[[nodiscard]] constexpr bool operator !=(const SelectionPosition &other) const noexcept {
+		return (position != other.position) || (virtualSpace != other.virtualSpace);
+	}
+	[[nodiscard]] constexpr bool operator <(const SelectionPosition &other) const noexcept {
+		if (position == other.position)
+			return virtualSpace < other.virtualSpace;
+		return position < other.position;
+	}
+	[[nodiscard]] bool operator >(const SelectionPosition &other) const noexcept;
+	[[nodiscard]] bool operator <=(const SelectionPosition &other) const noexcept;
+	[[nodiscard]] bool operator >=(const SelectionPosition &other) const noexcept;
 	Sci::Position Position() const noexcept {
 		return position;
 	}
@@ -55,15 +64,15 @@ public:
 	bool IsValid() const noexcept {
 		return position >= 0;
 	}
+	std::string ToString() const;
 };
 
 // Ordered range to make drawing simpler
 struct SelectionSegment {
 	SelectionPosition start;
 	SelectionPosition end;
-	SelectionSegment() noexcept : start(), end() {
-	}
-	SelectionSegment(SelectionPosition a, SelectionPosition b) noexcept {
+	constexpr SelectionSegment() noexcept = default;
+	constexpr SelectionSegment(SelectionPosition a, SelectionPosition b) noexcept {
 		if (a < b) {
 			start = a;
 			end = b;
@@ -72,6 +81,12 @@ struct SelectionSegment {
 			end = a;
 		}
 	}
+	constexpr SelectionSegment(Sci::Position a, Sci::Position b) :
+		SelectionSegment(SelectionPosition(a), SelectionPosition(b)) {
+	}
+	[[nodiscard]] constexpr bool operator ==(const SelectionSegment &other) const noexcept {
+		return (start == other.start) && (end == other.end);
+	}
 	bool Empty() const noexcept {
 		return start == end;
 	}
@@ -96,15 +111,18 @@ struct SelectionRange {
 	SelectionPosition caret;
 	SelectionPosition anchor;
 
-	SelectionRange() noexcept : caret(), anchor() {
+	constexpr SelectionRange() noexcept = default;
+	constexpr explicit SelectionRange(SelectionPosition single) noexcept : caret(single), anchor(single) {
 	}
-	explicit SelectionRange(SelectionPosition single) noexcept : caret(single), anchor(single) {
+	constexpr explicit SelectionRange(Sci::Position single) noexcept : caret(single), anchor(single) {
 	}
-	explicit SelectionRange(Sci::Position single) noexcept : caret(single), anchor(single) {
+	constexpr SelectionRange(SelectionPosition caret_, SelectionPosition anchor_) noexcept : caret(caret_), anchor(anchor_) {
 	}
-	SelectionRange(SelectionPosition caret_, SelectionPosition anchor_) noexcept : caret(caret_), anchor(anchor_) {
+	constexpr SelectionRange(Sci::Position caret_, Sci::Position anchor_) noexcept : caret(caret_), anchor(anchor_) {
 	}
-	SelectionRange(Sci::Position caret_, Sci::Position anchor_) noexcept : caret(caret_), anchor(anchor_) {
+	explicit SelectionRange(std::string_view sv);
+	SelectionSegment AsSegment() const noexcept {
+		return {caret, anchor};
 	}
 	bool Empty() const noexcept {
 		return anchor == caret;
@@ -139,16 +157,19 @@ struct SelectionRange {
 	}
 	void Swap() noexcept;
 	bool Trim(SelectionRange range) noexcept;
+	void Truncate(Sci::Position length) noexcept;
 	// If range is all virtual collapse to start of virtual space
 	void MinimizeVirtualSpace() noexcept;
+	std::string ToString() const;
 };
 
 // Deliberately an enum rather than an enum class to allow treating as bool
 enum InSelection { inNone, inMain, inAdditional };
 
 class Selection {
-	std::vector<SelectionRange> ranges;
-	std::vector<SelectionRange> rangesSaved;
+	using Ranges = std::vector<SelectionRange>;
+	Ranges ranges;
+	Ranges rangesSaved;
 	SelectionRange rangeRectangular;
 	size_t mainRange;
 	bool moveExtends;
@@ -157,11 +178,14 @@ public:
 	enum class SelTypes { none, stream, rectangle, lines, thin };
 	SelTypes selType;
 
-	Selection();
+	Selection();	// Allocates so may throw.
+	explicit Selection(std::string_view sv);
+
 	bool IsRectangular() const noexcept;
 	Sci::Position MainCaret() const noexcept;
 	Sci::Position MainAnchor() const noexcept;
 	SelectionRange &Rectangular() noexcept;
+	SelectionRange RectangularCopy() const noexcept;
 	SelectionSegment Limits() const noexcept;
 	// This is for when you want to move the caret in response to a
 	// user direction command - for rectangular selections, use the range
@@ -198,9 +222,12 @@ public:
 	void RemoveDuplicates() noexcept;
 	void RotateMain() noexcept;
 	bool Tentative() const noexcept { return tentativeMain; }
-	std::vector<SelectionRange> RangesCopy() const {
+	Ranges RangesCopy() const {
 		return ranges;
 	}
+	void SetRanges(const Ranges &rangesToSet);
+	void Truncate(Sci::Position length) noexcept;
+	std::string ToString() const;
 };
 
 }
diff --git a/scintilla/src/SplitVector.h b/scintilla/src/SplitVector.h
index 4889ce4eb..6a9a8b25d 100644
--- a/scintilla/src/SplitVector.h
+++ b/scintilla/src/SplitVector.h
@@ -191,7 +191,7 @@ public:
 			}
 			RoomFor(insertLength);
 			GapTo(position);
-			std::fill(body.data() + part1Length, body.data() + part1Length + insertLength, v);
+			std::fill_n(body.data() + part1Length, insertLength, v);
 			lengthBody += insertLength;
 			part1Length += insertLength;
 			gapLength -= insertLength;
@@ -210,9 +210,10 @@ public:
 			}
 			RoomFor(insertLength);
 			GapTo(position);
-			for (ptrdiff_t elem = part1Length; elem < part1Length + insertLength; elem++) {
+			T *ptr = body.data() + part1Length;
+			for (ptrdiff_t elem = 0; elem < insertLength; elem++, ptr++) {
 				T emptyOne = {};
-				body[elem] = std::move(emptyOne);
+				*ptr = std::move(emptyOne);
 			}
 			lengthBody += insertLength;
 			part1Length += insertLength;
@@ -238,7 +239,7 @@ public:
 			}
 			RoomFor(insertLength);
 			GapTo(positionToInsert);
-			std::copy(s + positionFrom, s + positionFrom + insertLength, body.data() + part1Length);
+			std::copy_n(s + positionFrom, insertLength, body.data() + part1Length);
 			lengthBody += insertLength;
 			part1Length += insertLength;
 			gapLength -= insertLength;
@@ -284,11 +285,11 @@ public:
 			if (range1Length > part1AfterPosition)
 				range1Length = part1AfterPosition;
 		}
-		std::copy(body.data() + position, body.data() + position + range1Length, buffer);
+		std::copy_n(body.data() + position, range1Length, buffer);
 		buffer += range1Length;
 		position = position + range1Length + gapLength;
 		const ptrdiff_t range2Length = retrieveLength - range1Length;
-		std::copy(body.data() + position, body.data() + position + range2Length, buffer);
+		std::copy_n(body.data() + position, range2Length, buffer);
 	}
 
 	/// Compact the buffer and return a pointer to the first element.
diff --git a/scintilla/src/UndoHistory.cxx b/scintilla/src/UndoHistory.cxx
index c0d7ba5f2..29a80c6d1 100644
--- a/scintilla/src/UndoHistory.cxx
+++ b/scintilla/src/UndoHistory.cxx
@@ -354,6 +354,14 @@ int UndoHistory::UndoSequenceDepth() const noexcept {
 	return undoSequenceDepth;
 }
 
+bool UndoHistory::AfterUndoSequenceStart() const noexcept {
+	if (currentAction == 0) {
+		return false;
+	}
+	// Count back to last sequence start?
+	return !actions.AtStart(currentAction-1);
+}
+
 void UndoHistory::DropUndoSequence() noexcept {
 	undoSequenceDepth = 0;
 }
diff --git a/scintilla/src/UndoHistory.h b/scintilla/src/UndoHistory.h
index be639c541..299e28f58 100644
--- a/scintilla/src/UndoHistory.h
+++ b/scintilla/src/UndoHistory.h
@@ -102,6 +102,7 @@ public:
 	void BeginUndoAction(bool mayCoalesce=false) noexcept;
 	void EndUndoAction() noexcept;
 	int UndoSequenceDepth() const noexcept;
+	bool AfterUndoSequenceStart() const noexcept;
 	void DropUndoSequence() noexcept;
 	void DeleteUndoHistory() noexcept;
 
diff --git a/scintilla/src/UniConversion.cxx b/scintilla/src/UniConversion.cxx
index c733c8a43..52aa6351f 100644
--- a/scintilla/src/UniConversion.cxx
+++ b/scintilla/src/UniConversion.cxx
@@ -261,6 +261,18 @@ unsigned int UTF16FromUTF32Character(unsigned int val, wchar_t *tbuf) noexcept {
 	return 2;
 }
 
+int UnicodeFromUTF8(std::string_view sv) noexcept {
+	if (!sv.empty()) {
+		const unsigned char uch = sv.front();
+		const unsigned int byteCount = UTF8BytesOfLead[uch];
+		if (sv.length() >= byteCount) {
+			return UnicodeFromUTF8(reinterpret_cast<const unsigned char *>(sv.data()));
+		}
+	}
+	// Failure so let the caller know  
+	return unicodeReplacementChar;
+}
+
 const unsigned char UTF8BytesOfLead[256] = {
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 00 - 0F
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 10 - 1F
diff --git a/scintilla/src/UniConversion.h b/scintilla/src/UniConversion.h
index 86d9f756a..b541ed9ff 100644
--- a/scintilla/src/UniConversion.h
+++ b/scintilla/src/UniConversion.h
@@ -43,11 +43,16 @@ inline int UnicodeFromUTF8(const unsigned char *us) noexcept {
 		return ((us[0] & 0x7) << 18) + ((us[1] & 0x3F) << 12) + ((us[2] & 0x3F) << 6) + (us[3] & 0x3F);
 	}
 }
+int UnicodeFromUTF8(std::string_view sv) noexcept;
 
 constexpr bool UTF8IsTrailByte(unsigned char ch) noexcept {
 	return (ch >= 0x80) && (ch < 0xc0);
 }
 
+constexpr bool UTF8IsFirstByte(unsigned char ch) noexcept {
+	return (ch >= 0xc2) && (ch <= 0xf4);
+}
+
 constexpr bool UTF8IsAscii(unsigned char ch) noexcept {
 	return ch < 0x80;
 }
diff --git a/scintilla/test/simpleTests.py b/scintilla/test/simpleTests.py
index da7e11b7e..b4542b7a6 100644
--- a/scintilla/test/simpleTests.py
+++ b/scintilla/test/simpleTests.py
@@ -2242,6 +2242,39 @@ class TestMultiSelection(unittest.TestCase):
 		self.assertEqual(self.ed.Contents(), b'a    1')
 		self.assertEqual(self.textOfSelection(0), b' ')
 
+	def testSelectionSerialization(self):
+		self.ed.SetContents(b"a")
+		self.ed.SetSelection(0, 1)
+		self.assertEqual(self.ed.GetSelectionSerialized(), b'1-0')
+		self.ed.SetSelection(1, 1)
+		self.assertEqual(self.ed.GetSelectionSerialized(), b'1')
+		self.ed.SetSelectionNAnchorVirtualSpace(0, 2)
+		self.ed.SetSelectionNCaretVirtualSpace(0, 3)
+		self.assertEqual(selectionRepresentation(self.ed, 0), "1+2v-1+3v")
+		self.assertEqual(self.textOfSelection(0), b'')
+		self.assertEqual(self.ed.GetSelectionSerialized(), b'1v2-1v3')
+		self.ed.SetSelectionSerialized(0, b'1-0')
+		self.assertEqual(self.ed.MainSelection, 0)
+		self.assertEqual(self.ed.Anchor, 1)
+		self.assertEqual(self.ed.CurrentPos, 0)
+		self.assertEqual(self.ed.GetSelectionNAnchor(0), 1)
+		self.assertEqual(self.ed.GetSelectionNCaret(0), 0)
+
+	def testSelectionSerializationOutOfBounds(self):
+		# Try setting selections that extend past document end through serialized form
+		# and check that the selection is limited to the document.
+		self.ed.SetContents(b"a")
+		self.ed.SetSelectionSerialized(0, b'200-0')
+		self.assertEqual(self.ed.GetSelectionSerialized(), b'1-0')
+		
+		# Retain virtual space
+		self.ed.SetSelectionSerialized(0, b'0v1-200')
+		self.assertEqual(self.ed.GetSelectionSerialized(), b'0v1-1')
+
+		# Drop identical ranges, but touching empty range survives
+		self.ed.SetSelectionSerialized(0, b'0-200,300-400,500-600')
+		self.assertEqual(self.ed.GetSelectionSerialized(), b'0-1,1')
+
 
 class TestModalSelection(unittest.TestCase):
 
diff --git a/scintilla/test/unit/UnitTester.vcxproj b/scintilla/test/unit/UnitTester.vcxproj
index bb68d374a..41fa08ef4 100644
--- a/scintilla/test/unit/UnitTester.vcxproj
+++ b/scintilla/test/unit/UnitTester.vcxproj
@@ -75,13 +75,14 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <LinkIncremental>true</LinkIncremental>
     <EnableClangTidyCodeAnalysis>true</EnableClangTidyCodeAnalysis>
-    <CodeAnalysisRuleSet>..\..\..\..\..\Users\Neil\SensibleRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSet>..\..\..\lexilla\src\Lexilla.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <LinkIncremental>false</LinkIncremental>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <LinkIncremental>false</LinkIncremental>
+    <CodeAnalysisRuleSet>..\..\..\lexilla\src\Lexilla.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -165,6 +166,7 @@
     <ClCompile Include="..\..\src\PerLine.cxx" />
     <ClCompile Include="..\..\src\RESearch.cxx" />
     <ClCompile Include="..\..\src\RunStyles.cxx" />
+    <ClCompile Include="..\..\src\Selection.cxx" />
     <ClCompile Include="..\..\src\UndoHistory.cxx" />
     <ClCompile Include="..\..\src\UniConversion.cxx" />
     <ClCompile Include="..\..\src\UniqueString.cxx" />
diff --git a/scintilla/test/unit/makefile b/scintilla/test/unit/makefile
index 78484ad9a..1eb0737f2 100644
--- a/scintilla/test/unit/makefile
+++ b/scintilla/test/unit/makefile
@@ -68,6 +68,7 @@ Geometry.o \
 PerLine.o \
 RESearch.o \
 RunStyles.o \
+Selection.o \
 UndoHistory.o \
 UniConversion.o \
 UniqueString.o
diff --git a/scintilla/test/unit/test.mak b/scintilla/test/unit/test.mak
index e4a448f8c..15d9eba43 100644
--- a/scintilla/test/unit/test.mak
+++ b/scintilla/test/unit/test.mak
@@ -25,6 +25,7 @@ TESTEDSRC=\
  ../../src/PerLine.cxx \
  ../../src/RESearch.cxx \
  ../../src/RunStyles.cxx \
+ ../../src/Selection.cxx \
  ../../src/UndoHistory.cxx \
  ../../src/UniConversion.cxx \
  ../../src/UniqueString.cxx
diff --git a/scintilla/test/unit/testCharClassify.cxx b/scintilla/test/unit/testCharClassify.cxx
index 4329dbd20..a797915b9 100644
--- a/scintilla/test/unit/testCharClassify.cxx
+++ b/scintilla/test/unit/testCharClassify.cxx
@@ -21,11 +21,16 @@ using namespace Scintilla::Internal;
 
 // Test CharClassify.
 
+constexpr int byteValues = 256;
+
 class CharClassifyTest {
+public:
+	// Avoid warnings, deleted so never called.
+	CharClassifyTest(const CharClassifyTest &) = delete;
 protected:
 	CharClassifyTest() {
 		pcc = std::make_unique<CharClassify>();
-		for (int ch = 0; ch < 256; ch++) {
+		for (int ch = 0; ch < byteValues; ch++) {
 			if (ch == '\r' || ch == '\n')
 				charClass[ch] = CharacterClass::newLine;
 			else if (ch < 0x20 || ch == ' ' || ch == '\x7f')
@@ -36,11 +41,9 @@ protected:
 				charClass[ch] = CharacterClass::punctuation;
 		}
 	}
-	// Avoid warnings, deleted so never called.
-	CharClassifyTest(const CharClassifyTest &) = delete;
 
 	std::unique_ptr<CharClassify> pcc;
-	CharacterClass charClass[256] {};
+	CharacterClass charClass[byteValues] {};
 
 	static const char* GetClassName(CharacterClass charClass) noexcept {
 		switch(charClass) {
@@ -57,37 +60,39 @@ protected:
 };
 
 TEST_CASE_METHOD(CharClassifyTest, "Defaults") {
-	for (int i = 0; i < 256; i++) {
-		if (charClass[i] != pcc->GetClass(i))
+	for (int i = 0; i < byteValues; i++) {
+		if (charClass[i] != pcc->GetClass(i)) {
 			std::cerr
 			<< "Character " << i
 			<< " should be class " << GetClassName(charClass[i])
 			<< ", but got " << GetClassName(pcc->GetClass(i)) << std::endl;
+		}
 		REQUIRE(charClass[i] == pcc->GetClass(i));
 	}
 }
 
 TEST_CASE_METHOD(CharClassifyTest, "Custom") {
 	unsigned char buf[2] = {0, 0};
-	for (int i = 0; i < 256; i++) {
+	for (int i = 0; i < byteValues; i++) {
 		const CharacterClass thisClass = static_cast<CharacterClass>(i % 4);
 		buf[0] = i;
 		pcc->SetCharClasses(buf, thisClass);
 		charClass[i] = thisClass;
 	}
-	for (int i = 0; i < 256; i++) {
-		if (charClass[i] != pcc->GetClass(i))
+	for (int i = 0; i < byteValues; i++) {
+		if (charClass[i] != pcc->GetClass(i)) {
 			std::cerr
 			<< "Character " << i
 			<< " should be class " << GetClassName(charClass[i])
 			<< ", but got " << GetClassName(pcc->GetClass(i)) << std::endl;
+		}
 		REQUIRE(charClass[i] == pcc->GetClass(i));
 	}
 }
 
 TEST_CASE_METHOD(CharClassifyTest, "CharsOfClass") {
 	unsigned char buf[2] = {0, 0};
-	for (int i = 1; i < 256; i++) {
+	for (int i = 1; i < byteValues; i++) {
 		const CharacterClass thisClass = static_cast<CharacterClass>(i % 4);
 		buf[0] = i;
 		pcc->SetCharClasses(buf, thisClass);
@@ -99,24 +104,26 @@ TEST_CASE_METHOD(CharClassifyTest, "CharsOfClass") {
 		std::vector<unsigned char> buffer(size+1);
 		const unsigned char *pBuffer = buffer.data();
 		pcc->GetCharsOfClass(thisClass, buffer.data());
-		for (int i = 1; i < 256; i++) {
+		for (int i = 1; i < byteValues; i++) {
 			if (charClass[i] == thisClass) {
-				if (!memchr(pBuffer, i, size))
+				if (!memchr(pBuffer, i, size)) {
 					std::cerr
 					<< "Character " << i
 					<< " should be class " << GetClassName(thisClass)
 					<< ", but was not in GetCharsOfClass;"
 					<< " it is reported to be "
 					<< GetClassName(pcc->GetClass(i)) << std::endl;
+				}
 				REQUIRE(memchr(pBuffer, i, size));
 			} else {
-				if (memchr(pBuffer, i, size))
+				if (memchr(pBuffer, i, size)) {
 					std::cerr
 					<< "Character " << i
 					<< " should not be class " << GetClassName(thisClass)
 					<< ", but was in GetCharsOfClass"
 					<< " it is reported to be "
 					<< GetClassName(pcc->GetClass(i)) << std::endl;
+				}
 				REQUIRE_FALSE(memchr(pBuffer, i, size));
 			}
 		}
diff --git a/scintilla/test/unit/testDocument.cxx b/scintilla/test/unit/testDocument.cxx
index c4985f330..e764e209b 100644
--- a/scintilla/test/unit/testDocument.cxx
+++ b/scintilla/test/unit/testDocument.cxx
@@ -8,6 +8,7 @@
 #include <stdexcept>
 #include <string_view>
 #include <vector>
+#include <map>
 #include <set>
 #include <optional>
 #include <algorithm>
@@ -33,6 +34,7 @@
 #include "Decoration.h"
 #include "CaseFolder.h"
 #include "Document.h"
+#include "UniConversion.h"
 
 #include "catch.hpp"
 
@@ -67,23 +69,6 @@ const Folding foldings1252[] = {
 	{0xd8, 0xf8, 0x07},
 };
 
-// Table of case folding for non-ASCII bytes in Windows Russian code page 1251
-const Folding foldings1251[] = {
-	{0x80, 0x90, 0x01},
-	{0x81, 0x83, 0x01},
-	{0x8a, 0x9a, 0x01},
-	{0x8c, 0x9c, 0x04},
-	{0xa1, 0xa2, 0x01},
-	{0xa3, 0xbc, 0x01},
-	{0xa5, 0xb4, 0x01},
-	{0xa8, 0xb8, 0x01},
-	{0xaa, 0xba, 0x01},
-	{0xaf, 0xbf, 0x01},
-	{0xb2, 0xb3, 0x01},
-	{0xbd, 0xbe, 0x01},
-	{0xc0, 0xe0, 0x20},
-};
-
 std::string ReadFile(const std::string &path) {
 	std::ifstream ifs(path, std::ios::binary);
 	std::string content((std::istreambuf_iterator<char>(ifs)),
@@ -956,6 +941,61 @@ TEST_CASE("SafeSegment") {
 		REQUIRE(text[length] == '\xf0');
 	}
 
+	SECTION("UTF-8 Character Fragments") {
+		// PositionCache breaks long texts into fixed length sub-strings that are passed to SafeSegment
+		// so the final character in the sub-string may be incomplete without all needed trail bytes.
+		// For UTF-8, SafeSegment first discards any final bytes that do not represent a valid character
+		// then discards the final whole character.
+
+		const DocPlus doc("", CpUtf8);
+
+		// break before last character after discarding incomplete last character: 0 trail byte
+		std::string_view text = "Japanese\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e\xc2";	// Invalid text as ends with start byte
+		size_t length = doc.document.SafeSegment(text);
+		REQUIRE(text[length - 1] == '\xac');
+		REQUIRE(text[length] == '\xe8');
+		REQUIRE(UTF8IsValid(text.substr(0, length)));
+
+		// break before last character after discarding incomplete last character: 1 trail byte and 2 needed
+		text = "Japanese\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e\xe6\x97";	// Invalid text as ends with only 1 trail byte
+		length = doc.document.SafeSegment(text);
+		REQUIRE(text[length - 1] == '\xac');
+		REQUIRE(text[length] == '\xe8');
+		REQUIRE(UTF8IsValid(text.substr(0, length)));
+	}
+
+	SECTION("UTF-8 Combining Characters") {
+		const DocPlus doc("", CpUtf8);
+
+		// There may be combining characters like accents and tone marks after the
+		// last letter in a sub-string and these may be included in the sub-string
+		// or follow it.
+		// Correct display requires that the combining characters are measured and
+		// drawn with the letter they follow. Thus the final letter and any
+		// following combining characters are discarded.
+
+		// A Thai text example with 8 characters, each taking 3 bytes:
+		// HO HIP, SARA AA, KHO KHAI, MAI THO, O ANG, MO MA, SARA UU, LO LING
+		// Most are letters (Lo) but 2 characters are modifiers (Mn):
+		// MAI THO is a tone mark and SARA UU is a vowel.
+		const std::string_view text = "\xe0\xb8\xab\xe0\xb8\xb2\xe0\xb8\x82\xe0\xb9\x89\xe0\xb8\xad\xe0\xb8\xa1\xe0\xb8\xb9\xe0\xb8\xa5";
+		REQUIRE(text.length() == 8 * 3);
+		size_t length = doc.document.SafeSegment(text);
+		REQUIRE(length == (8 - 1) * 3);	// Discard last character
+
+		// Remove last character (letter LO LING) then run again.
+		// Should skip past SARA UU combining vowel mark to discard letter MO MA and SARA UU.
+		const std::string_view textWithoutLoLing = text.substr(0, length);
+		length = doc.document.SafeSegment(textWithoutLoLing);
+		REQUIRE(length == (8 - 3) * 3);	// Discard 2 characters
+
+		// Remove last character SARA UU combining vowel mark then run again
+		// Final letter may have following combining mark so discard producing same text as previous step.
+		const std::string_view textWithoutSaraUu = text.substr(0, (8 - 2) * 3);
+		length = doc.document.SafeSegment(textWithoutSaraUu);
+		REQUIRE(length == (8 - 3) * 3);	// Discard 1 character
+	}
+
 	SECTION("DBCS Shift-JIS") {
 		const DocPlus doc("", 932);
 		// word and punctuation boundary in middle of text: single byte
diff --git a/scintilla/test/unit/testRESearch.cxx b/scintilla/test/unit/testRESearch.cxx
index cc356e796..925d1a532 100644
--- a/scintilla/test/unit/testRESearch.cxx
+++ b/scintilla/test/unit/testRESearch.cxx
@@ -40,10 +40,10 @@ public:
 	[[nodiscard]] Sci::Position Length() const noexcept {
 		return s.length();
 	}
-	char CharAt(Sci::Position index) const override {
+	[[nodiscard]] char CharAt(Sci::Position index) const override {
 		return s.at(index);
 	}
-	Sci::Position MovePositionOutsideChar(Sci::Position pos, [[maybe_unused]] Sci::Position moveDir) const noexcept override {
+	[[nodiscard]] Sci::Position MovePositionOutsideChar(Sci::Position pos, [[maybe_unused]] Sci::Position moveDir) const noexcept override {
 		return pos;
 	}
 	[[nodiscard]] std::string GetCharRange(Sci::Position position, Sci::Position lengthRetrieve) const {
diff --git a/scintilla/test/unit/testSelection.cxx b/scintilla/test/unit/testSelection.cxx
new file mode 100644
index 000000000..609feaf00
--- /dev/null
+++ b/scintilla/test/unit/testSelection.cxx
@@ -0,0 +1,295 @@
+/** @file testSelection.cxx
+ ** Unit Tests for Scintilla internal data structures
+ **/
+
+#include <cstdint>
+
+#include <stdexcept>
+#include <string_view>
+#include <vector>
+
+#include "Debugging.h"
+
+#include "Position.h"
+#include "Selection.h"
+
+#include "catch.hpp"
+
+using namespace Scintilla;
+using namespace Scintilla::Internal;
+
+// Test Selection.
+
+namespace {
+
+constexpr SelectionPosition invalid;
+constexpr SelectionPosition zero(0);
+constexpr SelectionRange rangeInvalid;
+constexpr SelectionRange rangeZero(0);
+
+}
+
+TEST_CASE("SelectionPosition") {
+
+	SECTION("SelectionPosition") {
+		SelectionPosition sel;
+		REQUIRE(sel.Position() == Sci::invalidPosition);
+		REQUIRE(sel.VirtualSpace() == 0);
+		REQUIRE(!sel.IsValid());
+		REQUIRE(sel.VirtualSpace() == 0);
+
+		REQUIRE(sel == invalid);
+		REQUIRE(sel != zero);
+		sel.Reset();
+		REQUIRE(sel != invalid);
+		REQUIRE(sel == zero);
+	}
+
+	SECTION("Comparison") {
+		constexpr SelectionPosition sel(2,3);
+		REQUIRE(sel > invalid);
+		REQUIRE(sel > zero);
+		REQUIRE(sel >= zero);
+		REQUIRE(zero < sel);
+		REQUIRE(zero <= sel);
+
+		SelectionPosition virtuous(0, 4);
+		REQUIRE(virtuous > zero);
+		REQUIRE(virtuous >= zero);
+		REQUIRE(zero < virtuous);
+		REQUIRE(zero <= virtuous);
+
+		REQUIRE(virtuous.Position() == 0);
+		REQUIRE(virtuous.VirtualSpace() == 4);
+
+		virtuous.SetPosition(1);	// Also resets virtualSpace
+		REQUIRE(virtuous.Position() == 1);
+		REQUIRE(virtuous.VirtualSpace() == 0);
+		virtuous.SetVirtualSpace(3);	// Does not reset position
+		REQUIRE(virtuous.Position() == 1);
+		REQUIRE(virtuous.VirtualSpace() == 3);
+	}
+
+	SECTION("Add") {
+		SelectionPosition sel(2,3);
+		sel.Add(1);
+		REQUIRE(sel.Position() == 3);
+		REQUIRE(sel.VirtualSpace() == 3);
+		sel.AddVirtualSpace(2);
+		REQUIRE(sel.Position() == 3);
+		REQUIRE(sel.VirtualSpace() == 5);
+	}
+
+	SECTION("MoveForInsertDelete") {
+		// There are multiple details implemented in MoveForInsertDelete that are supposed to
+		// move selections in a way that appears to be natural to a user.
+
+		SelectionPosition sel(2,3);
+		sel.MoveForInsertDelete(true, 0,1, false);
+		REQUIRE(sel == SelectionPosition(3,3));
+
+		// Converts a virtual space to real space
+		sel.MoveForInsertDelete(true, 3,1, false);
+		REQUIRE(sel == SelectionPosition(4,2));
+
+		// Deletion at position clears virtual space
+		sel.MoveForInsertDelete(false, 4,1, false);
+		REQUIRE(sel == SelectionPosition(4,0));
+
+		sel.MoveForInsertDelete(false, 3,1, false);
+		REQUIRE(sel == SelectionPosition(3,0));
+
+		// Insert at position with and without move for equal
+		sel.MoveForInsertDelete(true, 3, 1, false);
+		REQUIRE(sel == SelectionPosition(3, 0));
+		sel.MoveForInsertDelete(true, 3, 1, true);
+		REQUIRE(sel == SelectionPosition(4, 0));
+
+		// Deletion over the position moves to start of deletion
+		sel.MoveForInsertDelete(false, 2, 5, false);
+		REQUIRE(sel == SelectionPosition(2, 0));
+	}
+
+	SECTION("Serialization") {
+		// Conversion to/from string form
+
+		const std::string invalidString(invalid.ToString());
+		REQUIRE(invalidString == "-1");
+		const SelectionPosition invalidReturned(invalidString);
+		REQUIRE(invalidReturned == invalid);
+
+		const std::string zeroString(zero.ToString());
+		REQUIRE(zeroString == "0");
+		const SelectionPosition zeroReturned(zeroString);
+		REQUIRE(zeroReturned == zero);
+
+		const SelectionPosition virtue(2, 3);
+		const std::string virtueString(virtue.ToString());
+		REQUIRE(virtueString == "2v3");
+		const SelectionPosition virtueReturned(virtueString);
+		REQUIRE(virtueReturned == virtue);
+	}
+
+}
+
+TEST_CASE("SelectionSegment") {
+
+	SECTION("SelectionSegment") {
+		const SelectionSegment ss;
+		REQUIRE(ss.start == invalid);
+		REQUIRE(ss.end == invalid);
+	}
+
+}
+
+TEST_CASE("SelectionRange") {
+
+	SECTION("SelectionRange") {
+		const SelectionRange sr;
+		REQUIRE(sr.anchor == invalid);
+		REQUIRE(sr.caret == invalid);
+	}
+
+	SECTION("Serialization") {
+		// Conversion to/from string form
+
+		// Range from 1 to 2 with 3 virtual spaces
+		const SelectionRange range123(SelectionPosition(2, 3), SelectionPosition(1));
+		const std::string range123String(range123.ToString());
+		// Opposite order to constructor: from anchor to caret 
+		REQUIRE(range123String == "1-2v3");
+		const SelectionRange range123Returned(range123String);
+		REQUIRE(range123Returned == range123);
+	}
+
+	SECTION("Intersect") {
+		constexpr SelectionSegment segmentEmpty;
+
+		// Range from 1 to 2 with 3 virtual spaces
+		const SelectionRange range123(SelectionPosition(2, 3), SelectionPosition(1));
+		const SelectionSegment segment12(1, 2);
+		const SelectionSegment inside = range123.Intersect(segment12);
+		REQUIRE(inside == segment12);
+
+		const SelectionSegment segment121(SelectionPosition(1), SelectionPosition(2, 1));
+		const SelectionSegment withVirtual = range123.Intersect(segment121);
+		REQUIRE(withVirtual == segment121);
+
+		const SelectionSegment segment052(SelectionPosition(0), SelectionPosition(5, 2));
+		const SelectionSegment internal = range123.Intersect(segment052);	// All inside
+		REQUIRE(internal == range123.AsSegment());
+
+		const SelectionSegment wayOut(SelectionPosition(100), SelectionPosition(105, 2));
+		const SelectionSegment nothing = range123.Intersect(wayOut);
+		REQUIRE(nothing == segmentEmpty);
+
+		const SelectionSegment edge(1, 1);
+		const SelectionSegment nowt = range123.Intersect(edge);
+		REQUIRE(nowt == edge);
+
+		// (0, 1) and (1, 2v3) touch so intersection is a single position.
+		const SelectionSegment front(0, 1);
+		const SelectionSegment single(1, 1);
+		const SelectionSegment thin = range123.Intersect(front);
+		REQUIRE(thin == single);
+	}
+
+}
+
+TEST_CASE("Selection") {
+
+	SECTION("Selection") {
+		Selection sel;
+		
+		REQUIRE(sel.selType == Selection::SelTypes::stream);
+		REQUIRE(!sel.IsRectangular());
+		REQUIRE(sel.Count() == 1);
+		REQUIRE(sel.Main() == 0);
+
+		REQUIRE(sel.Range(0) == rangeZero);
+		REQUIRE(sel.RangeMain() == rangeZero);
+		REQUIRE(sel.Rectangular() == rangeInvalid);
+		REQUIRE(sel.Empty());
+	}
+
+	SECTION("Serialization") {
+		// Conversion to/from string form
+
+		// Range from 5 with 3 virtual spaces to 2
+		const SelectionRange range532(SelectionPosition(2), SelectionPosition(5, 3));
+		Selection selection;
+		selection.SetSelection(range532);
+		const std::string selectionString(selection.ToString());
+		// Opposite order to constructor: from anchor to caret 
+		REQUIRE(selectionString == "5v3-2");
+		const SelectionRange selectionReturned(selectionString);
+
+		REQUIRE(selection.selType == Selection::SelTypes::stream);
+		REQUIRE(!selection.IsRectangular());
+		REQUIRE(selection.Count() == 1);
+		REQUIRE(selection.Main() == 0);
+
+		REQUIRE(selection.Range(0) == range532);
+		REQUIRE(selection.RangeMain() == range532);
+		REQUIRE(selection.Rectangular() == rangeInvalid);
+		REQUIRE(!selection.Empty());
+	}
+
+	SECTION("SerializationMultiple") {
+		// Conversion to/from string form
+
+		// Range from 5 with 3 virtual spaces to 2
+		const SelectionRange range532(SelectionPosition(2), SelectionPosition(5, 3));
+		const SelectionRange range1(SelectionPosition(1));
+		Selection selection;
+		selection.SetSelection(range532);
+		selection.AddSelection(range1);
+		selection.SetMain(1);
+		const std::string selectionString(selection.ToString());
+		REQUIRE(selectionString == "5v3-2,1#1");
+		const SelectionRange selectionReturned(selectionString);
+
+		REQUIRE(selection.selType == Selection::SelTypes::stream);
+		REQUIRE(!selection.IsRectangular());
+		REQUIRE(selection.Count() == 2);
+		REQUIRE(selection.Main() == 1);
+
+		REQUIRE(selection.Range(0) == range532);
+		REQUIRE(selection.Range(1) == range1);
+		REQUIRE(selection.RangeMain() == range1);
+		REQUIRE(selection.Rectangular() == rangeInvalid);
+		REQUIRE(!selection.Empty());
+	}
+
+	SECTION("SerializationRectangular") {
+		// Conversion to/from string form
+
+		// Range from 5 with 3 virtual spaces to 2
+		const SelectionRange range532(SelectionPosition(2), SelectionPosition(5, 3));
+		
+		// Create a single-line rectangular selection
+		Selection selection;
+		selection.selType = Selection::SelTypes::rectangle;
+		selection.Rectangular() = range532;
+		// Set arbitrary realized range - inside editor ranges would be calculated from line layout
+		selection.SetSelection(rangeZero);
+
+		const std::string selectionString(selection.ToString());
+		REQUIRE(selectionString == "R5v3-2");
+		const Selection selectionReturned(selectionString);
+
+		REQUIRE(selection.selType == Selection::SelTypes::rectangle);
+		REQUIRE(selection.IsRectangular());
+		REQUIRE(selection.Count() == 1);
+		REQUIRE(selection.Main() == 0);
+
+		REQUIRE(selection.Range(0) == rangeZero);
+		REQUIRE(selection.RangeMain() == rangeZero);
+		REQUIRE(selection.Rectangular() == range532);
+
+		selection.selType = Selection::SelTypes::thin;
+		const std::string thinString(selection.ToString());
+		REQUIRE(thinString == "T5v3-2");
+	}
+
+}
diff --git a/scintilla/test/unit/testUniConversion.cxx b/scintilla/test/unit/testUniConversion.cxx
index 0327db7e1..a3b15d84c 100644
--- a/scintilla/test/unit/testUniConversion.cxx
+++ b/scintilla/test/unit/testUniConversion.cxx
@@ -108,6 +108,11 @@ TEST_CASE("UniConversion") {
 		REQUIRE(UnicodeFromUTF8(s) == 0x10348);
 	}
 
+	SECTION("UnicodeFromUTF8 StringView") {
+		const unsigned char s[]="\xF0\x90\x8D\x88";
+		REQUIRE(UnicodeFromUTF8(s) == 0x10348);
+	}
+
 	// UTF16FromUTF8
 
 	SECTION("UTF16FromUTF8 ASCII") {
diff --git a/scintilla/test/unit/unitTest.cxx b/scintilla/test/unit/unitTest.cxx
index 00cd01f3b..789f02218 100644
--- a/scintilla/test/unit/unitTest.cxx
+++ b/scintilla/test/unit/unitTest.cxx
@@ -4,33 +4,27 @@
 
 /*
     Currently tested:
-        SplitVector
-        Partitioning
-        RunStyles
-        ContractionState
+        CellBuffer
+        CharacterCategoryMap
         CharClassify
+        ContractionState
         Decoration
         DecorationList
-        CellBuffer
+        Document
+        Geometry
+        Partitioning
+        PerLine
+        RESearch
+        RunStyles
+        Selection
+        SplitVector
         UniConversion
 
     To do:
-        PerLine *
         Range
         StyledText
         CaseFolder ...
-        Document
-        RESearch
-        Selection
         Style
-
-        lexlib:
-        Accessor
-        LexAccessor
-        CharacterSet
-        OptionSet
-        PropSetSimple
-        StyleContext
 */
 
 #include <cstdio>
diff --git a/scintilla/version.txt b/scintilla/version.txt
index 2e5e52f09..48faa0cc2 100644
--- a/scintilla/version.txt
+++ b/scintilla/version.txt
@@ -1 +1 @@
-554
+555
diff --git a/scintilla/win32/PlatWin.cxx b/scintilla/win32/PlatWin.cxx
index eff622f56..c1deb13af 100644
--- a/scintilla/win32/PlatWin.cxx
+++ b/scintilla/win32/PlatWin.cxx
@@ -39,13 +39,17 @@
 #include <windowsx.h>
 #include <shellscalingapi.h>
 
+#include <wrl.h>
+using Microsoft::WRL::ComPtr;
+
 #if !defined(DISABLE_D2D)
 #define USE_D2D 1
 #endif
 
 #if defined(USE_D2D)
-#include <d2d1.h>
-#include <dwrite.h>
+#include <d2d1_1.h>
+#include <d3d11_1.h>
+#include <dwrite_1.h>
 #endif
 
 #include "ScintillaTypes.h"
@@ -72,12 +76,17 @@ namespace Scintilla::Internal {
 UINT CodePageFromCharSet(CharacterSet characterSet, UINT documentCodePage) noexcept;
 
 #if defined(USE_D2D)
-IDWriteFactory *pIDWriteFactory = nullptr;
-ID2D1Factory *pD2DFactory = nullptr;
+IDWriteFactory1 *pIDWriteFactory = nullptr;
+ID2D1Factory1 *pD2DFactory = nullptr;
 D2D1_DRAW_TEXT_OPTIONS d2dDrawTextOptions = D2D1_DRAW_TEXT_OPTIONS_NONE;
 
-static HMODULE hDLLD2D {};
-static HMODULE hDLLDWrite {};
+namespace {
+
+HMODULE hDLLD2D{};
+HMODULE hDLLD3D{};
+HMODULE hDLLDWrite{};
+
+PFN_D3D11_CREATE_DEVICE fnDCD {};
 
 void LoadD2DOnce() noexcept {
 	DWORD loadLibraryFlags = 0;
@@ -96,16 +105,17 @@ void LoadD2DOnce() noexcept {
 	typedef HRESULT (WINAPI *DWriteCFSig)(DWRITE_FACTORY_TYPE factoryType, REFIID iid,
 		IUnknown **factory);
 
-	hDLLD2D = ::LoadLibraryEx(TEXT("D2D1.DLL"), 0, loadLibraryFlags);
+	hDLLD2D = ::LoadLibraryEx(TEXT("D2D1.DLL"), {}, loadLibraryFlags);
 	D2D1CFSig fnD2DCF = DLLFunction<D2D1CFSig>(hDLLD2D, "D2D1CreateFactory");
 	if (fnD2DCF) {
+		const D2D1_FACTORY_OPTIONS options {};
 		// A multi threaded factory in case Scintilla is used with multiple GUI threads
 		fnD2DCF(D2D1_FACTORY_TYPE_MULTI_THREADED,
-			__uuidof(ID2D1Factory),
-			nullptr,
+			__uuidof(ID2D1Factory1),
+			&options,
 			reinterpret_cast<IUnknown**>(&pD2DFactory));
 	}
-	hDLLDWrite = ::LoadLibraryEx(TEXT("DWRITE.DLL"), 0, loadLibraryFlags);
+	hDLLDWrite = ::LoadLibraryEx(TEXT("DWRITE.DLL"), {}, loadLibraryFlags);
 	DWriteCFSig fnDWCF = DLLFunction<DWriteCFSig>(hDLLDWrite, "DWriteCreateFactory");
 	if (fnDWCF) {
 		const GUID IID_IDWriteFactory2 = // 0439fc60-ca44-4994-8dee-3a9af7b732ec
@@ -119,10 +129,69 @@ void LoadD2DOnce() noexcept {
 			d2dDrawTextOptions = static_cast<D2D1_DRAW_TEXT_OPTIONS>(0x00000004);
 		} else {
 			fnDWCF(DWRITE_FACTORY_TYPE_SHARED,
-				__uuidof(IDWriteFactory),
+				__uuidof(IDWriteFactory1),
 				reinterpret_cast<IUnknown**>(&pIDWriteFactory));
 		}
 	}
+
+	hDLLD3D = ::LoadLibraryEx(TEXT("D3D11.DLL"), {}, loadLibraryFlags);
+	if (!hDLLD3D) {
+		Platform::DebugPrintf("Direct3D not loaded\n");
+	}
+	fnDCD = DLLFunction<PFN_D3D11_CREATE_DEVICE>(hDLLD3D, "D3D11CreateDevice");
+	if (!fnDCD) {
+		Platform::DebugPrintf("Direct3D does not have D3D11CreateDevice\n");
+	}
+}
+
+}
+
+HRESULT CreateD3D(D3D11Device &device) noexcept {
+	device = nullptr;
+	if (!fnDCD) {
+		return E_FAIL;
+	}
+
+	const D3D_FEATURE_LEVEL featureLevels[] = {
+		D3D_FEATURE_LEVEL_11_1,
+		D3D_FEATURE_LEVEL_11_0,
+		D3D_FEATURE_LEVEL_10_1,
+		D3D_FEATURE_LEVEL_10_0,
+		D3D_FEATURE_LEVEL_9_3,
+		D3D_FEATURE_LEVEL_9_2,
+		D3D_FEATURE_LEVEL_9_1
+	};
+
+	// Create device.
+	// Try for a hardware device but, if that fails, fall back to the Warp software rasterizer.
+	ComPtr<ID3D11Device> upDevice;
+	HRESULT hr = S_OK;
+	const D3D_DRIVER_TYPE typesToTry[] = { D3D_DRIVER_TYPE_HARDWARE, D3D_DRIVER_TYPE_WARP };
+	for (const D3D_DRIVER_TYPE type : typesToTry) {
+		hr = fnDCD(nullptr,
+			type,
+			{},
+			D3D11_CREATE_DEVICE_BGRA_SUPPORT,
+			featureLevels,
+			ARRAYSIZE(featureLevels),
+			D3D11_SDK_VERSION,
+			upDevice.GetAddressOf(),
+			nullptr,
+			nullptr);
+		if (SUCCEEDED(hr))
+			break;
+	}
+	if (FAILED(hr)) {
+		Platform::DebugPrintf("Failed to create D3D11 device 0x%lx\n", hr);
+		return hr;
+	}
+
+	// Convert from D3D11 to D3D11.1
+	hr = upDevice.As(&device);
+	if (FAILED(hr)) {
+		Platform::DebugPrintf("Failed to create D3D11.1 device 0x%lx\n", hr);
+	}
+	return hr;
 }
 
 bool LoadD2D() noexcept {
@@ -135,6 +204,12 @@ bool LoadD2D() noexcept {
 	return pIDWriteFactory && pD2DFactory;
 }
 
+HRESULT CreateDCRenderTarget(const D2D1_RENDER_TARGET_PROPERTIES *renderTargetProperties, DCRenderTarget &dcRT) noexcept {
+	return pD2DFactory->CreateDCRenderTarget(renderTargetProperties, dcRT.ReleaseAndGetAddressOf());
+}
+
+namespace {
+
 constexpr D2D_COLOR_F ColorFromColourAlpha(ColourRGBA colour) noexcept {
 	return D2D_COLOR_F{
 		colour.GetRedComponent(),
@@ -144,38 +219,61 @@ constexpr D2D_COLOR_F ColorFromColourAlpha(ColourRGBA colour) noexcept {
 	};
 }
 
-using BrushSolid = std::unique_ptr<ID2D1SolidColorBrush, UnknownReleaser>;
+using BrushSolid = ComPtr<ID2D1SolidColorBrush>;
 
 BrushSolid BrushSolidCreate(ID2D1RenderTarget *pTarget, COLORREF colour) noexcept {
-	ID2D1SolidColorBrush *pBrush = nullptr;
+	BrushSolid brush;
 	const D2D_COLOR_F col = ColorFromColourAlpha(ColourRGBA::FromRGB(colour));
-	const HRESULT hr = pTarget->CreateSolidColorBrush(col, &pBrush);
-	if (FAILED(hr) || !pBrush) {
+	if (FAILED(pTarget->CreateSolidColorBrush(col, brush.GetAddressOf()))) {
 		return {};
 	}
-	return BrushSolid(pBrush);
+	return brush;
 }
 
-using Geometry = std::unique_ptr<ID2D1PathGeometry, UnknownReleaser>;
+using Geometry = ComPtr<ID2D1PathGeometry>;
 
 Geometry GeometryCreate() noexcept {
-	ID2D1PathGeometry *geometry = nullptr;
-	const HRESULT hr = pD2DFactory->CreatePathGeometry(&geometry);
-	if (FAILED(hr) || !geometry) {
+	Geometry geometry;
+	if (FAILED(pD2DFactory->CreatePathGeometry(geometry.GetAddressOf()))) {
 		return {};
 	}
-	return Geometry(geometry);
+	return geometry;
 }
 
-using GeometrySink = std::unique_ptr<ID2D1GeometrySink, UnknownReleaser>;
+using GeometrySink = ComPtr<ID2D1GeometrySink>;
 
 GeometrySink GeometrySinkCreate(ID2D1PathGeometry *geometry) noexcept {
-	ID2D1GeometrySink *sink = nullptr;
-	const HRESULT hr = geometry->Open(&sink);
-	if (FAILED(hr) || !sink) {
+	GeometrySink sink;
+	if (FAILED(geometry->Open(sink.GetAddressOf()))) {
 		return {};
 	}
-	return GeometrySink(sink);
+	return sink;
+}
+
+using StrokeStyle = ComPtr<ID2D1StrokeStyle>;
+
+StrokeStyle StrokeStyleCreate(const D2D1_STROKE_STYLE_PROPERTIES &strokeStyleProperties) noexcept {
+	StrokeStyle strokeStyle;
+	const HRESULT hr = pD2DFactory->CreateStrokeStyle(
+		strokeStyleProperties, nullptr, 0, strokeStyle.GetAddressOf());
+	if (FAILED(hr)) {
+		return {};
+	}
+	return strokeStyle;
+}
+
+using TextLayout = ComPtr<IDWriteTextLayout>;
+
+TextLayout LayoutCreate(std::wstring_view wsv, IDWriteTextFormat *pTextFormat, FLOAT maxWidth=10000.0F, FLOAT maxHeight=1000.0F) noexcept {
+	TextLayout layout;
+	const HRESULT hr = pIDWriteFactory->CreateTextLayout(wsv.data(), static_cast<UINT32>(wsv.length()),
+		pTextFormat, maxWidth, maxHeight, layout.GetAddressOf());
+	if (FAILED(hr)) {
+		return {};
+	}
+	return layout;
+}
+
 }
 
 #endif
@@ -289,7 +387,7 @@ constexpr D2D1_TEXT_ANTIALIAS_MODE DWriteMapFontQuality(FontQuality extraFontFla
 
 // Both GDI and DirectWrite can produce a HFONT for use in list boxes
 struct FontWin : public Font {
-	virtual HFONT HFont() const noexcept = 0;
+	[[nodiscard]] virtual HFONT HFont() const noexcept = 0;
 };
 
 void SetLogFont(LOGFONTW &lf, const char *faceName, CharacterSet characterSet, XYPOSITION size, FontWeight weight, bool italic, FontQuality extraFontFlag) {
@@ -305,7 +403,7 @@ void SetLogFont(LOGFONTW &lf, const char *faceName, CharacterSet characterSet, X
 
 struct FontGDI : public FontWin {
 	HFONT hfont = {};
-	FontGDI(const FontParameters &fp) {
+	explicit FontGDI(const FontParameters &fp) {
 		LOGFONTW lf;
 		SetLogFont(lf, fp.faceName, fp.characterSet, fp.size, fp.weight, fp.italic, fp.extraFontFlag);
 		hfont = ::CreateFontIndirectW(&lf);
@@ -319,7 +417,7 @@ struct FontGDI : public FontWin {
 		if (hfont)
 			::DeleteObject(hfont);
 	}
-	HFONT HFont() const noexcept override {
+	[[nodiscard]] HFONT HFont() const noexcept override {
 		// Duplicating hfont
 		LOGFONTW lf = {};
 		if (0 == ::GetObjectW(hfont, sizeof(lf), &lf)) {
@@ -331,14 +429,14 @@ struct FontGDI : public FontWin {
 
 #if defined(USE_D2D)
 struct FontDirectWrite : public FontWin {
-	IDWriteTextFormat *pTextFormat = nullptr;
+	ComPtr<IDWriteTextFormat> pTextFormat;
 	FontQuality extraFontFlag = FontQuality::QualityDefault;
 	CharacterSet characterSet = CharacterSet::Ansi;
 	FLOAT yAscent = 2.0f;
 	FLOAT yDescent = 1.0f;
 	FLOAT yInternalLeading = 0.0f;
 
-	FontDirectWrite(const FontParameters &fp) :
+	explicit FontDirectWrite(const FontParameters &fp) :
 		extraFontFlag(fp.extraFontFlag),
 		characterSet(fp.characterSet) {
 		const std::wstring wsFace = WStringFromUTF8(fp.faceName);
@@ -349,22 +447,19 @@ struct FontDirectWrite : public FontWin {
 			static_cast<DWRITE_FONT_WEIGHT>(fp.weight),
 			style,
 			static_cast<DWRITE_FONT_STRETCH>(fp.stretch),
-				fHeight, wsLocale.c_str(), &pTextFormat);
+				fHeight, wsLocale.c_str(), pTextFormat.GetAddressOf());
 		if (hr == E_INVALIDARG) {
 			// Possibly a bad locale name like "/" so try "en-us".
 			hr = pIDWriteFactory->CreateTextFormat(wsFace.c_str(), nullptr,
 				static_cast<DWRITE_FONT_WEIGHT>(fp.weight),
 				style,
 				static_cast<DWRITE_FONT_STRETCH>(fp.stretch),
-				fHeight, L"en-us", &pTextFormat);
+				fHeight, L"en-us", pTextFormat.ReleaseAndGetAddressOf());
 		}
 		if (SUCCEEDED(hr)) {
 			pTextFormat->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP);
 
-			IDWriteTextLayout *pTextLayout = nullptr;
-			hr = pIDWriteFactory->CreateTextLayout(L"X", 1, pTextFormat,
-					100.0f, 100.0f, &pTextLayout);
-			if (SUCCEEDED(hr) && pTextLayout) {
+			if (TextLayout pTextLayout = LayoutCreate(L"X", pTextFormat.Get())) {
 				constexpr int maxLines = 2;
 				DWRITE_LINE_METRICS lineMetrics[maxLines]{};
 				UINT32 lineCount = 0;
@@ -379,7 +474,6 @@ struct FontDirectWrite : public FontWin {
 						yInternalLeading = lineMetrics[0].height - emHeight;
 					}
 				}
-				ReleaseUnknown(pTextLayout);
 				pTextFormat->SetLineSpacing(DWRITE_LINE_SPACING_METHOD_UNIFORM, lineMetrics[0].height, lineMetrics[0].baseline);
 			}
 		}
@@ -389,10 +483,8 @@ struct FontDirectWrite : public FontWin {
 	FontDirectWrite(FontDirectWrite &&) = delete;
 	FontDirectWrite &operator=(const FontDirectWrite &) = delete;
 	FontDirectWrite &operator=(FontDirectWrite &&) = delete;
-	~FontDirectWrite() noexcept override {
-		ReleaseUnknown(pTextFormat);
-	}
-	HFONT HFont() const noexcept override {
+	~FontDirectWrite() noexcept override = default;
+	[[nodiscard]] HFONT HFont() const noexcept override {
 		LOGFONTW lf = {};
 		const HRESULT hr = pTextFormat->GetFontFamilyName(lf.lfFaceName, LF_FACESIZE);
 		if (!SUCCEEDED(hr)) {
@@ -404,7 +496,7 @@ struct FontDirectWrite : public FontWin {
 		return ::CreateFontIndirectW(&lf);
 	}
 
-	int CodePageText(int codePage) const noexcept {
+	[[nodiscard]] int CodePageText(int codePage) const noexcept {
 		if (!(codePage == CpUtf8) && (characterSet != CharacterSet::Ansi)) {
 			codePage = CodePageFromCharSet(characterSet, codePage);
 		}
@@ -509,8 +601,11 @@ public:
 				buffer, static_cast<int>(text.length()));
 		}
 	}
+	[[nodiscard]] std::wstring_view AsView() const noexcept {
+		return std::wstring_view(buffer, tlen);
+	}
 };
-typedef VarBuffer<XYPOSITION, stackBufferLength> TextPositions;
+using TextPositions = VarBuffer<XYPOSITION, stackBufferLength>;
 
 UINT DpiForWindow(WindowID wid) noexcept {
 	if (fnGetDpiForWindow) {
@@ -562,7 +657,7 @@ class SurfaceGDI : public Surface {
 	void Clear() noexcept;
 
 public:
-	SurfaceGDI() noexcept;
+	SurfaceGDI() noexcept = default;
 	SurfaceGDI(HDC hdcCompatible, int width, int height, SurfaceMode mode_, int logPixelsY_) noexcept;
 	// Deleted so SurfaceGDI objects can not be copied.
 	SurfaceGDI(const SurfaceGDI &) = delete;
@@ -628,9 +723,6 @@ public:
 	void FlushDrawing() override;
 };
 
-SurfaceGDI::SurfaceGDI() noexcept {
-}
-
 SurfaceGDI::SurfaceGDI(HDC hdcCompatible, int width, int height, SurfaceMode mode_, int logPixelsY_) noexcept {
 	hdc = ::CreateCompatibleDC(hdcCompatible);
 	hdcOwned = true;
@@ -829,7 +921,7 @@ void SurfaceGDI::FillRectangleAligned(PRectangle rc, Fill fill) {
 }
 
 void SurfaceGDI::FillRectangle(PRectangle rc, Surface &surfacePattern) {
-	HBRUSH br;
+	HBRUSH br{};
 	if (SurfaceGDI *psgdi = dynamic_cast<SurfaceGDI *>(&surfacePattern); psgdi && psgdi->bitmap) {
 		br = ::CreatePatternBrush(psgdi->bitmap);
 	} else {	// Something is wrong so display in red
@@ -885,13 +977,13 @@ public:
 	operator bool() const noexcept {
 		return hMemDC && hbmMem && pixels;
 	}
-	DWORD *Pixels() const noexcept {
+	[[nodiscard]] DWORD *Pixels() const noexcept {
 		return pixels;
 	}
-	unsigned char *Bytes() const noexcept {
+	[[nodiscard]] unsigned char *Bytes() const noexcept {
 		return reinterpret_cast<unsigned char *>(pixels);
 	}
-	HDC DC() const noexcept {
+	[[nodiscard]] HDC DC() const noexcept {
 		return hMemDC;
 	}
 	void SetPixel(LONG x, LONG y, DWORD value) noexcept {
@@ -964,10 +1056,6 @@ ColourRGBA GradientValue(const std::vector<ColourStop> &stops, XYPOSITION propor
 	return ColourRGBA();
 }
 
-constexpr SIZE SizeOfRect(RECT rc) noexcept {
-	return { rc.right - rc.left, rc.bottom - rc.top };
-}
-
 constexpr BLENDFUNCTION mergeAlpha = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
 
 }
@@ -1100,7 +1188,7 @@ std::unique_ptr<IScreenLineLayout> SurfaceGDI::Layout(const IScreenLine *) {
 	return {};
 }
 
-typedef VarBuffer<int, stackBufferLength> TextPositionsI;
+using TextPositionsI = VarBuffer<int, stackBufferLength>;
 
 void SurfaceGDI::DrawTextCommon(PRectangle rc, const Font *font_, XYPOSITION ybase, std::string_view text, UINT fuOptions) {
 	SetFont(font_);
@@ -1367,12 +1455,14 @@ class BlobInline;
 class SurfaceD2D : public Surface, public ISetRenderingParams {
 	SurfaceMode mode;
 
-	ID2D1RenderTarget *pRenderTarget = nullptr;
-	ID2D1BitmapRenderTarget *pBitmapRenderTarget = nullptr;
-	bool ownRenderTarget = false;
+	// Text measuring surface: both pRenderTarget and pBitmapRenderTarget are null.
+	// Window surface: pRenderTarget is valid but not pBitmapRenderTarget.
+	// Bitmap drawing surface: both pRenderTarget and pBitmapRenderTarget are valid and the same.
+	ComPtr<ID2D1RenderTarget> pRenderTarget;
+	ComPtr<ID2D1BitmapRenderTarget> pBitmapRenderTarget;
 	int clipsActive = 0;
 
-	ID2D1SolidColorBrush *pBrush = nullptr;
+	BrushSolid pBrush = nullptr;
 
 	static constexpr FontQuality invalidFontQuality = FontQuality::QualityMask;
 	FontQuality fontQuality = invalidFontQuality;
@@ -1383,10 +1473,10 @@ class SurfaceD2D : public Surface, public ISetRenderingParams {
 	void Clear() noexcept;
 	void SetFontQuality(FontQuality extraFontFlag);
 	HRESULT GetBitmap(ID2D1Bitmap **ppBitmap);
-	void SetDeviceScaleFactor(const ID2D1RenderTarget *const pRenderTarget) noexcept;
+	void SetDeviceScaleFactor(const ID2D1RenderTarget *const pD2D1RenderTarget) noexcept;
 
 public:
-	SurfaceD2D() noexcept;
+	SurfaceD2D() noexcept = default;
 	SurfaceD2D(ID2D1RenderTarget *pRenderTargetCompatible, int width, int height, SurfaceMode mode_, int logPixelsY_) noexcept;
 	// Deleted so SurfaceD2D objects can not be copied.
 	SurfaceD2D(const SurfaceD2D &) = delete;
@@ -1457,9 +1547,6 @@ public:
 	void SetRenderingParams(std::shared_ptr<RenderingParams> renderingParams_) override;
 };
 
-SurfaceD2D::SurfaceD2D() noexcept {
-}
-
 SurfaceD2D::SurfaceD2D(ID2D1RenderTarget *pRenderTargetCompatible, int width, int height, SurfaceMode mode_, int logPixelsY_) noexcept {
 	const D2D1_SIZE_F desiredSize = D2D1::SizeF(static_cast<float>(width), static_cast<float>(height));
 	D2D1_PIXEL_FORMAT desiredFormat;
@@ -1470,12 +1557,11 @@ SurfaceD2D::SurfaceD2D(ID2D1RenderTarget *pRenderTargetCompatible, int width, in
 #endif
 	desiredFormat.alphaMode = D2D1_ALPHA_MODE_IGNORE;
 	const HRESULT hr = pRenderTargetCompatible->CreateCompatibleRenderTarget(
-		&desiredSize, nullptr, &desiredFormat, D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, &pBitmapRenderTarget);
+		&desiredSize, nullptr, &desiredFormat, D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, pBitmapRenderTarget.GetAddressOf());
 	if (SUCCEEDED(hr)) {
 		pRenderTarget = pBitmapRenderTarget;
-		SetDeviceScaleFactor(pRenderTarget);
+		SetDeviceScaleFactor(pRenderTarget.Get());
 		pRenderTarget->BeginDraw();
-		ownRenderTarget = true;
 	}
 	mode = mode_;
 	logPixelsY = logPixelsY_;
@@ -1486,19 +1572,17 @@ SurfaceD2D::~SurfaceD2D() noexcept {
 }
 
 void SurfaceD2D::Clear() noexcept {
-	ReleaseUnknown(pBrush);
+	pBrush = nullptr;
 	if (pRenderTarget) {
 		while (clipsActive) {
 			pRenderTarget->PopAxisAlignedClip();
 			clipsActive--;
 		}
-		if (ownRenderTarget) {
+		if (pBitmapRenderTarget) {
 			pRenderTarget->EndDraw();
-			ReleaseUnknown(pRenderTarget);
-			ownRenderTarget = false;
 		}
-		pRenderTarget = nullptr;
 	}
+	pRenderTarget = nullptr;
 	pBitmapRenderTarget = nullptr;
 }
 
@@ -1520,7 +1604,7 @@ int SurfaceD2D::SupportsFeature(Supports feature) noexcept {
 }
 
 bool SurfaceD2D::Initialised() {
-	return pRenderTarget != nullptr;
+	return pRenderTarget;
 }
 
 void SurfaceD2D::Init(WindowID wid) {
@@ -1532,11 +1616,11 @@ void SurfaceD2D::Init(SurfaceID sid, WindowID wid) {
 	Release();
 	SetScale(wid);
 	pRenderTarget = static_cast<ID2D1RenderTarget *>(sid);
-	SetDeviceScaleFactor(pRenderTarget);
+	SetDeviceScaleFactor(pRenderTarget.Get());
 }
 
 std::unique_ptr<Surface> SurfaceD2D::AllocatePixMap(int width, int height) {
-	std::unique_ptr<SurfaceD2D> surf = std::make_unique<SurfaceD2D>(pRenderTarget, width, height, mode, logPixelsY);
+	std::unique_ptr<SurfaceD2D> surf = std::make_unique<SurfaceD2D>(pRenderTarget.Get(), width, height, mode, logPixelsY);
 	surf->SetRenderingParams(renderingParams);
 	return surf;
 }
@@ -1558,7 +1642,7 @@ void SurfaceD2D::D2DPenColourAlpha(ColourRGBA fore) noexcept {
 		} else {
 			const HRESULT hr = pRenderTarget->CreateSolidColorBrush(col, &pBrush);
 			if (!SUCCEEDED(hr)) {
-				ReleaseUnknown(pBrush);
+				pBrush = nullptr;
 			}
 		}
 	}
@@ -1569,9 +1653,9 @@ void SurfaceD2D::SetFontQuality(FontQuality extraFontFlag) {
 		fontQuality = extraFontFlag;
 		const D2D1_TEXT_ANTIALIAS_MODE aaMode = DWriteMapFontQuality(extraFontFlag);
 		if (aaMode == D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE && renderingParams->customRenderingParams) {
-			pRenderTarget->SetTextRenderingParams(renderingParams->customRenderingParams.get());
+			pRenderTarget->SetTextRenderingParams(renderingParams->customRenderingParams.Get());
 		} else if (renderingParams->defaultRenderingParams) {
-			pRenderTarget->SetTextRenderingParams(renderingParams->defaultRenderingParams.get());
+			pRenderTarget->SetTextRenderingParams(renderingParams->defaultRenderingParams.Get());
 		}
 		pRenderTarget->SetTextAntialiasMode(aaMode);
 	}
@@ -1609,22 +1693,17 @@ void SurfaceD2D::LineDraw(Point start, Point end, Stroke stroke) {
 	strokeProps.dashOffset = 0;
 
 	// get the stroke style to apply
-	ID2D1StrokeStyle *pStrokeStyle = nullptr;
-	const HRESULT hr = pD2DFactory->CreateStrokeStyle(
-		strokeProps, nullptr, 0, &pStrokeStyle);
-	if (SUCCEEDED(hr)) {
+	if (const StrokeStyle pStrokeStyle = StrokeStyleCreate(strokeProps)) {
 		pRenderTarget->DrawLine(
 			DPointFromPoint(start),
-			DPointFromPoint(end), pBrush, stroke.WidthF(), pStrokeStyle);
+			DPointFromPoint(end), pBrush.Get(), stroke.WidthF(), pStrokeStyle.Get());
 	}
-
-	ReleaseUnknown(pStrokeStyle);
 }
 
 Geometry SurfaceD2D::GeometricFigure(const Point *pts, size_t npts, D2D1_FIGURE_BEGIN figureBegin) noexcept {
 	Geometry geometry = GeometryCreate();
 	if (geometry) {
-		if (const GeometrySink sink = GeometrySinkCreate(geometry.get())) {
+		if (const GeometrySink sink = GeometrySinkCreate(geometry.Get())) {
 			sink->BeginFigure(DPointFromPoint(pts[0]), figureBegin);
 			for (size_t i = 1; i < npts; i++) {
 				sink->AddLine(DPointFromPoint(pts[i]));
@@ -1660,13 +1739,9 @@ void SurfaceD2D::PolyLine(const Point *pts, size_t npts, Stroke stroke) {
 	strokeProps.dashOffset = 0;
 
 	// get the stroke style to apply
-	ID2D1StrokeStyle *pStrokeStyle = nullptr;
-	const HRESULT hr = pD2DFactory->CreateStrokeStyle(
-		strokeProps, nullptr, 0, &pStrokeStyle);
-	if (SUCCEEDED(hr)) {
-		pRenderTarget->DrawGeometry(geometry.get(), pBrush, stroke.WidthF(), pStrokeStyle);
+	if (const StrokeStyle pStrokeStyle = StrokeStyleCreate(strokeProps)) {
+		pRenderTarget->DrawGeometry(geometry.Get(), pBrush.Get(), stroke.WidthF(), pStrokeStyle.Get());
 	}
-	ReleaseUnknown(pStrokeStyle);
 }
 
 void SurfaceD2D::Polygon(const Point *pts, size_t npts, FillStroke fillStroke) {
@@ -1676,9 +1751,9 @@ void SurfaceD2D::Polygon(const Point *pts, size_t npts, FillStroke fillStroke) {
 		PLATFORM_ASSERT(geometry);
 		if (geometry) {
 			D2DPenColourAlpha(fillStroke.fill.colour);
-			pRenderTarget->FillGeometry(geometry.get(), pBrush);
+			pRenderTarget->FillGeometry(geometry.Get(), pBrush.Get());
 			D2DPenColourAlpha(fillStroke.stroke.colour);
-			pRenderTarget->DrawGeometry(geometry.get(), pBrush, fillStroke.stroke.WidthF());
+			pRenderTarget->DrawGeometry(geometry.Get(), pBrush.Get(), fillStroke.stroke.WidthF());
 		}
 	}
 }
@@ -1692,9 +1767,9 @@ void SurfaceD2D::RectangleDraw(PRectangle rc, FillStroke fillStroke) {
 	const D2D1_RECT_F rectOutline = RectangleInset(rect, halfStroke);
 
 	D2DPenColourAlpha(fillStroke.fill.colour);
-	pRenderTarget->FillRectangle(&rectFill, pBrush);
+	pRenderTarget->FillRectangle(&rectFill, pBrush.Get());
 	D2DPenColourAlpha(fillStroke.stroke.colour);
-	pRenderTarget->DrawRectangle(&rectOutline, pBrush, fillStroke.stroke.WidthF());
+	pRenderTarget->DrawRectangle(&rectOutline, pBrush.Get(), fillStroke.stroke.WidthF());
 }
 
 void SurfaceD2D::RectangleFrame(PRectangle rc, Stroke stroke) {
@@ -1702,7 +1777,7 @@ void SurfaceD2D::RectangleFrame(PRectangle rc, Stroke stroke) {
 		const XYPOSITION halfStroke = stroke.width / 2.0f;
 		const D2D1_RECT_F rectangle1 = RectangleFromPRectangle(rc.Inset(halfStroke));
 		D2DPenColourAlpha(stroke.colour);
-		pRenderTarget->DrawRectangle(&rectangle1, pBrush, stroke.WidthF());
+		pRenderTarget->DrawRectangle(&rectangle1, pBrush.Get(), stroke.WidthF());
 	}
 }
 
@@ -1710,7 +1785,7 @@ void SurfaceD2D::FillRectangle(PRectangle rc, Fill fill) {
 	if (pRenderTarget) {
 		D2DPenColourAlpha(fill.colour);
 		const D2D1_RECT_F rectangle = RectangleFromPRectangle(rc);
-		pRenderTarget->FillRectangle(&rectangle, pBrush);
+		pRenderTarget->FillRectangle(&rectangle, pBrush.Get());
 	}
 }
 
@@ -1724,21 +1799,19 @@ void SurfaceD2D::FillRectangle(PRectangle rc, Surface &surfacePattern) {
 	if (!psurfOther) {
 		throw std::runtime_error("SurfaceD2D::FillRectangle: wrong Surface type.");
 	}
-	ID2D1Bitmap *pBitmap = nullptr;
-	HRESULT hr = psurfOther->GetBitmap(&pBitmap);
+	ComPtr<ID2D1Bitmap> pBitmap;
+	HRESULT hr = psurfOther->GetBitmap(pBitmap.GetAddressOf());
 	if (SUCCEEDED(hr) && pBitmap) {
-		ID2D1BitmapBrush *pBitmapBrush = nullptr;
+		ComPtr<ID2D1BitmapBrush> pBitmapBrush;
 		const D2D1_BITMAP_BRUSH_PROPERTIES brushProperties =
 	        D2D1::BitmapBrushProperties(D2D1_EXTEND_MODE_WRAP, D2D1_EXTEND_MODE_WRAP,
 			D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR);
 		// Create the bitmap brush.
-		hr = pRenderTarget->CreateBitmapBrush(pBitmap, brushProperties, &pBitmapBrush);
-		ReleaseUnknown(pBitmap);
+		hr = pRenderTarget->CreateBitmapBrush(pBitmap.Get(), brushProperties, pBitmapBrush.GetAddressOf());
 		if (SUCCEEDED(hr) && pBitmapBrush) {
 			pRenderTarget->FillRectangle(
 				RectangleFromPRectangle(rc),
-				pBitmapBrush);
-			ReleaseUnknown(pBitmapBrush);
+				pBitmapBrush.Get());
 		}
 	}
 }
@@ -1752,19 +1825,19 @@ void SurfaceD2D::RoundedRectangle(PRectangle rc, FillStroke fillStroke) {
 				RectangleFromPRectangle(rc),
 				radius, radius };
 			D2DPenColourAlpha(fillStroke.fill.colour);
-			pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush);
+			pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush.Get());
 		} else {
 			const D2D1_ROUNDED_RECT roundedRectFill = {
 				RectangleFromPRectangle(rc.Inset(1.0)),
 				radius-1, radius-1 };
 			D2DPenColourAlpha(fillStroke.fill.colour);
-			pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush);
+			pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush.Get());
 
 			const D2D1_ROUNDED_RECT roundedRect = {
 				RectangleFromPRectangle(rc.Inset(0.5)),
 				radius, radius };
 			D2DPenColourAlpha(fillStroke.stroke.colour);
-			pRenderTarget->DrawRoundedRectangle(roundedRect, pBrush, fillStroke.stroke.WidthF());
+			pRenderTarget->DrawRoundedRectangle(roundedRect, pBrush.Get(), fillStroke.stroke.WidthF());
 		}
 	}
 }
@@ -1778,21 +1851,21 @@ void SurfaceD2D::AlphaRectangle(PRectangle rc, XYPOSITION cornerSize, FillStroke
 		if (cornerSize == 0) {
 			// When corner size is zero, draw square rectangle to prevent blurry pixels at corners
 			D2DPenColourAlpha(fillStroke.fill.colour);
-			pRenderTarget->FillRectangle(rectFill, pBrush);
+			pRenderTarget->FillRectangle(rectFill, pBrush.Get());
 
 			D2DPenColourAlpha(fillStroke.stroke.colour);
-			pRenderTarget->DrawRectangle(rectOutline, pBrush, fillStroke.stroke.WidthF());
+			pRenderTarget->DrawRectangle(rectOutline, pBrush.Get(), fillStroke.stroke.WidthF());
 		} else {
 			const float cornerSizeF = static_cast<float>(cornerSize);
 			const D2D1_ROUNDED_RECT roundedRectFill = {
 				rectFill, cornerSizeF - 1.0f, cornerSizeF - 1.0f };
 			D2DPenColourAlpha(fillStroke.fill.colour);
-			pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush);
+			pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush.Get());
 
 			const D2D1_ROUNDED_RECT roundedRect = {
 				rectOutline, cornerSizeF, cornerSizeF};
 			D2DPenColourAlpha(fillStroke.stroke.colour);
-			pRenderTarget->DrawRoundedRectangle(roundedRect, pBrush, fillStroke.stroke.WidthF());
+			pRenderTarget->DrawRoundedRectangle(roundedRect, pBrush.Get(), fillStroke.stroke.WidthF());
 		}
 	}
 }
@@ -1816,22 +1889,20 @@ void SurfaceD2D::GradientRectangle(PRectangle rc, const std::vector<ColourStop>
 		for (const ColourStop &stop : stops) {
 			gradientStops.push_back({ static_cast<FLOAT>(stop.position), ColorFromColourAlpha(stop.colour) });
 		}
-		ID2D1GradientStopCollection *pGradientStops = nullptr;
+		ComPtr<ID2D1GradientStopCollection> pGradientStops;
 		HRESULT hr = pRenderTarget->CreateGradientStopCollection(
-			gradientStops.data(), static_cast<UINT32>(gradientStops.size()), &pGradientStops);
+			gradientStops.data(), static_cast<UINT32>(gradientStops.size()), pGradientStops.GetAddressOf());
 		if (FAILED(hr) || !pGradientStops) {
 			return;
 		}
-		ID2D1LinearGradientBrush *pBrushLinear = nullptr;
+		ComPtr<ID2D1LinearGradientBrush> pBrushLinear;
 		hr = pRenderTarget->CreateLinearGradientBrush(
-			lgbp, pGradientStops, &pBrushLinear);
+			lgbp, pGradientStops.Get(), pBrushLinear.GetAddressOf());
 		if (SUCCEEDED(hr) && pBrushLinear) {
 			const D2D1_RECT_F rectangle = RectangleFromPRectangle(PRectangle(
 				std::round(rc.left), rc.top, std::round(rc.right), rc.bottom));
-			pRenderTarget->FillRectangle(&rectangle, pBrushLinear);
-			ReleaseUnknown(pBrushLinear);
+			pRenderTarget->FillRectangle(&rectangle, pBrushLinear.Get());
 		}
-		ReleaseUnknown(pGradientStops);
 	}
 }
 
@@ -1847,16 +1918,15 @@ void SurfaceD2D::DrawRGBAImage(PRectangle rc, int width, int height, const unsig
 		std::vector<unsigned char> image(RGBAImage::bytesPerPixel * height * width);
 		RGBAImage::BGRAFromRGBA(image.data(), pixelsImage, static_cast<ptrdiff_t>(height) * width);
 
-		ID2D1Bitmap *bitmap = nullptr;
+		ComPtr<ID2D1Bitmap> bitmap;
 		const D2D1_SIZE_U size = D2D1::SizeU(width, height);
 		const D2D1_BITMAP_PROPERTIES props = {{DXGI_FORMAT_B8G8R8A8_UNORM,
 		    D2D1_ALPHA_MODE_PREMULTIPLIED}, 72.0, 72.0};
 		const HRESULT hr = pRenderTarget->CreateBitmap(size, image.data(),
-                  width * 4, &props, &bitmap);
+                  width * 4, &props, bitmap.GetAddressOf());
 		if (SUCCEEDED(hr)) {
 			const D2D1_RECT_F rcDestination = RectangleFromPRectangle(rc);
-			pRenderTarget->DrawBitmap(bitmap, rcDestination);
-			ReleaseUnknown(bitmap);
+			pRenderTarget->DrawBitmap(bitmap.Get(), rcDestination);
 		}
 	}
 }
@@ -1870,13 +1940,13 @@ void SurfaceD2D::Ellipse(PRectangle rc, FillStroke fillStroke) {
 	const D2D1_ELLIPSE ellipseFill = { centre, radiusFill, radiusFill };
 
 	D2DPenColourAlpha(fillStroke.fill.colour);
-	pRenderTarget->FillEllipse(ellipseFill, pBrush);
+	pRenderTarget->FillEllipse(ellipseFill, pBrush.Get());
 
 	const FLOAT radiusOutline = static_cast<FLOAT>(rc.Width() / 2.0f - fillStroke.stroke.width / 2.0f);
 	const D2D1_ELLIPSE ellipseOutline = { centre, radiusOutline, radiusOutline };
 
 	D2DPenColourAlpha(fillStroke.stroke.colour);
-	pRenderTarget->DrawEllipse(ellipseOutline, pBrush, fillStroke.stroke.WidthF());
+	pRenderTarget->DrawEllipse(ellipseOutline, pBrush.Get(), fillStroke.stroke.WidthF());
 }
 
 void SurfaceD2D::Stadium(PRectangle rc, FillStroke fillStroke, Ends ends) {
@@ -1895,12 +1965,12 @@ void SurfaceD2D::Stadium(PRectangle rc, FillStroke fillStroke, Ends ends) {
 		const D2D1_ROUNDED_RECT roundedRectFill = { RectangleInset(rect, fillStroke.stroke.WidthF()),
 			radiusFill, radiusFill };
 		D2DPenColourAlpha(fillStroke.fill.colour);
-		pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush);
+		pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush.Get());
 
 		const D2D1_ROUNDED_RECT roundedRect = { RectangleInset(rect, halfStroke),
 			radius, radius };
 		D2DPenColourAlpha(fillStroke.stroke.colour);
-		pRenderTarget->DrawRoundedRectangle(roundedRect, pBrush, fillStroke.stroke.WidthF());
+		pRenderTarget->DrawRoundedRectangle(roundedRect, pBrush.Get(), fillStroke.stroke.WidthF());
 	} else {
 		const Ends leftSide = static_cast<Ends>(static_cast<int>(ends) & 0xf);
 		const Ends rightSide = static_cast<Ends>(static_cast<int>(ends) & 0xf0);
@@ -1910,7 +1980,7 @@ void SurfaceD2D::Stadium(PRectangle rc, FillStroke fillStroke, Ends ends) {
 		const Geometry pathGeometry = GeometryCreate();
 		if (!pathGeometry)
 			return;
-		if (const GeometrySink pSink = GeometrySinkCreate(pathGeometry.get())) {
+		if (const GeometrySink pSink = GeometrySinkCreate(pathGeometry.Get())) {
 			switch (leftSide) {
 				case Ends::leftFlat:
 					pSink->BeginFigure(DPointFromPoint(Point(rc.left + halfStroke, rc.top + halfStroke)), D2D1_FIGURE_BEGIN_FILLED);
@@ -1964,23 +2034,22 @@ void SurfaceD2D::Stadium(PRectangle rc, FillStroke fillStroke, Ends ends) {
 			pSink->Close();
 		}
 		D2DPenColourAlpha(fillStroke.fill.colour);
-		pRenderTarget->FillGeometry(pathGeometry.get(), pBrush);
+		pRenderTarget->FillGeometry(pathGeometry.Get(), pBrush.Get());
 		D2DPenColourAlpha(fillStroke.stroke.colour);
-		pRenderTarget->DrawGeometry(pathGeometry.get(), pBrush, fillStroke.stroke.WidthF());
+		pRenderTarget->DrawGeometry(pathGeometry.Get(), pBrush.Get(), fillStroke.stroke.WidthF());
 	}
 }
 
 void SurfaceD2D::Copy(PRectangle rc, Point from, Surface &surfaceSource) {
 	SurfaceD2D &surfOther = dynamic_cast<SurfaceD2D &>(surfaceSource);
-	ID2D1Bitmap *pBitmap = nullptr;
-	const HRESULT hr = surfOther.GetBitmap(&pBitmap);
+	ComPtr<ID2D1Bitmap> pBitmap;
+	const HRESULT hr = surfOther.GetBitmap(pBitmap.GetAddressOf());
 	if (SUCCEEDED(hr) && pBitmap) {
 		const D2D1_RECT_F rcDestination = RectangleFromPRectangle(rc);
 		const D2D1_RECT_F rcSource = RectangleFromPRectangle(PRectangle(
 			from.x, from.y, from.x + rc.Width(), from.y + rc.Height()));
-		pRenderTarget->DrawBitmap(pBitmap, rcDestination, 1.0f,
+		pRenderTarget->DrawBitmap(pBitmap.Get(), rcDestination, 1.0f,
 			D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR, rcSource);
-		ReleaseUnknown(pBitmap);
 	}
 }
 
@@ -2008,7 +2077,7 @@ class BlobInline final : public IDWriteInlineObject {
 		DWRITE_BREAK_CONDITION *breakConditionBefore,
 		DWRITE_BREAK_CONDITION *breakConditionAfter) override;
 public:
-	BlobInline(XYPOSITION width_=0.0f) noexcept : width(width_) {
+	explicit BlobInline(XYPOSITION width_=0.0f) noexcept : width(width_) {
 	}
 };
 
@@ -2089,7 +2158,7 @@ COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE BlobInline::GetBreakConditions(
 }
 
 class ScreenLineLayout : public IScreenLineLayout {
-	IDWriteTextLayout *textLayout = nullptr;
+	TextLayout textLayout;
 	std::string text;
 	std::wstring buffer;
 	std::vector<BlobInline> blobs;
@@ -2097,13 +2166,13 @@ class ScreenLineLayout : public IScreenLineLayout {
 	static std::wstring ReplaceRepresentation(std::string_view text);
 	static size_t GetPositionInLayout(std::string_view text, size_t position);
 public:
-	ScreenLineLayout(const IScreenLine *screenLine);
+	explicit ScreenLineLayout(const IScreenLine *screenLine);
 	// Deleted so ScreenLineLayout objects can not be copied
 	ScreenLineLayout(const ScreenLineLayout &) = delete;
 	ScreenLineLayout(ScreenLineLayout &&) = delete;
 	ScreenLineLayout &operator=(const ScreenLineLayout &) = delete;
 	ScreenLineLayout &operator=(ScreenLineLayout &&) = delete;
-	~ScreenLineLayout() noexcept override;
+	~ScreenLineLayout() noexcept override = default;
 	size_t PositionFromX(XYPOSITION xDistance, bool charPosition) override;
 	XYPOSITION XFromPosition(size_t caretPosition) override;
 	std::vector<Interval> FindRangeIntervals(size_t start, size_t end) override;
@@ -2217,23 +2286,17 @@ ScreenLineLayout::ScreenLineLayout(const IScreenLine *screenLine) {
 	buffer = ReplaceRepresentation(screenLine->Text());
 
 	// Create a text layout
-	const HRESULT hrCreate = pIDWriteFactory->CreateTextLayout(
-		buffer.c_str(),
-		static_cast<UINT32>(buffer.length()),
-		pfm->pTextFormat,
+	textLayout = LayoutCreate(
+		buffer,
+		pfm->pTextFormat.Get(),
 		static_cast<FLOAT>(screenLine->Width()),
-		static_cast<FLOAT>(screenLine->Height()),
-		&textLayout);
-	if (!SUCCEEDED(hrCreate)) {
+		static_cast<FLOAT>(screenLine->Height()));
+	if (!textLayout) {
 		return;
 	}
 
 	// Fill the textLayout chars with their own formats
-	FillTextLayoutFormats(screenLine, textLayout, blobs);
-}
-
-ScreenLineLayout::~ScreenLineLayout() noexcept {
-	ReleaseUnknown(textLayout);
+	FillTextLayoutFormats(screenLine, textLayout.Get(), blobs);
 }
 
 // Get the position from the provided x
@@ -2392,18 +2455,14 @@ void SurfaceD2D::DrawTextCommon(PRectangle rc, const Font *font_, XYPOSITION yba
 		}
 
 		// Explicitly creating a text layout appears a little faster
-		IDWriteTextLayout *pTextLayout = nullptr;
-		const HRESULT hr = pIDWriteFactory->CreateTextLayout(
-				tbuf.buffer,
-				tbuf.tlen,
-				pfm->pTextFormat,
+		TextLayout pTextLayout = LayoutCreate(
+				tbuf.AsView(),
+				pfm->pTextFormat.Get(),
 				static_cast<FLOAT>(rc.Width()),
-				static_cast<FLOAT>(rc.Height()),
-				&pTextLayout);
-		if (SUCCEEDED(hr)) {
+				static_cast<FLOAT>(rc.Height()));
+		if (pTextLayout) {
 			const D2D1_POINT_2F origin = DPointFromPoint(Point(rc.left, ybase - pfm->yAscent));
-			pRenderTarget->DrawTextLayout(origin, pTextLayout, pBrush, d2dDrawTextOptions);
-			ReleaseUnknown(pTextLayout);
+			pRenderTarget->DrawTextLayout(origin, pTextLayout.Get(), pBrush.Get(), d2dDrawTextOptions);
 		}
 
 		if (fuOptions & ETO_CLIPPED) {
@@ -2455,18 +2514,13 @@ HRESULT MeasurePositions(TextPositions &poses, const TextWide &tbuf, IDWriteText
 	// Initialize poses for safety.
 	std::fill(poses.buffer, poses.buffer + tbuf.tlen, 0.0f);
 	// Create a layout
-	IDWriteTextLayout *pTextLayout = nullptr;
-	const HRESULT hrCreate = pIDWriteFactory->CreateTextLayout(tbuf.buffer, tbuf.tlen, pTextFormat, 10000.0, 1000.0, &pTextLayout);
-	if (!SUCCEEDED(hrCreate)) {
-		return hrCreate;
-	}
+	TextLayout pTextLayout = LayoutCreate(tbuf.AsView(), pTextFormat);
 	if (!pTextLayout) {
 		return E_FAIL;
 	}
 	VarBuffer<DWRITE_CLUSTER_METRICS, stackBufferLength> cm(tbuf.tlen);
 	UINT32 count = 0;
 	const HRESULT hrGetCluster = pTextLayout->GetClusterMetrics(cm.buffer, tbuf.tlen, &count);
-	ReleaseUnknown(pTextLayout);
 	if (!SUCCEEDED(hrGetCluster)) {
 		return hrGetCluster;
 	}
@@ -2491,7 +2545,7 @@ void SurfaceD2D::MeasureWidths(const Font *font_, std::string_view text, XYPOSIT
 	const int codePageText = pfm->CodePageText(mode.codePage);
 	const TextWide tbuf(text, codePageText);
 	TextPositions poses(tbuf.tlen);
-	if (FAILED(MeasurePositions(poses, tbuf, pfm->pTextFormat))) {
+	if (FAILED(MeasurePositions(poses, tbuf, pfm->pTextFormat.Get()))) {
 		return;
 	}
 	if (codePageText == CpUtf8) {
@@ -2543,13 +2597,10 @@ XYPOSITION SurfaceD2D::WidthText(const Font *font_, std::string_view text) {
 	if (pfm->pTextFormat) {
 		const TextWide tbuf(text, pfm->CodePageText(mode.codePage));
 		// Create a layout
-		IDWriteTextLayout *pTextLayout = nullptr;
-		const HRESULT hr = pIDWriteFactory->CreateTextLayout(tbuf.buffer, tbuf.tlen, pfm->pTextFormat, 1000.0, 1000.0, &pTextLayout);
-		if (SUCCEEDED(hr) && pTextLayout) {
+		if (TextLayout pTextLayout = LayoutCreate(tbuf.AsView(), pfm->pTextFormat.Get())) {
 			DWRITE_TEXT_METRICS textMetrics;
 			if (SUCCEEDED(pTextLayout->GetMetrics(&textMetrics)))
 				width = textMetrics.widthIncludingTrailingWhitespace;
-			ReleaseUnknown(pTextLayout);
 		}
 	}
 	return width;
@@ -2591,7 +2642,7 @@ void SurfaceD2D::MeasureWidthsUTF8(const Font *font_, std::string_view text, XYP
 	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
 	const TextWide tbuf(text, CpUtf8);
 	TextPositions poses(tbuf.tlen);
-	if (FAILED(MeasurePositions(poses, tbuf, pfm->pTextFormat))) {
+	if (FAILED(MeasurePositions(poses, tbuf, pfm->pTextFormat.Get()))) {
 		return;
 	}
 	// Map the widths given for UTF-16 characters back onto the UTF-8 input string
@@ -2619,13 +2670,10 @@ XYPOSITION SurfaceD2D::WidthTextUTF8(const Font * font_, std::string_view text)
 	if (pfm->pTextFormat) {
 		const TextWide tbuf(text, CpUtf8);
 		// Create a layout
-		IDWriteTextLayout *pTextLayout = nullptr;
-		const HRESULT hr = pIDWriteFactory->CreateTextLayout(tbuf.buffer, tbuf.tlen, pfm->pTextFormat, 1000.0, 1000.0, &pTextLayout);
-		if (SUCCEEDED(hr)) {
+		if (TextLayout pTextLayout = LayoutCreate(tbuf.AsView(), pfm->pTextFormat.Get())) {
 			DWRITE_TEXT_METRICS textMetrics;
 			if (SUCCEEDED(pTextLayout->GetMetrics(&textMetrics)))
 				width = textMetrics.widthIncludingTrailingWhitespace;
-			ReleaseUnknown(pTextLayout);
 		}
 	}
 	return width;
@@ -2656,16 +2704,11 @@ XYPOSITION SurfaceD2D::AverageCharWidth(const Font *font_) {
 	const FontDirectWrite *pfm = FontDirectWrite::Cast(font_);
 	if (pfm->pTextFormat) {
 		// Create a layout
-		IDWriteTextLayout *pTextLayout = nullptr;
-		static constexpr WCHAR wszAllAlpha[] = L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-		const size_t lenAllAlpha = wcslen(wszAllAlpha);
-		const HRESULT hr = pIDWriteFactory->CreateTextLayout(wszAllAlpha, static_cast<UINT32>(lenAllAlpha),
-			pfm->pTextFormat, 1000.0, 1000.0, &pTextLayout);
-		if (SUCCEEDED(hr) && pTextLayout) {
+		static constexpr std::wstring_view wsvAllAlpha = L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+		if (TextLayout pTextLayout = LayoutCreate(wsvAllAlpha, pfm->pTextFormat.Get())) {
 			DWRITE_TEXT_METRICS textMetrics;
 			if (SUCCEEDED(pTextLayout->GetMetrics(&textMetrics)))
-				width = textMetrics.width / lenAllAlpha;
-			ReleaseUnknown(pTextLayout);
+				width = textMetrics.width / wsvAllAlpha.length();
 		}
 	}
 	return width;
@@ -2704,17 +2747,14 @@ void SurfaceD2D::SetRenderingParams(std::shared_ptr<RenderingParams> renderingPa
 
 std::unique_ptr<Surface> Surface::Allocate([[maybe_unused]] Technology technology) {
 #if defined(USE_D2D)
-	if (technology == Technology::Default)
-		return std::make_unique<SurfaceGDI>();
-	else
+	if (technology != Technology::Default) {
 		return std::make_unique<SurfaceD2D>();
-#else
-	return std::make_unique<SurfaceGDI>();
+	}
 #endif
+	return std::make_unique<SurfaceGDI>();
 }
 
-Window::~Window() noexcept {
-}
+Window::~Window() noexcept = default;
 
 void Window::Destroy() noexcept {
 	if (wid)
@@ -2730,7 +2770,7 @@ PRectangle Window::GetPosition() const {
 
 void Window::SetPosition(PRectangle rc) {
 	::SetWindowPos(HwndFromWindowID(wid),
-		0, static_cast<int>(rc.left), static_cast<int>(rc.top),
+		{}, static_cast<int>(rc.left), static_cast<int>(rc.top),
 		static_cast<int>(rc.Width()), static_cast<int>(rc.Height()), SWP_NOZORDER | SWP_NOACTIVATE);
 }
 
@@ -2879,7 +2919,7 @@ public:
 		}
 	}
 
-	bool HasBitmap() const noexcept {
+	[[nodiscard]] bool HasBitmap() const noexcept {
 		return hOldBitmap != nullptr;
 	}
 
@@ -2917,15 +2957,14 @@ public:
 			D2D1_ALPHA_MODE_PREMULTIPLIED
 		);
 
-		ID2D1DCRenderTarget *pTarget_ = nullptr;
-		HRESULT hr = pD2DFactory->CreateDCRenderTarget(&drtp, &pTarget_);
-		if (FAILED(hr) || !pTarget_) {
+		DCRenderTarget pTarget;
+		HRESULT hr = CreateDCRenderTarget(&drtp, pTarget);
+		if (FAILED(hr) || !pTarget) {
 			return false;
 		}
-		const std::unique_ptr<ID2D1DCRenderTarget, UnknownReleaser> pTarget(pTarget_);
 
 		const RECT rc = {0, 0, width, height};
-		hr = pTarget_->BindDC(hMemDC, &rc);
+		hr = pTarget->BindDC(hMemDC, &rc);
 		if (FAILED(hr)) {
 			return false;
 		}
@@ -2946,7 +2985,7 @@ public:
 			return false;
 		}
 
-		const GeometrySink sink = GeometrySinkCreate(geometry.get());
+		const GeometrySink sink = GeometrySinkCreate(geometry.Get());
 		if (!sink) {
 			return false;
 		}
@@ -2961,12 +3000,12 @@ public:
 			return false;
 		}
 
-		if (const BrushSolid pBrushFill = BrushSolidCreate(pTarget.get(), fillColour)) {
-			pTarget->FillGeometry(geometry.get(), pBrushFill.get());
+		if (const BrushSolid pBrushFill = BrushSolidCreate(pTarget.Get(), fillColour)) {
+			pTarget->FillGeometry(geometry.Get(), pBrushFill.Get());
 		}
 
-		if (const BrushSolid pBrushStroke = BrushSolidCreate(pTarget.get(), strokeColour)) {
-			pTarget->DrawGeometry(geometry.get(), pBrushStroke.get(), scale);
+		if (const BrushSolid pBrushStroke = BrushSolidCreate(pTarget.Get(), strokeColour)) {
+			pTarget->DrawGeometry(geometry.Get(), pBrushStroke.Get(), scale);
 		}
 
 		hr = pTarget->EndDraw();
@@ -2991,7 +3030,7 @@ public:
 		}
 
 		const DWORD penWidth = std::lround(scale);
-		HPEN pen;
+		HPEN pen{};
 		if (penWidth > 1) {
 			const LOGBRUSH brushParameters { BS_SOLID, strokeColour, 0 };
 			pen = ::ExtCreatePen(PS_GEOMETRIC | PS_ENDCAP_ROUND | PS_JOIN_MITER,
@@ -3022,6 +3061,39 @@ public:
 	}
 };
 
+void ChooseCursor(LPCTSTR cursor) noexcept {
+	::SetCursor(::LoadCursor({}, cursor));
+}
+
+void ChooseCursor(Window::Cursor curs) noexcept {
+	switch (curs) {
+	case Window::Cursor::text:
+		ChooseCursor(IDC_IBEAM);
+		break;
+	case Window::Cursor::up:
+		ChooseCursor(IDC_UPARROW);
+		break;
+	case Window::Cursor::wait:
+		ChooseCursor(IDC_WAIT);
+		break;
+	case Window::Cursor::horizontal:
+		ChooseCursor(IDC_SIZEWE);
+		break;
+	case Window::Cursor::vertical:
+		ChooseCursor(IDC_SIZENS);
+		break;
+	case Window::Cursor::hand:
+		ChooseCursor(IDC_HAND);
+		break;
+	case Window::Cursor::reverseArrow:
+	case Window::Cursor::arrow:
+	case Window::Cursor::invalid:	// Should not occur, but just in case.
+	default:
+		ChooseCursor(IDC_ARROW);
+		break;
+	}
+}
+
 }
 
 HCURSOR LoadReverseArrowCursor(UINT dpi) noexcept {
@@ -3083,32 +3155,7 @@ HCURSOR LoadReverseArrowCursor(UINT dpi) noexcept {
 }
 
 void Window::SetCursor(Cursor curs) {
-	switch (curs) {
-	case Cursor::text:
-		::SetCursor(::LoadCursor(NULL,IDC_IBEAM));
-		break;
-	case Cursor::up:
-		::SetCursor(::LoadCursor(NULL,IDC_UPARROW));
-		break;
-	case Cursor::wait:
-		::SetCursor(::LoadCursor(NULL,IDC_WAIT));
-		break;
-	case Cursor::horizontal:
-		::SetCursor(::LoadCursor(NULL,IDC_SIZEWE));
-		break;
-	case Cursor::vertical:
-		::SetCursor(::LoadCursor(NULL,IDC_SIZENS));
-		break;
-	case Cursor::hand:
-		::SetCursor(::LoadCursor(NULL,IDC_HAND));
-		break;
-	case Cursor::reverseArrow:
-	case Cursor::arrow:
-	case Cursor::invalid:	// Should not occur, but just in case.
-	default:
-		::SetCursor(::LoadCursor(NULL,IDC_ARROW));
-		break;
-	}
+	ChooseCursor(curs);
 }
 
 /* Returns rectangle of monitor pt is on, both rect and pt are in Window's
@@ -3127,9 +3174,8 @@ PRectangle Window::GetMonitorRect(Point pt) {
 			rcWork.right - rcPosition.left,
 			rcWork.bottom - rcPosition.top);
 		return rcMonitor;
-	} else {
-		return PRectangle();
 	}
+	return PRectangle();
 }
 
 struct ListItemData {
@@ -3148,15 +3194,14 @@ public:
 		data.clear();
 	}
 
-	ListItemData Get(size_t index) const noexcept {
+	[[nodiscard]] ListItemData Get(size_t index) const noexcept {
 		if (index < data.size()) {
 			return data[index];
-		} else {
-			ListItemData missing = {"", -1};
-			return missing;
 		}
+		ListItemData missing = {"", -1};
+		return missing;
 	}
-	int Count() const noexcept {
+	[[nodiscard]] int Count() const noexcept {
 		return static_cast<int>(data.size());
 	}
 
@@ -3173,30 +3218,28 @@ public:
 
 const TCHAR ListBoxX_ClassName[] = TEXT("ListBoxX");
 
-ListBox::ListBox() noexcept {
-}
+ListBox::ListBox() noexcept = default;
 
-ListBox::~ListBox() noexcept {
-}
+ListBox::~ListBox() noexcept = default;
 
 class ListBoxX : public ListBox {
-	int lineHeight;
-	HFONT fontCopy;
-	Technology technology;
+	int lineHeight = 10;
+	HFONT fontCopy {};
+	Technology technology = Technology::Default;
 	RGBAImageSet images;
 	LineToItem lti;
-	HWND lb;
-	bool unicodeMode;
-	int desiredVisibleRows;
-	unsigned int maxItemCharacters;
-	unsigned int aveCharWidth;
-	Window *parent;
-	int ctrlID;
-	UINT dpi;
-	IListBoxDelegate *delegate;
-	const char *widestItem;
-	unsigned int maxCharWidth;
-	WPARAM resizeHit;
+	HWND lb {};
+	bool unicodeMode = false;
+	int desiredVisibleRows = 9;
+	unsigned int maxItemCharacters = 0;
+	unsigned int aveCharWidth = 8;
+	Window *parent = nullptr;
+	int ctrlID = 0;
+	UINT dpi = USER_DEFAULT_SCREEN_DPI;
+	IListBoxDelegate *delegate = nullptr;
+	const char *widestItem = nullptr;
+	unsigned int maxCharWidth = 1;
+	WPARAM resizeHit = 0;
 	PRectangle rcPreSize;
 	Point dragOffset;
 	Point location;	// Caret location at which the list is opened
@@ -3207,12 +3250,12 @@ class ListBoxX : public ListBox {
 	HWND GetHWND() const noexcept;
 	void AppendListItem(const char *text, const char *numword);
 	void AdjustWindowRect(PRectangle *rc, UINT dpiAdjust) const noexcept;
-	int ItemHeight() const;
+	int ItemHeight() const noexcept;
 	int MinClientWidth() const noexcept;
-	int TextOffset() const;
+	int TextOffset() const noexcept;
 	POINT GetClientExtent() const noexcept;
-	POINT MinTrackSize() const;
-	POINT MaxTrackSize() const;
+	POINT MinTrackSize() const noexcept;
+	POINT MaxTrackSize() const noexcept;
 	void SetRedraw(bool on) noexcept;
 	void OnDoubleClick();
 	void OnSelChange();
@@ -3223,17 +3266,12 @@ class ListBoxX : public ListBox {
 	void Paint(HDC);
 	static LRESULT PASCAL ControlWndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
 
-	static constexpr Point ItemInset {0, 0};	// Padding around whole item
-	static constexpr Point TextInset {2, 0};	// Padding around text
-	static constexpr Point ImageInset {1, 0};	// Padding around image
+	static constexpr POINT ItemInset {0, 0};	// Padding around whole item
+	static constexpr POINT TextInset {2, 0};	// Padding around text
+	static constexpr POINT ImageInset {1, 0};	// Padding around image
 
 public:
-	ListBoxX() : lineHeight(10), fontCopy{}, technology(Technology::Default), lb{}, unicodeMode(false),
-		desiredVisibleRows(9), maxItemCharacters(0), aveCharWidth(8),
-		parent(nullptr), ctrlID(0), dpi(USER_DEFAULT_SCREEN_DPI),
-		delegate(nullptr),
-		widestItem(nullptr), maxCharWidth(1), resizeHit(0) {
-	}
+	ListBoxX() = default;
 	ListBoxX(const ListBoxX &) = delete;
 	ListBoxX(ListBoxX &&) = delete;
 	ListBoxX &operator=(const ListBoxX &) = delete;
@@ -3241,7 +3279,7 @@ public:
 	~ListBoxX() noexcept override {
 		if (fontCopy) {
 			::DeleteObject(fontCopy);
-			fontCopy = 0;
+			fontCopy = {};
 		}
 	}
 	void SetFont(const Font *font) override;
@@ -3252,7 +3290,7 @@ public:
 	PRectangle GetDesiredRect() override;
 	int CaretFromEdge() override;
 	void Clear() noexcept override;
-	void Append(char *s, int type = -1) override;
+	void Append(char *s, int type) override;
 	int Length() override;
 	void Select(int n) override;
 	int GetSelection() override;
@@ -3287,13 +3325,13 @@ void ListBoxX::Create(Window &parent_, int ctrlID_, Point location_, int lineHei
 		WS_EX_WINDOWEDGE, ListBoxX_ClassName, TEXT(""),
 		WS_POPUP | frameStyle,
 		100,100, 150,80, hwndParent,
-		NULL,
+		{},
 		hinstanceParent,
 		this);
 
 	dpi = DpiForWindow(hwndParent);
 	POINT locationw = POINTFromPoint(location);
-	::MapWindowPoints(hwndParent, NULL, &locationw, 1);
+	::MapWindowPoints(hwndParent, {}, &locationw, 1);
 	location = PointFromPOINT(locationw);
 }
 
@@ -3302,7 +3340,7 @@ void ListBoxX::SetFont(const Font *font) {
 	if (pfm) {
 		if (fontCopy) {
 			::DeleteObject(fontCopy);
-			fontCopy = 0;
+			fontCopy = {};
 		}
 		fontCopy = pfm->HFont();
 		SetWindowFont(lb, fontCopy, 0);
@@ -3365,9 +3403,9 @@ PRectangle ListBoxX::GetDesiredRect() {
 	return rcDesired;
 }
 
-int ListBoxX::TextOffset() const {
+int ListBoxX::TextOffset() const noexcept {
 	const int pixWidth = images.GetWidth();
-	return static_cast<int>(pixWidth == 0 ? ItemInset.x : ItemInset.x + pixWidth + (ImageInset.x * 2));
+	return pixWidth == 0 ? ItemInset.x : ItemInset.x + pixWidth + (ImageInset.x * 2);
 }
 
 int ListBoxX::CaretFromEdge() {
@@ -3435,9 +3473,8 @@ namespace {
 int ColourOfElement(std::optional<ColourRGBA> colour, int nIndex) {
 	if (colour.has_value()) {
 		return colour.value().OpaqueRGB();
-	} else {
-		return ::GetSysColor(nIndex);
 	}
+	return ::GetSysColor(nIndex);
 }
 
 void FillRectColour(HDC hdc, const RECT *lprc, int colour) noexcept {
@@ -3472,7 +3509,7 @@ void ListBoxX::Draw(DRAWITEMSTRUCT *pDrawItem) {
 		const int len = static_cast<int>(strlen(text));
 
 		RECT rcText = rcBox;
-		::InsetRect(&rcText, static_cast<int>(TextInset.x), static_cast<int>(TextInset.y));
+		::InsetRect(&rcText, TextInset.x, TextInset.y);
 
 		if (unicodeMode) {
 			const TextWide tbuf(text, CpUtf8);
@@ -3487,7 +3524,7 @@ void ListBoxX::Draw(DRAWITEMSTRUCT *pDrawItem) {
 			std::unique_ptr<Surface> surfaceItem(Surface::Allocate(technology));
 			if (technology == Technology::Default) {
 				surfaceItem->Init(pDrawItem->hDC, pDrawItem->hwndItem);
-				const long left = pDrawItem->rcItem.left + static_cast<int>(ItemInset.x + ImageInset.x);
+				const long left = pDrawItem->rcItem.left + ItemInset.x + ImageInset.x;
 				const PRectangle rcImage = PRectangle::FromInts(left, pDrawItem->rcItem.top,
 					left + images.GetWidth(), pDrawItem->rcItem.bottom);
 				surfaceItem->DrawRGBAImage(rcImage,
@@ -3505,10 +3542,10 @@ void ListBoxX::Draw(DRAWITEMSTRUCT *pDrawItem) {
 					D2D1_RENDER_TARGET_USAGE_NONE,
 					D2D1_FEATURE_LEVEL_DEFAULT
 					);
-				ID2D1DCRenderTarget *pDCRT = nullptr;
-				HRESULT hr = pD2DFactory->CreateDCRenderTarget(&props, &pDCRT);
+				DCRenderTarget pDCRT;
+				HRESULT hr = CreateDCRenderTarget(&props, pDCRT);
 				if (SUCCEEDED(hr) && pDCRT) {
-					const long left = pDrawItem->rcItem.left + static_cast<long>(ItemInset.x + ImageInset.x);
+					const long left = pDrawItem->rcItem.left + ItemInset.x + ImageInset.x;
 
 					RECT rcItem = pDrawItem->rcItem;
 					rcItem.left = left;
@@ -3516,13 +3553,12 @@ void ListBoxX::Draw(DRAWITEMSTRUCT *pDrawItem) {
 
 					hr = pDCRT->BindDC(pDrawItem->hDC, &rcItem);
 					if (SUCCEEDED(hr)) {
-						surfaceItem->Init(pDCRT, pDrawItem->hwndItem);
+						surfaceItem->Init(pDCRT.Get(), pDrawItem->hwndItem);
 						pDCRT->BeginDraw();
 						const PRectangle rcImage = PRectangle::FromInts(0, 0, images.GetWidth(), rcItem.bottom - rcItem.top);
 						surfaceItem->DrawRGBAImage(rcImage,
 							pimage->GetWidth(), pimage->GetHeight(), pimage->Pixels());
 						pDCRT->EndDraw();
-						ReleaseUnknown(pDCRT);
 					}
 				}
 #endif
@@ -3604,9 +3640,9 @@ void ListBoxX::AdjustWindowRect(PRectangle *rc, UINT dpiAdjust) const noexcept {
 	*rc = PRectangle::FromInts(rcw.left, rcw.top, rcw.right, rcw.bottom);
 }
 
-int ListBoxX::ItemHeight() const {
-	int itemHeight = lineHeight + (static_cast<int>(TextInset.y) * 2);
-	const int pixHeight = images.GetHeight() + (static_cast<int>(ImageInset.y) * 2);
+int ListBoxX::ItemHeight() const noexcept {
+	int itemHeight = lineHeight + (TextInset.y * 2);
+	const int pixHeight = images.GetHeight() + (ImageInset.y * 2);
 	if (itemHeight < pixHeight) {
 		itemHeight = pixHeight;
 	}
@@ -3617,17 +3653,17 @@ int ListBoxX::MinClientWidth() const noexcept {
 	return 12 * (aveCharWidth+aveCharWidth/3);
 }
 
-POINT ListBoxX::MinTrackSize() const {
+POINT ListBoxX::MinTrackSize() const noexcept {
 	PRectangle rc = PRectangle::FromInts(0, 0, MinClientWidth(), ItemHeight());
 	AdjustWindowRect(&rc, dpi);
 	POINT ret = {static_cast<LONG>(rc.Width()), static_cast<LONG>(rc.Height())};
 	return ret;
 }
 
-POINT ListBoxX::MaxTrackSize() const {
+POINT ListBoxX::MaxTrackSize() const noexcept {
 	PRectangle rc = PRectangle::FromInts(0, 0,
-		std::max(static_cast<unsigned int>(MinClientWidth()),
-		maxCharWidth * maxItemCharacters + static_cast<int>(TextInset.x) * 2 +
+		std::max<int>(static_cast<unsigned int>(MinClientWidth()),
+		maxCharWidth * maxItemCharacters + TextInset.x * 2 +
 		 TextOffset() + SystemMetricsForDpi(SM_CXVSCROLL, dpi)),
 		ItemHeight() * lti.Count());
 	AdjustWindowRect(&rc, dpi);
@@ -3888,9 +3924,8 @@ LRESULT PASCAL ListBoxX::ControlWndProc(HWND hWnd, UINT iMessage, WPARAM wParam,
 		WNDPROC prevWndProc = reinterpret_cast<WNDPROC>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
 		if (prevWndProc) {
 			return ::CallWindowProc(prevWndProc, hWnd, iMessage, wParam, lParam);
-		} else {
-			return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
 		}
+		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
 	} catch (...) {
 	}
 	return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
@@ -3909,7 +3944,7 @@ LRESULT ListBoxX::WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam
 				0, 0, 150,80, hWnd,
 				reinterpret_cast<HMENU>(static_cast<ptrdiff_t>(ctrlID)),
 				hinstanceParent,
-				0);
+				nullptr);
 			WNDPROC prevWndProc = SubclassWindow(lb, ControlWndProc);
 			::SetWindowLongPtr(lb, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(prevWndProc));
 		}
@@ -3918,7 +3953,7 @@ LRESULT ListBoxX::WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam
 	case WM_SIZE:
 		if (lb) {
 			SetRedraw(false);
-			::SetWindowPos(lb, 0, 0,0, LOWORD(lParam), HIWORD(lParam), SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOMOVE);
+			::SetWindowPos(lb, {}, 0, 0, LOWORD(lParam), HIWORD(lParam), SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE);
 			// Ensure the selection remains visible
 			CentreItem(GetSelection());
 			SetRedraw(true);
@@ -3949,7 +3984,7 @@ LRESULT ListBoxX::WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam
 		break;
 
 	case WM_DESTROY:
-		lb = 0;
+		lb = {};
 		SetWindowPointer(hWnd, nullptr);
 		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
 
@@ -3980,9 +4015,8 @@ LRESULT ListBoxX::WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam
 	case WM_MOUSEMOVE: {
 			if (resizeHit == 0) {
 				return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
-			} else {
-				ResizeToCursor();
 			}
+			ResizeToCursor();
 		}
 		break;
 
@@ -4023,9 +4057,8 @@ LRESULT PASCAL ListBoxX::StaticWndProc(
 	ListBoxX *lbx = static_cast<ListBoxX *>(PointerFromWindow(hWnd));
 	if (lbx) {
 		return lbx->WndProc(hWnd, iMessage, wParam, lParam);
-	} else {
-		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
 	}
+	return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
 }
 
 namespace {
@@ -4040,7 +4073,7 @@ bool ListBoxX_Register() noexcept {
 	wndclassc.cbWndExtra = sizeof(ListBoxX *);
 	wndclassc.hInstance = hinstPlatformRes;
 	wndclassc.lpfnWndProc = ListBoxX::StaticWndProc;
-	wndclassc.hCursor = ::LoadCursor(NULL, IDC_ARROW);
+	wndclassc.hCursor = ::LoadCursor({}, IDC_ARROW);
 	wndclassc.lpszClassName = ListBoxX_ClassName;
 
 	return ::RegisterClassEx(&wndclassc) != 0;
@@ -4065,7 +4098,7 @@ void Menu::CreatePopUp() {
 void Menu::Destroy() noexcept {
 	if (mid)
 		::DestroyMenu(static_cast<HMENU>(mid));
-	mid = 0;
+	mid = {};
 }
 
 void Menu::Show(Point pt, const Window &w) {
@@ -4127,7 +4160,7 @@ void Platform::Assert(const char *c, const char *file, int line) noexcept {
 	char buffer[2000] {};
 	snprintf(buffer, std::size(buffer), "Assertion [%s] failed at %s %d%s", c, file, line, assertionPopUps ? "" : "\r\n");
 	if (assertionPopUps) {
-		const int idButton = ::MessageBoxA(0, buffer, "Assertion failure",
+		const int idButton = ::MessageBoxA({}, buffer, "Assertion failure",
 			MB_ABORTRETRYIGNORE|MB_ICONHAND|MB_SETFOREGROUND|MB_TASKMODAL);
 		if (idButton == IDRETRY) {
 			::DebugBreak();
@@ -4149,24 +4182,27 @@ void Platform_Initialise(void *hInstance) noexcept {
 	ListBoxX_Register();
 }
 
+namespace {
+
+void ReleaseLibrary(HMODULE &hLib) noexcept {
+	if (hLib) {
+		FreeLibrary(hLib);
+		hLib = {};
+	}
+}
+
+}
+
 void Platform_Finalise(bool fromDllMain) noexcept {
-#if defined(USE_D2D)
 	if (!fromDllMain) {
+#if defined(USE_D2D)
 		ReleaseUnknown(pIDWriteFactory);
 		ReleaseUnknown(pD2DFactory);
-		if (hDLLDWrite) {
-			FreeLibrary(hDLLDWrite);
-			hDLLDWrite = {};
-		}
-		if (hDLLD2D) {
-			FreeLibrary(hDLLD2D);
-			hDLLD2D = {};
-		}
-	}
+		ReleaseLibrary(hDLLDWrite);
+		ReleaseLibrary(hDLLD3D);
+		ReleaseLibrary(hDLLD2D);
 #endif
-	if (!fromDllMain && hDLLShcore) {
-		FreeLibrary(hDLLShcore);
-		hDLLShcore = {};
+		ReleaseLibrary(hDLLShcore);
 	}
 	ListBoxX_Unregister();
 }
diff --git a/scintilla/win32/PlatWin.h b/scintilla/win32/PlatWin.h
index ab455c25d..322c47b34 100644
--- a/scintilla/win32/PlatWin.h
+++ b/scintilla/win32/PlatWin.h
@@ -32,6 +32,10 @@ constexpr Point PointFromPOINT(POINT pt) noexcept {
 	return Point::FromInts(pt.x, pt.y);
 }
 
+constexpr SIZE SizeOfRect(RECT rc) noexcept {
+	return { rc.right - rc.left, rc.bottom - rc.top };
+}
+
 constexpr HWND HwndFromWindowID(WindowID wid) noexcept {
 	return static_cast<HWND>(wid);
 }
@@ -68,12 +72,21 @@ public:
 
 #if defined(USE_D2D)
 extern bool LoadD2D() noexcept;
-extern ID2D1Factory *pD2DFactory;
-extern IDWriteFactory *pIDWriteFactory;
+extern ID2D1Factory1 *pD2DFactory;
+extern IDWriteFactory1 *pIDWriteFactory;
+
+using DCRenderTarget = ComPtr<ID2D1DCRenderTarget>;
+
+using D3D11Device = ComPtr<ID3D11Device1>;
+
+HRESULT CreateDCRenderTarget(const D2D1_RENDER_TARGET_PROPERTIES *renderTargetProperties, DCRenderTarget &dcRT) noexcept;
+extern HRESULT CreateD3D(D3D11Device &device) noexcept;
+
+using WriteRenderingParams = ComPtr<IDWriteRenderingParams1>;
 
 struct RenderingParams {
-	std::unique_ptr<IDWriteRenderingParams, UnknownReleaser> defaultRenderingParams;
-	std::unique_ptr<IDWriteRenderingParams, UnknownReleaser> customRenderingParams;
+	WriteRenderingParams defaultRenderingParams;
+	WriteRenderingParams customRenderingParams;
 };
 
 struct ISetRenderingParams {
diff --git a/scintilla/win32/ScintRes.rc b/scintilla/win32/ScintRes.rc
index f5cf8889a..2de2f62f4 100644
--- a/scintilla/win32/ScintRes.rc
+++ b/scintilla/win32/ScintRes.rc
@@ -4,8 +4,8 @@
 
 #include <windows.h>
 
-#define VERSION_SCINTILLA "5.5.4"
-#define VERSION_WORDS 5, 5, 4, 0
+#define VERSION_SCINTILLA "5.5.5"
+#define VERSION_WORDS 5, 5, 5, 0
 
 VS_VERSION_INFO VERSIONINFO
 FILEVERSION	VERSION_WORDS
diff --git a/scintilla/win32/ScintillaWin.cxx b/scintilla/win32/ScintillaWin.cxx
index 4bc8d8b6d..31ff74f9c 100644
--- a/scintilla/win32/ScintillaWin.cxx
+++ b/scintilla/win32/ScintillaWin.cxx
@@ -43,13 +43,17 @@
 #include <zmouse.h>
 #include <ole2.h>
 
+#include <wrl.h>
+using Microsoft::WRL::ComPtr;
+
 #if !defined(DISABLE_D2D)
 #define USE_D2D 1
 #endif
 
 #if defined(USE_D2D)
-#include <d2d1.h>
-#include <dwrite.h>
+#include <d2d1_1.h>
+#include <d3d11_1.h>
+#include <dwrite_1.h>
 #endif
 
 #include "ScintillaTypes.h"
@@ -131,6 +135,11 @@
 #define MK_ALT 32
 #endif
 
+// __uuidof is a Microsoft extension but makes COM code neater, so disable warning
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wlanguage-extension-token"
+#endif
+
 namespace {
 
 // Two idle messages SC_WIN_IDLE and SC_WORK_IDLE.
@@ -372,10 +381,96 @@ CLIPFORMAT RegisterClipboardType(LPCWSTR lpszFormat) noexcept {
 	return ::RegisterClipboardFormatW(lpszFormat) & 0xFFFF;
 }
 
+RECT GetClientRect(HWND hwnd) noexcept {
+	RECT rect{};
+	::GetClientRect(hwnd, &rect);
+	return rect;
+}
+
+#if defined(USE_D2D)
+
+D2D1_SIZE_U GetSizeUFromRect(const RECT &rc, const int scaleFactor) noexcept {
+	const SIZE size = SizeOfRect(rc);
+	const UINT32 scaledWidth = size.cx * scaleFactor;
+	const UINT32 scaledHeight = size.cy * scaleFactor;
+	return D2D1::SizeU(scaledWidth, scaledHeight);
+}
+
+#endif
+
 }
 
 namespace Scintilla::Internal {
 
+#if defined(USE_D2D)
+
+using HwndRenderTarget = ComPtr<ID2D1HwndRenderTarget>;
+
+// There may be either a Hwnd or DC render target
+struct RenderTargets {
+	HwndRenderTarget pHwndRT;
+	DCRenderTarget pDCRT;
+	ComPtr<ID2D1DeviceContext> pDeviceContext;
+	bool valid = true;
+	[[nodiscard]] ID2D1RenderTarget *RenderTarget() const noexcept {
+		if (pHwndRT)
+			return pHwndRT.Get();
+		if (pDCRT)
+			return pDCRT.Get();
+		if (pDeviceContext)
+			return pDeviceContext.Get();
+		return nullptr;
+	}
+	void Release() noexcept {
+		pHwndRT = nullptr;
+		pDCRT = nullptr;
+		pDeviceContext = nullptr;
+	}
+};
+
+// These resources are device-dependent but not window-dependent
+struct DirectDevice {
+	D3D11Device pDirect3DDevice;
+	ComPtr<ID2D1Device> pDirect2DDevice;
+	ComPtr<IDXGIDevice> pDXGIDevice;
+
+	void Release() noexcept;
+	HRESULT CreateDevice() noexcept;
+};
+
+void DirectDevice::Release() noexcept {
+	pDirect3DDevice = nullptr;
+	pDirect2DDevice = nullptr;
+	pDXGIDevice = nullptr;
+}
+
+HRESULT DirectDevice::CreateDevice() noexcept {
+	if (pDirect2DDevice) {	// Must be released before creation
+		return E_FAIL;
+	}
+
+	HRESULT hr = CreateD3D(pDirect3DDevice);
+	if (FAILED(hr)) {
+		return hr;
+	}
+
+	hr = pDirect3DDevice.As(&pDXGIDevice);
+	if (FAILED(hr)) {
+		Platform::DebugPrintf("Failed to create DXGI device 0x%lx\n", hr);
+		return hr;
+	}
+
+	hr = pD2DFactory->CreateDevice(pDXGIDevice.Get(), pDirect2DDevice.ReleaseAndGetAddressOf());
+	if (FAILED(hr)) {
+		Platform::DebugPrintf("Failed to create D2D device 0x%lx\n", hr);
+		return hr;
+	}
+
+	return S_OK;
+}
+
+#endif
+
 /**
  */
 class ScintillaWin :
@@ -423,8 +518,9 @@ class ScintillaWin :
 	}
 
 #if defined(USE_D2D)
-	ID2D1RenderTarget *pRenderTarget;
-	bool renderTargetValid;
+	DirectDevice device;
+	ComPtr<IDXGISwapChain1> pDXGISwapChain;
+	RenderTargets targets;
 	// rendering parameters for current monitor
 	HMONITOR hCurrentMonitor;
 	std::shared_ptr<RenderingParams> renderingParams;
@@ -441,6 +537,10 @@ class ScintillaWin :
 	void Finalise() override;
 #if defined(USE_D2D)
 	bool UpdateRenderingParams(bool force) noexcept;
+	HRESULT Create3D() noexcept;
+	void CreateRenderTarget();
+	HRESULT SetBackBuffer(HWND hwnd, IDXGISwapChain1 *pSwapChain);
+	HRESULT CreateSwapChain(HWND hwnd);
 	void EnsureRenderTarget(HDC hdc);
 #endif
 	void DropRenderTarget() noexcept;
@@ -646,8 +746,6 @@ ScintillaWin::ScintillaWin(HWND hwnd) {
 	styleIdleInQueue = false;
 
 #if defined(USE_D2D)
-	pRenderTarget = nullptr;
-	renderTargetValid = true;
 	hCurrentMonitor = {};
 #endif
 
@@ -693,6 +791,15 @@ void ScintillaWin::Finalise() {
 
 #if defined(USE_D2D)
 
+namespace {
+
+HRESULT CreateHwndRenderTarget(const D2D1_RENDER_TARGET_PROPERTIES *renderTargetProperties,
+	const D2D1_HWND_RENDER_TARGET_PROPERTIES *hwndRenderTargetProperties, HwndRenderTarget &hwndRT) noexcept {
+	return pD2DFactory->CreateHwndRenderTarget(renderTargetProperties, hwndRenderTargetProperties, hwndRT.ReleaseAndGetAddressOf());
+}
+
+}
+
 bool ScintillaWin::UpdateRenderingParams(bool force) noexcept {
 	if (!renderingParams) {
 		try {
@@ -707,104 +814,202 @@ bool ScintillaWin::UpdateRenderingParams(bool force) noexcept {
 		return false;
 	}
 
-	IDWriteRenderingParams *monitorRenderingParams = nullptr;
-	IDWriteRenderingParams *customClearTypeRenderingParams = nullptr;
-	const HRESULT hr = pIDWriteFactory->CreateMonitorRenderingParams(monitor, &monitorRenderingParams);
+	ComPtr<IDWriteRenderingParams> upMrp;
+	HRESULT hr = pIDWriteFactory->CreateMonitorRenderingParams(monitor, upMrp.GetAddressOf());
+	if (FAILED(hr)) {
+		return false;
+	}
+
+	// Cast to IDWriteRenderingParams1 so can call GetGrayscaleEnhancedContrast
+	WriteRenderingParams monitorRenderingParams{};
+	hr = upMrp.As(&monitorRenderingParams);
+
+	WriteRenderingParams customClearTypeRenderingParams;
 	UINT clearTypeContrast = 0;
-	if (SUCCEEDED(hr) && ::SystemParametersInfo(SPI_GETFONTSMOOTHINGCONTRAST, 0, &clearTypeContrast, 0) != 0) {
+	if (SUCCEEDED(hr) && monitorRenderingParams &&
+		::SystemParametersInfo(SPI_GETFONTSMOOTHINGCONTRAST, 0, &clearTypeContrast, 0) != 0) {
 		if (clearTypeContrast >= 1000 && clearTypeContrast <= 2200) {
 			const FLOAT gamma = static_cast<FLOAT>(clearTypeContrast) / 1000.0f;
 			pIDWriteFactory->CreateCustomRenderingParams(gamma,
 				monitorRenderingParams->GetEnhancedContrast(),
+				monitorRenderingParams->GetGrayscaleEnhancedContrast(),
 				monitorRenderingParams->GetClearTypeLevel(),
 				monitorRenderingParams->GetPixelGeometry(),
 				monitorRenderingParams->GetRenderingMode(),
-				&customClearTypeRenderingParams);
+				customClearTypeRenderingParams.GetAddressOf());
 		}
 	}
 
 	hCurrentMonitor = monitor;
 	deviceScaleFactor = Internal::GetDeviceScaleFactorWhenGdiScalingActive(hRootWnd);
-	renderingParams->defaultRenderingParams.reset(monitorRenderingParams);
-	renderingParams->customRenderingParams.reset(customClearTypeRenderingParams);
+	renderingParams->defaultRenderingParams = std::move(monitorRenderingParams);
+	renderingParams->customRenderingParams = std::move(customClearTypeRenderingParams);
 	return true;
 }
 
-namespace {
-
-D2D1_SIZE_U GetSizeUFromRect(const RECT &rc, const int scaleFactor) noexcept {
-	const long width = rc.right - rc.left;
-	const long height = rc.bottom - rc.top;
-	const UINT32 scaledWidth = width * scaleFactor;
-	const UINT32 scaledHeight = height * scaleFactor;
-	return D2D1::SizeU(scaledWidth, scaledHeight);
+HRESULT ScintillaWin::Create3D() noexcept {
+	if (device.pDirect2DDevice) {
+		return S_OK;
+	}
+	targets.Release();
+	pDXGISwapChain = nullptr;
+	device.Release();
+	const HRESULT hr = device.CreateDevice();
+	if (FAILED(hr)) {
+		device.Release();
+	}
+	return hr;
 }
 
+void ScintillaWin::CreateRenderTarget() {
+	HWND hw = MainHWND();
+	const RECT rc = GetClientRect(hw);
+
+	// Create a Direct2D render target.
+	D2D1_RENDER_TARGET_PROPERTIES drtp{};
+	drtp.type = D2D1_RENDER_TARGET_TYPE_DEFAULT;
+	drtp.usage = D2D1_RENDER_TARGET_USAGE_NONE;
+	drtp.minLevel = D2D1_FEATURE_LEVEL_DEFAULT;
+
+	if (technology == Technology::DirectWriteDC) {
+		drtp.dpiX = 96.f;
+		drtp.dpiY = 96.f;
+		// Explicit pixel format needed.
+		drtp.pixelFormat = D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM,
+			D2D1_ALPHA_MODE_IGNORE);
+
+		const HRESULT hr = CreateDCRenderTarget(&drtp, targets.pDCRT);
+		if (FAILED(hr)) {
+			Platform::DebugPrintf("Failed CreateDCRenderTarget 0x%lx\n", hr);
+			targets.Release();
+		}
+
+	} else if (technology == Technology::DirectWrite1) {
+		HRESULT hr = Create3D();	// Need pDirect2DDevice
+		if (SUCCEEDED(hr)) {
+			hr = device.pDirect2DDevice->CreateDeviceContext(D2D1_DEVICE_CONTEXT_OPTIONS_NONE,
+				targets.pDeviceContext.ReleaseAndGetAddressOf());
+			if (FAILED(hr)) {
+				Platform::DebugPrintf("Failed CreateDeviceContext 0x%lx\n", hr);
+			} else {
+				hr = CreateSwapChain(hw);
+				if (FAILED(hr)) {
+					Platform::DebugPrintf("Failed CreateSwapChain 0x%lx\n", hr);
+					targets.Release();
+				}
+			}
+		}
+
+	} else { // DirectWrite or DirectWriteRetain
+		const int integralDeviceScaleFactor = GetFirstIntegralMultipleDeviceScaleFactor();
+		drtp.dpiX = 96.f * integralDeviceScaleFactor;
+		drtp.dpiY = 96.f * integralDeviceScaleFactor;
+		drtp.pixelFormat = D2D1::PixelFormat(DXGI_FORMAT_UNKNOWN,
+			D2D1_ALPHA_MODE_UNKNOWN);
+
+		D2D1_HWND_RENDER_TARGET_PROPERTIES dhrtp{};
+		dhrtp.hwnd = hw;
+		dhrtp.pixelSize = ::GetSizeUFromRect(rc, integralDeviceScaleFactor);
+		dhrtp.presentOptions = (technology == Technology::DirectWriteRetain) ?
+			D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS : D2D1_PRESENT_OPTIONS_NONE;
+
+		const HRESULT hr = CreateHwndRenderTarget(&drtp, &dhrtp, targets.pHwndRT);
+		if (FAILED(hr)) {
+			Platform::DebugPrintf("Failed CreateHwndRenderTarget 0x%lx\n", hr);
+			targets.Release();
+		}
+
+	}
+}
+
+HRESULT ScintillaWin::SetBackBuffer(HWND hwnd, IDXGISwapChain1 *pSwapChain) {
+	assert(targets.pDeviceContext);
+	// Back buffer as an IDXGISurface
+	ComPtr<IDXGISurface> dxgiBackBuffer;
+	HRESULT hr = pSwapChain->GetBuffer(0, IID_PPV_ARGS(dxgiBackBuffer.GetAddressOf()));
+	if (FAILED(hr))
+		return hr;
+
+	const FLOAT dpiX = static_cast<FLOAT>(DpiForWindow(hwnd));
+	const FLOAT dpiY = dpiX;
+
+	// Direct2D bitmap linked to Direct3D texture through DXGI back buffer
+	const D2D1_BITMAP_PROPERTIES1 bitmapProperties =
+		D2D1::BitmapProperties1(D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW,
+			D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE), dpiX, dpiY);
+	ComPtr<ID2D1Bitmap1> pDirect2DBackBuffer;
+	hr = targets.pDeviceContext->CreateBitmapFromDxgiSurface(dxgiBackBuffer.Get(), &bitmapProperties, pDirect2DBackBuffer.GetAddressOf());
+	if (FAILED(hr))
+		return hr;
+
+	// Bitmap is render target
+	targets.pDeviceContext->SetTarget(pDirect2DBackBuffer.Get());
+
+	return S_OK;
+}
+
+HRESULT ScintillaWin::CreateSwapChain(HWND hwnd) {
+	// Sets pDXGISwapChain but only when each call succeeds
+	// Needs pDXGIDevice, pDirect3DDevice
+	pDXGISwapChain = nullptr;
+	assert(device.pDXGIDevice);
+
+	// At each stage, place object in a unique_ptr to ensure release occurs
+
+	ComPtr<IDXGIAdapter> dxgiAdapter;
+	HRESULT hr = device.pDXGIDevice->GetAdapter(dxgiAdapter.GetAddressOf());
+	if (FAILED(hr))
+		return hr;
+
+	ComPtr<IDXGIFactory2> dxgiFactory;
+	hr = dxgiAdapter->GetParent(IID_PPV_ARGS(dxgiFactory.GetAddressOf()));
+	if (FAILED(hr))
+		return hr;
+
+	DXGI_SWAP_CHAIN_DESC1 swapChainDesc{};
+	swapChainDesc.Width = 0;
+	swapChainDesc.Height = 0;
+	swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+	swapChainDesc.Stereo = false;
+	swapChainDesc.SampleDesc.Count = 1;
+	swapChainDesc.SampleDesc.Quality = 0;
+	swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+	swapChainDesc.BufferCount = 2;
+	swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
+	swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
+	swapChainDesc.Flags = 0;
+
+	// DXGI swap chain for window
+	ComPtr<IDXGISwapChain1> pSwapChain;
+	hr = dxgiFactory->CreateSwapChainForHwnd(device.pDirect3DDevice.Get(), hwnd, &swapChainDesc,
+		nullptr, nullptr, pSwapChain.GetAddressOf());
+	if (FAILED(hr))
+		return hr;
+
+	hr = SetBackBuffer(hwnd, pSwapChain.Get());
+	if (FAILED(hr))
+		return hr;
+
+	// All successful so export swap chain for later presentation 
+	pDXGISwapChain = std::move(pSwapChain);
+	return S_OK;
 }
 
 void ScintillaWin::EnsureRenderTarget(HDC hdc) {
-	if (!renderTargetValid) {
+	if (!targets.valid) {
 		DropRenderTarget();
-		renderTargetValid = true;
+		targets.valid = true;
 	}
-	if (!pRenderTarget) {
-		HWND hw = MainHWND();
-		RECT rc;
-		::GetClientRect(hw, &rc);
-
-		// Create a Direct2D render target.
-		D2D1_RENDER_TARGET_PROPERTIES drtp {};
-		drtp.type = D2D1_RENDER_TARGET_TYPE_DEFAULT;
-		drtp.usage = D2D1_RENDER_TARGET_USAGE_NONE;
-		drtp.minLevel = D2D1_FEATURE_LEVEL_DEFAULT;
-
-		if (technology == Technology::DirectWriteDC) {
-			drtp.dpiX = 96.f;
-			drtp.dpiY = 96.f;
-			// Explicit pixel format needed.
-			drtp.pixelFormat = D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM,
-				D2D1_ALPHA_MODE_IGNORE);
-
-			ID2D1DCRenderTarget *pDCRT = nullptr;
-			const HRESULT hr = pD2DFactory->CreateDCRenderTarget(&drtp, &pDCRT);
-			if (SUCCEEDED(hr)) {
-				pRenderTarget = pDCRT;
-			} else {
-				Platform::DebugPrintf("Failed CreateDCRenderTarget 0x%lx\n", hr);
-				pRenderTarget = nullptr;
-			}
-
-		} else {
-			const int integralDeviceScaleFactor = GetFirstIntegralMultipleDeviceScaleFactor();
-			drtp.dpiX = 96.f * integralDeviceScaleFactor;
-			drtp.dpiY = 96.f * integralDeviceScaleFactor;
-			drtp.pixelFormat = D2D1::PixelFormat(DXGI_FORMAT_UNKNOWN,
-				D2D1_ALPHA_MODE_UNKNOWN);
-
-			D2D1_HWND_RENDER_TARGET_PROPERTIES dhrtp {};
-			dhrtp.hwnd = hw;
-			dhrtp.pixelSize = ::GetSizeUFromRect(rc, integralDeviceScaleFactor);
-			dhrtp.presentOptions = (technology == Technology::DirectWriteRetain) ?
-			D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS : D2D1_PRESENT_OPTIONS_NONE;
-
-			ID2D1HwndRenderTarget *pHwndRenderTarget = nullptr;
-			const HRESULT hr = pD2DFactory->CreateHwndRenderTarget(drtp, dhrtp, &pHwndRenderTarget);
-			if (SUCCEEDED(hr)) {
-				pRenderTarget = pHwndRenderTarget;
-			} else {
-				Platform::DebugPrintf("Failed CreateHwndRenderTarget 0x%lx\n", hr);
-				pRenderTarget = nullptr;
-			}
-		}
+	if (!targets.RenderTarget()) {
+		CreateRenderTarget();
 		// Pixmaps were created to be compatible with previous render target so
 		// need to be recreated.
 		DropGraphics();
 	}
 
-	if ((technology == Technology::DirectWriteDC) && pRenderTarget) {
-		RECT rcWindow;
-		::GetClientRect(MainHWND(), &rcWindow);
-		const HRESULT hr = static_cast<ID2D1DCRenderTarget*>(pRenderTarget)->BindDC(hdc, &rcWindow);
+	if ((technology == Technology::DirectWriteDC) && targets.pDCRT) {	// DC RenderTarget needs binding
+		const RECT rcWindow = GetClientRect(MainHWND());
+		const HRESULT hr = targets.pDCRT->BindDC(hdc, &rcWindow);
 		if (FAILED(hr)) {
 			Platform::DebugPrintf("BindDC failed 0x%lx\n", hr);
 			DropRenderTarget();
@@ -815,7 +1020,7 @@ void ScintillaWin::EnsureRenderTarget(HDC hdc) {
 
 void ScintillaWin::DropRenderTarget() noexcept {
 #if defined(USE_D2D)
-	ReleaseUnknown(pRenderTarget);
+	targets.Release();
 #endif
 }
 
@@ -1059,8 +1264,13 @@ bool ScintillaWin::PaintDC(HDC hdc) {
 		}
 	} else {
 #if defined(USE_D2D)
+		// RefreshStyleData may set scroll bars and resize the window.
+		// Avoid issues resizing inside Paint when calling IDXGISwapChain1->ResizeBuffers
+		// with committed resources by refreshing the style data first.
+		RefreshStyleData();
+
 		EnsureRenderTarget(hdc);
-		if (pRenderTarget) {
+		if (ID2D1RenderTarget *pRenderTarget = targets.RenderTarget()) {
 			AutoSurface surfaceWindow(pRenderTarget, this);
 			if (surfaceWindow) {
 				SetRenderingParams(surfaceWindow);
@@ -1072,6 +1282,14 @@ bool ScintillaWin::PaintDC(HDC hdc) {
 					DropRenderTarget();
 					return false;
 				}
+				if ((technology == Technology::DirectWrite1) && pDXGISwapChain) {
+					const DXGI_PRESENT_PARAMETERS parameters{};
+					const HRESULT hrPresent = pDXGISwapChain->Present1(1, 0, &parameters);
+					if (FAILED(hrPresent)) {
+						DropRenderTarget();
+						return false;
+					}
+				}
 			}
 		}
 #endif
@@ -1590,15 +1808,37 @@ PRectangle ScintillaWin::GetClientRectangle() const {
 }
 
 void ScintillaWin::SizeWindow() {
+	rectangleClient = wMain.GetClientPosition();
 #if defined(USE_D2D)
-	if (paintState == PaintState::notPainting) {
-		DropRenderTarget();
-	} else {
-		renderTargetValid = false;
+	HRESULT hrResize = E_FAIL;
+	if (((technology == Technology::DirectWrite) || (technology == Technology::DirectWriteRetain)) && targets.pHwndRT) {
+		// May be able to just resize the HWND render target
+		const int scaleFactor = GetFirstIntegralMultipleDeviceScaleFactor();
+		const D2D1_SIZE_U pixelSize = ::GetSizeUFromRect(GetClientRect(MainHWND()), scaleFactor);
+		hrResize = targets.pHwndRT->Resize(pixelSize);
+		if (FAILED(hrResize)) {
+			Platform::DebugPrintf("Failed to Resize ID2D1HwndRenderTarget 0x%lx\n", hrResize);
+		}
+	}
+	if ((technology == Technology::DirectWrite1) && pDXGISwapChain && targets.pDeviceContext &&
+		(paintState == PaintState::notPainting)) {
+		targets.pDeviceContext->SetTarget(NULL);	// ResizeBuffers fails if bitmap still owned by swap chain
+		hrResize = pDXGISwapChain->ResizeBuffers(0, 0, 0, DXGI_FORMAT_UNKNOWN, 0);
+		if (SUCCEEDED(hrResize)) {
+			hrResize = SetBackBuffer(MainHWND(), pDXGISwapChain.Get());
+		} else {
+			Platform::DebugPrintf("Failed ResizeBuffers 0x%lx\n", hrResize);
+		}
+	}
+	if (FAILED(hrResize)) {
+		if (paintState == PaintState::notPainting) {
+			DropRenderTarget();
+		} else {
+			targets.valid = false;
+		}
 	}
 #endif
 	//Platform::DebugPrintf("Scintilla WM_SIZE %d %d\n", LOWORD(lParam), HIWORD(lParam));
-	rectangleClient = wMain.GetClientPosition();
 	ChangeSize();
 }
 
@@ -2033,7 +2273,8 @@ sptr_t ScintillaWin::SciMessage(Message iMessage, uptr_t wParam, sptr_t lParam)
 			(technologyNew == Technology::Default) ||
 			(technologyNew == Technology::DirectWriteRetain) ||
 			(technologyNew == Technology::DirectWriteDC) ||
-			(technologyNew == Technology::DirectWrite)) {
+			(technologyNew == Technology::DirectWrite) ||
+			(technologyNew == Technology::DirectWrite1)) {
 			if (technology != technologyNew) {
 				if (technologyNew > Technology::Default) {
 #if defined(USE_D2D)
@@ -3751,10 +3992,9 @@ LRESULT PASCAL ScintillaWin::CTWndProc(
 				::BeginPaint(hWnd, &ps);
 				std::unique_ptr<Surface> surfaceWindow(Surface::Allocate(sciThis->technology));
 #if defined(USE_D2D)
-				ID2D1HwndRenderTarget *pCTRenderTarget = nullptr;
+				HwndRenderTarget pCTRenderTarget;
 #endif
-				RECT rc;
-				GetClientRect(hWnd, &rc);
+				const RECT rc = GetClientRect(hWnd);
 				if (sciThis->technology == Technology::Default) {
 					surfaceWindow->Init(ps.hdc, hWnd);
 				} else {
@@ -3777,7 +4017,8 @@ LRESULT PASCAL ScintillaWin::CTWndProc(
 					drtp.usage = D2D1_RENDER_TARGET_USAGE_NONE;
 					drtp.minLevel = D2D1_FEATURE_LEVEL_DEFAULT;
 
-					if (!SUCCEEDED(pD2DFactory->CreateHwndRenderTarget(drtp, dhrtp, &pCTRenderTarget))) {
+					const HRESULT hr = CreateHwndRenderTarget(&drtp, &dhrtp, pCTRenderTarget);
+					if (!SUCCEEDED(hr)) {
 						surfaceWindow->Release();
 						::EndPaint(hWnd, &ps);
 						return 0;
@@ -3785,7 +4026,7 @@ LRESULT PASCAL ScintillaWin::CTWndProc(
 					// If above SUCCEEDED, then pCTRenderTarget not nullptr
 					assert(pCTRenderTarget);
 					if (pCTRenderTarget) {
-						surfaceWindow->Init(pCTRenderTarget, hWnd);
+						surfaceWindow->Init(pCTRenderTarget.Get(), hWnd);
 						pCTRenderTarget->BeginDraw();
 					}
 #endif
@@ -3798,9 +4039,6 @@ LRESULT PASCAL ScintillaWin::CTWndProc(
 					pCTRenderTarget->EndDraw();
 #endif
 				surfaceWindow->Release();
-#if defined(USE_D2D)
-				ReleaseUnknown(pCTRenderTarget);
-#endif
 				::EndPaint(hWnd, &ps);
 				return 0;
 			} else if ((iMessage == WM_NCLBUTTONDOWN) || (iMessage == WM_NCLBUTTONDBLCLK)) {
diff --git a/scintilla/win32/WinTypes.h b/scintilla/win32/WinTypes.h
index 9badd70a8..c0d6c558d 100644
--- a/scintilla/win32/WinTypes.h
+++ b/scintilla/win32/WinTypes.h
@@ -38,7 +38,6 @@ struct UnknownReleaser {
 	}
 };
 
-
 /// Find a function in a DLL and convert to a function pointer.
 /// This avoids undefined and conditionally defined behaviour.
 template<typename T>