From 5bbf68518b63ae8c848a26e251443d66c66a6017 Mon Sep 17 00:00:00 2001
From: zufuliu <zufuliu@gmail.com>
Date: Sun, 8 Dec 2024 19:09:20 +0800
Subject: [PATCH] Weekly Scintilla sync up.

---
 scintilla/src/CaseFolder.cxx    | 13 ++++----
 scintilla/src/CellBuffer.cxx    | 58 ++++++++++++++++++---------------
 scintilla/src/CellBuffer.h      | 10 +++---
 scintilla/src/Document.cxx      |  5 ++-
 scintilla/src/Document.h        |  2 +-
 scintilla/src/EditModel.cxx     |  7 ++--
 scintilla/src/EditModel.h       |  2 +-
 scintilla/src/Editor.cxx        | 12 ++++---
 scintilla/src/Partitioning.h    |  2 +-
 scintilla/src/PerLine.h         |  6 ++--
 scintilla/src/PositionCache.cxx |  2 +-
 scintilla/src/RunStyles.cxx     | 26 +++++++++++----
 scintilla/src/SparseVector.h    |  4 +--
 scintilla/src/SplitVector.h     | 23 +++++++++----
 scintilla/src/Style.cxx         |  2 +-
 scintilla/src/UndoHistory.cxx   |  3 +-
 scintilla/src/UndoHistory.h     |  2 +-
 src/Edit.cpp                    |  3 ++
 version.txt                     |  2 +-
 19 files changed, 109 insertions(+), 75 deletions(-)

