From ee3b9f190723670892d31dea9571bbff6820603f Mon Sep 17 00:00:00 2001
From: "METANEOCORTEX\\Kotti" <rainer.kottenhoff@gmail.com>
Date: Sat, 3 Oct 2026 14:11:51 +0200
Subject: [PATCH] +upd: Lexilla v5.5.4

---
 lexilla/cppcheck.suppress                     |   3 +-
 lexilla/doc/Lexilla.html                      |   8 +-
 lexilla/doc/LexillaDownload.html              |  10 +-
 lexilla/doc/LexillaHistory.html               |  29 ++
 lexilla/include/LexicalStyles.iface           |   4 +-
 lexilla/include/SciLexer.h                    |   4 +-
 lexilla/lexers/LexCPP.cxx                     |  47 ++-
 lexilla/lexers/LexHTML.cxx                    |  10 +-
 lexilla/lexers/LexMarkdown.cxx                | 350 ++++++++++++------
 lexilla/lexers/LexTCL.cxx                     |   2 +-
 lexilla/lexers/LexYAML.cxx                    |  35 +-
 lexilla/lexlib/LexerBase.h                    |   4 +
 lexilla/lexlib/LexerModule.h                  |  16 +-
 lexilla/lexlib/OptionSet.h                    |   4 +-
 lexilla/lexlib/SubStyles.h                    |  59 ++-
 lexilla/src/Lexilla/Info.plist                |   2 +-
 .../Lexilla/Lexilla.xcodeproj/project.pbxproj |   4 +-
 lexilla/src/LexillaVersion.rc                 |   4 +-
 lexilla/src/deps.mak                          |   4 +-
 lexilla/src/nmdeps.mak                        |   4 +-
 lexilla/version.txt                           |   2 +-
 src/StyleLexers/styleLexMARKDOWN.c            |   2 +-
 22 files changed, 401 insertions(+), 206 deletions(-)

diff --git a/lexilla/cppcheck.suppress b/lexilla/cppcheck.suppress
index 0b8df047bf..b5169f0ec9 100644
--- a/lexilla/cppcheck.suppress
+++ b/lexilla/cppcheck.suppress
@@ -104,6 +104,7 @@ knownConditionTrueFalse:lexilla/lexers/LexFSharp.cxx
 variableScope:lexilla/lexers/LexFSharp.cxx
 constParameterReference:lexilla/lexers/LexGAP.cxx
 constParameterReference:lexilla/lexers/LexGDScript.cxx
+knownConditionTrueFalse:lexilla/lexers/LexGDScript.cxx
 variableScope:lexilla/lexers/LexGui4Cli.cxx
 constParameterReference:lexilla/lexers/LexHaskell.cxx
 constParameterReference:lexilla/lexers/LexHex.cxx
@@ -148,13 +149,13 @@ constParameterReference:lexilla/lexers/LexPascal.cxx
 variableScope:lexilla/lexers/LexPB.cxx
 constParameterReference:lexilla/lexers/LexPerl.cxx
 constVariableReference:lexilla/lexers/LexPerl.cxx
-knownConditionTrueFalse:lexilla/lexers/LexPerl.cxx
 functionStatic:lexilla/lexers/LexPerl.cxx
 constParameterReference:lexilla/lexers/LexPLM.cxx
 constParameterReference:lexilla/lexers/LexPO.cxx
 variableScope:lexilla/lexers/LexPO.cxx
 constVariablePointer:lexilla/lexers/LexPOV.cxx
 constParameterReference:lexilla/lexers/LexPython.cxx
+knownConditionTrueFalse:lexilla/lexers/LexPython.cxx
 shadowVariable:lexilla/lexers/LexPowerPro.cxx
 knownConditionTrueFalse:lexilla/lexers/LexPowerPro.cxx
 variableScope:lexilla/lexers/LexProgress.cxx
