diff --git a/scintilla/doc/ScintillaDownload.html b/scintilla/doc/ScintillaDownload.html
index a86f1edb..69b4a008 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="http://www.scintilla.org/scintilla363.zip">
+          <font size="4"> <a href="http://www.scintilla.org/scintilla364.zip">
 	Windows</a>&nbsp;&nbsp;
-	<a href="http://www.scintilla.org/scintilla363.tgz">
+	<a href="http://www.scintilla.org/scintilla364.tgz">
           GTK+/Linux</a>&nbsp;&nbsp;
 	</font>
         </td>
@@ -42,7 +42,7 @@ <h2>
       containing very few restrictions.
     </p>
     <h3>
-       Release 3.6.3
+       Release 3.6.4
     </h3>
     <h4>
        Source Code
@@ -50,8 +50,8 @@ <h4>
        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="http://www.scintilla.org/scintilla363.zip">zip format</a> (1500K) commonly used on Windows</li>
-       <li><a href="http://www.scintilla.org/scintilla363.tgz">tgz format</a> (1400K) commonly used on Linux and compatible operating systems</li>
+       <li><a href="http://www.scintilla.org/scintilla364.zip">zip format</a> (1500K) commonly used on Windows</li>
+       <li><a href="http://www.scintilla.org/scintilla364.tgz">tgz format</a> (1400K) 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 e2e57c8c..14bead6a 100644
--- a/scintilla/doc/ScintillaHistory.html
+++ b/scintilla/doc/ScintillaHistory.html
@@ -480,6 +480,10 @@ <h3>
 	<td>Yury Dubinsky</td>
 	<td>Sam Hocevar</td>
 	<td>Luyomi</td>
+	<td>Matt Gilarde</td>
+      </tr><tr>
+	<td>Mark C</td>
+	<td>Johannes Sasongko</td>
     </tr>
     </table>
     <p>
@@ -491,18 +495,72 @@ <h3>
         Icons</a> Copyright(C) 1998 by Dean S. Jones<br />
       </li>
     </ul>
+    <h3>
+       <a href="http://www.scintilla.org/scite365.zip">Release 3.6.5</a>
+    </h3>
+    <ul>
+	<li>
+	Released 13 March 2016.
+	</li>
+	<li>
+	JSON lexer added.
+	<a href="http://sourceforge.net/p/scintilla/feature-requests/1140/">Feature #1140.</a>
+	</li>
+	<li>
+	The Python lexer treats '@' as an operator except when it is the first visible character on a line.
+	This is for Python 3.5.
+	</li>
+	<li>
+	SciTE bug fixed with exported HTML where extra line shown.
+	<a href="http://sourceforge.net/p/scintilla/bugs/1816/">Bug #1816</a>.
+	</li>
+	<li>
+	SciTE on Windows fixes bugs with pop-up menus in the find and replace strips.
+	For the replace strip, menu choices change the state.
+	For the find strip, menu choices are reflected in the appearance of their corresponding buttons.
+	</li>
+    </ul>
     <h3>
        <a href="http://www.scintilla.org/scite364.zip">Release 3.6.4</a>
     </h3>
     <ul>
 	<li>
-	Released 18 January 2016.
+	Released 13 March 2016.
+	</li>
+	<li>
+	SciTE allows setting the autocompletion type separator character.
+	</li>
+	<li>
+	The C++ folder folds code on '(' and ')' to allow multi-line calls to be folded.
+	<a href="http://sourceforge.net/p/scintilla/feature-requests/1138/">Feature #1138.</a>
 	</li>
 	<li>
 	For the HTML lexer, limit the extent of Mako line comments to finish before
 	the line end characters.
 	</li>
 	<li>
+	Folds unfolded when two fold regions are merged by either deleting an intervening line
+	or changing its fold level by adding characters.
+	This was fixed both in Scintilla and in SciTE's equivalent code.
+	<a href="http://sourceforge.net/p/scintilla/bugs/1799/">Bug #1799</a>.<br />
+	</li>
+	<li>
+	The Progress lexer supports hexadecimal numeric literals,
+	single-line comments, abbreviated keywords and
+	extends nested comments to unlimited levels.
+	</li>
+	<li>
+	Ruby lexer treats alternate hash key syntax "key:" as a symbol.
+	<a href="http://sourceforge.net/p/scintilla/bugs/1810/">Bug #1810</a>.
+	</li>
+	<li>
+	Rust lexer handles bracketed Unicode string escapes like "\u{123abc}".
+	<a href="http://sourceforge.net/p/scintilla/bugs/1809/">Bug #1809</a>.
+	</li>
+	<li>
+	For GTK+ on Windows fix 64-bit build which was broken in 3.6.3.
+	</li>
+	<li>
 	For Qt, release builds have assertions turned off.
 	</li>
 	<li>
@@ -511,6 +569,23 @@ <h3>
 	<li>
 	IME target range displayed on Qt for OS X.
 	</li>
+	<li>
+	On Windows, make clipboard operations more robust by retrying OpenClipboard if it fails
+	as this may occur when another application has opened the clipboard.
+	</li>
+	<li>
+	On Windows back out change that removed use of def file to ensure
+	Scintilla_DirectFunction exported without name mangling.
+	<a href="http://sourceforge.net/p/scintilla/bugs/1813/">Bug #1813</a>.
+	</li>
+	<li>
+	On GTK+ and Qt over Win32 in Korean fix bug caused by last release's word input change.
+	</li>
+	<li>
+	For SciTE, more descriptive error messages are displayed when there are problems loading the
+	Lua startup script.
+	<a href="http://sourceforge.net/p/scintilla/feature-requests/1139/">Feature #1139.</a>
+	</li>
     </ul>
     <h3>
        <a href="http://www.scintilla.org/scite363.zip">Release 3.6.3</a>
diff --git a/scintilla/doc/index.html b/scintilla/doc/index.html
index 77161471..cc1365f3 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="20160118" />
+    <meta name="Date.Modified" content="20160313" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <style type="text/css">
         #versionlist {
@@ -56,8 +56,8 @@
           GTK+, and OS X</font>
         </td>
         <td width="40%" align="right">
-          <font color="#FFCC99" size="3"> Release version 3.6.3<br />
-           Site last modified January 18 2016</font>
+          <font color="#FFCC99" size="3"> Release version 3.6.4<br />
+           Site last modified March 13 2016</font>
         </td>
         <td width="20%">
           &nbsp;
@@ -72,6 +72,7 @@
       </tr>
     </table>
     <ul id="versionlist">
+      <li>Version 3.6.4 avoids some folding bugs by automatically unfolding and improves clipboard robustness on Win32.</li>
       <li>Version 3.6.3 supports idle-time styling.</li>
       <li>Version 3.6.2 fixes crashes and other bugs, particularly on Cocoa.</li>
       <li>Version 3.6.1 adds minor features and fixes bugs.</li>
diff --git a/scintilla/include/SciLexer.h b/scintilla/include/SciLexer.h
index adf45eca..55cfece6 100644
--- a/scintilla/include/SciLexer.h
+++ b/scintilla/include/SciLexer.h
@@ -132,6 +132,7 @@
 #define SCLEX_SREC 117
 #define SCLEX_IHEX 118
 #define SCLEX_TEHEX 119
+#define SCLEX_JSON 120
 #define SCLEX_AHK 200
 #define SCLEX_AUTOMATIC 1000
 #define SCE_P_DEFAULT 0
@@ -1809,6 +1810,20 @@
 #define SCE_HEX_CHECKSUM 16
 #define SCE_HEX_CHECKSUM_WRONG 17
 #define SCE_HEX_GARBAGE 18
+#define SCE_JSON_DEFAULT 0
+#define SCE_JSON_NUMBER 1
+#define SCE_JSON_STRING 2
+#define SCE_JSON_STRINGEOL 3
+#define SCE_JSON_PROPERTYNAME 4
+#define SCE_JSON_ESCAPESEQUENCE 5
+#define SCE_JSON_LINECOMMENT 6
+#define SCE_JSON_BLOCKCOMMENT 7
+#define SCE_JSON_OPERATOR 8
+#define SCE_JSON_URI 9
+#define SCE_JSON_COMPACTIRI 10
+#define SCE_JSON_KEYWORD 11
+#define SCE_JSON_LDKEYWORD 12
+#define SCE_JSON_ERROR 13
 /* --Autogenerated -- end of section automatically generated from Scintilla.iface */
 
 #endif
diff --git a/scintilla/include/Scintilla.iface b/scintilla/include/Scintilla.iface
index 6e2928ae..419b2b2f 100644
--- a/scintilla/include/Scintilla.iface
+++ b/scintilla/include/Scintilla.iface
@@ -2799,6 +2799,7 @@ val SCLEX_BIBTEX=116
 val SCLEX_SREC=117
 val SCLEX_IHEX=118
 val SCLEX_TEHEX=119
+val SCLEX_JSON=120
 ## notepad2 custom code for the AHK lexer - start
 val SCLEX_AHK=200
 ## notepad2 custom code for the AHK lexer - end
@@ -4705,6 +4706,22 @@ val SCE_HEX_GARBAGE=18
 lex IHex=SCLEX_IHEX SCE_HEX_
 # Lexical state for SCLEX_TEHEX (shared with Srec)
 lex TEHex=SCLEX_TEHEX SCE_HEX_