diff --git a/scintilla/src/CaseFolder.cxx b/scintilla/src/CaseFolder.cxx
index 236c9a7174..f7938db7fa 100644
--- a/scintilla/src/CaseFolder.cxx
+++ b/scintilla/src/CaseFolder.cxx
@@ -35,16 +35,15 @@ CaseFolderTable::CaseFolderTable() noexcept {
 size_t CaseFolderTable::Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) {
 	if (lenMixed > sizeFolded) {
 		return 0;
-	} else {
-		for (size_t i = 0; i < lenMixed; i++) {
-			folded[i] = mapping[IndexFromChar(mixed[i])];
-		}
-		return lenMixed;
 	}
+	for (size_t i = 0; i < lenMixed; i++) {
+		folded[i] = mapping[IndexFromChar(mixed[i])];
+	}
+	return lenMixed;
 }
 
 void CaseFolderTable::SetTranslation(char ch, char chTranslation) noexcept {
-	mapping[static_cast<unsigned char>(ch)] = chTranslation;
+	mapping[IndexFromChar(ch)] = chTranslation;
 }
 
 CaseFolderUnicode::CaseFolderUnicode() {
@@ -53,7 +52,7 @@ CaseFolderUnicode::CaseFolderUnicode() {
 
 size_t CaseFolderUnicode::Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) {
 	if ((lenMixed == 1) && (sizeFolded > 0)) {
-		folded[0] = mapping[static_cast<unsigned char>(mixed[0])];
+		folded[0] = mapping[IndexFromChar(mixed[0])];
 		return 1;
 	} else {
 		return converter->CaseConvertString(folded, sizeFolded, mixed, lenMixed);
diff --git a/scintilla/src/CellBuffer.cxx b/scintilla/src/CellBuffer.cxx
index 7c1f171379..00e5209238 100644
--- a/scintilla/src/CellBuffer.cxx
+++ b/scintilla/src/CellBuffer.cxx
@@ -97,6 +97,8 @@ class ILineVector {
 using namespace Scintilla;
 using namespace Scintilla::Internal;
 
+namespace {
+
 template <typename POS>
 class LineStartIndex final {
 	// line_cast(): cast Sci::Line to either 32-bit or 64-bit value
@@ -334,28 +336,23 @@ class LineVector final : public ILineVector {
 	}
 };
 
-SplitView::SplitView(const SplitVector<char> &instance) noexcept {
-	length = instance.Length();
-	length1 = instance.GapPosition();
-	if (length1 == 0) {
-		// Assign segment2 to segment1 / length1 to avoid useless test against 0 length1
-		length1 = length;
-	}
-	segment1 = instance.ElementPointer(0);
-	segment2 = instance.ElementPointer(length1) - length1;
+std::unique_ptr<ILineVector> LineVectorCreate(bool largeDocument) {
+	if (largeDocument)
+		return std::make_unique<LineVector<Sci::Position>>();
+	else
+		return std::make_unique<LineVector<int>>();
+}
+
 }
 
 CellBuffer::CellBuffer(bool hasStyles_, bool largeDocument_) :
-	hasStyles(hasStyles_), largeDocument(largeDocument_) {
+	hasStyles(hasStyles_), largeDocument(largeDocument_),
+	uh{std::make_unique<UndoHistory>()},
+	plv{LineVectorCreate(largeDocument_)} {
 	readOnly = false;
 	utf8Substance = false;
 	utf8LineEnds = LineEndType::Default;
 	collectingUndo = true;
-	uh = std::make_unique<UndoHistory>();
-	if (largeDocument)
-		plv = std::make_unique<LineVector<Sci::Position>>();
-	else
-		plv = std::make_unique<LineVector<int>>();
 }
 
 CellBuffer::~CellBuffer() noexcept = default;
@@ -364,10 +361,6 @@ char CellBuffer::CharAt(Sci::Position position) const noexcept {
 	return substance.ValueAt(position);
 }
 
-unsigned char CellBuffer::UCharAt(Sci::Position position) const noexcept {
-	return substance.ValueAt(position);
-}
-
 void CellBuffer::GetCharRange(char *buffer, Sci::Position position, Sci::Position lengthRetrieve) const noexcept {
 	if ((position | lengthRetrieve) <= 0) {
 		return;
@@ -425,7 +418,18 @@ Sci::Position CellBuffer::GapPosition() const noexcept {
 }
 
 SplitView CellBuffer::AllView() const noexcept {
-	return SplitView(substance);
+	const size_t length = substance.Length();
+	size_t length1 = substance.GapPosition();
+	if (length1 == 0) {
+		// Assign segment2 to segment1 / length1 to avoid useless test against 0 length1
+		length1 = length;
+	}
+	return SplitView {
+		substance.ElementPointer(0),
+		length1,
+		substance.ElementPointer(length1) - length1,
+		length
+	};
 }
 
 // The char* returned is to an allocation owned by the undo history
@@ -705,7 +709,7 @@ void CellBuffer::ResetLineEnds() {
 	unsigned char chBeforePrev = 0;
 	unsigned char chPrev = 0;
 	for (Sci::Position i = 0; i < length; i++) {
-		const unsigned char ch = substance.ValueAt(position + i);
+		const unsigned char ch = substance[position + 1];
 		if (ch == '\r') {
 			InsertLine(lineInsert, (position + i) + 1, atLineStart);
 			lineInsert++;
@@ -1260,11 +1264,13 @@ void CellBuffer::BasicDeleteChars(const Sci::Position position, const Sci::Posit
 				} else {
 					RemoveLine(lineRemove);
 				}
-			} else if (utf8LineEnds != LineEndType::Default && !UTF8IsAscii(ch)) {
-				const unsigned char next3[3] = { ch, chNext,
-					static_cast<unsigned char>(substance.ValueAt(position + i + 2)) };
-				if (UTF8IsSeparator(next3) || UTF8IsNEL(next3)) {
-					RemoveLine(lineRemove);
+			} else if (utf8LineEnds != LineEndType::Default) {
+				if (!UTF8IsAscii(ch)) {
+					const unsigned char next3[3] = { ch, chNext,
+						static_cast<unsigned char>(substance.ValueAt(position + i + 2)) };
+					if (UTF8IsSeparator(next3) || UTF8IsNEL(next3)) {
+						RemoveLine(lineRemove);
+					}
 				}
 			}
 
diff --git a/scintilla/src/CellBuffer.h b/scintilla/src/CellBuffer.h
index 4e0257e3a2..cff04156e3 100644
--- a/scintilla/src/CellBuffer.h
+++ b/scintilla/src/CellBuffer.h
@@ -48,8 +48,6 @@ struct SplitView {
 	const char *segment2 = nullptr;
 	size_t length = 0;
 
-	SplitView(const SplitVector<char> &instance) noexcept;
-
 	char operator[](size_t position) const noexcept {
 		if (position < length1) {
 			return segment1[position];
@@ -84,11 +82,11 @@ class CellBuffer {
 	SplitVector<char> style;
 
 	bool collectingUndo;
-	std::unique_ptr<UndoHistory> uh;
+	const std::unique_ptr<UndoHistory> uh;
 
 	std::unique_ptr<ChangeHistory> changeHistory;
 
-	std::unique_ptr<ILineVector> plv;
+	const std::unique_ptr<ILineVector> plv;
 
 	bool UTF8LineEndOverlaps(Sci::Position position) const noexcept;
 	bool UTF8IsCharacterBoundary(Sci::Position position) const;
@@ -110,7 +108,9 @@ class CellBuffer {
 
 	/// Retrieving positions outside the range of the buffer works and returns 0
 	char CharAt(Sci::Position position) const noexcept;
-	unsigned char UCharAt(Sci::Position position) const noexcept;
+	unsigned char UCharAt(Sci::Position position) const noexcept {
+		return CharAt(position);
+	}
 	void GetCharRange(char *buffer, Sci::Position position, Sci::Position lengthRetrieve) const noexcept;
 	char StyleAt(Sci::Position position) const noexcept;
 	void GetStyleRange(unsigned char *buffer, Sci::Position position, Sci::Position lengthRetrieve) const noexcept;
diff --git a/scintilla/src/Document.cxx b/scintilla/src/Document.cxx
index 81c4253c79..4cd2a105a5 100644
--- a/scintilla/src/Document.cxx
+++ b/scintilla/src/Document.cxx
@@ -142,7 +142,8 @@ CharacterExtracted::CharacterExtracted(const unsigned char *charBytes, size_t wi
 
 Document::Document(DocumentOption options) :
 	cb(!FlagSet(options, DocumentOption::StylesNone), FlagSet(options, DocumentOption::TextLarge)),
-	durationStyleOneUnit(1e-6) {
+	durationStyleOneUnit(1e-6),
+	decorations{DecorationListCreate(IsLarge())} {
 
 	perLineData[ldMarkers] = std::make_unique<LineMarkers>();
 	perLineData[ldLevels] = std::make_unique<LineLevels>();
@@ -151,8 +152,6 @@ Document::Document(DocumentOption options) :
 	perLineData[ldAnnotation] = std::make_unique<LineAnnotation>();
 	perLineData[ldEOLAnnotation] = std::make_unique<LineAnnotation>();
 
-	decorations = DecorationListCreate(IsLarge());
-
 	cb.SetPerLine(this);
 	cb.SetUTF8Substance(CpUtf8 == dbcsCodePage);
 }
diff --git a/scintilla/src/Document.h b/scintilla/src/Document.h
index 3d8318bef7..d4bd556652 100644
--- a/scintilla/src/Document.h
+++ b/scintilla/src/Document.h
@@ -329,7 +329,7 @@ class Document : PerLine, public Scintilla::IDocument, public Scintilla::ILoader
 	uint8_t asciiBackwardSafeChar = 0xff;
 	ActionDuration durationStyleOneUnit;
 
-	std::unique_ptr<IDecorationList> decorations;
+	const std::unique_ptr<IDecorationList> decorations;
 
 	explicit Document(Scintilla::DocumentOption options);
 	// Deleted so Document objects can not be copied.
diff --git a/scintilla/src/EditModel.cxx b/scintilla/src/EditModel.cxx
index 5be12f0db3..b7c56547f8 100644
--- a/scintilla/src/EditModel.cxx
+++ b/scintilla/src/EditModel.cxx
@@ -58,7 +58,10 @@ using namespace Scintilla::Internal;
 Caret::Caret() noexcept :
 	active(false), on(false), period(500) {}
 
-EditModel::EditModel() : durationWrapOneUnit(0.01 / 64), durationWrapOneThread(0.01 / 16) {
+EditModel::EditModel() :
+	reprs{std::make_unique<SpecialRepresentations>()},
+	pcs{ContractionStateCreate(false)},
+	durationWrapOneUnit(0.01 / 64), durationWrapOneThread(0.01 / 16) {
 	inOverstrike = false;
 	trackLineWidth = false;
 	hasFocus = false;
@@ -77,11 +80,9 @@ EditModel::EditModel() : durationWrapOneUnit(0.01 / 64), durationWrapOneThread(0
 	hotspotSingleLine = true;
 	hoverIndicatorPos = Sci::invalidPosition;
 	wrapWidth = LineLayout::wrapWidthInfinite;
-	reprs = std::make_unique<SpecialRepresentations>();
 	// before setting a lexer, style buffer is useless.
 	pdoc = new Document(DocumentOption::StylesNone);
 	pdoc->AddRef();
-	pcs = ContractionStateCreate(pdoc->IsLarge());
 
 	SYSTEM_INFO info;
 	GetNativeSystemInfo(&info);
diff --git a/scintilla/src/EditModel.h b/scintilla/src/EditModel.h
index eabc3996ea..5972c11eaa 100644
--- a/scintilla/src/EditModel.h
+++ b/scintilla/src/EditModel.h
@@ -28,7 +28,7 @@ class EditModel {
 	bool primarySelection;
 	int xOffset;		///< Horizontal scrolled amount in pixels
 
-	std::unique_ptr<SpecialRepresentations> reprs;
+	const std::unique_ptr<SpecialRepresentations> reprs;
 	Caret caret;
 	SelectionPosition posDrag;
 	Sci::Position braces[2];
diff --git a/scintilla/src/Editor.cxx b/scintilla/src/Editor.cxx
index 2bf951f0d2..bbf76a5892 100644
--- a/scintilla/src/Editor.cxx
+++ b/scintilla/src/Editor.cxx
@@ -516,10 +516,14 @@ void Editor::RedrawSelMargin(Sci::Line line, bool allAfter) noexcept {
 }
 
 PRectangle Editor::RectangleFromRange(Range r, int overlap) const noexcept {
-	const Sci::Line minLine = pcs->DisplayFromDoc(
-		pdoc->SciLineFromPosition(r.First()));
-	const Sci::Line maxLine = pcs->DisplayLastFromDoc(
-		pdoc->SciLineFromPosition(r.Last()));
+	const Sci::Line docLineFirst = pdoc->SciLineFromPosition(r.First());
+	const Sci::Line minLine = pcs->DisplayFromDoc(docLineFirst);
+	Sci::Line docLineLast = docLineFirst;	// Common case where range is wholly in one document line
+	if (r.Last() >= pdoc->LineStart(docLineFirst + 1)) {
+		// Range covers multiple lines so need last line
+		docLineLast = pdoc->SciLineFromPosition(r.Last());
+	}
+	const Sci::Line maxLine = pcs->DisplayLastFromDoc(docLineLast);
 	const PRectangle rcClientDrawing = GetClientDrawingRectangle();
 	PRectangle rc;
 	const int leftTextOverlap = ((xOffset == 0) && (vs.leftMarginWidth > 0)) ? 1 : 0;
diff --git a/scintilla/src/Partitioning.h b/scintilla/src/Partitioning.h
index 274bc04b8a..f6f5d08f09 100644
--- a/scintilla/src/Partitioning.h
+++ b/scintilla/src/Partitioning.h
@@ -202,7 +202,7 @@ class Partitioning {
 		T upper = partition;
 		do {
 			const T middle = (upper + lower + 1) / 2; 	// Round high
-			T posMiddle = body.ValueAt(middle);
+			T posMiddle = body[middle];
 			if (middle > stepPartition)
 				posMiddle += stepLength;
 			if (pos < posMiddle) {
diff --git a/scintilla/src/PerLine.h b/scintilla/src/PerLine.h
index 980e05ae5e..52c493ec9f 100644
--- a/scintilla/src/PerLine.h
+++ b/scintilla/src/PerLine.h
@@ -63,7 +63,7 @@ class LineLevels final : public PerLine {
 	SplitVector<int> levels;
 	Scintilla::FoldLevel GetFoldLevel(Sci::Line line) const noexcept;
 public:
-	LineLevels() = default;
+	LineLevels() noexcept = default;
 	void Init() override;
 	bool IsActive() const noexcept override;
 	void InsertLine(Sci::Line line) override;
@@ -80,7 +80,7 @@ class LineLevels final : public PerLine {
 class LineState final : public PerLine {
 	SplitVector<int> lineStates;
 public:
-	LineState() = default;
+	LineState() noexcept = default;
 	void Init() override;
 	bool IsActive() const noexcept override;
 	void InsertLine(Sci::Line line) override;
@@ -94,7 +94,7 @@ class LineState final : public PerLine {
 class LineAnnotation : public PerLine {
 	SplitVector<std::unique_ptr<char[]>> annotations;
 public:
-	LineAnnotation() = default;
+	LineAnnotation() noexcept = default;
 
 	[[nodiscard]] bool Empty() const noexcept;
 	void Init() override;
diff --git a/scintilla/src/PositionCache.cxx b/scintilla/src/PositionCache.cxx
index a551daec05..68507a0d04 100644
--- a/scintilla/src/PositionCache.cxx
+++ b/scintilla/src/PositionCache.cxx
@@ -799,7 +799,7 @@ LineLayout *LineLayoutCache::Retrieve(Sci::Line lineNumber, Sci::Line lineCaret,
 			//printf("USE line=%zd/%zd, caret=%zd/%zd top=%zd, pos=%zu, clock=%d\n",
 			//	lineNumber, ret->lineNumber, lineCaret, lastCaretSlot, topLine, pos, styleClock_);
 			ret->Free();
-			new (ret) LineLayout(lineNumber, maxChars);
+			::new (ret) LineLayout(lineNumber, maxChars);
 		} else {
 			//printf("HIT line=%zd, caret=%zd/%zd top=%zd, pos=%zu, clock=%d, validity=%d\n",
 			//	lineNumber, lineCaret, lastCaretSlot, topLine, pos, styleClock_, ret->validity);
diff --git a/scintilla/src/RunStyles.cxx b/scintilla/src/RunStyles.cxx
index c8b48197f8..41ecf3948d 100644
--- a/scintilla/src/RunStyles.cxx
+++ b/scintilla/src/RunStyles.cxx
@@ -81,8 +81,6 @@ void RunStyles<DISTANCE, STYLE>::RemoveRunIfSameAsPrevious(DISTANCE run) {
 
 template <typename DISTANCE, typename STYLE>
 RunStyles<DISTANCE, STYLE>::RunStyles() {
-	starts = Partitioning<DISTANCE>(8);
-	styles = SplitVector<STYLE>();
 	styles.InsertValue(0, 2, 0);
 }
 
@@ -137,7 +135,8 @@ FillResult<DISTANCE> RunStyles<DISTANCE, STYLE>::FillRange(DISTANCE position, ST
 		return resultNoChange;
 	}
 	DISTANCE runEnd = RunFromPosition(end);
-	if (styles.ValueAt(runEnd) == value) {
+	const STYLE valueCurrent = styles.ValueAt(runEnd);
+	if (valueCurrent == value) {
 		// End already has value so trim range.
 		end = starts.PositionFromPartition(runEnd);
 		if (position >= end) {
@@ -146,6 +145,22 @@ FillResult<DISTANCE> RunStyles<DISTANCE, STYLE>::FillRange(DISTANCE position, ST
 		}
 		fillLength = end - position;
 	} else {
+		const DISTANCE startRun = starts.PositionFromPartition(runEnd);
+		if (position > startRun) {
+			const DISTANCE runNext = runEnd + 1;
+			const DISTANCE endRun = starts.PositionFromPartition(runNext);
+			if (end < endRun) {
+				// New piece is completely inside a run with a different value so its a simple
+				// insertion of two points [ (position, value), (end, valueCurrent) ]
+				const DISTANCE range[] { position, end};
+				starts.InsertPartitions(runEnd + 1, range, 2);
+				// Temporary runEndIndex silences non-useful arithmetic overflow warnings
+				const ptrdiff_t runEndIndex = runEnd;
+				styles.Insert(runEndIndex + 1, value);
+				styles.Insert(runEndIndex + 2, valueCurrent);
+				return { true, position, fillLength };
+			}
+		}
 		runEnd = SplitRun(end);
 	}
 	DISTANCE runStart = RunFromPosition(position);
@@ -173,9 +188,8 @@ FillResult<DISTANCE> RunStyles<DISTANCE, STYLE>::FillRange(DISTANCE position, ST
 		runEnd = RunFromPosition(end);
 		RemoveRunIfEmpty(runEnd);
 		return result;
-	} else {
-		return resultNoChange;
 	}
+	return resultNoChange;
 }
 
 template <typename DISTANCE, typename STYLE>
@@ -214,7 +228,7 @@ void RunStyles<DISTANCE, STYLE>::InsertSpace(DISTANCE position, DISTANCE insertL
 
 template <typename DISTANCE, typename STYLE>
 void RunStyles<DISTANCE, STYLE>::DeleteAll() {
-	starts = Partitioning<DISTANCE>(8);
+	starts = Partitioning<DISTANCE>();
 	styles = SplitVector<STYLE>();
 	styles.InsertValue(0, 2, 0);
 }
diff --git a/scintilla/src/SparseVector.h b/scintilla/src/SparseVector.h
index 2ae2f1e06d..4f2467424c 100644
--- a/scintilla/src/SparseVector.h
+++ b/scintilla/src/SparseVector.h
@@ -26,8 +26,6 @@ class SparseVector {
 
 public:
 	SparseVector() {
-		starts = Partitioning<Sci::Position>(8);
-		values = SplitVector<T>();
 		values.InsertEmpty(0, 2);
 	}
 
@@ -177,7 +175,7 @@ class SparseVector {
 	}
 
 	void DeleteAll() {
-		starts = Partitioning<Sci::Position>(8);
+		starts = Partitioning<Sci::Position>();
 		values = SplitVector<T>();
 		values.InsertEmpty(0, 2);
 	}
diff --git a/scintilla/src/SplitVector.h b/scintilla/src/SplitVector.h
index 6862836ae4..4405a2d935 100644
--- a/scintilla/src/SplitVector.h
+++ b/scintilla/src/SplitVector.h
@@ -257,9 +257,16 @@ class SplitVector {
 			}
 			RoomFor(insertLength);
 			GapTo(position);
-			for (ptrdiff_t elem = part1Length; elem < part1Length + insertLength; elem++) {
-				T emptyOne = {};
-				body[elem] = std::move(emptyOne);
+			T *ptr = body.data() + part1Length;
+			//std::uninitialized_value_construct_n(ptr, insertLength);
+			if constexpr (std::is_scalar_v<T>) {
+				memset(ptr, 0, insertLength*sizeof(T));
+			} else {
+				static_assert(std::is_nothrow_default_constructible_v<T>);
+				for (ptrdiff_t elem = 0; elem < insertLength; elem++) {
+					::new (ptr)T();
+					ptr++;
+				}
 			}
 			lengthBody += insertLength;
 			part1Length += insertLength;
@@ -285,7 +292,11 @@ class SplitVector {
 			}
 			RoomFor(insertLength);
 			GapTo(positionToInsert);
-			std::copy_n(s + positionFrom, insertLength, body.data() + part1Length);
+			if constexpr (__is_standard_layout(T)) {
+				memcpy(body.data() + part1Length, s + positionFrom, insertLength*sizeof(T));
+			} else {
+				std::copy_n(s + positionFrom, insertLength, body.data() + part1Length);
+			}
 			lengthBody += insertLength;
 			part1Length += insertLength;
 			gapLength -= insertLength;
@@ -341,13 +352,13 @@ class SplitVector {
 		const T* data = body.data() + position;
 		if (position < part1Length) {
 			range1Length = std::min(rangeLength, part1Length - position);
-			result = memcmp(data, buffer, range1Length*sizeof(T));
+			result = memcmp(buffer, data, range1Length*sizeof(T));
 		}
 		if (range1Length < rangeLength) {
 			data += range1Length + gapLength;
 			const ptrdiff_t range2Length = rangeLength - range1Length;
 			// NOLINTNEXTLINE(bugprone-suspicious-string-compare)
-			result |= memcmp(data, buffer + range1Length, range2Length*sizeof(T));
+			result |= memcmp(buffer + range1Length, data, range2Length*sizeof(T));
 		}
 		return result;
 	}
diff --git a/scintilla/src/Style.cxx b/scintilla/src/Style.cxx
index fde5eed355..1a54de0ad7 100644
--- a/scintilla/src/Style.cxx
+++ b/scintilla/src/Style.cxx
@@ -62,7 +62,7 @@ Style::Style(const char *fontName_) noexcept :
 
 void Style::ResetDefault(const char *fontName_) noexcept {
 	font.reset();
-	new (this)Style(fontName_);
+	::new (this)Style(fontName_);
 }
 
 void Style::Copy(std::shared_ptr<Font> font_, const FontMeasurements &fm_) noexcept {
diff --git a/scintilla/src/UndoHistory.cxx b/scintilla/src/UndoHistory.cxx
index ac6ac8a2a5..7080402555 100644
--- a/scintilla/src/UndoHistory.cxx
+++ b/scintilla/src/UndoHistory.cxx
@@ -319,8 +319,7 @@ int UndoHistory::PreviousAction() const noexcept {
 	return currentAction - 1;
 }
 
-UndoHistory::UndoHistory() {
-	scraps = std::make_unique<ScrapStack>();
+UndoHistory::UndoHistory() : scraps{std::make_unique<ScrapStack>()} {
 }
 
 UndoHistory::~UndoHistory() noexcept = default;
diff --git a/scintilla/src/UndoHistory.h b/scintilla/src/UndoHistory.h
index b597291431..3856df0784 100644
--- a/scintilla/src/UndoHistory.h
+++ b/scintilla/src/UndoHistory.h
@@ -86,7 +86,7 @@ class UndoHistory final {
 	int savePoint = 0;
 	int tentativePoint = -1;
 	std::optional<int> detach;	// Never set if savePoint set (>= 0)
-	std::unique_ptr<ScrapStack> scraps;
+	const std::unique_ptr<ScrapStack> scraps;
 	struct actPos { int act; size_t position; };
 	std::optional<actPos> memory;
 
diff --git a/src/Edit.cpp b/src/Edit.cpp
index 4de6ef92b3..4f5320f2f5 100644
--- a/src/Edit.cpp
+++ b/src/Edit.cpp
@@ -4366,6 +4366,9 @@ void EditEnsureSelectionVisible() noexcept {
 
 void EditEnsureConsistentLineEndings() noexcept {
 	const size_t lineCount = SciCall_GetLineCount();
+	if (lineCount < 2) {
+		return;
+	}
 	const size_t actions = SciCall_GetUndoActions();
 	if (lineCount + actions >= static_cast<size_t>(INT_MAX)) {
 		// Scintilla undo stack is indexed with int
diff --git a/version.txt b/version.txt
index 2547a0e64f..95f60dddc8 100644
--- a/version.txt
+++ b/version.txt
@@ -5,7 +5,7 @@ git clone https://github.com/XhmikosR/notepad2-mod.git
 Scintilla (upstream)
 hg clone http://hg.code.sf.net/p/scintilla/code scintilla
 5.5.3
-2024-12-01 9608:9efd284c1e24
+2024-12-06 9617:7f805fc34a65
 
 Lexilla (upstream)
 git clone https://github.com/ScintillaOrg/lexilla.git