diff --git a/lexilla/doc/Lexilla.html b/lexilla/doc/Lexilla.html
index 14520b42c4..335f75c786 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="20260812" />
+    <meta name="Date.Modified" content="20260928" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <style type="text/css">
         .logo {
@@ -62,8 +62,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.5.3<br />
-           Site last modified August 12 2026</font>
+          <font color="#FFCC99" size="3">Release version 5.5.4<br />
+           Site last modified September 28 2026</font>
         </td>
         <td width="20%">
           &nbsp;
@@ -78,11 +78,11 @@
       </tr>
     </table>
     <ul id="versionlist">
+      <li>Version 5.5.4 improves JavaScript and YAML</li>
       <li>Version 5.5.3 improves Progress ABL.</li>
       <li>Version 5.5.2 improves JavaScript.</li>
       <li>Version 5.5.1 improves Baan, HTML, and XML.</li>
       <li>Version 5.5.0 improves Fortran and LaTeX.</li>
-      <li>Version 5.4.9 improves Assembler, C++, F#, LaTeX, Pascal, and Ruby.</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 5cef3e608a..2b3ce628d9 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/lexilla553.zip">
+          <font size="4"> <a href="https://www.scintilla.org/lexilla554.zip">
 	Windows</a>&nbsp;&nbsp;
-	<a href="https://www.scintilla.org/lexilla553.tgz">
+	<a href="https://www.scintilla.org/lexilla554.tgz">
           GTK/Linux</a>&nbsp;&nbsp;
 	</font>
         </td>
@@ -42,7 +42,7 @@ <h2>
       containing very few restrictions.
     </p>
     <h3>
-       Release 5.5.3
+       Release 5.5.4
     </h3>
     <h4>
        Source Code
@@ -50,8 +50,8 @@ <h4>
        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/lexilla553.zip">zip format</a> (1.5M) commonly used on Windows</li>
-       <li><a href="https://www.scintilla.org/lexilla553.tgz">tgz format</a> (1.1M) commonly used on Linux and compatible operating systems</li>
+       <li><a href="https://www.scintilla.org/lexilla554.zip">zip format</a> (1.5M) commonly used on Windows</li>
+       <li><a href="https://www.scintilla.org/lexilla554.tgz">tgz format</a> (1.1M) 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 e9bce439d4..a47a9f7100 100644
--- a/lexilla/doc/LexillaHistory.html
+++ b/lexilla/doc/LexillaHistory.html
@@ -599,6 +599,35 @@ <h2>Contributors</h2>
     </tr>
     </table>
     <h2 id="Releases">Releases</h2>
+    <h3>
+       <a href="https://www.scintilla.org/lexilla555.zip">Release 5.5.5</a>
+    </h3>
+    <ul>
+	<li>
+	Released 28 September 2026.
+	</li>
+	<li>
+	Markdown: Recognize 'front matter' key-value metadata at file start specified in YAML, TOML or JSON.
+	<a href="https://github.com/ScintillaOrg/lexilla/issues/59">Issue #59</a>.
+	</li>
+    </ul>
+    <h3>
+       <a href="https://www.scintilla.org/lexilla554.zip">Release 5.5.4</a>
+    </h3>
+    <ul>
+	<li>
+	Released 28 September 2026.
+	</li>
+	<li>
+	JavaScript: Option lexer.cpp.continuation.only.in.strings to choose JavaScript behaviour where
+	line continuation only occurs inside string literals.
+	<a href="https://github.com/ScintillaOrg/lexilla/issues/55">Issue #55</a>.
+	</li>
+	<li>
+	YAML: Fix empty lines terminating text blocks.
+	<a href="https://github.com/ScintillaOrg/lexilla/issues/326">Issue #326</a>.
+	</li>
+    </ul>
     <h3>
        <a href="https://www.scintilla.org/lexilla553.zip">Release 5.5.3</a>
     </h3>
diff --git a/lexilla/include/LexicalStyles.iface b/lexilla/include/LexicalStyles.iface
index 06ff4cfcff..f0f3ee5ef0 100644
--- a/lexilla/include/LexicalStyles.iface
+++ b/lexilla/include/LexicalStyles.iface
@@ -1775,7 +1775,9 @@ val SCE_MARKDOWN_LINK=18
 val SCE_MARKDOWN_CODE=19
 val SCE_MARKDOWN_CODE2=20
 val SCE_MARKDOWN_CODEBK=21
-val SCE_MARKDOWN_HDRTEXT=22
+val SCE_MARKDOWN_FRONT_MARK=22
+val SCE_MARKDOWN_FRONT=23
+val SCE_MARKDOWN_FRONT_KEY=24
 # Lexical state for SCLEX_TXT2TAGS
 lex Txt2tags=SCLEX_TXT2TAGS SCE_TXT2TAGS_
 val SCE_TXT2TAGS_DEFAULT=0
diff --git a/lexilla/include/SciLexer.h b/lexilla/include/SciLexer.h
index e9e7e25170..145f3d30b9 100644
--- a/lexilla/include/SciLexer.h
+++ b/lexilla/include/SciLexer.h
@@ -1585,7 +1585,9 @@
 #define SCE_MARKDOWN_CODE 19
 #define SCE_MARKDOWN_CODE2 20
 #define SCE_MARKDOWN_CODEBK 21
-#define SCE_MARKDOWN_HDRTEXT 22
+#define SCE_MARKDOWN_FRONT_MARK 22
+#define SCE_MARKDOWN_FRONT 23
+#define SCE_MARKDOWN_FRONT_KEY 24
 #define SCE_TXT2TAGS_DEFAULT 0
 #define SCE_TXT2TAGS_LINE_BEGIN 1
 #define SCE_TXT2TAGS_STRONG1 2
diff --git a/lexilla/lexers/LexCPP.cxx b/lexilla/lexers/LexCPP.cxx
index 71d8a255a3..da4e6523aa 100644
--- a/lexilla/lexers/LexCPP.cxx
+++ b/lexilla/lexers/LexCPP.cxx
@@ -180,14 +180,16 @@ class EscapeSequence {
 		digitsLeft = 0;
 		outerState = state;
 		escapeSetValid = &setNoneNumeric;
+		constexpr int lengthU = 9;
+		constexpr int lengthxu = 5;
 		if (nextChar == 'U') {
-			digitsLeft = 9;
+			digitsLeft = lengthU;
 			escapeSetValid = &setHexDigits;
 		} else if (nextChar == 'u') {
-			digitsLeft = 5;
+			digitsLeft = lengthxu;
 			escapeSetValid = &setHexDigits;
 		} else if (nextChar == 'x') {
-			digitsLeft = 5;
+			digitsLeft = lengthxu;
 			escapeSetValid = &setHexDigits;
 		} else if (setOctDigits.Contains(nextChar)) {
 			digitsLeft = 3;
@@ -236,6 +238,10 @@ constexpr bool IsStreamCommentStyle(int style) noexcept {
 		style == SCE_C_COMMENTDOCKEYWORDERROR;
 }
 
+constexpr bool IsStringStyle(int style) noexcept {
+	return AnyOf(style, SCE_C_STRING, SCE_C_CHARACTER, SCE_C_STRINGRAW);
+}
+
 struct PPDefinition {
 	Sci_Position line;
 	std::string key;
@@ -407,6 +413,7 @@ struct OptionsCPP {
 	bool hashquotedStrings = false;
 	BackQuotedString backQuotedStrings = BackQuotedString::None;
 	bool escapeSequence = false;
+	bool continuationOnlyStrings = false;
 	bool fold = false;
 	bool foldSyntaxBased = true;
 	bool foldComment = false;
@@ -471,6 +478,9 @@ struct OptionSetCPP : public OptionSet<OptionsCPP> {
 		DefineProperty("lexer.cpp.escape.sequence", &OptionsCPP::escapeSequence,
 			"Set to 1 to enable highlighting of escape sequences in strings");
 
+		DefineProperty("lexer.cpp.continuation.only.in.strings", &OptionsCPP::continuationOnlyStrings,
+			"Set to 1 to only handle line continuation inside string literals");
+
 		DefineProperty("fold", &OptionsCPP::fold);
 
 		DefineProperty("fold.cpp.syntax.based", &OptionsCPP::foldSyntaxBased,
@@ -688,7 +698,7 @@ class LexerCPP : public ILexer5 {
 		const int firstSubStyle = subStyles.FirstAllocated();
 		if (firstSubStyle >= 0) {
 			const int lastSubStyle = subStyles.LastAllocated();
-			if (((style >= firstSubStyle) && (style <= (lastSubStyle))) ||
+			if (((style >= firstSubStyle) && (style <= lastSubStyle)) ||
 				((style >= firstSubStyle + inactiveFlag) && (style <= (lastSubStyle + inactiveFlag)))) {
 				int styleActive = style;
 				if (style > lastSubStyle) {
@@ -855,14 +865,17 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int i
 		}
 	}
 
-	if ((MaskActive(initStyle) == SCE_C_PREPROCESSOR) ||
-      (MaskActive(initStyle) == SCE_C_COMMENTLINE) ||
-      (MaskActive(initStyle) == SCE_C_COMMENTLINEDOC)) {
+	if (AnyOf(MaskActive(initStyle), SCE_C_PREPROCESSOR, SCE_C_COMMENTLINE, SCE_C_COMMENTLINEDOC)) {
 		// Set continuationLine if last character of previous line is '\'
 		if (lineCurrent > 0) {
-			const Sci_Position endLinePrevious = styler.LineEnd(lineCurrent - 1);
-			if (endLinePrevious > 0) {
-				continuationLine = styler.SafeGetCharAt(endLinePrevious-1) == '\\';
+			const Sci_Position lastOfLinePrevious = styler.LineEnd(lineCurrent - 1) - 1;
+			if (lastOfLinePrevious >= 0) {
+				if (styler.SafeGetCharAt(lastOfLinePrevious) == '\\') {
+					if (!options.continuationOnlyStrings ||
+						IsStringStyle(styler.StyleAt(lastOfLinePrevious))) {
+						continuationLine = true;
+					}
+				}
 			}
 		}
 	}
@@ -959,13 +972,16 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int i
 		}
 
 		// Handle line continuation generically.
-		if (sc.ch == '\\') {
-			if ((sc.currentPos+1) >= lineEndNext) {
+		if ((sc.ch == '\\') && ((sc.currentPos+1) >= lineEndNext)) {
+			if (!options.continuationOnlyStrings || IsStringStyle(sc.state)) {
+				// Handle line continuation when option disabled or inside string literals
+				// For C++, all \ at line end are continuations but,
+				// for JavaScript, \ is only a continuation inside string literals.
 				lineCurrent++;
 				lineEndNext = styler.LineEnd(lineCurrent);
 				vlls.Add(lineCurrent, preproc);
 				if (!rawStringTerminator.empty()) {
-					rawSTNew.Set(lineCurrent-1, rawStringTerminator);
+					rawSTNew.Set(lineCurrent - 1, rawStringTerminator);
 				}
 				sc.Forward();
 				if (sc.ch == '\r' && sc.chNext == '\n') {
@@ -1294,6 +1310,9 @@ void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int i
 					sc.SetState(styleBeforeTaskMarker|activitySet);
 					styleBeforeTaskMarker = SCE_C_DEFAULT;
 				}
+				break;
+			default:
+				break;
 		}
 
 		if (sc.atLineEnd && !atLineEndBeforeSwitch) {
@@ -1629,7 +1648,7 @@ void SCI_METHOD LexerCPP::Fold(Sci_PositionU startPos, Sci_Position length, int
 			lineStartNext = styler.LineStart(lineCurrent+1);
 			levelCurrent = levelNext;
 			levelMinCurrent = levelCurrent;
-			if (atEOL && (i == static_cast<Sci_PositionU>(styler.Length()-1))) {
+			if (atEOL && ((i+1) == static_cast<Sci_PositionU>(styler.Length()))) {
 				// There is an empty line at end of file so give it same level and empty
 				styler.SetLevel(lineCurrent, FoldLevelForCurrent(levelCurrent) | SC_FOLDLEVELWHITEFLAG);
 			}
diff --git a/lexilla/lexers/LexHTML.cxx b/lexilla/lexers/LexHTML.cxx
index 99778d93f8..b6fa8f80e7 100644
--- a/lexilla/lexers/LexHTML.cxx
+++ b/lexilla/lexers/LexHTML.cxx
@@ -746,10 +746,9 @@ Sci_Position FindPhpStringDelimiter(std::string &phpStringDelimiter, Sci_Positio
 				isQuoted = false;
 				j++;
 				break;
-			} else {
-				phpStringDelimiter.clear();
-				return beginning;
 			}
+			phpStringDelimiter.clear();
+			return beginning;
 		}
 		phpStringDelimiter.push_back(styler[j]);
 	}
@@ -1083,8 +1082,7 @@ class LexerHTML : public DefaultLexer {
 		osHTML(isPHPScript_),
 		nonFoldingTags(std::begin(tagsThatDoNotFold), std::end(tagsThatDoNotFold)) {
 	}
-	~LexerHTML() override {
-	}
+	~LexerHTML() override = default;
 	void SCI_METHOD Release() override {
 		delete this;
 	}
@@ -1787,7 +1785,7 @@ void SCI_METHOD LexerHTML::Lex(Sci_PositionU startPos, Sci_Position length, int
 
 		// handle the end of a pre-processor = Non-HTML
 		else if ((!isMako && !isDjango && ((inScriptType == eNonHtmlPreProc) || (inScriptType == eNonHtmlScriptPreProc)) &&
-				  (((scriptLanguage != eScriptNone) && stateAllowsTermination(state))) &&
+				  ((scriptLanguage != eScriptNone) && stateAllowsTermination(state)) &&
 				  ((chNext == '>') && isPreProcessorEndTag(state, ch))) ||
 		         ((scriptLanguage == eScriptSGML) && (ch == '>') && !AnyOf(state, SCE_H_SGML_COMMENT, SCE_H_SGML_DOUBLESTRING, SCE_H_SGML_SIMPLESTRING))) {
 			if (state == SCE_H_ASPAT) {
diff --git a/lexilla/lexers/LexMarkdown.cxx b/lexilla/lexers/LexMarkdown.cxx
index 8cbffec222..5af3e3de80 100644
--- a/lexilla/lexers/LexMarkdown.cxx
+++ b/lexilla/lexers/LexMarkdown.cxx
@@ -42,6 +42,7 @@
 
 #include <string>
 #include <string_view>
+#include <map>
 
 #include "ILexer.h"
 #include "Scintilla.h"
@@ -53,7 +54,10 @@
 #include "StyleContext.h"
 #include "CharacterSet.h"
 #include "LexerModule.h"
+#include "OptionSet.h"
+#include "DefaultLexer.h"
 
+using namespace Scintilla;
 using namespace Lexilla;
 
 namespace {
@@ -105,14 +109,15 @@ void SetStateAndZoom(const int state, const Sci_Position length, const int token
 // Does the previous line have more than spaces and tabs?
 bool HasPrevLineContent(StyleContext &sc) {
     Sci_Position i = 0;
+    const Sci_Position currentPos = sc.currentPos;
     // Go back to the previous newline
-    while ((--i + (Sci_Position)sc.currentPos) >= 0 && !IsNewline(sc.GetRelative(i)))
+    while ((--i + currentPos) >= 0 && !IsNewline(sc.GetRelative(i)))
         ;
-    while ((--i + (Sci_Position)sc.currentPos) >= 0) {
+    while ((--i + currentPos) >= 0) {
         const int ch = sc.GetRelative(i);
         if (ch == '\n')
             break;
-        if (!((ch == '\r' || IsASpaceOrTab(ch))))
+        if (!AnyOf(ch, '\r', ' ', '\t'))
             return true;
     }
     return false;
@@ -158,10 +163,10 @@ bool IsValidHrule(const Sci_PositionU endPos, StyleContext &sc) {
     for (;;) {
         ++i;
         const int c = sc.GetRelative(i);
-        if (c == sc.ch)
+        if (c == sc.ch) {
             ++count;
-        // hit a terminating character
-        else if (!IsASpaceOrTab(c) || sc.currentPos + i == endPos) {
+            // hit a terminating character
+        } else if (!IsASpaceOrTab(c) || sc.currentPos + i == endPos) {
             // Are we a valid HRULE
             if ((IsNewline(c) || sc.currentPos + i == endPos) &&
                     count >= 3 && !HasPrevLineContent(sc)) {
@@ -176,8 +181,110 @@ bool IsValidHrule(const Sci_PositionU endPos, StyleContext &sc) {
     }
 }
 
-void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
-                                WordList **, Accessor &styler) {
+enum class FrontMatter { None, YAML, TOML, JSON };
+
+constexpr std::string_view markYAML = "---";
+constexpr std::string_view markTOML = "+++";
+constexpr std::string_view markJSON = ";;;";
+
+constexpr FrontMatter FrontMatterFromString(std::string_view value) {
+    if (value == markYAML) {
+        return FrontMatter::YAML;
+    }
+    if (value == markTOML) {
+        return FrontMatter::TOML;
+    }
+    if (value == markJSON) {
+        return FrontMatter::JSON;
+    }
+    return FrontMatter::None;
+}
+
+FrontMatter DetectFrontMatter(const Accessor &styler) {
+    return FrontMatterFromString(styler.GetRange(0, 3));
+}
+
+constexpr std::string_view header5 = "#####";
+constexpr std::string_view header6 = "######";
+
+// Options used for LexerMarkdown
+struct OptionsMarkdown {
+    bool headerEOLFill = false;
+};
+
+struct OptionSetMarkdown : public OptionSet<OptionsMarkdown> {
+    OptionSetMarkdown() {
+        DefineProperty("lexer.markdown.header.eolfill", &OptionsMarkdown::headerEOLFill,
+            "Set to 1 to highlight all ATX header text.");
+    }
+};
+
+// Using "default" for tags as have not defined tags for text roles.
+
+const LexicalClass lexicalClasses[] = {
+    // Lexer markdown SCLEX_MARKDOWN SCE_MARKDOWN_
+    0, "SCE_MARKDOWN_DEFAULT", "default", "Regular text",
+    1, "SCE_MARKDOWN_LINE_BEGIN", "default", "Special",
+    2, "SCE_MARKDOWN_STRONG1", "default", "Strong emphasis (bold)",
+    3, "SCE_MARKDOWN_STRONG2", "default", "Strong emphasis (bold)",
+    4, "SCE_MARKDOWN_EM1", "default", "Emphasis (italic)",
+    5, "SCE_MARKDOWN_EM2", "default", "Emphasis (italic)",
+    6, "SCE_MARKDOWN_HEADER1", "default", "Level-one header",
+    7, "SCE_MARKDOWN_HEADER2", "default", "Level-two header",
+    8, "SCE_MARKDOWN_HEADER3", "default", "Level-three header",
+    9, "SCE_MARKDOWN_HEADER4", "default", "Level-four header",
+    10, "SCE_MARKDOWN_HEADER5", "default", "Level-five header",
+    11, "SCE_MARKDOWN_HEADER6", "default", "Level-six header",
+    12, "SCE_MARKDOWN_PRECHAR", "default", "Prechar (up to three indent spaces)",
+    13, "SCE_MARKDOWN_ULIST_ITEM", "default", "Unordered list item",
+    14, "SCE_MARKDOWN_OLIST_ITEM", "default", "Ordered list item",
+    15, "SCE_MARKDOWN_BLOCKQUOTE", "default", "Block quote",
+    16, "SCE_MARKDOWN_STRIKEOUT", "default", "Strikeout",
+    17, "SCE_MARKDOWN_HRULE", "default", "Horizontal rule",
+    18, "SCE_MARKDOWN_LINK", "default", "Link or image",
+    19, "SCE_MARKDOWN_CODE", "default", "Inline code",
+    20, "SCE_MARKDOWN_CODE2", "default", "Inline code (quotes code containing a single backtick)",
+    21, "SCE_MARKDOWN_CODEBK", "default", "Code block",
+    22, "SCE_MARKDOWN_FRONT_MARK", "default", "Front matter marker",
+    23, "SCE_MARKDOWN_FRONT", "default", "Front matter",
+    24, "SCE_MARKDOWN_FRONT_KEY", "default", "Front matter key",
+};
+
+class LexerMarkdown : public DefaultLexer {
+    OptionsMarkdown options;
+    OptionSetMarkdown osMarkdown;
+    FrontMatter frontMatter = FrontMatter::None;
+public:
+    LexerMarkdown() :
+        DefaultLexer("markdown", SCLEX_MARKDOWN, lexicalClasses, std::size(lexicalClasses)) {
+        SetOptionSet(&osMarkdown);
+    }
+    // Deleted so LexerMarkdown objects can not be copied.
+    LexerMarkdown(const LexerMarkdown &) = delete;
+    LexerMarkdown(LexerMarkdown &&) = delete;
+    void operator=(const LexerMarkdown &) = delete;
+    void operator=(LexerMarkdown &&) = delete;
+    ~LexerMarkdown() override = default;
+
+    Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+
+    void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override;
+
+    static ILexer5 *LexerFactoryMarkdown() {
+        return new LexerMarkdown();
+    }
+};
+
+Sci_Position SCI_METHOD LexerMarkdown::PropertySet(const char *key, const char *val) {
+    if (osMarkdown.PropertySet(&options, key, val)) {
+        return 0;
+    }
+    return -1;
+}
+
+void SCI_METHOD LexerMarkdown::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+    Accessor styler(pAccess, nullptr);
+
     const Sci_PositionU endPos = startPos + length;
     int precharCount = 0;
     bool isLinkNameDetecting = false;
@@ -186,12 +293,17 @@ void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int initSt
     // in the default state.
     bool freezeCursor = false;
 
-    // property lexer.markdown.header.eolfill
-    //  Set to 1 to highlight all ATX header text.
-    const bool headerEOLFill = styler.GetPropertyInt("lexer.markdown.header.eolfill", 0) == 1;
+    const bool headerEOLFill = options.headerEOLFill;
 
     StyleContext sc(startPos, static_cast<Sci_PositionU>(length), initStyle, styler);
 
+    if (startPos == 0) {
+        frontMatter = DetectFrontMatter(styler);
+        if (frontMatter != FrontMatter::None) {
+            sc.SetState(SCE_MARKDOWN_FRONT_MARK);
+        }
+    }
+
     while (sc.More()) {
         // Skip past escaped characters
         if (sc.ch == '\\') {
@@ -204,65 +316,97 @@ void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int initSt
             sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
 
         // Conditional state-based actions
-        if (sc.state == SCE_MARKDOWN_CODE2) {
+        switch (sc.state) {
+        case SCE_MARKDOWN_CODE2:
             if (sc.Match("``")) {
                 const int closingSpan = (sc.GetRelative(2) == '`') ? 3 : 2;
                 sc.Forward(closingSpan);
                 sc.SetState(SCE_MARKDOWN_DEFAULT);
             }
-        }
-        else if (sc.state == SCE_MARKDOWN_CODE) {
+            break;
+
+        case SCE_MARKDOWN_CODE:
             if (sc.ch == '`' && sc.chPrev != ' ')
                 sc.ForwardSetState(SCE_MARKDOWN_DEFAULT);
-        }
-        /* De-activated because it gets in the way of other valid indentation
-         * schemes, for example multiple paragraphs inside a list item.
-        // Code block
-        else if (sc.state == SCE_MARKDOWN_CODEBK) {
-            bool d = true;
-            if (IsNewline(sc.ch)) {
-                if (sc.chNext != '\t') {
-                    for (int c = 1; c < 5; ++c) {
-                        if (sc.GetRelative(c) != ' ')
-                            d = false;
-                    }
+            break;
+
+        case SCE_MARKDOWN_FRONT_MARK:
+            if (sc.atLineStart && (sc.currentLine > 0)) {
+                if (sc.currentLine > 1) {
+                    sc.SetState(SCE_MARKDOWN_DEFAULT);
+                } else if (sc.ch == '{') {
+                    sc.SetState(SCE_MARKDOWN_FRONT);
+                } else {
+                    sc.SetState(SCE_MARKDOWN_FRONT_KEY);
+                }
+            }
+            break;
+
+        case SCE_MARKDOWN_FRONT: 
+            if (sc.atLineStart) {
+                const FrontMatter frontMatterMark = FrontMatterFromString(
+                    styler.GetRange(sc.currentPos, sc.currentPos + 3));
+                if (frontMatterMark == frontMatter) {
+                    sc.SetState(SCE_MARKDOWN_FRONT_MARK);
+                } else if (AnyOf(sc.ch, '{', '}')) {
+                    sc.SetState(SCE_MARKDOWN_FRONT);
+                } else {
+                    sc.SetState(SCE_MARKDOWN_FRONT_KEY);
                 }
             }
-            else if (sc.atLineStart) {
-                if (sc.ch != '\t' ) {
-                    for (int i = 0; i < 4; ++i) {
-                        if (sc.GetRelative(i) != ' ')
-                            d = false;
+            break;
+
+        case SCE_MARKDOWN_FRONT_KEY:
+            if (sc.atLineEnd) {
+                sc.SetState(SCE_MARKDOWN_FRONT);
+            } else {
+                switch (frontMatter) {
+                case FrontMatter::YAML:
+                    if (AnyOf(sc.ch, ':', ' ')) {
+                        sc.SetState(SCE_MARKDOWN_FRONT);
                     }
+                    break;
+                case FrontMatter::TOML:
+                    if (AnyOf(sc.ch, '=', ' ')) {
+                        sc.SetState(SCE_MARKDOWN_FRONT);
+                    }
+                    break;
+                case FrontMatter::JSON:
+                    if (AnyOf(sc.ch, ':', '{')) {
+                        sc.SetState(SCE_MARKDOWN_FRONT);
+                    }
+                    break;
+                default:
+                    break;
                 }
             }
-            if (!d)
-                sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
-        }
-        */
-        // Strong
-        else if (sc.state == SCE_MARKDOWN_STRONG1) {
+            break;
+
+            // Strong
+        case SCE_MARKDOWN_STRONG1:
             if ((sc.Match("**") && sc.chPrev != ' ') || IsNewline(sc.GetRelative(2))) {
                 sc.Forward(2);
                 sc.SetState(SCE_MARKDOWN_DEFAULT);
             }
-        }
-        else if (sc.state == SCE_MARKDOWN_STRONG2) {
+            break;
+        case SCE_MARKDOWN_STRONG2:
             if ((sc.Match("__") && sc.chPrev != ' ') || IsNewline(sc.GetRelative(2))) {
                 sc.Forward(2);
                 sc.SetState(SCE_MARKDOWN_DEFAULT);
             }
-        }
-        // Emphasis
-        else if (sc.state == SCE_MARKDOWN_EM1) {
+            break;
+
+            // Emphasis
+        case SCE_MARKDOWN_EM1:
             if ((sc.ch == '*' && sc.chPrev != ' ') || IsNewline(sc.chNext))
                 sc.ForwardSetState(SCE_MARKDOWN_DEFAULT);
-        }
-        else if (sc.state == SCE_MARKDOWN_EM2) {
+            break;
+        case SCE_MARKDOWN_EM2:
             if ((sc.ch == '_' && sc.chPrev != ' ') || IsNewline(sc.chNext))
                 sc.ForwardSetState(SCE_MARKDOWN_DEFAULT);
-        }
-        else if (sc.state == SCE_MARKDOWN_CODEBK) {
+            break;
+
+        case SCE_MARKDOWN_CODEBK:
             if (sc.atLineStart && sc.Match("~~~")) {
                 Sci_Position i = 1;
                 while (!IsNewline(sc.GetRelative(i)) && sc.currentPos + i < endPos)
@@ -270,56 +414,52 @@ void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int initSt
                 sc.Forward(i);
                 sc.SetState(SCE_MARKDOWN_DEFAULT);
             }
-        }
-        else if (sc.state == SCE_MARKDOWN_STRIKEOUT) {
+            break;
+
+        case SCE_MARKDOWN_STRIKEOUT:
             if ((sc.Match("~~") && sc.chPrev != ' ') || IsNewline(sc.GetRelative(2))) {
                 sc.Forward(2);
                 sc.SetState(SCE_MARKDOWN_DEFAULT);
             }
-        }
-        else if (sc.state == SCE_MARKDOWN_LINE_BEGIN) {
+            break;
+
+        case SCE_MARKDOWN_LINE_BEGIN:
             // Header
             if (sc.Match("######")) {
                 if (headerEOLFill)
                     sc.SetState(SCE_MARKDOWN_HEADER6);
                 else
-                    SetStateAndZoom(SCE_MARKDOWN_HEADER6, 6, '#', sc);
-            }
-            else if (sc.Match("#####")) {
+                    SetStateAndZoom(SCE_MARKDOWN_HEADER6, header6.length(), '#', sc);
+            } else if (sc.Match("#####")) {
                 if (headerEOLFill)
                     sc.SetState(SCE_MARKDOWN_HEADER5);
                 else
-                    SetStateAndZoom(SCE_MARKDOWN_HEADER5, 5, '#', sc);
-            }
-            else if (sc.Match("####")) {
+                    SetStateAndZoom(SCE_MARKDOWN_HEADER5, header5.length(), '#', sc);
+            } else if (sc.Match("####")) {
                 if (headerEOLFill)
                     sc.SetState(SCE_MARKDOWN_HEADER4);
                 else
                     SetStateAndZoom(SCE_MARKDOWN_HEADER4, 4, '#', sc);
-            }
-            else if (sc.Match("###")) {
+            } else if (sc.Match("###")) {
                 if (headerEOLFill)
                     sc.SetState(SCE_MARKDOWN_HEADER3);
                 else
                     SetStateAndZoom(SCE_MARKDOWN_HEADER3, 3, '#', sc);
-            }
-            else if (sc.Match("##")) {
+            } else if (sc.Match("##")) {
                 if (headerEOLFill)
                     sc.SetState(SCE_MARKDOWN_HEADER2);
                 else
                     SetStateAndZoom(SCE_MARKDOWN_HEADER2, 2, '#', sc);
-            }
-            else if (sc.Match("#")) {
+            } else if (sc.Match("#")) {
                 // Catch the special case of an unordered list
                 if (sc.chNext == '.' && IsASpaceOrTab(sc.GetRelative(2))) {
                     precharCount = 0;
                     sc.SetState(SCE_MARKDOWN_PRECHAR);
-                }
-                else if (headerEOLFill) {
+                } else if (headerEOLFill) {
                     sc.SetState(SCE_MARKDOWN_HEADER1);
-                }
-                else
+                } else {
                     SetStateAndZoom(SCE_MARKDOWN_HEADER1, 1, '#', sc);
+                }
             }
             // Code block
             else if (sc.Match("~~~")) {
@@ -327,52 +467,56 @@ void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int initSt
                     sc.SetState(SCE_MARKDOWN_CODEBK);
                 else
                     sc.SetState(SCE_MARKDOWN_DEFAULT);
-            }
-            else if (sc.ch == '=') {
+            } else if (sc.ch == '=') {
                 if (HasPrevLineContent(sc) && FollowToLineEnd('=', SCE_MARKDOWN_HEADER1, endPos, sc)) {
                     if (!headerEOLFill)
                         sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
-                }
-                else
+                } else {
                     sc.SetState(SCE_MARKDOWN_DEFAULT);
-            }
-            else if (sc.ch == '-') {
+                }
+            } else if (sc.ch == '-') {
                 if (HasPrevLineContent(sc) && FollowToLineEnd('-', SCE_MARKDOWN_HEADER2, endPos, sc)) {
                     if (!headerEOLFill)
                         sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
-                }
-                else {
+                } else {
                     precharCount = 0;
                     sc.SetState(SCE_MARKDOWN_PRECHAR);
                 }
-            }
-            else if (IsNewline(sc.ch))
+            } else if (IsNewline(sc.ch)) {
                 sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
-            else {
+            } else {
                 precharCount = 0;
                 sc.SetState(SCE_MARKDOWN_PRECHAR);
             }
-        }
+            break;
 
-        // The header lasts until the newline
-        else if (sc.state == SCE_MARKDOWN_HEADER1 || sc.state == SCE_MARKDOWN_HEADER2 ||
-                 sc.state == SCE_MARKDOWN_HEADER3 || sc.state == SCE_MARKDOWN_HEADER4 ||
-                 sc.state == SCE_MARKDOWN_HEADER5 || sc.state == SCE_MARKDOWN_HEADER6) {
+            // The header lasts until the newline
+        case SCE_MARKDOWN_HEADER1:
+        case SCE_MARKDOWN_HEADER2:
+        case SCE_MARKDOWN_HEADER3:
+        case SCE_MARKDOWN_HEADER4:
+        case SCE_MARKDOWN_HEADER5:
+        case SCE_MARKDOWN_HEADER6:
             if (headerEOLFill) {
                 if (sc.atLineStart) {
                     sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
                     freezeCursor = true;
                 }
-            }
-            else if (IsNewline(sc.ch))
+            } else if (IsNewline(sc.ch)) {
                 sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
+            }
+            break;
+
+        default:
+            break;
         }
 
         // New state only within the initial whitespace
         if (sc.state == SCE_MARKDOWN_PRECHAR) {
             // Blockquote
-            if (sc.ch == '>' && precharCount < 5)
+            if (sc.ch == '>' && precharCount <= 4) {
                 sc.SetState(SCE_MARKDOWN_BLOCKQUOTE);
+            }
             /*
             // Begin of code block
             else if (!HasPrevLineContent(sc) && (sc.chPrev == '\t' || precharCount >= 4))
@@ -380,8 +524,9 @@ void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int initSt
             */
             // HRule - Total of three or more hyphens, asterisks, or underscores
             // on a line by themselves
-            else if ((sc.ch == '-' || sc.ch == '*' || sc.ch == '_') && IsValidHrule(endPos, sc))
+            else if ((sc.ch == '-' || sc.ch == '*' || sc.ch == '_') && IsValidHrule(endPos, sc)) {
                 ;
+            }
             // Unordered list
             else if ((sc.ch == '-' || sc.ch == '*' || sc.ch == '+') && IsASpaceOrTab(sc.chNext)) {
                 sc.SetState(SCE_MARKDOWN_ULIST_ITEM);
@@ -389,7 +534,7 @@ void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int initSt
             }
             // Ordered list
             else if (IsADigit(sc.ch)) {
-                int digitCount = 0;
+                Sci_Position digitCount = 0;
                 while (IsADigit(sc.GetRelative(++digitCount)))
                     ;
                 if (sc.GetRelative(digitCount) == '.' &&
@@ -407,11 +552,11 @@ void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int initSt
                 sc.SetState(SCE_MARKDOWN_OLIST_ITEM);
                 sc.Forward(2);
                 sc.SetState(SCE_MARKDOWN_DEFAULT);
-            }
-            else if (sc.ch != ' ' || precharCount > 2)
+            } else if (sc.ch != ' ' || precharCount > 2) {
                 sc.SetState(SCE_MARKDOWN_DEFAULT);
-            else
+            } else {
                 ++precharCount;
+            }
         }
 
         // Any link
@@ -419,16 +564,13 @@ void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int initSt
             if (sc.Match("](") && sc.GetRelative(-1) != '\\') {
                 sc.Forward(2);
                 isLinkNameDetecting = true;
-            }
-            else if (sc.Match("]:") && sc.GetRelative(-1) != '\\') {
+            } else if (sc.Match("]:") && sc.GetRelative(-1) != '\\') {
                 sc.Forward(2);
                 sc.SetState(SCE_MARKDOWN_DEFAULT);
-            }
-            else if (!isLinkNameDetecting && sc.ch == ']' && sc.GetRelative(-1) != '\\') {
+            } else if (!isLinkNameDetecting && sc.ch == ']' && sc.GetRelative(-1) != '\\') {
                 sc.Forward();
                 sc.SetState(SCE_MARKDOWN_DEFAULT);
-            }
-            else if (isLinkNameDetecting && sc.ch == ')' && sc.GetRelative(-1) != '\\') {
+            } else if (isLinkNameDetecting && sc.ch == ')' && sc.GetRelative(-1) != '\\') {
                 sc.Forward();
                 sc.SetState(SCE_MARKDOWN_DEFAULT);
                 isLinkNameDetecting = false;
@@ -445,8 +587,7 @@ void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int initSt
             if (sc.Match("![")) {
                 sc.SetState(SCE_MARKDOWN_LINK);
                 sc.Forward(1);
-            }
-            else if (sc.ch == '[' && sc.GetRelative(-1) != '\\') {
+            } else if (sc.ch == '[' && sc.GetRelative(-1) != '\\') {
                 sc.SetState(SCE_MARKDOWN_LINK);
             }
             // Code - also a special case for alternate inside spacing
@@ -454,28 +595,25 @@ void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int initSt
                 const int openingSpan = (sc.GetRelative(2) == '`') ? 2 : 1;
                 sc.SetState(SCE_MARKDOWN_CODE2);
                 sc.Forward(openingSpan);
-            }
-            else if (sc.ch == '`' && sc.chNext != ' ' && IsCompleteStyleRegion(sc, "`")) {
+            } else if (sc.ch == '`' && sc.chNext != ' ' && IsCompleteStyleRegion(sc, "`")) {
                 sc.SetState(SCE_MARKDOWN_CODE);
             }
             // Strong
             else if (sc.Match("**") && sc.GetRelative(2) != ' ' && IsCompleteStyleRegion(sc, "**")) {
                 sc.SetState(SCE_MARKDOWN_STRONG1);
                 sc.Forward();
-            }
-            else if (sc.Match("__") && sc.GetRelative(2) != ' ' && IsCompleteStyleRegion(sc, "__")) {
+            } else if (sc.Match("__") && sc.GetRelative(2) != ' ' && IsCompleteStyleRegion(sc, "__")) {
                 sc.SetState(SCE_MARKDOWN_STRONG2);
                 sc.Forward();
             }
             // Emphasis
             else if (sc.ch == '*' && sc.chNext != ' ' && IsCompleteStyleRegion(sc, "*")) {
                 sc.SetState(SCE_MARKDOWN_EM1);
-            }
-            else if (sc.ch == '_' && sc.chNext != ' ' && IsCompleteStyleRegion(sc, "_")) {
+            } else if (sc.ch == '_' && sc.chNext != ' ' && IsCompleteStyleRegion(sc, "_")) {
                 sc.SetState(SCE_MARKDOWN_EM2);
             }
             // Strikeout
-            else if (sc.Match("~~") && !(sc.GetRelative(2) == '~' || sc.GetRelative(2) == ' ') &&
+            else if (sc.Match("~~") && !(AnyOf(sc.GetRelative(2), '~', ' ')) &&
                      IsCompleteStyleRegion(sc, "~~")) {
                 sc.SetState(SCE_MARKDOWN_STRIKEOUT);
                 sc.Forward();
@@ -495,4 +633,4 @@ void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int initSt
 
 }
 
-extern const LexerModule lmMarkdown(SCLEX_MARKDOWN, ColorizeMarkdownDoc, "markdown");
+extern const LexerModule lmMarkdown(SCLEX_MARKDOWN, LexerMarkdown::LexerFactoryMarkdown, "markdown");
diff --git a/lexilla/lexers/LexTCL.cxx b/lexilla/lexers/LexTCL.cxx
index 1578582e83..dc4b80b5c2 100644
--- a/lexilla/lexers/LexTCL.cxx
+++ b/lexilla/lexers/LexTCL.cxx
@@ -152,7 +152,7 @@ void ColouriseTCLDoc(Sci_PositionU startPos, Sci_Position length, int, WordList
 			if ((sc.state == SCE_TCL_IDENTIFIER && expected) ||  sc.state == SCE_TCL_MODIFIER) {
 				char w[100];
 				sc.GetCurrent(w, sizeof(w));
-				char *s=w;
+				const char *s=w;
 				if (w[strlen(w)-1]=='\r')
 					w[strlen(w)-1]=0;
 				while (*s == ':') // ignore leading : like in ::set a 10
diff --git a/lexilla/lexers/LexYAML.cxx b/lexilla/lexers/LexYAML.cxx
index 3f8006a64b..fb5b94276a 100644
--- a/lexilla/lexers/LexYAML.cxx
+++ b/lexilla/lexers/LexYAML.cxx
@@ -52,12 +52,16 @@ unsigned int SpaceCount(const char* lineBuffer) noexcept {
 	if (lineBuffer == nullptr)
 		return 0;
 
-	const char* headBuffer = lineBuffer;
+	unsigned int spaces = 0;
+	while (lineBuffer[spaces] == ' ') {
+		spaces++;
+	}
 
-	while (*headBuffer == ' ')
-		headBuffer++;
+	return spaces;
+}
 
-	return static_cast<unsigned int>(headBuffer - lineBuffer);
+constexpr bool EmptyLine(std::string_view line) noexcept {
+	return line.find_first_not_of("\n\r") == std::string_view::npos;
 }
 
 bool KeywordAtChar(const char* lineBuffer, const char* startComment, const WordList &keywords) noexcept {
@@ -66,13 +70,14 @@ bool KeywordAtChar(const char* lineBuffer, const char* startComment, const WordL
 	const char* endValue = startComment - 1;
 	while (endValue >= lineBuffer && *endValue == ' ')
 		endValue--;
-	Sci_PositionU len = static_cast<Sci_PositionU>(endValue - lineBuffer) + 1;
-	char s[100];
-	if (len > (sizeof(s) / sizeof(s[0]) - 1))
+	const Sci_PositionU len = endValue - lineBuffer + 1;
+	constexpr size_t keywordLength = 100;
+	char s[keywordLength];
+	if (len > (keywordLength - 1))
 		return false;
 	strncpy(s, lineBuffer, len);
 	s[len] = '\0';
-	return (keywords.InList(s));
+	return keywords.InList(s);
 }
 
 #define YAML_STATE_BITSIZE		16
@@ -101,7 +106,7 @@ void ColouriseYAMLLine(
 
 		if ((parentLineState&YAML_STATE_MASK) == YAML_STATE_TEXT || (parentLineState&YAML_STATE_MASK) == YAML_STATE_TEXT_PARENT) {
 			const unsigned int parentIndentAmount = parentLineState&(~YAML_STATE_MASK);
-			if (indentAmount > parentIndentAmount) {
+			if ((indentAmount > parentIndentAmount) || EmptyLine(lineBuffer)) {
 				styler.SetLineState(currentLine, YAML_STATE_TEXT | parentIndentAmount);
 				styler.ColourTo(endPos, SCE_YAML_TEXT);
 				return;
@@ -241,9 +246,7 @@ void ColouriseYAMLDoc(Sci_PositionU startPos, Sci_Position length, int, WordList
 
 bool IsCommentLine(Sci_Position line, Accessor &styler) {
 	const Sci_Position pos = styler.LineStart(line);
-	if (styler[pos] == '#')
-		return true;
-	return false;
+	return styler[pos] == '#';
 }
 
 void FoldYAMLDoc(Sci_PositionU startPos, Sci_Position length, int /*initStyle - unused*/,
@@ -273,7 +276,7 @@ void FoldYAMLDoc(Sci_PositionU startPos, Sci_Position length, int /*initStyle -
 	int indentCurrentLevel = indentCurrent & SC_FOLDLEVELNUMBERMASK;
 
 	// Set up initial loop state
-	int prevComment = 0;
+	bool prevComment = false;
 	if (lineCurrent >= 1)
 		prevComment = foldComment && IsCommentLine(lineCurrent - 1, styler);
 
@@ -290,10 +293,10 @@ void FoldYAMLDoc(Sci_PositionU startPos, Sci_Position length, int /*initStyle -
 			// Information about next line is only available if not at end of document
 			indentNext = styler.IndentAmount(lineNext, &spaceFlags, nullptr);
 		}
-		const int comment = foldComment && IsCommentLine(lineCurrent, styler);
-		const int comment_start = (comment && !prevComment && (lineNext <= docLines) &&
+		const bool comment = foldComment && IsCommentLine(lineCurrent, styler);
+		const bool comment_start = (comment && !prevComment && (lineNext <= docLines) &&
 		                           IsCommentLine(lineNext, styler) && (lev > SC_FOLDLEVELBASE));
-		const int comment_continue = (comment && prevComment);
+		const bool comment_continue = comment && prevComment;
 		if (!comment)
 			indentCurrentLevel = indentCurrent & SC_FOLDLEVELNUMBERMASK;
 		if (indentNext & SC_FOLDLEVELWHITEFLAG)
diff --git a/lexilla/lexlib/LexerBase.h b/lexilla/lexlib/LexerBase.h
index 0fdd182ac8..2394d5cd74 100644
--- a/lexilla/lexlib/LexerBase.h
+++ b/lexilla/lexlib/LexerBase.h
@@ -20,6 +20,10 @@ class LexerBase : public Scintilla::ILexer5 {
 	WordList *keyWordLists[numWordLists+1]{};
 public:
 	LexerBase(const LexicalClass *lexClasses_=nullptr, size_t nClasses_=0);
+	LexerBase(const LexerBase &) = delete;
+	LexerBase(LexerBase &&) = delete;
+	LexerBase &operator=(const LexerBase &) = delete;
+	LexerBase &operator=(LexerBase &&) = delete;
 	virtual ~LexerBase();
 	void SCI_METHOD Release() override;
 	int SCI_METHOD Version() const override;
diff --git a/lexilla/lexlib/LexerModule.h b/lexilla/lexlib/LexerModule.h
index 20a626e42d..09553e8fed 100644
--- a/lexilla/lexlib/LexerModule.h
+++ b/lexilla/lexlib/LexerModule.h
@@ -14,9 +14,9 @@ class Accessor;
 class WordList;
 struct LexicalClass;
 
-typedef void (*LexerFunction)(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle,
+using LexerFunction = void (*)(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle,
                   WordList *keywordlists[], Accessor &styler);
-typedef Scintilla::ILexer5 *(*LexerFactoryFunction)();
+using LexerFactoryFunction = Scintilla::ILexer5 *(*)();
 
 /**
  * A LexerModule is responsible for lexing and folding a particular language.
@@ -49,15 +49,15 @@ class LexerModule {
 		LexerFactoryFunction fnFactory_,
 		const char *languageName_,
 		const char * const wordListDescriptions_[]=nullptr) noexcept;
-	int GetLanguage() const noexcept;
+	[[nodiscard]] int GetLanguage() const noexcept;
 
 	// -1 is returned if no WordList information is available
-	int GetNumWordLists() const noexcept;
-	const char *GetWordListDescription(int index) const noexcept;
-	const LexicalClass *LexClasses() const noexcept;
-	size_t NamedStyles() const noexcept;
+	[[nodiscard]] int GetNumWordLists() const noexcept;
+	[[nodiscard]] const char *GetWordListDescription(int index) const noexcept;
+	[[nodiscard]] const LexicalClass *LexClasses() const noexcept;
+	[[nodiscard]] size_t NamedStyles() const noexcept;
 
-	Scintilla::ILexer5 *Create() const;
+	[[nodiscard]] Scintilla::ILexer5 *Create() const;
 
 	void Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle,
                   WordList *keywordlists[], Accessor &styler) const;
diff --git a/lexilla/lexlib/OptionSet.h b/lexilla/lexlib/OptionSet.h
index 230a46ce9e..65a52597b0 100644
--- a/lexilla/lexlib/OptionSet.h
+++ b/lexilla/lexlib/OptionSet.h
@@ -51,7 +51,7 @@ class OptionSet : public OptionSetInterface {
 		Option() :
 			opType(SC_TYPE_BOOLEAN), pb(nullptr) {
 		}
-		Option(plcob pb_, std::string_view description_="") :
+		explicit Option(plcob pb_, std::string_view description_="") :
 			opType(SC_TYPE_BOOLEAN), pb(pb_), description(description_) {
 		}
 		Option(plcoi pi_, std::string_view description_) :
@@ -122,7 +122,7 @@ class OptionSet : public OptionSetInterface {
 	}
 	template <typename E>
 	void DefineProperty(const char *name, E T::*pe, std::string_view description="") {
-		static_assert(std::is_enum<E>::value);
+		static_assert(std::is_enum_v<E>);
 		plcoi pi {};
 		static_assert(sizeof(pe) == sizeof(pi));
 		memcpy(&pi, &pe, sizeof(pe));
diff --git a/lexilla/lexlib/SubStyles.h b/lexilla/lexlib/SubStyles.h
index 5eaeee61d6..5ddb55016b 100644
--- a/lexilla/lexlib/SubStyles.h
+++ b/lexilla/lexlib/SubStyles.h
@@ -12,14 +12,14 @@ namespace Lexilla {
 
 class WordClassifier {
 	int baseStyle;
-	int firstStyle;
-	int lenStyles;
+	int firstStyle = 0;
+	int lenStyles = 0;
 	using WordStyleMap = std::map<std::string, int, std::less<>>;
 	WordStyleMap wordToStyle;
 
 public:
 
-	explicit WordClassifier(int baseStyle_) : baseStyle(baseStyle_), firstStyle(0), lenStyles(0) {
+	explicit WordClassifier(int baseStyle_) : baseStyle(baseStyle_) {
 	}
 
 	void Allocate(int firstStyle_, int lenStyles_) noexcept {
@@ -28,19 +28,19 @@ class WordClassifier {
 		wordToStyle.clear();
 	}
 
-	int Base() const noexcept {
+	[[nodiscard]] int Base() const noexcept {
 		return baseStyle;
 	}
 
-	int Start() const noexcept {
+	[[nodiscard]] int Start() const noexcept {
 		return firstStyle;
 	}
 
-	int Last() const noexcept {
+	[[nodiscard]] int Last() const noexcept {
 		return firstStyle + lenStyles - 1;
 	}
 
-	int Length() const noexcept {
+	[[nodiscard]] int Length() const noexcept {
 		return lenStyles;
 	}
 
@@ -50,15 +50,14 @@ class WordClassifier {
 		wordToStyle.clear();
 	}
 
-	int ValueFor(std::string_view s) const {
+	[[nodiscard]] int ValueFor(std::string_view s) const {
 		WordStyleMap::const_iterator const it = wordToStyle.find(s);
 		if (it != wordToStyle.end())
 			return it->second;
-		else
-			return -1;
+		return -1;
 	}
 
-	bool IncludesStyle(int style) const noexcept {
+	[[nodiscard]] bool IncludesStyle(int style) const noexcept {
 		return (style >= firstStyle) && (style < (firstStyle + lenStyles));
 	}
 
@@ -102,15 +101,15 @@ constexpr int SubStylesFirst = 0x80;
 constexpr int SubStylesAvailable = 0x40;
 
 class SubStyles {
-	int classifications;
+	int classifications = 0;
 	const char *baseStyles;
 	int styleFirst;
 	int stylesAvailable;
 	int secondaryDistance;
-	int allocated;
+	int allocated = 0;
 	std::vector<WordClassifier> classifiers;
 
-	int BlockFromBaseStyle(int baseStyle) const noexcept {
+	[[nodiscard]] int BlockFromBaseStyle(int baseStyle) const noexcept {
 		for (int b=0; b < classifications; b++) {
 			if (baseStyle == baseStyles[b])
 				return b;
@@ -118,7 +117,7 @@ class SubStyles {
 		return -1;
 	}
 
-	int BlockFromStyle(int style) const noexcept {
+	[[nodiscard]] int BlockFromStyle(int style) const noexcept {
 		int b = 0;
 		for (const WordClassifier &wc : classifiers) {
 			if (wc.IncludesStyle(style))
@@ -130,20 +129,18 @@ class SubStyles {
 
 public:
 
-	SubStyles(const char *baseStyles_, int styleFirst_=SubStylesFirst, int stylesAvailable_=SubStylesAvailable, int secondaryDistance_=0) :
-		classifications(0),
+	explicit SubStyles(const char *baseStyles_, int styleFirst_=SubStylesFirst, int stylesAvailable_=SubStylesAvailable, int secondaryDistance_=0) :
 		baseStyles(baseStyles_),
 		styleFirst(styleFirst_),
 		stylesAvailable(stylesAvailable_),
-		secondaryDistance(secondaryDistance_),
-		allocated(0) {
+		secondaryDistance(secondaryDistance_) {
 		while (baseStyles[classifications]) {
-			classifiers.push_back(WordClassifier(baseStyles[classifications]));
+			classifiers.emplace_back(baseStyles[classifications]);
 			classifications++;
 		}
 	}
 
-	int Allocate(int styleBase, int numberStyles) noexcept {
+	[[nodiscard]] int Allocate(int styleBase, int numberStyles) noexcept {
 		const int block = BlockFromBaseStyle(styleBase);
 		if (block >= 0) {
 			if ((allocated + numberStyles) > stylesAvailable)
@@ -152,34 +149,32 @@ class SubStyles {
 			allocated += numberStyles;
 			classifiers[block].Allocate(startBlock, numberStyles);
 			return startBlock;
-		} else {
-			return -1;
 		}
+		return -1;
 	}
 
-	int Start(int styleBase) noexcept {
+	[[nodiscard]] int Start(int styleBase) noexcept {
 		const int block = BlockFromBaseStyle(styleBase);
 		return (block >= 0) ? classifiers[block].Start() : -1;
 	}
 
-	int Length(int styleBase) noexcept {
+	[[nodiscard]] int Length(int styleBase) noexcept {
 		const int block = BlockFromBaseStyle(styleBase);
 		return (block >= 0) ? classifiers[block].Length() : 0;
 	}
 
-	int BaseStyle(int subStyle) const noexcept {
+	[[nodiscard]] int BaseStyle(int subStyle) const noexcept {
 		const int block = BlockFromStyle(subStyle);
 		if (block >= 0)
 			return classifiers[block].Base();
-		else
-			return subStyle;
+		return subStyle;
 	}
 
-	int DistanceToSecondaryStyles() const noexcept {
+	[[nodiscard]] int DistanceToSecondaryStyles() const noexcept {
 		return secondaryDistance;
 	}
 
-	int FirstAllocated() const noexcept {
+	[[nodiscard]] int FirstAllocated() const noexcept {
 		int start = 257;
 		for (const WordClassifier &wc : classifiers) {
 			if ((wc.Length() > 0) && (start > wc.Start()))
@@ -188,7 +183,7 @@ class SubStyles {
 		return (start < 256) ? start : -1;
 	}
 
-	int LastAllocated() const noexcept {
+	[[nodiscard]] int LastAllocated() const noexcept {
 		int last = -1;
 		for (const WordClassifier &wc : classifiers) {
 			if ((wc.Length() > 0) && (last < wc.Last()))
@@ -210,7 +205,7 @@ class SubStyles {
 		}
 	}
 
-	const WordClassifier &Classifier(int baseStyle) const noexcept {
+	[[nodiscard]] const WordClassifier &Classifier(int baseStyle) const noexcept {
 		const int block = BlockFromBaseStyle(baseStyle);
 		return classifiers[block >= 0 ? block : 0];
 	}
diff --git a/lexilla/src/Lexilla/Info.plist b/lexilla/src/Lexilla/Info.plist
index c214653e41..0b38cedfc2 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.5.3</string>
+	<string>5.5.4</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 25e54009b9..d95d14c3b4 100644
--- a/lexilla/src/Lexilla/Lexilla.xcodeproj/project.pbxproj
+++ b/lexilla/src/Lexilla/Lexilla.xcodeproj/project.pbxproj
@@ -900,7 +900,7 @@
 			buildSettings = {
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++17";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 5.5.3;
+				CURRENT_PROJECT_VERSION = 5.5.4;
 				DEAD_CODE_STRIPPING = YES;
 				DEVELOPMENT_TEAM = 4F446KW87E;
 				DYLIB_COMPATIBILITY_VERSION = 1;
@@ -928,7 +928,7 @@
 			buildSettings = {
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++17";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 5.5.3;
+				CURRENT_PROJECT_VERSION = 5.5.4;
 				DEAD_CODE_STRIPPING = YES;
 				DEVELOPMENT_TEAM = 4F446KW87E;
 				DYLIB_COMPATIBILITY_VERSION = 1;
diff --git a/lexilla/src/LexillaVersion.rc b/lexilla/src/LexillaVersion.rc
index 265793c63c..2dab72190b 100644
--- a/lexilla/src/LexillaVersion.rc
+++ b/lexilla/src/LexillaVersion.rc
@@ -4,8 +4,8 @@
 
 #include <windows.h>
 
-#define VERSION_LEXILLA "5.5.3"
-#define VERSION_WORDS 5, 5, 3, 0
+#define VERSION_LEXILLA "5.5.4"
+#define VERSION_WORDS 5, 5, 4, 0
 
 VS_VERSION_INFO VERSIONINFO
 FILEVERSION	VERSION_WORDS
diff --git a/lexilla/src/deps.mak b/lexilla/src/deps.mak
index ff55b475ef..8d6c2066fa 100644
--- a/lexilla/src/deps.mak
+++ b/lexilla/src/deps.mak
@@ -932,7 +932,9 @@ $(DIR_O)/LexMarkdown.o: \
 	../lexlib/Accessor.h \
 	../lexlib/StyleContext.h \
 	../lexlib/CharacterSet.h \
-	../lexlib/LexerModule.h
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
 $(DIR_O)/LexMatlab.o: \
 	../lexers/LexMatlab.cxx \
 	../../scintilla/include/ILexer.h \
diff --git a/lexilla/src/nmdeps.mak b/lexilla/src/nmdeps.mak
index 1611c6f238..8a59c5763f 100644
--- a/lexilla/src/nmdeps.mak
+++ b/lexilla/src/nmdeps.mak
@@ -932,7 +932,9 @@ $(DIR_O)/LexMarkdown.obj: \
 	../lexlib/Accessor.h \
 	../lexlib/StyleContext.h \
 	../lexlib/CharacterSet.h \
-	../lexlib/LexerModule.h
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
 $(DIR_O)/LexMatlab.obj: \
 	../lexers/LexMatlab.cxx \
 	../../scintilla/include/ILexer.h \
diff --git a/lexilla/version.txt b/lexilla/version.txt
index 4c7798cefd..8d28c8c9eb 100644
--- a/lexilla/version.txt
+++ b/lexilla/version.txt
@@ -1 +1 @@
-553
\ No newline at end of file
+554
\ No newline at end of file
diff --git a/src/StyleLexers/styleLexMARKDOWN.c b/src/StyleLexers/styleLexMARKDOWN.c
index c54ba21867..e5bec5acb7 100644
--- a/src/StyleLexers/styleLexMARKDOWN.c
+++ b/src/StyleLexers/styleLexMARKDOWN.c
@@ -20,7 +20,7 @@ EDITLEXER lexMARKDOWN =
         { {SCE_MARKDOWN_HEADER4}, IDS_LEX_STR_63323, L"Header 4", L"bold; fore:#336193; eolfilled", L"" },
         { {SCE_MARKDOWN_HEADER5}, IDS_LEX_STR_63324, L"Header 5", L"bold; fore:#3F77B6; eolfilled", L"" },
         { {SCE_MARKDOWN_HEADER6}, IDS_LEX_STR_63325, L"Header 6", L"bold; fore:#5C8FC7; eolfilled", L"" },
-        { {SCE_MARKDOWN_HDRTEXT}, IDS_LEX_STR_HdrText, L"Header Text", L"bold; fore:#336193", L"" },
+        //{ {SCE_MARKDOWN_HDRTEXT}, IDS_LEX_STR_HdrText, L"Header Text", L"bold; fore:#336193", L"" },
         { {SCE_MARKDOWN_PRECHAR}, IDS_LEX_STR_63326, L"Pre Char", L"fore:#00007F", L"" },
         { {SCE_MARKDOWN_ULIST_ITEM}, IDS_LEX_STR_63327, L"Unordered List", L"bold; fore:#0080FF", L"" },
         { {SCE_MARKDOWN_OLIST_ITEM}, IDS_LEX_STR_63268, L"Ordered List", L"bold; fore:#0080FF", L"" },