+# Lexical states for SCLEX_JSON
+lex JSON=SCLEX_JSON SCE_JSON_
+val SCE_JSON_DEFAULT=0
+val SCE_JSON_NUMBER=1
+val SCE_JSON_STRING=2
+val SCE_JSON_STRINGEOL=3
+val SCE_JSON_PROPERTYNAME=4
+val SCE_JSON_ESCAPESEQUENCE=5
+val SCE_JSON_LINECOMMENT=6
+val SCE_JSON_BLOCKCOMMENT=7
+val SCE_JSON_OPERATOR=8
+val SCE_JSON_URI=9
+val SCE_JSON_COMPACTIRI=10
+val SCE_JSON_KEYWORD=11
+val SCE_JSON_LDKEYWORD=12
+val SCE_JSON_ERROR=13
 
 # Events
 
diff --git a/scintilla/include/ScintillaWidget.h b/scintilla/include/ScintillaWidget.h
index 8409c655..89dedca8 100644
--- a/scintilla/include/ScintillaWidget.h
+++ b/scintilla/include/ScintillaWidget.h
@@ -44,7 +44,7 @@ struct _ScintillaClass {
 
 GType		scintilla_object_get_type		(void);
 GtkWidget*	scintilla_object_new			(void);
-long		scintilla_object_send_message	(ScintillaObject *sci, unsigned int iMessage, guintptr wParam, gintptr lParam);
+gintptr		scintilla_object_send_message	(ScintillaObject *sci, unsigned int iMessage, guintptr wParam, gintptr lParam);
 
 #ifndef G_IR_SCANNING
 /* The legacy names confuse the g-ir-scanner program */
diff --git a/scintilla/lexers/LexCPP.cxx b/scintilla/lexers/LexCPP.cxx
index fc9b5b86..76190002 100644
--- a/scintilla/lexers/LexCPP.cxx
+++ b/scintilla/lexers/LexCPP.cxx
@@ -1349,14 +1349,14 @@ void SCI_METHOD LexerCPP::Fold(Sci_PositionU startPos, Sci_Position length, int
 			}
 		}
 		if (options.foldSyntaxBased && (style == SCE_C_OPERATOR)) {
-			if (ch == '{' || ch == '[') {
+			if (ch == '{' || ch == '[' || ch == '(') {
 				// Measure the minimum before a '{' to allow
 				// folding on "} else {"
 				if (levelMinCurrent > levelNext) {
 					levelMinCurrent = levelNext;
 				}
 				levelNext++;
-			} else if (ch == '}' || ch == ']') {
+			} else if (ch == '}' || ch == ']' || ch == ')') {
 				levelNext--;
 			}
 		}
diff --git a/scintilla/lexers/LexJSON.cxx b/scintilla/lexers/LexJSON.cxx
new file mode 100644
index 00000000..9c044e52
--- /dev/null
+++ b/scintilla/lexers/LexJSON.cxx
@@ -0,0 +1,497 @@
+// Scintilla source code edit control
+/**
+ * @file LexJSON.cxx
+ * @date February 19, 2016
+ * @brief Lexer for JSON and JSON-LD formats
+ * @author nkmathew
+ *
+ * The License.txt file describes the conditions under which this software may
+ * be distributed.
+ *
+ */
+
+#include <cstdlib>
+#include <cassert>
+#include <cctype>
+#include <cstdio>
+#include <string>
+#include <vector>
+#include <map>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+
+#ifdef SCI_NAMESPACE
+using namespace Scintilla;
+#endif
+
+static const char *const JSONWordListDesc[] = {
+	"JSON Keywords",
+	"JSON-LD Keywords",
+	0
+};
+
+/**
+ * Used to detect compact IRI/URLs in JSON-LD without first looking ahead for the
+ * colon separating the prefix and suffix
+ *
+ * https://www.w3.org/TR/json-ld/#dfn-compact-iri
+ */
+struct CompactIRI {
+	int colonCount;
+	bool foundInvalidChar;
+	CharacterSet setCompactIRI;
+	CompactIRI() {
+		colonCount = 0;
+		foundInvalidChar = false;
+		setCompactIRI = CharacterSet(CharacterSet::setAlpha, "$_-");
+	}
+	void resetState() {
+		colonCount = 0;
+		foundInvalidChar = false;
+	}
+	void checkChar(int ch) {
+		if (ch == ':') {
+			colonCount++;
+		} else {
+			foundInvalidChar |= !setCompactIRI.Contains(ch);
+		}
+	}
+	bool shouldHighlight() const {
+		return !foundInvalidChar && colonCount == 1;
+	}
+};
+
+/**
+ * Keeps track of escaped characters in strings as per:
+ *
+ * https://tools.ietf.org/html/rfc7159#section-7
+ */
+struct EscapeSequence {
+	int digitsLeft;
+	CharacterSet setHexDigits;
+	CharacterSet setEscapeChars;
+	EscapeSequence() {
+		digitsLeft = 0;
+		setHexDigits = CharacterSet(CharacterSet::setDigits, "ABCDEFabcdef");
+		setEscapeChars = CharacterSet(CharacterSet::setNone, "\\\"tnbfru/");
+	}
+	// Returns true if the following character is a valid escaped character
+	bool newSequence(int nextChar) {
+		digitsLeft = 0;
+		if (nextChar == 'u') {
+			digitsLeft = 5;
+		} else if (!setEscapeChars.Contains(nextChar)) {
+			return false;
+		}
+		return true;
+	}
+	bool atEscapeEnd() const {
+		return digitsLeft <= 0;
+	}
+	bool isInvalidChar(int currChar) const {
+		return !setHexDigits.Contains(currChar);
+	}
+};
+
+struct OptionsJSON {
+	bool foldCompact;
+	bool fold;
+	bool allowComments;
+	bool escapeSequence;
+	OptionsJSON() {
+		foldCompact = false;
+		fold = false;
+		allowComments = false;
+		escapeSequence = false;
+	}
+};
+
+struct OptionSetJSON : public OptionSet<OptionsJSON> {
+	OptionSetJSON() {
+		DefineProperty("lexer.json.escape.sequence", &OptionsJSON::escapeSequence,
+					   "Set to 1 to enable highlighting of escape sequences in strings");
+
+		DefineProperty("lexer.json.allow.comments", &OptionsJSON::allowComments,
+					   "Set to 1 to enable highlighting of line/block comments in JSON");
+
+		DefineProperty("fold.compact", &OptionsJSON::foldCompact);
+		DefineProperty("fold", &OptionsJSON::fold);
+		DefineWordListSets(JSONWordListDesc);
+	}
+};
+
+class LexerJSON : public ILexer {
+	OptionsJSON options;
+	OptionSetJSON optSetJSON;
+	EscapeSequence escapeSeq;
+	WordList keywordsJSON;
+	WordList keywordsJSONLD;
+	CharacterSet setOperators;
+	CharacterSet setURL;
+	CharacterSet setKeywordJSONLD;
+	CharacterSet setKeywordJSON;
+	CompactIRI compactIRI;
+
+	static bool IsNextNonWhitespace(LexAccessor &styler, Sci_Position start, char ch) {
+		Sci_Position i = 0;
+		while (i < 50) {
+			i++;
+			char curr = styler.SafeGetCharAt(start+i, '\0');
+			char next = styler.SafeGetCharAt(start+i+1, '\0');
+			bool atEOL = (curr == '\r' && next != '\n') || (curr == '\n');
+			if (curr == ch) {
+				return true;
+			} else if (!isspacechar(curr) || atEOL) {
+				return false;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Looks for the colon following the end quote
+	 *
+	 * Assumes property names of lengths no longer than a 100 characters.
+	 * The colon is also expected to be less than 50 spaces after the end
+	 * quote for the string to be considered a property name
+	 */
+	static bool AtPropertyName(LexAccessor &styler, Sci_Position start) {
+		Sci_Position i = 0;
+		bool escaped = false;
+		while (i < 100) {
+			i++;
+			char curr = styler.SafeGetCharAt(start+i, '\0');
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			escaped = curr == '\\';
+			if (curr == '"') {
+				return IsNextNonWhitespace(styler, start+i, ':');
+			} else if (!curr) {
+				return false;
+			}
+		}
+		return false;
+	}
+
+	static bool IsNextWordInList(WordList &keywordList, CharacterSet wordSet,
+								 StyleContext &context, LexAccessor &styler) {
+		char word[51];
+		Sci_Position currPos = (Sci_Position) context.currentPos;
+		int i = 0;
+		while (i < 50) {
+			char ch = styler.SafeGetCharAt(currPos + i);
+			if (!wordSet.Contains(ch)) {
+				break;
+			}
+			word[i] = ch;
+			i++;
+		}
+		word[i] = '\0';
+		return keywordList.InList(word);
+	}
+
+	public:
+	LexerJSON() :
+		setOperators(CharacterSet::setNone, "[{}]:,"),
+		setURL(CharacterSet::setAlphaNum, "-._~:/?#[]@!$&'()*+,),="),
+		setKeywordJSONLD(CharacterSet::setAlpha, ":@"),
+		setKeywordJSON(CharacterSet::setAlpha, "$_") {
+	}
+	virtual ~LexerJSON() {}
+	virtual int SCI_METHOD Version() const {
+		return lvOriginal;
+	}
+	virtual void SCI_METHOD Release() {
+		delete this;
+	}
+	virtual const char *SCI_METHOD PropertyNames() {
+		return optSetJSON.PropertyNames();
+	}
+	virtual int SCI_METHOD PropertyType(const char *name) {
+		return optSetJSON.PropertyType(name);
+	}
+	virtual const char *SCI_METHOD DescribeProperty(const char *name) {
+		return optSetJSON.DescribeProperty(name);
+	}
+	virtual Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) {
+		if (optSetJSON.PropertySet(&options, key, val)) {
+			return 0;
+		}
+		return -1;
+	}
+	virtual Sci_Position SCI_METHOD WordListSet(int n, const char *wl) {
+		WordList *wordListN = 0;
+		switch (n) {
+			case 0:
+				wordListN = &keywordsJSON;
+				break;
+			case 1:
+				wordListN = &keywordsJSONLD;
+				break;
+		}
+		Sci_Position firstModification = -1;
+		if (wordListN) {
+			WordList wlNew;
+			wlNew.Set(wl);
+			if (*wordListN != wlNew) {
+				wordListN->Set(wl);
+				firstModification = 0;
+			}
+		}
+		return firstModification;
+	}
+	virtual void *SCI_METHOD PrivateCall(int, void *) {
+		return 0;
+	}
+	static ILexer *LexerFactoryJSON() {
+		return new LexerJSON;
+	}
+	virtual const char *SCI_METHOD DescribeWordListSets() {
+		return optSetJSON.DescribeWordListSets();
+	}
+	virtual void SCI_METHOD Lex(Sci_PositionU startPos,
+								Sci_Position length,
+								int initStyle,
+								IDocument *pAccess);
+	virtual void SCI_METHOD Fold(Sci_PositionU startPos,
+								 Sci_Position length,
+								 int initStyle,
+								 IDocument *pAccess);
+};
+
+void SCI_METHOD LexerJSON::Lex(Sci_PositionU startPos,
+							   Sci_Position length,
+							   int initStyle,
+							   IDocument *pAccess) {
+	LexAccessor styler(pAccess);
+	StyleContext context(startPos, length, initStyle, styler);
+	int stringStyleBefore = SCE_JSON_STRING;
+	while (context.More()) {
+		switch (context.state) {
+			case SCE_JSON_BLOCKCOMMENT:
+				if (context.Match("*/")) {
+					context.Forward();
+					context.ForwardSetState(SCE_JSON_DEFAULT);
+				}
+				break;
+			case SCE_JSON_LINECOMMENT:
+				if (context.atLineEnd) {
+					context.SetState(SCE_JSON_DEFAULT);
+				}
+				break;
+			case SCE_JSON_STRINGEOL:
+				if (context.atLineStart) {
+					context.SetState(SCE_JSON_DEFAULT);
+				}
+				break;
+			case SCE_JSON_ESCAPESEQUENCE:
+				escapeSeq.digitsLeft--;
+				if (!escapeSeq.atEscapeEnd()) {
+					if (escapeSeq.isInvalidChar(context.ch)) {
+						context.SetState(SCE_JSON_ERROR);
+					}
+					break;
+				}
+				if (context.ch == '"') {
+					context.SetState(stringStyleBefore);
+					context.ForwardSetState(SCE_C_DEFAULT);
+				} else if (context.ch == '\\') {
+					if (!escapeSeq.newSequence(context.chNext)) {
+						context.SetState(SCE_JSON_ERROR);
+					}
+					context.Forward();
+				} else {
+					context.SetState(stringStyleBefore);
+					if (context.atLineEnd) {
+						context.ChangeState(SCE_JSON_STRINGEOL);
+					}
+				}
+				break;
+			case SCE_JSON_PROPERTYNAME:
+			case SCE_JSON_STRING:
+				if (context.ch == '"') {
+					if (compactIRI.shouldHighlight()) {
+						context.ChangeState(SCE_JSON_COMPACTIRI);
+						context.ForwardSetState(SCE_JSON_DEFAULT);
+						compactIRI.resetState();
+					} else {
+						context.ForwardSetState(SCE_JSON_DEFAULT);
+					}
+				} else if (context.atLineEnd) {
+					context.ChangeState(SCE_JSON_STRINGEOL);
+				} else if (context.ch == '\\') {
+					stringStyleBefore = context.state;
+					if (options.escapeSequence) {
+						context.SetState(SCE_JSON_ESCAPESEQUENCE);
+						if (!escapeSeq.newSequence(context.chNext)) {
+							context.SetState(SCE_JSON_ERROR);
+						}
+					}
+					context.Forward();
+				} else if (context.Match("https://") ||
+						   context.Match("http://") ||
+						   context.Match("ssh://") ||
+						   context.Match("git://") ||
+						   context.Match("svn://") ||
+						   context.Match("ftp://") ||
+						   context.Match("mailto:")) {
+					// Handle most common URI schemes only
+					stringStyleBefore = context.state;
+					context.SetState(SCE_JSON_URI);
+				} else if (context.ch == '@') {
+					// https://www.w3.org/TR/json-ld/#dfn-keyword
+					if (IsNextWordInList(keywordsJSONLD, setKeywordJSONLD, context, styler)) {
+						stringStyleBefore = context.state;
+						context.SetState(SCE_JSON_LDKEYWORD);
+					}
+				} else {
+					compactIRI.checkChar(context.ch);
+				}
+				break;
+			case SCE_JSON_LDKEYWORD:
+			case SCE_JSON_URI:
+				if ((!setKeywordJSONLD.Contains(context.ch) &&
+					 (context.state == SCE_JSON_LDKEYWORD)) ||
+					(!setURL.Contains(context.ch))) {
+					context.SetState(stringStyleBefore);
+				}
+				if (context.ch == '"') {
+					context.ForwardSetState(SCE_JSON_DEFAULT);
+				} else if (context.atLineEnd) {
+					context.ChangeState(SCE_JSON_STRINGEOL);
+				}
+				break;
+			case SCE_JSON_OPERATOR:
+			case SCE_JSON_NUMBER:
+				context.SetState(SCE_JSON_DEFAULT);
+				break;
+			case SCE_JSON_ERROR:
+				if (context.atLineEnd) {
+					context.SetState(SCE_JSON_DEFAULT);
+				}
+				break;
+			case SCE_JSON_KEYWORD:
+				if (!setKeywordJSON.Contains(context.ch)) {
+					context.SetState(SCE_JSON_DEFAULT);
+				}
+				break;
+		}
+		if (context.state == SCE_JSON_DEFAULT) {
+			if (context.ch == '"') {
+				compactIRI.resetState();
+				context.SetState(SCE_JSON_STRING);
+				Sci_Position currPos = static_cast<Sci_Position>(context.currentPos);
+				if (AtPropertyName(styler, currPos)) {
+					context.SetState(SCE_JSON_PROPERTYNAME);
+				}
+			} else if (setOperators.Contains(context.ch)) {
+				context.SetState(SCE_JSON_OPERATOR);
+			} else if (options.allowComments && context.Match("/*")) {
+				context.SetState(SCE_JSON_BLOCKCOMMENT);
+				context.Forward();
+			} else if (options.allowComments && context.Match("//")) {
+				context.SetState(SCE_JSON_LINECOMMENT);
+			} else if (setKeywordJSON.Contains(context.ch)) {
+				if (IsNextWordInList(keywordsJSON, setKeywordJSON, context, styler)) {
+					context.SetState(SCE_JSON_KEYWORD);
+				}
+			}
+			bool numberStart =
+				IsADigit(context.ch) && (context.chPrev == '+'||
+										 context.chPrev == '-' ||
+										 context.atLineStart ||
+										 IsASpace(context.chPrev) ||
+										 setOperators.Contains(context.chPrev));
+			bool exponentPart =
+				tolower(context.ch) == 'e' &&
+				IsADigit(context.chPrev) &&
+				(IsADigit(context.chNext) ||
+				 context.chNext == '+' ||
+				 context.chNext == '-');
+			bool signPart =
+				(context.ch == '-' || context.ch == '+') &&
+				((tolower(context.chPrev) == 'e' && IsADigit(context.chNext)) ||
+				 ((IsASpace(context.chPrev) || setOperators.Contains(context.chPrev))
+				  && IsADigit(context.chNext)));
+			bool adjacentDigit =
+				IsADigit(context.ch) && IsADigit(context.chPrev);
+			bool afterExponent = IsADigit(context.ch) && tolower(context.chPrev) == 'e';
+			bool dotPart = context.ch == '.' &&
+				IsADigit(context.chPrev) &&
+				IsADigit(context.chNext);
+			bool afterDot = IsADigit(context.ch) && context.chPrev == '.';
+			if (numberStart ||
+				exponentPart ||
+				signPart ||
+				adjacentDigit ||
+				dotPart ||
+				afterExponent ||
+				afterDot) {
+				context.SetState(SCE_JSON_NUMBER);
+			} else if (context.state == SCE_JSON_DEFAULT && !IsASpace(context.ch)) {
+				context.SetState(SCE_JSON_ERROR);
+			}
+		}
+		context.Forward();
+	}
+	context.Complete();
+}
+
+void SCI_METHOD LexerJSON::Fold(Sci_PositionU startPos,
+								Sci_Position length,
+								int,
+								IDocument *pAccess) {
+	if (!options.fold) {
+		return;
+	}
+	LexAccessor styler(pAccess);
+	Sci_PositionU currLine = styler.GetLine(startPos);
+	Sci_PositionU endPos = startPos + length;
+	int currLevel = styler.LevelAt(currLine) & SC_FOLDLEVELNUMBERMASK;
+	int nextLevel = currLevel;
+	int visibleChars = 0;
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		char curr = styler.SafeGetCharAt(i);
+		char next = styler.SafeGetCharAt(i+1);
+		bool atEOL = (curr == '\r' && next != '\n') || (curr == '\n');
+		if (styler.StyleAt(i) == SCE_JSON_OPERATOR) {
+			if (curr == '{' || curr == '[') {
+				nextLevel++;
+			} else if (curr == '}' || curr == ']') {
+				nextLevel--;
+			}
+		}
+		if (atEOL || i == (endPos-1)) {
+			int level = currLevel;
+			if (!visibleChars && options.foldCompact) {
+				level |= SC_FOLDLEVELWHITEFLAG;
+			} else if (nextLevel > currLevel) {
+				level |= SC_FOLDLEVELHEADERFLAG;
+			}
+			if (level != styler.LevelAt(currLine)) {
+				styler.SetLevel(currLine, level);
+			}
+			currLine++;
+			currLevel = nextLevel;
+			visibleChars = 0;
+		}
+		if (!isspacechar(curr)) {
+			visibleChars++;
+		}
+	}
+}
+
+LexerModule lmJSON(SCLEX_JSON,
+				   LexerJSON::LexerFactoryJSON,
+				   "json",
+				   JSONWordListDesc);
diff --git a/scintilla/lexers/LexProgress.cxx b/scintilla/lexers/LexProgress.cxx
index 198d98c2..19f43f42 100644
--- a/scintilla/lexers/LexProgress.cxx
+++ b/scintilla/lexers/LexProgress.cxx
@@ -9,7 +9,6 @@
 /** TODO:
 WebSpeed support in html lexer
 Support "end triggers" expression of the triggers phrase
-Support more than 6 comments levels
 **/
 #include <stdlib.h>
 #include <string.h>
@@ -44,13 +43,26 @@ static inline bool IsAWordStart(int ch) {
 enum SentenceStart { SetSentenceStart = 0xf, ResetSentenceStart = 0x10}; // true -> bit = 0
 
 static void Colourise4glDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
-                            Accessor &styler) {
+							Accessor &styler) {
+
+	WordList &keywords1 = *keywordlists[0];   // regular keywords
+	WordList &keywords2 = *keywordlists[1];   // block opening keywords, only when SentenceStart
+	WordList &keywords3 = *keywordlists[2];   // block opening keywords
+	//WordList &keywords4 = *keywordlists[3]; // preprocessor keywords. Not implemented
 
-    WordList &keywords1 = *keywordlists[0];   // regular keywords
-    WordList &keywords2 = *keywordlists[1];   // block opening keywords, only when SentenceStart
-    WordList &keywords3 = *keywordlists[2];   // block opening keywords
-    //WordList &keywords4 = *keywordlists[3]; // preprocessor keywords. Not implemented
+	Sci_Position currentLine = styler.GetLine(startPos);
+	// Initialize the block comment /* */ nesting level, if we are inside such a comment.
+	int blockCommentLevel = 0;
+	if (initStyle == SCE_4GL_COMMENT1 ||
+		initStyle == SCE_4GL_COMMENT1_) {
+		blockCommentLevel = styler.GetLineState(currentLine - 1);
+	}
 
+	// Do not leak single-line comments onto next line
+	if (initStyle == SCE_4GL_COMMENT2 ||
+		initStyle == SCE_4GL_COMMENT2_) {
+		initStyle = SCE_4GL_DEFAULT;
+	}
 
 	int visibleChars = 0;
 	int mask;
@@ -65,6 +77,19 @@ static void Colourise4glDoc(Sci_PositionU startPos, Sci_Position length, int ini
 			visibleChars = 0;
 		}
 
+		if (sc.atLineEnd) {
+			// Update the line state, so it can be seen by next line
+			currentLine = styler.GetLine(sc.currentPos);
+			if (sc.state == SCE_4GL_COMMENT1 ||
+				sc.state == SCE_4GL_COMMENT1_) {
+				// Inside a block comment, we set the line state
+				styler.SetLineState(currentLine, blockCommentLevel);
+			} else {
+				// Reset the line state
+				styler.SetLineState(currentLine, 0);
+			}
+		}
+
 		// Handle line continuation generically.
 		if ((sc.state & 0xf) < SCE_4GL_COMMENT1) {
 		if (sc.ch == '~') {
@@ -96,7 +121,9 @@ static void Colourise4glDoc(Sci_PositionU startPos, Sci_Position length, int ini
 				sc.SetState(SCE_4GL_DEFAULT | mask);
 				break;
 			case SCE_4GL_NUMBER:
-				if (!(IsADigit(sc.ch))) {
+				// Hex numbers (0xnnnn) are supported so accept any
+				// alphanumeric character if it follows a leading digit.
+				if (!(IsAlphaNumeric(sc.ch))) {
 					sc.SetState(SCE_4GL_DEFAULT | mask);
 				}
 				break;
@@ -104,10 +131,10 @@ static void Colourise4glDoc(Sci_PositionU startPos, Sci_Position length, int ini
 				if (!IsAWordChar(sc.ch) && sc.ch != '-') {
 					char s[1000];
 					sc.GetCurrentLowered(s, sizeof(s));
-					if ((((sc.state & 0x10) == 0) && keywords2.InList(s)) || keywords3.InList(s)) {
+					if ((((sc.state & 0x10) == 0) && keywords2.InListAbbreviated(s, '(')) || keywords3.InListAbbreviated(s, '(')) {
 						sc.ChangeState(SCE_4GL_BLOCK | ResetSentenceStart);
 					}
-					else if (keywords1.InList(s)) {
+					else if (keywords1.InListAbbreviated(s, '(')) {
 						if ((s[0] == 'e' && s[1] =='n' && s[2] == 'd' && !isalnum(s[3]) && s[3] != '-') ||
 							(s[0] == 'f' && s[1] =='o' && s[2] == 'r' && s[3] == 'w' && s[4] =='a' && s[5] == 'r' && s[6] == 'd'&& !isalnum(s[7]))) {
 							sc.ChangeState(SCE_4GL_END | ResetSentenceStart);
@@ -141,20 +168,23 @@ static void Colourise4glDoc(Sci_PositionU startPos, Sci_Position length, int ini
 					sc.ForwardSetState(SCE_4GL_DEFAULT | mask);
 				}
 				break;
-			default:
-				if ((sc.state & 0xf) >= SCE_4GL_COMMENT1) {
-					if (sc.ch == '*' && sc.chNext == '/') {
-						sc.Forward();
-						if ((sc.state & 0xf) == SCE_4GL_COMMENT1) {
-							sc.ForwardSetState(SCE_4GL_DEFAULT | mask);
-						}
-						else
-							sc.SetState((sc.state & 0x1f) - 1);
-					} else if (sc.ch == '/' && sc.chNext == '*') {
-						sc.Forward();
-						sc.SetState((sc.state & 0x1f) + 1);
+			case SCE_4GL_COMMENT1:
+				if (sc.Match('/', '*')) {
+					blockCommentLevel++;
+					sc.Forward();
+				} else if (sc.Match('*', '/') && blockCommentLevel > 0) {
+					blockCommentLevel--;
+					sc.Forward();
+					if (blockCommentLevel == 0) {
+						sc.ForwardSetState(SCE_4GL_DEFAULT | mask);
 					}
 				}
+				break;
+			case SCE_4GL_COMMENT2:
+				if (sc.atLineEnd) {
+					sc.ForwardSetState(SCE_4GL_DEFAULT | mask);
+				}
+				break;
 		}
 
 		// Determine if a new state should be entered.
@@ -164,9 +194,13 @@ static void Colourise4glDoc(Sci_PositionU startPos, Sci_Position length, int ini
 				sc.SetState(SCE_4GL_NUMBER | ResetSentenceStart);
 			} else if (IsAWordStart(sc.ch) || (sc.ch == '@')) {
 				sc.SetState(SCE_4GL_IDENTIFIER | mask);
-			} else if (sc.ch == '/' && sc.chNext == '*') {
+			} else if (sc.Match('/', '*')) {
+				blockCommentLevel = 1;
 				sc.SetState(SCE_4GL_COMMENT1 | mask);
 				sc.Forward();
+			} else if (sc.Match('/', '/') &&
+					   (sc.atLineStart || sc.chPrev == ' ')) {
+				sc.SetState(SCE_4GL_COMMENT2 | mask);
 			} else if (sc.ch == '\"') {
 				sc.SetState(SCE_4GL_STRING | ResetSentenceStart);
 			} else if (sc.ch == '\'') {
@@ -199,7 +233,7 @@ static void Colourise4glDoc(Sci_PositionU startPos, Sci_Position length, int ini
 }
 
 static bool IsStreamCommentStyle(int style) {
-	return (style & 0xf) >= SCE_4GL_COMMENT1 ;
+	return (style & 0xf) == SCE_4GL_COMMENT1 ;
 }
 
 // Store both the current line's fold level and the next lines in the
diff --git a/scintilla/lexers/LexPython.cxx b/scintilla/lexers/LexPython.cxx
index b7317ae9..7062220d 100644
--- a/scintilla/lexers/LexPython.cxx
+++ b/scintilla/lexers/LexPython.cxx
@@ -117,6 +117,17 @@ inline bool IsAWordStart(int ch) {
 	return (ch < 0x80) && (isalnum(ch) || ch == '_');
 }
 
+static bool IsFirstNonWhitespace(Sci_Position pos, Accessor &styler) {
+	Sci_Position line = styler.GetLine(pos);
+	Sci_Position start_pos = styler.LineStart(line);
+	for (Sci_Position i = start_pos; i < pos; i++) {
+		char ch = styler[i];
+		if (!(ch == ' ' || ch == '\t'))
+			return false;
+	}
+	return true;
+}
+
 // Options used for LexerPython
 struct OptionsPython {
 	int whingeLevel;
@@ -560,7 +571,10 @@ void SCI_METHOD LexerPython::Lex(Sci_PositionU startPos, Sci_Position length, in
 			} else if (sc.ch == '#') {
 				sc.SetState(sc.chNext == '#' ? SCE_P_COMMENTBLOCK : SCE_P_COMMENTLINE);
 			} else if (sc.ch == '@') {
-				sc.SetState(SCE_P_DECORATOR);
+				if (IsFirstNonWhitespace(sc.currentPos, styler))
+					sc.SetState(SCE_P_DECORATOR);
+				else
+					sc.SetState(SCE_P_OPERATOR);
 			} else if (IsPyStringStart(sc.ch, sc.chNext, sc.GetRelative(2), allowedLiterals)) {
 				Sci_PositionU nextIndex = 0;
 				sc.SetState(GetPyStringState(styler, sc.currentPos, &nextIndex, allowedLiterals));
diff --git a/scintilla/lexers/LexRuby.cxx b/scintilla/lexers/LexRuby.cxx
index 520746c2..f4ae18e8 100644
--- a/scintilla/lexers/LexRuby.cxx
+++ b/scintilla/lexers/LexRuby.cxx
@@ -433,6 +433,32 @@ static bool haveTargetMatch(Sci_Position currPos,
     return true;
 }
 
+// Finds the start position of the expression containing @p pos
+// @p min_pos should be a known expression start, e.g. the start of the line
+static Sci_Position findExpressionStart(Sci_Position pos,
+                                        Sci_Position min_pos,
+                                        Accessor &styler) {
+    int depth = 0;
+    for (; pos > min_pos; pos -= 1) {
+        int style = styler.StyleAt(pos - 1);
+        if (style == SCE_RB_OPERATOR) {
+            int ch = styler[pos - 1];
+            if (ch == '}' || ch == ')' || ch == ']') {
+                depth += 1;
+            } else if (ch == '{' || ch == '(' || ch == '[') {
+                if (depth == 0) {
+                    break;
+                } else {
+                    depth -= 1;
+                }
+            } else if (ch == ';' && depth == 0) {
+                break;
+            }
+        }
+    }
+    return pos;
+}
+
 // We need a check because the form
 // [identifier] <<[target]
 // is ambiguous.  The Ruby lexer/parser resolves it by
@@ -458,14 +484,18 @@ static bool sureThisIsNotHeredoc(Sci_Position lt2StartPos,
     const bool definitely_not_a_here_doc = true;
     const bool looks_like_a_here_doc = false;
 
+    // find the expression start rather than the line start
+    Sci_Position exprStartPosn = findExpressionStart(lt2StartPos, lineStartPosn, styler);
+
     // Find the first word after some whitespace
-    Sci_Position firstWordPosn = skipWhitespace(lineStartPosn, lt2StartPos, styler);
+    Sci_Position firstWordPosn = skipWhitespace(exprStartPosn, lt2StartPos, styler);
     if (firstWordPosn >= lt2StartPos) {
         return definitely_not_a_here_doc;
     }
     prevStyle = styler.StyleAt(firstWordPosn);
     // If we have '<<' following a keyword, it's not a heredoc
     if (prevStyle != SCE_RB_IDENTIFIER
+            && prevStyle != SCE_RB_SYMBOL
             && prevStyle != SCE_RB_INSTANCE_VAR
             && prevStyle != SCE_RB_CLASS_VAR) {
         return definitely_not_a_here_doc;
@@ -503,6 +533,16 @@ static bool sureThisIsNotHeredoc(Sci_Position lt2StartPos,
     }
     // 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) {
+        for (; firstWordPosn <= lt2StartPos; firstWordPosn += 1) {
+            if (styler.StyleAt(firstWordPosn) != SCE_RB_SYMBOL) {
+                break;
+            }
+        }
+        // Skip next batch of white-space
+        firstWordPosn = skipWhitespace(firstWordPosn, lt2StartPos, styler);
+    }
     if (firstWordPosn != lt2StartPos) {
         // Have [[^ws[identifier]ws[*something_else*]ws<<
         return definitely_not_a_here_doc;
@@ -1088,6 +1128,10 @@ static void ColouriseRbDoc(Sci_PositionU startPos, Sci_Position length, int init
                     // <name>= is a name only when being def'd -- Get it the next time
                     // This means that <name>=<name> is always lexed as
                     // <name>, (op, =), <name>
+                } else if (ch == ':'
+                           && isSafeWordcharOrHigh(chPrev)
+                           && strchr(" \t\n\r", chNext) != NULL) {
+                    state = SCE_RB_SYMBOL;
                 } else if ((ch == '?' || ch == '!')
                            && isSafeWordcharOrHigh(chPrev)
                            && !isSafeWordcharOrHigh(chNext)) {
diff --git a/scintilla/lexers/LexRust.cxx b/scintilla/lexers/LexRust.cxx
index ca5f3c7f..0d40de2c 100644
--- a/scintilla/lexers/LexRust.cxx
+++ b/scintilla/lexers/LexRust.cxx
@@ -407,7 +407,18 @@ static void ScanCharacterLiteralOrLifetime(Accessor &styler, Sci_Position& pos,
 					valid_char = ScanNumericEscape(styler, pos, 2, false);
 				} else if (n == 'u' && !ascii_only) {
 					pos += 2;
-					valid_char = ScanNumericEscape(styler, pos, 4, false);
+					if (styler.SafeGetCharAt(pos, '\0') != '{') {
+						// old-style
+						valid_char = ScanNumericEscape(styler, pos, 4, false);
+					} else {
+						int n_digits = 0;
+						while (IsADigit(styler.SafeGetCharAt(++pos, '\0'), 16) && n_digits++ < 6) {
+						}
+						if (n_digits > 0 && styler.SafeGetCharAt(pos, '\0') == '}')
+							pos++;
+						else
+							valid_char = false;
+					}
 				} else if (n == 'U' && !ascii_only) {
 					pos += 2;
 					valid_char = ScanNumericEscape(styler, pos, 8, false);
@@ -579,7 +590,18 @@ static void ResumeString(Accessor &styler, Sci_Position& pos, Sci_Position max,
 				error = !ScanNumericEscape(styler, pos, 2, true);
 			} else if (n == 'u' && !ascii_only) {
 				pos += 2;
-				error = !ScanNumericEscape(styler, pos, 4, true);
+				if (styler.SafeGetCharAt(pos, '\0') != '{') {
+					// old-style
+					error = !ScanNumericEscape(styler, pos, 4, true);
+				} else {
+					int n_digits = 0;
+					while (IsADigit(styler.SafeGetCharAt(++pos, '\0'), 16) && n_digits++ < 6) {
+					}
+					if (n_digits > 0 && styler.SafeGetCharAt(pos, '\0') == '}')
+						pos++;
+					else
+						error = true;
+				}
 			} else if (n == 'U' && !ascii_only) {
 				pos += 2;
 				error = !ScanNumericEscape(styler, pos, 8, true);
diff --git a/scintilla/scripts/HeaderOrder.txt b/scintilla/scripts/HeaderOrder.txt
index ff92bac2..054086d4 100644
--- a/scintilla/scripts/HeaderOrder.txt
+++ b/scintilla/scripts/HeaderOrder.txt
@@ -3,10 +3,10 @@
 // and each of these groups are then divided into directory groups.
 
 // C standard library
+#include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include <stddef.h>
 #include <stdarg.h>
 #include <time.h>
 #include <math.h>
diff --git a/scintilla/src/Catalogue.cxx b/scintilla/src/Catalogue.cxx
index 5eedabc3..0c1e22c2 100644
--- a/scintilla/src/Catalogue.cxx
+++ b/scintilla/src/Catalogue.cxx
@@ -127,6 +127,7 @@ int Scintilla_LinkLexers() {
 	LINK_LEXER(lmHTML);
 	//LINK_LEXER(lmIHex);
 	LINK_LEXER(lmInno);
+	//LINK_LEXER(lmJSON);
 	//LINK_LEXER(lmKix);
 	//LINK_LEXER(lmKVIrc);
 	LINK_LEXER(lmLatex);
diff --git a/scintilla/src/Document.cxx b/scintilla/src/Document.cxx
index bea6a3e3..1d029623 100644
--- a/scintilla/src/Document.cxx
+++ b/scintilla/src/Document.cxx
@@ -436,12 +436,12 @@ static bool IsSubordinate(int levelStart, int levelTry) {
 	if (levelTry & SC_FOLDLEVELWHITEFLAG)
 		return true;
 	else
-		return (levelStart & SC_FOLDLEVELNUMBERMASK) < (levelTry & SC_FOLDLEVELNUMBERMASK);
+		return LevelNumber(levelStart) < LevelNumber(levelTry);
 }
 
 int Document::GetLastChild(int lineParent, int level, int lastLine) {
 	if (level == -1)
-		level = GetLevel(lineParent) & SC_FOLDLEVELNUMBERMASK;
+		level = LevelNumber(GetLevel(lineParent));
 	int maxLine = LinesTotal();
 	int lookLastLine = (lastLine != -1) ? Platform::Minimum(LinesTotal() - 1, lastLine) : -1;
 	int lineMaxSubord = lineParent;
@@ -454,7 +454,7 @@ int Document::GetLastChild(int lineParent, int level, int lastLine) {
 		lineMaxSubord++;
 	}
 	if (lineMaxSubord > lineParent) {
-		if (level > (GetLevel(lineMaxSubord + 1) & SC_FOLDLEVELNUMBERMASK)) {
+		if (level > LevelNumber(GetLevel(lineMaxSubord + 1))) {
 			// Have chewed up some whitespace that belongs to a parent so seek back
 			if (GetLevel(lineMaxSubord) & SC_FOLDLEVELWHITEFLAG) {
 				lineMaxSubord--;
@@ -465,16 +465,16 @@ int Document::GetLastChild(int lineParent, int level, int lastLine) {
 }
 
 int Document::GetFoldParent(int line) const {
-	int level = GetLevel(line) & SC_FOLDLEVELNUMBERMASK;
+	int level = LevelNumber(GetLevel(line));
 	int lineLook = line - 1;
 	while ((lineLook > 0) && (
 	            (!(GetLevel(lineLook) & SC_FOLDLEVELHEADERFLAG)) ||
-	            ((GetLevel(lineLook) & SC_FOLDLEVELNUMBERMASK) >= level))
+	            (LevelNumber(GetLevel(lineLook)) >= level))
 	      ) {
 		lineLook--;
 	}
 	if ((GetLevel(lineLook) & SC_FOLDLEVELHEADERFLAG) &&
-	        ((GetLevel(lineLook) & SC_FOLDLEVELNUMBERMASK) < level)) {
+	        (LevelNumber(GetLevel(lineLook)) < level)) {
 		return lineLook;
 	} else {
 		return -1;
@@ -487,11 +487,11 @@ void Document::GetHighlightDelimiters(HighlightDelimiter &highlightDelimiter, in
 
 	int lookLine = line;
 	int lookLineLevel = level;
-	int lookLineLevelNum = lookLineLevel & SC_FOLDLEVELNUMBERMASK;
+	int lookLineLevelNum = LevelNumber(lookLineLevel);
 	while ((lookLine > 0) && ((lookLineLevel & SC_FOLDLEVELWHITEFLAG) ||
-		((lookLineLevel & SC_FOLDLEVELHEADERFLAG) && (lookLineLevelNum >= (GetLevel(lookLine + 1) & SC_FOLDLEVELNUMBERMASK))))) {
+		((lookLineLevel & SC_FOLDLEVELHEADERFLAG) && (lookLineLevelNum >= LevelNumber(GetLevel(lookLine + 1)))))) {
 		lookLineLevel = GetLevel(--lookLine);
-		lookLineLevelNum = lookLineLevel & SC_FOLDLEVELNUMBERMASK;
+		lookLineLevelNum = LevelNumber(lookLineLevel);
 	}
 
 	int beginFoldBlock = (lookLineLevel & SC_FOLDLEVELHEADERFLAG) ? lookLine : GetFoldParent(lookLine);
@@ -505,7 +505,7 @@ void Document::GetHighlightDelimiters(HighlightDelimiter &highlightDelimiter, in
 	if (endFoldBlock < line) {
 		lookLine = beginFoldBlock - 1;
 		lookLineLevel = GetLevel(lookLine);
-		lookLineLevelNum = lookLineLevel & SC_FOLDLEVELNUMBERMASK;
+		lookLineLevelNum = LevelNumber(lookLineLevel);
 		while ((lookLine >= 0) && (lookLineLevelNum >= SC_FOLDLEVELBASE)) {
 			if (lookLineLevel & SC_FOLDLEVELHEADERFLAG) {
 				if (GetLastChild(lookLine, -1, lookLastLine) == line) {
@@ -514,17 +514,17 @@ void Document::GetHighlightDelimiters(HighlightDelimiter &highlightDelimiter, in
 					firstChangeableLineBefore = line - 1;
 				}
 			}
-			if ((lookLine > 0) && (lookLineLevelNum == SC_FOLDLEVELBASE) && ((GetLevel(lookLine - 1) & SC_FOLDLEVELNUMBERMASK) > lookLineLevelNum))
+			if ((lookLine > 0) && (lookLineLevelNum == SC_FOLDLEVELBASE) && (LevelNumber(GetLevel(lookLine - 1)) > lookLineLevelNum))
 				break;
 			lookLineLevel = GetLevel(--lookLine);
-			lookLineLevelNum = lookLineLevel & SC_FOLDLEVELNUMBERMASK;
+			lookLineLevelNum = LevelNumber(lookLineLevel);
 		}
 	}
 	if (firstChangeableLineBefore == -1) {
-		for (lookLine = line - 1, lookLineLevel = GetLevel(lookLine), lookLineLevelNum = lookLineLevel & SC_FOLDLEVELNUMBERMASK;
+		for (lookLine = line - 1, lookLineLevel = GetLevel(lookLine), lookLineLevelNum = LevelNumber(lookLineLevel);
 			lookLine >= beginFoldBlock;
-			lookLineLevel = GetLevel(--lookLine), lookLineLevelNum = lookLineLevel & SC_FOLDLEVELNUMBERMASK) {
-			if ((lookLineLevel & SC_FOLDLEVELWHITEFLAG) || (lookLineLevelNum > (level & SC_FOLDLEVELNUMBERMASK))) {
+			lookLineLevel = GetLevel(--lookLine), lookLineLevelNum = LevelNumber(lookLineLevel)) {
+			if ((lookLineLevel & SC_FOLDLEVELWHITEFLAG) || (lookLineLevelNum > LevelNumber(level))) {
 				firstChangeableLineBefore = lookLine;
 				break;
 			}
@@ -534,10 +534,10 @@ void Document::GetHighlightDelimiters(HighlightDelimiter &highlightDelimiter, in
 		firstChangeableLineBefore = beginFoldBlock - 1;
 
 	int firstChangeableLineAfter = -1;
-	for (lookLine = line + 1, lookLineLevel = GetLevel(lookLine), lookLineLevelNum = lookLineLevel & SC_FOLDLEVELNUMBERMASK;
+	for (lookLine = line + 1, lookLineLevel = GetLevel(lookLine), lookLineLevelNum = LevelNumber(lookLineLevel);
 		lookLine <= endFoldBlock;
-		lookLineLevel = GetLevel(++lookLine), lookLineLevelNum = lookLineLevel & SC_FOLDLEVELNUMBERMASK) {
-		if ((lookLineLevel & SC_FOLDLEVELHEADERFLAG) && (lookLineLevelNum < (GetLevel(lookLine + 1) & SC_FOLDLEVELNUMBERMASK))) {
+		lookLineLevel = GetLevel(++lookLine), lookLineLevelNum = LevelNumber(lookLineLevel)) {
+		if ((lookLineLevel & SC_FOLDLEVELHEADERFLAG) && (lookLineLevelNum < LevelNumber(GetLevel(lookLine + 1)))) {
 			firstChangeableLineAfter = lookLine;
 			break;
 		}
diff --git a/scintilla/src/Document.h b/scintilla/src/Document.h
index bf9117cb..12d37a07 100644
--- a/scintilla/src/Document.h
+++ b/scintilla/src/Document.h
@@ -171,6 +171,10 @@ class HighlightDelimiter {
 
 class Document;
 
+inline int LevelNumber(int level) {
+	return level & SC_FOLDLEVELNUMBERMASK;
+}
+
 class LexInterface {
 protected:
 	Document *pdoc;
diff --git a/scintilla/src/EditView.cxx b/scintilla/src/EditView.cxx
index fc98c3d6..805971a8 100644
--- a/scintilla/src/EditView.cxx
+++ b/scintilla/src/EditView.cxx
@@ -1744,7 +1744,7 @@ static void DrawFoldLines(Surface *surface, const EditModel &model, const ViewSt
 	const int level = model.pdoc->GetLevel(line);
 	const int levelNext = model.pdoc->GetLevel(line + 1);
 	if ((level & SC_FOLDLEVELHEADERFLAG) &&
-		((level & SC_FOLDLEVELNUMBERMASK) < (levelNext & SC_FOLDLEVELNUMBERMASK))) {
+		(LevelNumber(level) < LevelNumber(levelNext))) {
 		// Paint the line above the fold
 		if ((expanded && (model.foldFlags & SC_FOLDFLAG_LINEBEFORE_EXPANDED))
 			||
diff --git a/scintilla/src/Editor.cxx b/scintilla/src/Editor.cxx
index 7128e965..a5d34a03 100644
--- a/scintilla/src/Editor.cxx
+++ b/scintilla/src/Editor.cxx
@@ -5308,7 +5308,7 @@ void Editor::FoldExpand(int line, int action, int level) {
 	if (expanding && (cs.HiddenLines() == 0))
 		// Nothing to do
 		return;
-	int lineMaxSubord = pdoc->GetLastChild(line, level & SC_FOLDLEVELNUMBERMASK);
+	int lineMaxSubord = pdoc->GetLastChild(line, LevelNumber(level));
 	line++;
 	cs.SetVisible(line, lineMaxSubord, expanding);
 	while (line <= lineMaxSubord) {
@@ -5415,7 +5415,7 @@ void Editor::FoldAll(int action) {
 		for (int line = 0; line < maxLine; line++) {
 			int level = pdoc->GetLevel(line);
 			if ((level & SC_FOLDLEVELHEADERFLAG) &&
-					(SC_FOLDLEVELBASE == (level & SC_FOLDLEVELNUMBERMASK))) {
+					(SC_FOLDLEVELBASE == LevelNumber(level))) {
 				SetFoldExpanded(line, false);
 				int lineMaxSubord = pdoc->GetLastChild(line, -1);
 				if (lineMaxSubord > line) {
@@ -5438,17 +5438,25 @@ void Editor::FoldChanged(int line, int levelNow, int levelPrev) {
 			FoldExpand(line, SC_FOLDACTION_EXPAND, levelPrev);
 		}
 	} else if (levelPrev & SC_FOLDLEVELHEADERFLAG) {
+		const int prevLine = line - 1;
+		const int prevLineLevel = pdoc->GetLevel(prevLine);
+
+		// Combining two blocks where the first block is collapsed (e.g. by deleting the line(s) which separate(s) the two blocks)
+		if ((LevelNumber(prevLineLevel) == LevelNumber(levelNow)) && !cs.GetVisible(prevLine))
+			FoldLine(pdoc->GetFoldParent(prevLine), SC_FOLDACTION_EXPAND);
+
 		if (!cs.GetExpanded(line)) {
 			// Removing the fold from one that has been contracted so should expand
 			// otherwise lines are left invisible with no way to make them visible
 			if (cs.SetExpanded(line, true)) {
 				RedrawSelMargin();
 			}
+			// Combining two blocks where the second one is collapsed (e.g. by adding characters in the line which separates the two blocks)
 			FoldExpand(line, SC_FOLDACTION_EXPAND, levelPrev);
 		}
 	}
 	if (!(levelNow & SC_FOLDLEVELWHITEFLAG) &&
-	        ((levelPrev & SC_FOLDLEVELNUMBERMASK) > (levelNow & SC_FOLDLEVELNUMBERMASK))) {
+	        (LevelNumber(levelPrev) > LevelNumber(levelNow))) {
 		if (cs.HiddenLines()) {
 			// See if should still be hidden
 			int parentLine = pdoc->GetFoldParent(line);
@@ -5459,6 +5467,15 @@ void Editor::FoldChanged(int line, int levelNow, int levelPrev) {
 			}
 		}
 	}
+
+	// Combining two blocks where the first one is collapsed (e.g. by adding characters in the line which separates the two blocks)
+	if (!(levelNow & SC_FOLDLEVELWHITEFLAG) && (LevelNumber(levelPrev) < LevelNumber(levelNow))) {
+		if (cs.HiddenLines()) {
+			const int parentLine = pdoc->GetFoldParent(line);
+			if (!cs.GetExpanded(parentLine) && cs.GetExpanded(line))
+				FoldLine(parentLine, SC_FOLDACTION_EXPAND);
+		}
+	}
 }
 
 void Editor::NeedShown(int pos, int len) {
diff --git a/scintilla/src/MarginView.cxx b/scintilla/src/MarginView.cxx
index f164a7cb..52a2cb2d 100644
--- a/scintilla/src/MarginView.cxx
+++ b/scintilla/src/MarginView.cxx
@@ -243,7 +243,7 @@ void MarginView::PaintMargin(Surface *surface, int topLine, PRectangle rc, PRect
 						levelPrev = model.pdoc->GetLevel(lineBack);
 					}
 					if (!(levelPrev & SC_FOLDLEVELHEADERFLAG)) {
-						if ((level & SC_FOLDLEVELNUMBERMASK) < (levelPrev & SC_FOLDLEVELNUMBERMASK))
+						if (LevelNumber(level) < LevelNumber(levelPrev))
 							needWhiteClosure = true;
 					}
 				}
@@ -279,8 +279,8 @@ void MarginView::PaintMargin(Surface *surface, int topLine, PRectangle rc, PRect
 					// Decide which fold indicator should be displayed
 					const int level = model.pdoc->GetLevel(lineDoc);
 					const int levelNext = model.pdoc->GetLevel(lineDoc + 1);
-					const int levelNum = level & SC_FOLDLEVELNUMBERMASK;
-					const int levelNextNum = levelNext & SC_FOLDLEVELNUMBERMASK;
+					const int levelNum = LevelNumber(level);
+					const int levelNextNum = LevelNumber(levelNext);
 					if (level & SC_FOLDLEVELHEADERFLAG) {
 						if (firstSubLine) {
 							if (levelNum < levelNextNum) {
@@ -312,7 +312,7 @@ void MarginView::PaintMargin(Surface *surface, int topLine, PRectangle rc, PRect
 						needWhiteClosure = false;
 						const int firstFollowupLine = model.cs.DocFromDisplay(model.cs.DisplayFromDoc(lineDoc + 1));
 						const int firstFollowupLineLevel = model.pdoc->GetLevel(firstFollowupLine);
-						const int secondFollowupLineLevelNum = model.pdoc->GetLevel(firstFollowupLine + 1) & SC_FOLDLEVELNUMBERMASK;
+						const int secondFollowupLineLevelNum = LevelNumber(model.pdoc->GetLevel(firstFollowupLine + 1));
 						if (!model.cs.GetExpanded(lineDoc)) {
 							if ((firstFollowupLineLevel & SC_FOLDLEVELWHITEFLAG) &&
 								(levelNum > secondFollowupLineLevelNum))
@@ -380,7 +380,7 @@ void MarginView::PaintMargin(Surface *surface, int topLine, PRectangle rc, PRect
 								sprintf(number, "%c%c %03X %03X",
 									(lev & SC_FOLDLEVELHEADERFLAG) ? 'H' : '_',
 									(lev & SC_FOLDLEVELWHITEFLAG) ? 'W' : '_',
-									lev & SC_FOLDLEVELNUMBERMASK,
+									LevelNumber(lev),
 									lev >> 16
 									);
 							} else {
diff --git a/scintilla/src/Position.h b/scintilla/src/Position.h
index 4ef65526..120b92f6 100644
--- a/scintilla/src/Position.h
+++ b/scintilla/src/Position.h
@@ -1,6 +1,6 @@
 // Scintilla source code edit control
 /** @file Position.h
- ** Will define global type name Position in the Sci internal namespace.
+ ** Defines global type name Position in the Sci internal namespace.
  **/
 // Copyright 2015 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
@@ -8,14 +8,21 @@
 #ifndef POSITION_H
 #define POSITION_H
 
+/**
+ * A Position is a position within a document between two characters or at the beginning or end.
+ * Sometimes used as a character index where it identifies the character after the position.
+ */
+
 namespace Sci {
 
-// After 3.6.0:
-// typedef int Position;
+typedef int Position;
 
 // A later version (4.x) of this file may:
 //#if defined(SCI_LARGE_FILE_SUPPORT)
-//typedef ptrdiff_t Position;
+//typedef std::ptrdiff_t Position;
+// or may allow runtime choice between different position sizes.
+
+const Position invalidPosition = -1;
 
 }
 
diff --git a/scintilla/version.txt b/scintilla/version.txt
index dbf96fd3..d5e11d3e 100644
--- a/scintilla/version.txt
+++ b/scintilla/version.txt
@@ -1 +1 @@
-363
+364
diff --git a/scintilla/win32/PlatWin.cxx b/scintilla/win32/PlatWin.cxx
index 62fa2e34..61eb2376 100644
--- a/scintilla/win32/PlatWin.cxx
+++ b/scintilla/win32/PlatWin.cxx
@@ -5,6 +5,7 @@
 // Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
+#include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
diff --git a/scintilla/win32/ScintillaWin.cxx b/scintilla/win32/ScintillaWin.cxx
index 67c43321..204efb15 100644
--- a/scintilla/win32/ScintillaWin.cxx
+++ b/scintilla/win32/ScintillaWin.cxx
@@ -210,6 +210,24 @@ class IMContext {
 		if (hIMC)
 			::ImmReleaseContext(hwnd, hIMC);
 	}
+
+	unsigned int GetImeCaretPos() {
+		return ImmGetCompositionStringW(hIMC, GCS_CURSORPOS, NULL, 0);
+	}
+
+	std::vector<BYTE> GetImeAttributes() {
+		int attrLen = ::ImmGetCompositionStringW(hIMC, GCS_COMPATTR, NULL, 0);
+		std::vector<BYTE> attr(attrLen, 0);
+		::ImmGetCompositionStringW(hIMC, GCS_COMPATTR, &attr[0], static_cast<DWORD>(attr.size()));
+		return attr;
+	}
+
+	std::wstring GetCompositionString(DWORD dwIndex) {
+		const LONG byteLen = ::ImmGetCompositionStringW(hIMC, dwIndex, NULL, 0);
+		std::wstring wcs(byteLen / 2, 0);
+		::ImmGetCompositionStringW(hIMC, dwIndex, &wcs[0], byteLen);
+		return wcs;
+	}
 };
 
 }
@@ -291,6 +309,7 @@ class ScintillaWin :
 	void SelectionToHangul();
 	void EscapeHanja();
 	void ToggleHanja();
+	void AddWString(std::wstring wcs);
 
 	UINT CodePageOfDocument() const;
 	virtual bool ValidCodePage(int codePage) const;
@@ -834,24 +853,8 @@ sptr_t ScintillaWin::HandleCompositionWindowed(uptr_t wParam, sptr_t lParam) {
 	if (lParam & GCS_RESULTSTR) {
 		IMContext imc(MainHWND());
 		if (imc.hIMC) {
-			wchar_t wcs[maxLenInputIME];
-			LONG bytes = ::ImmGetCompositionStringW(imc.hIMC,
-				GCS_RESULTSTR, wcs, (maxLenInputIME-1)*2);
-			int wides = bytes / 2;
-			if (IsUnicodeMode()) {
-				char utfval[maxLenInputIME * 3];
-				unsigned int len = UTF8Length(wcs, wides);
-				UTF8FromUTF16(wcs, wides, utfval, len);
-				utfval[len] = '\0';
-				AddCharUTF(utfval, len);
-			} else {
-				char dbcsval[maxLenInputIME * 2];
-				int size = ::WideCharToMultiByte(InputCodePage(),
-					0, wcs, wides, dbcsval, sizeof(dbcsval) - 1, 0, 0);
-				for (int i=0; i<size; i++) {
-					AddChar(dbcsval[i]);
-				}
-			}
+			AddWString(imc.GetCompositionString(GCS_RESULTSTR));
+
 			// Set new position after converted
 			Point pos = PointMainCaret();
 			COMPOSITIONFORM CompForm;
@@ -1002,17 +1005,6 @@ void ScintillaWin::ToggleHanja() {
 
 namespace {
 
-unsigned int GetImeCaretPos(HIMC hIMC) {
-	return ImmGetCompositionStringW(hIMC, GCS_CURSORPOS, NULL, 0);
-}
-
-std::vector<BYTE> GetImeAttributes(HIMC hIMC) {
-	int attrLen = ::ImmGetCompositionStringW(hIMC, GCS_COMPATTR, NULL, 0);
-	std::vector<BYTE> attr(attrLen, 0);
-	::ImmGetCompositionStringW(hIMC, GCS_COMPATTR, &attr[0], static_cast<DWORD>(attr.size()));
-	return attr;
-}
-
 std::vector<int> MapImeIndicators(std::vector<BYTE> inputStyle) {
 	std::vector<int> imeIndicator(inputStyle.size(), SC_INDICATOR_UNKNOWN);
 	for (size_t i = 0; i < inputStyle.size(); i++) {
@@ -1035,13 +1027,21 @@ std::vector<int> MapImeIndicators(std::vector<BYTE> inputStyle) {
 	return imeIndicator;
 }
 
-std::wstring GetCompositionString(HIMC hIMC, DWORD dwIndex) {
-	const LONG byteLen = ::ImmGetCompositionStringW(hIMC, dwIndex, NULL, 0);
-	std::wstring wcs(byteLen / 2, 0);
-	::ImmGetCompositionStringW(hIMC, dwIndex, &wcs[0], byteLen);
-	return wcs;
 }
 
+void ScintillaWin::AddWString(std::wstring wcs) {
+	if (wcs.empty())
+		return;
+
+	int codePage = CodePageOfDocument();
+	for (size_t i = 0; i < wcs.size(); ) {
+		const size_t ucWidth = UTF16CharLength(wcs[i]);
+		const std::wstring uniChar(wcs, i, ucWidth);
+		std::string docChar = StringEncode(uniChar, codePage);
+
+		AddCharUTF(docChar.c_str(), static_cast<unsigned int>(docChar.size()));
+		i += ucWidth;
+	}
 }
 
 sptr_t ScintillaWin::HandleCompositionInline(uptr_t, sptr_t lParam) {
@@ -1067,7 +1067,7 @@ sptr_t ScintillaWin::HandleCompositionInline(uptr_t, sptr_t lParam) {
 	view.imeCaretBlockOverride = false;
 
 	if (lParam & GCS_COMPSTR) {
-		const std::wstring wcs = GetCompositionString(imc.hIMC, GCS_COMPSTR);
+		const std::wstring wcs = imc.GetCompositionString(GCS_COMPSTR);
 		if ((wcs.size() == 0) || (wcs.size() >= maxLenInputIME)) {
 			ShowCaretAtCurrentPosition();
 			return 0;
@@ -1075,66 +1075,34 @@ sptr_t ScintillaWin::HandleCompositionInline(uptr_t, sptr_t lParam) {
 
 		pdoc->TentativeStart(); // TentativeActive from now on.
 
-		std::vector<int> imeIndicator = MapImeIndicators(GetImeAttributes(imc.hIMC));
-
-		// Display character by character.
-		int numBytes = 0;
-		int imeCharPos[maxLenInputIME + 1] = { 0 };
+		std::vector<int> imeIndicator = MapImeIndicators(imc.GetImeAttributes());
 
 		bool tmpRecordingMacro = recordingMacro;
 		recordingMacro = false;
+		int codePage = CodePageOfDocument();
 		for (size_t i = 0; i < wcs.size(); ) {
 			const size_t ucWidth = UTF16CharLength(wcs[i]);
 			const std::wstring uniChar(wcs, i, ucWidth);
-			char oneChar[UTF8MaxBytes + 1] = "\0\0\0\0"; // Maximum 4 bytes in utf8
-			unsigned int oneCharLen = 0;
+			std::string docChar = StringEncode(uniChar, codePage);
 
-			if (IsUnicodeMode()) {
-				oneCharLen = UTF8Length(uniChar.c_str(), static_cast<unsigned int>(uniChar.length()));
-				UTF8FromUTF16(uniChar.c_str(), static_cast<unsigned int>(uniChar.length()), oneChar, oneCharLen);
-			} else {
-				oneCharLen = ::WideCharToMultiByte(InputCodePage(), 0,
-					uniChar.c_str(), static_cast<unsigned int>(uniChar.length()), oneChar, sizeof(oneChar)-1, 0, 0);
-			}
-			oneChar[oneCharLen] = '\0';
-
-			// Display a character.
-			AddCharUTF(oneChar, oneCharLen);
-
-			// Record compstr character positions for moving IME carets.
-			numBytes += oneCharLen;
-			imeCharPos[i + ucWidth] = numBytes;
+			AddCharUTF(docChar.c_str(), static_cast<unsigned int>(docChar.size()));
 
-			DrawImeIndicator(imeIndicator[i], oneCharLen);
+			DrawImeIndicator(imeIndicator[i], static_cast<unsigned int>(docChar.size()));
 			i += ucWidth;
 		}
 		recordingMacro = tmpRecordingMacro;
 
-		// Move IME caret position.
-		unsigned int imeCursorPos = GetImeCaretPos(imc.hIMC);
-		MoveImeCarets(-imeCharPos[wcs.size()] + imeCharPos[imeCursorPos]);
+		// Move IME caret from current last position to imeCaretPos.
+		int toImeStart = static_cast<unsigned int>(StringEncode(wcs, codePage).size());
+		std::string imeCaret(StringEncode(wcs.substr(0, imc.GetImeCaretPos()), codePage));
+		int toImeCaret = static_cast<unsigned int>(imeCaret.size());
+		MoveImeCarets(- toImeStart + toImeCaret);
+
 		if (KoreanIME()) {
 			view.imeCaretBlockOverride = true;
 		}
 	} else if (lParam & GCS_RESULTSTR) {
-		const std::wstring wcs = GetCompositionString(imc.hIMC, GCS_RESULTSTR);
-		for (size_t i = 0; i < wcs.size();) {
-			const size_t ucWidth = UTF16CharLength(wcs[i]);
-			const std::wstring uniChar(wcs, i, ucWidth);
-			char oneChar[UTF8MaxBytes+1] = "\0\0\0\0"; // Maximum 4 bytes in UTF-8.
-			unsigned int oneCharLen = 0;
-
-			if (IsUnicodeMode()) {
-				oneCharLen = UTF8Length(uniChar.c_str(), static_cast<unsigned int>(uniChar.length()));
-				UTF8FromUTF16(uniChar.c_str(), static_cast<unsigned int>(uniChar.length()), oneChar, oneCharLen);
-			} else {
-				oneCharLen = ::WideCharToMultiByte(InputCodePage(), 0,
-					uniChar.c_str(), static_cast<unsigned int>(uniChar.length()), oneChar, sizeof(oneChar)-1, 0, 0);
-			}
-			oneChar[oneCharLen] = '\0';
-			AddCharUTF(oneChar, oneCharLen);
-			i += ucWidth;
-		}
+		AddWString(imc.GetCompositionString(GCS_RESULTSTR));
 	}
 	EnsureCaretVisible();
 	SetCandidateWindowPos();
@@ -2216,9 +2184,25 @@ class GlobalMemory {
 	}
 };
 
+// OpenClipboard may fail if another application has opened the clipboard.
+// Try up to 8 times, with an initial delay of 1 ms and an exponential back off
+// for a maximum total delay of 127 ms (1+2+4+8+16+32+64).
+static bool OpenClipboardRetry(HWND hwnd) {
+	for (int attempt=0; attempt<8; attempt++) {
+		if (attempt > 0) {
+			::Sleep(1 << (attempt-1));
+		}
+		if (::OpenClipboard(hwnd)) {
+			return true;
+		}
+	}
+	return false;
+}
+
 void ScintillaWin::Paste() {
-	if (!::OpenClipboard(MainHWND()))
+	if (!::OpenClipboardRetry(MainHWND())) {
 		return;
+	}
 	UndoGroup ug(pdoc);
 	const bool isLine = SelectionEmpty() &&
 		(::IsClipboardFormatAvailable(cfLineSelect) || ::IsClipboardFormatAvailable(cfVSLineTag));
@@ -2769,8 +2753,9 @@ void ScintillaWin::GetIntelliMouseParameters() {
 }
 
 void ScintillaWin::CopyToClipboard(const SelectionText &selectedText) {
-	if (!::OpenClipboard(MainHWND()))
+	if (!::OpenClipboardRetry(MainHWND())) {
 		return;
+	}
 	::EmptyClipboard();
 
 	GlobalMemory uniText;