Source.cpp

#pragma comment(linker,"\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
#define NOMINMAX
#include <windows.h>
#include <shellapi.h>
#include <shlobj.h>
#include <shobjidl.h>
#include <propkey.h>
#include <propvarutil.h>
#pragma comment(lib, "propsys.lib")
#include <shlwapi.h>
#pragma comment(lib, "shlwapi.lib")
#include <d3d11.h>
#include <dxgi1_2.h>
#include <d2d1_1.h>
#include <d2d1.h>
#include <dwrite.h>
#include <dcomp.h>
#include <initguid.h>
#include <d2d1effects.h>
#include <imm.h>
#include <commdlg.h>
#include <commctrl.h>
#include <dwmapi.h>
#include <uxtheme.h>
#include <string>
#include <vector>
#include <memory>
#include <cassert>
#include <algorithm>
#include <cmath>
#include <regex> 
#include <cstring>
#include <cstdint>
#include <mutex>
#include <thread>
#include <atomic>
#include <emmintrin.h>
#include <intrin.h>
#include "compact_enc_det/compact_enc_det.h"
#include "resource.h"
#include "include/Pele.h"
#include "include/MiuCore.h"
#include "include/MiuSyntax.h"
#include "include/MiuEmmet.h"
#include "include/MiuPreview.h"
#pragma comment(lib, "d2d1.lib")
#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "dxgi.lib")
#pragma comment(lib, "dcomp.lib")
#pragma comment(lib, "dwrite.lib")
#pragma comment(lib, "dxguid.lib")
#pragma comment(lib, "imm32.lib")
#pragma comment(lib, "comdlg32.lib")
#pragma comment(lib, "comctl32.lib")
#pragma comment(lib, "dwmapi.lib")
#pragma comment(lib, "uxtheme.lib")
#pragma comment(lib, "ced.lib")
const std::wstring APP_VERSION = L"miu v1.0.49";
enum MiuEncoding { ENC_UTF8_NOBOM = 0, ENC_UTF8_BOM, ENC_UTF16LE, ENC_UTF16BE, ENC_LOCAL };
struct DetectResult { MiuEncoding type; UINT codePage; };
static void SwapBytes(wchar_t* buf, size_t count) {
    for (size_t i = 0; i < count; ++i) { unsigned short x = (unsigned short)buf[i]; buf[i] = (wchar_t)((x >> 8) | (x << 8)); }
}
using MiuCore::IsValidUtf8;
static UINT MapCedEncodingToCodePage(Encoding enc) {
    switch (enc) {
    case JAPANESE_SHIFT_JIS:
    case JAPANESE_CP932:
    case KDDI_SHIFT_JIS:
    case DOCOMO_SHIFT_JIS:
    case SOFTBANK_SHIFT_JIS: return 932;
    case JAPANESE_EUC_JP:    return 20932;
    case JAPANESE_JIS:
    case KDDI_ISO_2022_JP:
    case SOFTBANK_ISO_2022_JP: return 50220;
    case CHINESE_GB:
    case GBK:
    case HZ_GB_2312:
    case ISO_2022_CN:        return 936;
    case GB18030:            return 54936;
    case CHINESE_BIG5:
    case CHINESE_BIG5_CP950:
    case BIG5_HKSCS:         return 950;
    case KOREAN_EUC_KR:
    case ISO_2022_KR:        return 949;
    case RUSSIAN_CP1251:     return 1251;
    case RUSSIAN_KOI8_R:     return 20866;
    case RUSSIAN_KOI8_RU:    return 21866;
    case ISO_8859_5:         return 28595;
    case RUSSIAN_CP866:      return 866;
    case LATIN1:
    case MSFT_CP1252:        return 1252;
    case ISO_8859_15:        return 28605;
    case MACINTOSH_ROMAN:    return 10000;
    case MSFT_CP1250:        return 1250;
    case ISO_8859_2:         return 28592;
    case CZECH_CP852:        return 852;
    case MSFT_CP1253:        return 1253;
    case ISO_8859_7:         return 28597;
    case MSFT_CP1254:        return 1254;
    case ISO_8859_9:         return 28599;
    case MSFT_CP1255:        return 1255;
    case ISO_8859_8:
    case ISO_8859_8_I:
    case HEBREW_VISUAL:      return 28598;
    case MSFT_CP1256:        return 1256;
    case ISO_8859_6:         return 28596;
    case MSFT_CP1257:        return 1257;
    case ISO_8859_4:         return 28594;
    case ISO_8859_13:        return 28603;
    case ISO_8859_11:
    case MSFT_CP874:         return 874;
    case UTF7:               return 65000;
    case UTF8:
    case UTF8UTF8:
    case ASCII_7BIT:         return CP_UTF8;
    default:                 return CP_ACP;
    }
}
static DetectResult DetectEncodingEx(const char* buf, size_t len) {
    DetectResult res = { ENC_UTF8_NOBOM, CP_UTF8 };
    if (len >= 3 && (unsigned char)buf[0] == 0xEF && (unsigned char)buf[1] == 0xBB && (unsigned char)buf[2] == 0xBF) { res.type = ENC_UTF8_BOM; return res; }
    if (len >= 2) {
        if ((unsigned char)buf[0] == 0xFF && (unsigned char)buf[1] == 0xFE) { res.type = ENC_UTF16LE; return res; }
        if ((unsigned char)buf[0] == 0xFE && (unsigned char)buf[1] == 0xFF) { res.type = ENC_UTF16BE; return res; }
    }
    if (IsValidUtf8(buf, len)) { res.type = ENC_UTF8_NOBOM; return res; }
    int bomless16 = MiuCore::DetectBomlessUtf16(buf, len);
    if (bomless16 == 1) { res.type = ENC_UTF16LE; return res; }
    if (bomless16 == 2) { res.type = ENC_UTF16BE; return res; }
    const char* sampleBuf = buf;
    size_t sampleLen = len;
    MiuCore::SelectCedSampleWindow(buf, len, sampleBuf, sampleLen);
    int bytes_consumed = 0; bool is_reliable = false;
    Encoding ced_enc = CompactEncDet::DetectEncoding(sampleBuf, static_cast<int>(sampleLen), nullptr, nullptr, nullptr, UNKNOWN_ENCODING, UNKNOWN_LANGUAGE, CompactEncDet::WEB_CORPUS, false, &bytes_consumed, &is_reliable);
    if (ced_enc == UTF16LE) { res.type = ENC_UTF16LE; return res; }
    if (ced_enc == UTF16BE) { res.type = ENC_UTF16BE; return res; }
    res.type = ENC_LOCAL; res.codePage = MapCedEncodingToCodePage(ced_enc);
    return res;
}
static std::wstring UTF8ToW(const std::string& s) {
    if (s.empty()) return {};
    int n = MultiByteToWideChar(CP_UTF8, 0, s.data(), (int)s.size(), NULL, 0);
    if (n <= 0) return {};
    std::wstring w; w.resize(n);
    MultiByteToWideChar(CP_UTF8, 0, s.data(), (int)s.size(), &w[0], n);
    return w;
}
static void UTF8ToW(const std::string& s, std::wstring& out) {
    out.clear();
    if (s.empty()) return;
    int n = MultiByteToWideChar(CP_UTF8, 0, s.data(), (int)s.size(), NULL, 0);
    if (n <= 0) return;
    out.resize(n);
    MultiByteToWideChar(CP_UTF8, 0, s.data(), (int)s.size(), &out[0], n);
}
using MiuCore::SanitizeUtf8;
static std::string LocalToUtf8(const char* data, size_t len, UINT cp) {
    if (len == 0) return "";
    int wLen = MultiByteToWideChar(cp, 0, data, (int)len, NULL, 0);
    if (wLen <= 0) return SanitizeUtf8(data, len);
    std::vector<wchar_t> wBuf(wLen);
    MultiByteToWideChar(cp, 0, data, (int)len, wBuf.data(), wLen);
    for (wchar_t& wc : wBuf) { if (wc == 0) wc = L'?'; }
    int uLen = WideCharToMultiByte(CP_UTF8, 0, wBuf.data(), wLen, NULL, 0, NULL, NULL);
    if (uLen <= 0) return SanitizeUtf8(data, len);
    std::string ret; ret.resize(uLen);
    WideCharToMultiByte(CP_UTF8, 0, wBuf.data(), wLen, &ret[0], uLen, NULL, NULL);
    return ret;
}
static std::string Utf8ToLocal(const std::string& utf8, UINT cp) {
    if (utf8.empty()) return "";
    std::wstring w = UTF8ToW(utf8);
    int len = WideCharToMultiByte(cp, 0, w.c_str(), (int)w.size(), NULL, 0, NULL, NULL);
    if (len <= 0) return "";
    std::string ret; ret.resize(len);
    WideCharToMultiByte(cp, 0, w.c_str(), (int)w.size(), &ret[0], len, NULL, NULL);
    return ret;
}
using MiuCore::Utf16ToUtf8;
static std::wstring Utf8ToUtf16(const std::string& utf8) {
    if (utf8.empty()) return L"";
    int wLen = MultiByteToWideChar(CP_UTF8, 0, utf8.data(), (int)utf8.size(), NULL, 0);
    if (wLen <= 0) return L"";
    std::wstring ret; ret.resize(wLen);
    MultiByteToWideChar(CP_UTF8, 0, utf8.data(), (int)utf8.size(), &ret[0], wLen);
    return ret;
}
static std::wstring GetResString(UINT id) {
    const wchar_t* pBuf = nullptr;
    int len = LoadStringW(GetModuleHandle(NULL), id, (LPWSTR)&pBuf, 0);
    if (len > 0 && pBuf) return std::wstring(pBuf, len);
    return L"";
}

const int MAX_RECENT_FILES = 60;
const UINT IDM_RECENT_SEP  = 0x7FF0;
const UINT IDM_RECENT_BASE = 0x8000;
const UINT IDM_CTX_UNDO       = 3001;
const UINT IDM_CTX_REDO       = 3002;
const UINT IDM_CTX_CUT        = 3003;
const UINT IDM_CTX_COPY       = 3004;
const UINT IDM_CTX_PASTE      = 3005;
const UINT IDM_CTX_SELECT_ALL = 3006;
const size_t MAX_RECENT_MENU_ITEMS = 20;
static std::vector<std::wstring> s_sysMenuRecentFiles;

#pragma pack(push, 1)
struct SavedCursorEntry {
    uint64_t head = 0;
    uint64_t anchor = 0;
    uint32_t headLine = 0;
    uint32_t headCol = 0;
    uint32_t anchorLine = 0;
    uint32_t anchorCol = 0;
    uint32_t selHash = 0;
    uint32_t selLen = 0;
    float desiredX = 0.0f;
    uint8_t affinity = 0;
    uint8_t reserved[3] = {};
};

struct FileViewState {
    uint64_t docByteLen = 0;
    uint64_t fileWriteTime = 0;
    uint32_t contextHash = 0;
    int32_t vScrollPos = 0;
    int32_t vScrollSubLine = 0;
    int32_t hScrollPos = 0;
    uint8_t isRectSelecting = 0;
    uint8_t cursorCount = 0;
    uint16_t reserved = 0;
    int32_t rectAnchorLine = 0;
    int32_t rectHeadLine = 0;
    float rectAnchorX = 0.0f;
    float rectHeadX = 0.0f;
    SavedCursorEntry cursors[16] = {};
};
#pragma pack(pop)
#pragma optimize("s", on)
struct StoredViewStateEntry {
    std::wstring path;
    FileViewState state;
};

static std::mutex s_recentMutex;
static bool s_recentCacheLoaded = false;
static std::vector<std::wstring> s_recentFilesCache;
static int s_lastSavedRecentCount = MAX_RECENT_FILES;
static bool s_viewStatesLoaded = false;
static std::vector<StoredViewStateEntry> s_viewStatesCache;
static const uint32_t VIEW_STATE_MAGIC = 0x3153564Du; // 'MVS1'
static const uint32_t VIEW_STATE_VERSION = 1u;

static std::wstring normalizePath(const std::wstring& p) {
    std::wstring s = p;
    while (!s.empty() && (s.front() == L' ' || s.front() == L'\"' || s.front() == L'\'')) s.erase(s.begin());
    while (!s.empty() && (s.back() == L' ' || s.back() == L'\"' || s.back() == L'\'')) s.pop_back();
    if (s.empty()) return L"";
    wchar_t fullPath[MAX_PATH];
    if (GetFullPathNameW(s.c_str(), MAX_PATH, fullPath, NULL)) {
        wchar_t longPath[MAX_PATH];
        if (GetLongPathNameW(fullPath, longPath, MAX_PATH)) {
            return longPath;
        }
        return fullPath;
    }
    return s;
}

static void loadViewStatesLocked() {
    if (s_viewStatesLoaded) return;
    s_viewStatesLoaded = true;
    s_viewStatesCache.clear();
    HKEY hKey;
    if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\miu\\RecentFiles", 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
        DWORD type = 0;
        DWORD size = 0;
        if (RegQueryValueExW(hKey, L"ViewStates", NULL, &type, NULL, &size) == ERROR_SUCCESS && type == REG_BINARY && size >= sizeof(uint32_t) * 3 && size <= 1024 * 1024) {
            std::vector<uint8_t> buf(size);
            if (RegQueryValueExW(hKey, L"ViewStates", NULL, &type, buf.data(), &size) == ERROR_SUCCESS) {
                size_t offset = 0;
                uint32_t magic = 0, version = 0, count = 0;
                std::memcpy(&magic, buf.data() + offset, sizeof(uint32_t)); offset += sizeof(uint32_t);
                std::memcpy(&version, buf.data() + offset, sizeof(uint32_t)); offset += sizeof(uint32_t);
                std::memcpy(&count, buf.data() + offset, sizeof(uint32_t)); offset += sizeof(uint32_t);
                if (magic == VIEW_STATE_MAGIC && version == VIEW_STATE_VERSION && count <= (uint32_t)(MAX_RECENT_FILES * 2)) {
                    s_viewStatesCache.reserve(std::min((size_t)count, (size_t)MAX_RECENT_FILES));
                    for (uint32_t i = 0; i < count; ++i) {
                        if (offset + sizeof(uint16_t) > size) break;
                        uint16_t pathLen = 0;
                        std::memcpy(&pathLen, buf.data() + offset, sizeof(uint16_t)); offset += sizeof(uint16_t);
                        if (pathLen == 0 || pathLen > MAX_PATH) break;
                        size_t pathBytes = (size_t)pathLen * sizeof(wchar_t);
                        if (offset + pathBytes + sizeof(FileViewState) > size) break;
                        StoredViewStateEntry entry;
                        entry.path.resize(pathLen);
                        std::memcpy(&entry.path[0], buf.data() + offset, pathBytes); offset += pathBytes;
                        std::memcpy(&entry.state, buf.data() + offset, sizeof(FileViewState)); offset += sizeof(FileViewState);
                        if (entry.state.cursorCount > 16) entry.state.cursorCount = 16;
                        if (s_viewStatesCache.size() < (size_t)MAX_RECENT_FILES) {
                            s_viewStatesCache.push_back(std::move(entry));
                        }
                    }
                }
            }
        }
        RegCloseKey(hKey);
    }
}

static void saveViewStatesLocked() {
    HKEY hKey;
    if (RegCreateKeyExW(HKEY_CURRENT_USER, L"Software\\miu\\RecentFiles", 0, NULL, 0, KEY_WRITE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
        uint32_t count = (uint32_t)std::min(s_viewStatesCache.size(), (size_t)MAX_RECENT_FILES);
        size_t totalBytes = sizeof(uint32_t) * 3;
        for (uint32_t i = 0; i < count; ++i) {
            uint16_t pLen = (uint16_t)std::min(s_viewStatesCache[i].path.size(), (size_t)MAX_PATH);
            totalBytes += sizeof(uint16_t) + (size_t)pLen * sizeof(wchar_t) + sizeof(FileViewState);
        }
        std::vector<uint8_t> buf(totalBytes);
        size_t offset = 0;
        std::memcpy(buf.data() + offset, &VIEW_STATE_MAGIC, sizeof(uint32_t)); offset += sizeof(uint32_t);
        std::memcpy(buf.data() + offset, &VIEW_STATE_VERSION, sizeof(uint32_t)); offset += sizeof(uint32_t);
        std::memcpy(buf.data() + offset, &count, sizeof(uint32_t)); offset += sizeof(uint32_t);
        for (uint32_t i = 0; i < count; ++i) {
            uint16_t pLen = (uint16_t)std::min(s_viewStatesCache[i].path.size(), (size_t)MAX_PATH);
            size_t pathBytes = (size_t)pLen * sizeof(wchar_t);
            std::memcpy(buf.data() + offset, &pLen, sizeof(uint16_t)); offset += sizeof(uint16_t);
            if (pathBytes > 0) {
                std::memcpy(buf.data() + offset, s_viewStatesCache[i].path.data(), pathBytes);
                offset += pathBytes;
            }
            std::memcpy(buf.data() + offset, &s_viewStatesCache[i].state, sizeof(FileViewState)); offset += sizeof(FileViewState);
        }
        RegSetValueExW(hKey, L"ViewStates", 0, REG_BINARY, buf.data(), (DWORD)buf.size());
        RegCloseKey(hKey);
    }
}

static void saveFileViewState(const std::wstring& path, const FileViewState& state) {
    if (path.empty()) return;
    std::wstring norm = normalizePath(path);
    if (norm.empty()) return;
    std::lock_guard<std::mutex> lock(s_recentMutex);
    loadViewStatesLocked();
    for (auto it = s_viewStatesCache.begin(); it != s_viewStatesCache.end(); ) {
        if (_wcsicmp(it->path.c_str(), norm.c_str()) == 0) it = s_viewStatesCache.erase(it);
        else ++it;
    }
    s_viewStatesCache.insert(s_viewStatesCache.begin(), { norm, state });
    if (s_viewStatesCache.size() > (size_t)MAX_RECENT_FILES) {
        s_viewStatesCache.resize(MAX_RECENT_FILES);
    }
    saveViewStatesLocked();
}

static bool getFileViewState(const std::wstring& path, FileViewState& outState) {
    if (path.empty()) return false;
    std::wstring norm = normalizePath(path);
    if (norm.empty()) return false;
    std::lock_guard<std::mutex> lock(s_recentMutex);
    loadViewStatesLocked();
    for (const auto& entry : s_viewStatesCache) {
        if (_wcsicmp(entry.path.c_str(), norm.c_str()) == 0) {
            outState = entry.state;
            return true;
        }
    }
    return false;
}

static std::vector<std::wstring> loadRecentFiles() {
    std::lock_guard<std::mutex> lock(s_recentMutex);
    if (s_recentCacheLoaded) return s_recentFilesCache;
    std::vector<std::wstring> list;
    HKEY hKey;
    if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\miu\\RecentFiles", 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
        for (int i = 0; i < MAX_RECENT_FILES; ++i) {
            std::wstring valName = std::to_wstring(i);
            wchar_t path[MAX_PATH] = {};
            DWORD size = sizeof(path);
            if (RegGetValueW(hKey, NULL, valName.c_str(), RRF_RT_REG_SZ, NULL, path, &size) == ERROR_SUCCESS && path[0] != L'\0') {
                list.push_back(path);
            }
        }
        RegCloseKey(hKey);
    }
    s_recentFilesCache = list;
    s_lastSavedRecentCount = (int)list.size();
    s_recentCacheLoaded = true;
    return list;
}

static void saveRecentFiles(const std::vector<std::wstring>& list) {
    std::lock_guard<std::mutex> lock(s_recentMutex);
    int count = std::min((int)list.size(), MAX_RECENT_FILES);
    s_recentFilesCache.assign(list.begin(), list.begin() + count);
    s_recentCacheLoaded = true;
    HKEY hKey;
    if (RegCreateKeyExW(HKEY_CURRENT_USER, L"Software\\miu\\RecentFiles", 0, NULL, 0, KEY_WRITE, NULL, &hKey, NULL) == ERROR_SUCCESS) {
        for (int i = 0; i < count; ++i) {
            std::wstring valName = std::to_wstring(i);
            const std::wstring& path = s_recentFilesCache[i];
            RegSetValueExW(hKey, valName.c_str(), 0, REG_SZ, (const BYTE*)path.c_str(), (DWORD)((path.size() + 1) * sizeof(wchar_t)));
        }
        int delEnd = std::max(s_lastSavedRecentCount, count);
        for (int i = count; i < delEnd; ++i) {
            std::wstring valName = std::to_wstring(i);
            RegDeleteValueW(hKey, valName.c_str());
        }
        s_lastSavedRecentCount = count;
        RegCloseKey(hKey);
    }
}

static bool isRunningAsPackagedApp() {
    static int s_state = -1;
    if (s_state != -1) return s_state == 1;
    typedef LONG(WINAPI* PFN_GetCurrentPackageFullName)(UINT32*, PWSTR);
    HMODULE hKernel32 = GetModuleHandleW(L"kernel32.dll");
    if (hKernel32) {
        auto pfn = (PFN_GetCurrentPackageFullName)GetProcAddress(hKernel32, "GetCurrentPackageFullName");
        if (pfn) {
            UINT32 len = 0;
            LONG rc = pfn(&len, nullptr);
            if (rc == ERROR_INSUFFICIENT_BUFFER && len > 0) {
                s_state = 1;
                return true;
            }
        }
    }
    s_state = 0;
    return false;
}

static std::wstring getJumpListLaunchExePath() {
    wchar_t exePath[MAX_PATH] = {};
    GetModuleFileNameW(NULL, exePath, MAX_PATH);
    if (isRunningAsPackagedApp()) {
        wchar_t localAppData[MAX_PATH] = {};
        if (GetEnvironmentVariableW(L"LOCALAPPDATA", localAppData, MAX_PATH) > 0) {
            std::wstring aliasPath = std::wstring(localAppData) + L"\\Microsoft\\WindowsApps\\miu.exe";
            DWORD attrs = GetFileAttributesW(aliasPath.c_str());
            if (attrs != INVALID_FILE_ATTRIBUTES && !(attrs & FILE_ATTRIBUTE_DIRECTORY)) {
                return aliasPath;
            }
        }
    }
    return exePath;
}

static std::vector<std::wstring> extractRemovedPaths(IObjectArray* pRemoved) {
    std::vector<std::wstring> toRemove;
    if (!pRemoved) return toRemove;

    UINT count = 0;
    if (FAILED(pRemoved->GetCount(&count)) || count == 0) return toRemove;

    wchar_t exePath[MAX_PATH] = {};
    GetModuleFileNameW(NULL, exePath, MAX_PATH);
    std::wstring normExe = normalizePath(exePath);
    std::wstring normLaunchExe = normalizePath(getJumpListLaunchExePath());

    for (UINT i = 0; i < count; ++i) {
        IUnknown* pUnk = nullptr;
        if (SUCCEEDED(pRemoved->GetAt(i, IID_PPV_ARGS(&pUnk)))) {
            IShellItem* pItem = nullptr;
            if (SUCCEEDED(pUnk->QueryInterface(IID_PPV_ARGS(&pItem)))) {
                LPWSTR pszPath = nullptr;
                if (SUCCEEDED(pItem->GetDisplayName(SIGDN_FILESYSPATH, &pszPath)) && pszPath) {
                    std::wstring norm = normalizePath(pszPath);
                    if (!norm.empty()) toRemove.push_back(norm);
                    CoTaskMemFree(pszPath);
                } else if (SUCCEEDED(pItem->GetDisplayName(SIGDN_DESKTOPABSOLUTEPARSING, &pszPath)) && pszPath) {
                    std::wstring norm = normalizePath(pszPath);
                    if (!norm.empty()) toRemove.push_back(norm);
                    CoTaskMemFree(pszPath);
                }
                pItem->Release();
            }

            IShellLinkW* pLink = nullptr;
            if (SUCCEEDED(pUnk->QueryInterface(IID_PPV_ARGS(&pLink)))) {
                wchar_t args[MAX_PATH] = {};
                if (SUCCEEDED(pLink->GetArguments(args, MAX_PATH)) && args[0] != L'\0') {
                    std::wstring norm = normalizePath(args);
                    if (!norm.empty()) toRemove.push_back(norm);
                }
                wchar_t path[MAX_PATH] = {};
                if (SUCCEEDED(pLink->GetPath(path, MAX_PATH, NULL, 0)) && path[0] != L'\0') {
                    std::wstring norm = normalizePath(path);
                    if (!norm.empty() && _wcsicmp(norm.c_str(), normExe.c_str()) != 0 && _wcsicmp(norm.c_str(), normLaunchExe.c_str()) != 0) {
                        toRemove.push_back(norm);
                    }
                }
                pLink->Release();
            }
            pUnk->Release();
        }
    }
    return toRemove;
}

static void removeFromRecentFiles(const std::vector<std::wstring>& toRemove) {
    if (toRemove.empty()) return;
    std::vector<std::wstring> normRemove;
    for (const auto& r : toRemove) {
        std::wstring n = normalizePath(r);
        if (!n.empty()) normRemove.push_back(n);
    }
    if (normRemove.empty()) return;

    std::vector<std::wstring> current = loadRecentFiles();
    std::vector<std::wstring> updated;
    for (const auto& item : current) {
        std::wstring normItem = normalizePath(item);
        bool match = false;
        for (const auto& rem : normRemove) {
            if (_wcsicmp(normItem.c_str(), rem.c_str()) == 0) {
                match = true;
                break;
            }
        }
        if (!match) updated.push_back(item);
    }
    if (updated.size() != current.size()) {
        saveRecentFiles(updated);
        std::lock_guard<std::mutex> lock(s_recentMutex);
        loadViewStatesLocked();
        bool stateRemoved = false;
        for (auto it = s_viewStatesCache.begin(); it != s_viewStatesCache.end(); ) {
            bool match = false;
            for (const auto& rem : normRemove) {
                if (_wcsicmp(it->path.c_str(), rem.c_str()) == 0) { match = true; break; }
            }
            if (match) { it = s_viewStatesCache.erase(it); stateRemoved = true; }
            else ++it;
        }
        if (stateRemoved) saveViewStatesLocked();
    }
}

static void updateJumpList() {
    CoInitialize(NULL);
    ICustomDestinationList* pDestList = nullptr;
    if (FAILED(CoCreateInstance(CLSID_DestinationList, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pDestList)))) {
        return;
    }
    if (!isRunningAsPackagedApp()) {
        pDestList->SetAppID(L"miu");
    }

    UINT cMinSlots = 0;
    IObjectArray* pRemoved = nullptr;
    if (FAILED(pDestList->BeginList(&cMinSlots, IID_PPV_ARGS(&pRemoved)))) {
        pDestList->Release();
        return;
    }

    if (pRemoved) {
        std::vector<std::wstring> toRemove = extractRemovedPaths(pRemoved);
        if (!toRemove.empty()) {
            removeFromRecentFiles(toRemove);
        }
        pRemoved->Release();
    }

    std::vector<std::wstring> recentList = loadRecentFiles();
    std::vector<std::wstring> validList;
    for (const auto& p : recentList) {
        DWORD attrs = GetFileAttributesW(p.c_str());
        if (attrs != INVALID_FILE_ATTRIBUTES && !(attrs & FILE_ATTRIBUTE_DIRECTORY)) {
            validList.push_back(p);
        }
    }
    if (validList.size() != recentList.size()) {
        saveRecentFiles(validList);
    }

    UINT maxSlots = (cMinSlots > 0) ? std::min((UINT)validList.size(), cMinSlots) : (UINT)validList.size();
    if (maxSlots > 0) {
        IObjectCollection* pCollection = nullptr;
        if (SUCCEEDED(CoCreateInstance(CLSID_EnumerableObjectCollection, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pCollection)))) {
            wchar_t exePath[MAX_PATH];
            GetModuleFileNameW(NULL, exePath, MAX_PATH);
            std::wstring launchPath = getJumpListLaunchExePath();

            for (UINT i = 0; i < maxSlots; ++i) {
                const std::wstring& filePath = validList[i];
                IShellLinkW* pLink = nullptr;
                if (SUCCEEDED(CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pLink)))) {
                    pLink->SetPath(launchPath.c_str());
                    std::wstring arg = L"\"" + filePath + L"\"";
                    pLink->SetArguments(arg.c_str());

                    std::wstring title = filePath;
                    size_t lastSlash = filePath.find_last_of(L"\\/");
                    if (lastSlash != std::wstring::npos) title = filePath.substr(lastSlash + 1);

                    IPropertyStore* pPropStore = nullptr;
                    if (SUCCEEDED(pLink->QueryInterface(IID_PPV_ARGS(&pPropStore)))) {
                        PROPVARIANT pv;
                        InitPropVariantFromString(title.c_str(), &pv);
                        pPropStore->SetValue(PKEY_Title, pv);
                        PropVariantClear(&pv);
                        pPropStore->Commit();
                        pPropStore->Release();
                    }
                    pLink->SetDescription(filePath.c_str());
                    pLink->SetIconLocation(exePath, 0);

                    pCollection->AddObject(pLink);
                    pLink->Release();
                }
            }

            std::wstring catName = GetResString(IDS_RECENT_FILES);
            if (catName.empty()) catName = L"Recent Files";
            pDestList->AppendCategory(catName.c_str(), pCollection);
            pCollection->Release();
        }
    }

    pDestList->CommitList();
    pDestList->Release();
}

static void syncRemovedJumpListItems() {
    CoInitialize(NULL);
    ICustomDestinationList* pDestList = nullptr;
    if (FAILED(CoCreateInstance(CLSID_DestinationList, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pDestList)))) {
        return;
    }
    if (!isRunningAsPackagedApp()) {
        pDestList->SetAppID(L"miu");
    }

    IObjectArray* pRemoved = nullptr;
    if (SUCCEEDED(pDestList->GetRemovedDestinations(IID_PPV_ARGS(&pRemoved)))) {
        if (pRemoved) {
            UINT count = 0;
            if (SUCCEEDED(pRemoved->GetCount(&count)) && count > 0) {
                std::vector<std::wstring> toRemove = extractRemovedPaths(pRemoved);
                pRemoved->Release();
                pDestList->Release();

                if (!toRemove.empty()) {
                    removeFromRecentFiles(toRemove);
                }
                updateJumpList();
                return;
            }
            pRemoved->Release();
        }
    }
    pDestList->Release();
}

static bool s_jumpListWorkerRunning = false;
static bool s_hasPendingShellUpdate = false;
static std::wstring s_pendingShellPath;

static void scheduleShellRecentUpdate(const std::wstring& normalizedPath) {
    {
        std::lock_guard<std::mutex> lock(s_recentMutex);
        s_hasPendingShellUpdate = true;
        if (!normalizedPath.empty()) {
            s_pendingShellPath = normalizedPath;
        }
        if (s_jumpListWorkerRunning) return;
        s_jumpListWorkerRunning = true;
    }
    std::thread([]() {
        try {
            CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
            for (;;) {
                std::wstring pathToNotify;
                {
                    std::lock_guard<std::mutex> lock(s_recentMutex);
                    if (!s_hasPendingShellUpdate) {
                        s_jumpListWorkerRunning = false;
                        break;
                    }
                    s_hasPendingShellUpdate = false;
                    pathToNotify = std::move(s_pendingShellPath);
                    s_pendingShellPath.clear();
                }
                updateJumpList();
                if (!pathToNotify.empty()) {
                    SHAddToRecentDocs(SHARD_PATHW, pathToNotify.c_str());
                }
            }
            CoUninitialize();
        } catch (...) {
            std::lock_guard<std::mutex> lock(s_recentMutex);
            s_jumpListWorkerRunning = false;
        }
    }).detach();
}

static void addToRecentFiles(const std::wstring& path, bool fileAlreadyVerified = false) {
    if (path.empty()) return;
    std::wstring normalizedPath = normalizePath(path);
    if (normalizedPath.empty()) return;

    if (!fileAlreadyVerified) {
        DWORD attrs = GetFileAttributesW(normalizedPath.c_str());
        if (attrs == INVALID_FILE_ATTRIBUTES || (attrs & FILE_ATTRIBUTE_DIRECTORY)) return;
    }

    std::vector<std::wstring> list = loadRecentFiles();
    if (list.empty() || _wcsicmp(list.front().c_str(), normalizedPath.c_str()) != 0) {
        std::vector<std::wstring> updated;
        updated.reserve(std::min((int)list.size() + 1, MAX_RECENT_FILES));
        updated.push_back(normalizedPath);
        for (const auto& item : list) {
            if (_wcsicmp(item.c_str(), normalizedPath.c_str()) != 0) {
                updated.push_back(item);
            }
            if (updated.size() >= MAX_RECENT_FILES) break;
        }
        saveRecentFiles(updated);
    }

    scheduleShellRecentUpdate(normalizedPath);
}

enum PreferredAppMode {
    PAM_DEFAULT = 0,
    PAM_ALLOW_DARK = 1,
    PAM_FORCE_DARK = 2,
    PAM_FORCE_LIGHT = 3,
    PAM_MAX = 4
};

using fnSetPreferredAppMode = PreferredAppMode (WINAPI *)(PreferredAppMode appMode);
using fnAllowDarkModeForWindow = BOOL (WINAPI *)(HWND hWnd, BOOL allow);
using fnFlushMenuThemes = void (WINAPI *)();

static void InitDarkMode() {
    HMODULE hUxtheme = GetModuleHandleW(L"uxtheme.dll");
    if (!hUxtheme) hUxtheme = LoadLibraryExW(L"uxtheme.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);
    if (hUxtheme) {
        auto pSetPreferredAppMode = (fnSetPreferredAppMode)GetProcAddress(hUxtheme, MAKEINTRESOURCEA(135));
        if (pSetPreferredAppMode) {
            pSetPreferredAppMode(PAM_ALLOW_DARK);
        }
        auto pFlushMenuThemes = (fnFlushMenuThemes)GetProcAddress(hUxtheme, MAKEINTRESOURCEA(136));
        if (pFlushMenuThemes) {
            pFlushMenuThemes();
        }
    }
}

static void EnableDarkModeForWindow(HWND hwnd, BOOL enable) {
    if (!hwnd) return;
    HMODULE hUxtheme = GetModuleHandleW(L"uxtheme.dll");
    if (hUxtheme) {
        auto pAllowDarkModeForWindow = (fnAllowDarkModeForWindow)GetProcAddress(hUxtheme, MAKEINTRESOURCEA(133));
        if (pAllowDarkModeForWindow) {
            pAllowDarkModeForWindow(hwnd, enable);
        }
    }
}

static void ApplyMenuTheme(bool isDarkMode) {
    HMODULE hUxtheme = GetModuleHandleW(L"uxtheme.dll");
    if (!hUxtheme) hUxtheme = LoadLibraryExW(L"uxtheme.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);
    if (hUxtheme) {
        auto pSetPreferredAppMode = (fnSetPreferredAppMode)GetProcAddress(hUxtheme, MAKEINTRESOURCEA(135));
        if (pSetPreferredAppMode) {
            pSetPreferredAppMode(isDarkMode ? PAM_FORCE_DARK : PAM_FORCE_LIGHT);
        }
        auto pFlushMenuThemes = (fnFlushMenuThemes)GetProcAddress(hUxtheme, MAKEINTRESOURCEA(136));
        if (pFlushMenuThemes) {
            pFlushMenuThemes();
        }
    }
}

static void FlushMenuThemesInternal() {
    HMODULE hUxtheme = GetModuleHandleW(L"uxtheme.dll");
    if (hUxtheme) {
        auto pFlushMenuThemes = (fnFlushMenuThemes)GetProcAddress(hUxtheme, MAKEINTRESOURCEA(136));
        if (pFlushMenuThemes) {
            pFlushMenuThemes();
        }
    }
}

static void updateSystemMenu(HWND hwnd) {
    if (!hwnd) return;
    syncRemovedJumpListItems();
    HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
    if (!hSysMenu) return;

    DeleteMenu(hSysMenu, IDM_RECENT_SEP, MF_BYCOMMAND);
    for (UINT id = IDM_RECENT_BASE; id < IDM_RECENT_BASE + (UINT)(MAX_RECENT_MENU_ITEMS * 16); id += 16) {
        DeleteMenu(hSysMenu, id, MF_BYCOMMAND);
    }
    s_sysMenuRecentFiles.clear();

    std::vector<std::wstring> recentList = loadRecentFiles();
    size_t count = std::min(recentList.size(), MAX_RECENT_MENU_ITEMS);
    if (count > 0) {
        AppendMenuW(hSysMenu, MF_SEPARATOR, IDM_RECENT_SEP, NULL);
        for (size_t i = 0; i < count; ++i) {
            const std::wstring& path = recentList[i];
            s_sysMenuRecentFiles.push_back(path);

            wchar_t dispPath[MAX_PATH] = {};
            if (path.length() > 60) {
                PathCompactPathExW(dispPath, path.c_str(), 60, 0);
            } else {
                wcsncpy_s(dispPath, MAX_PATH, path.c_str(), _TRUNCATE);
            }

            std::wstring escaped;
            for (const wchar_t* p = dispPath; *p; ++p) {
                if (*p == L'&') escaped += L"&&";
                else escaped += *p;
            }

            std::wstring itemText;
            if (i < 9) {
                itemText = L"&" + std::to_wstring(i + 1) + L"  " + escaped;
            } else if (i == 9) {
                itemText = L"1&0  " + escaped;
            } else {
                itemText = std::to_wstring(i + 1) + L"  " + escaped;
            }

            UINT itemID = IDM_RECENT_BASE + (UINT)(i * 16);
            AppendMenuW(hSysMenu, MF_STRING, itemID, itemText.c_str());
        }
    }
}

static std::string WToUTF8(const std::wstring& w) {
    if (w.empty()) return {};
    int n = WideCharToMultiByte(CP_UTF8, 0, w.data(), (int)w.size(), NULL, 0, NULL, NULL);
    if (n <= 0) return {};
    std::string s; s.resize(n);
    WideCharToMultiByte(CP_UTF8, 0, w.data(), (int)w.size(), &s[0], n, NULL, NULL);
    return s;
}
static std::string UnescapeString(const std::string& s, const std::string& newline) {
    return MiuCore::unescapeReplaceString(s, newline);
}
#pragma optimize("", on)
using MiuCore::Piece;
using MiuCore::PieceTable;
using MiuCore::Cursor;
using MiuCore::EditOp;
using MiuCore::EditBatch;
using MiuCore::UndoManager;
struct MappedFile {
    HANDLE hFile = INVALID_HANDLE_VALUE; HANDLE hMap = NULL; const char* ptr = nullptr; size_t size = 0;
    std::vector<char> heapBuffer; bool isMapped = false;
    FILETIME ftWrite = { 0, 0 };
    static const size_t THRESHOLD = 50 * 1024 * 1024; // 50MB
    bool open(const wchar_t* path) {
        hFile = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
        if (hFile == INVALID_HANDLE_VALUE) return false;
        GetFileTime(hFile, NULL, NULL, &ftWrite);
        LARGE_INTEGER li; if (!GetFileSizeEx(hFile, &li)) { CloseHandle(hFile); hFile = INVALID_HANDLE_VALUE; return false; }
        size = (size_t)li.QuadPart;
        if (size == 0) { ptr = nullptr; CloseHandle(hFile); hFile = INVALID_HANDLE_VALUE; return true; }
        if (size >= THRESHOLD) {
            hMap = CreateFileMappingW(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
            if (!hMap) { CloseHandle(hFile); hFile = INVALID_HANDLE_VALUE; return false; }
            ptr = (const char*)MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0); isMapped = true; return !!ptr;
        }
        else {
            heapBuffer.resize(size); DWORD bytesRead = 0;
            if (ReadFile(hFile, heapBuffer.data(), (DWORD)size, &bytesRead, NULL) && bytesRead == size) {
                ptr = heapBuffer.data(); isMapped = false; CloseHandle(hFile); hFile = INVALID_HANDLE_VALUE; return true;
            }
            CloseHandle(hFile); hFile = INVALID_HANDLE_VALUE; return false;
        }
    }
    void close() {
        if (isMapped && ptr) { UnmapViewOfFile(ptr); ptr = nullptr; }
        if (hMap) { CloseHandle(hMap); hMap = NULL; }
        if (hFile != INVALID_HANDLE_VALUE) { CloseHandle(hFile); hFile = INVALID_HANDLE_VALUE; }
        heapBuffer.clear(); ptr = nullptr; size = 0; isMapped = false;
    }
    ~MappedFile() { close(); }
};
#include <unordered_set>
#include <string_view>
#include <deque>
#include <cwctype>
class CustomTextRenderer : public IDWriteTextRenderer {
public:
    ID2D1DeviceContext* rend;
    ID2D1SolidColorBrush* defaultBrush;
    CustomTextRenderer(ID2D1DeviceContext* r, ID2D1SolidColorBrush* b) : rend(r), defaultBrush(b) {}
    IFACEMETHOD(DrawGlyphRun)(void*, FLOAT baselineOriginX, FLOAT baselineOriginY, DWRITE_MEASURING_MODE measuringMode, DWRITE_GLYPH_RUN const* glyphRun, DWRITE_GLYPH_RUN_DESCRIPTION const*, IUnknown* clientDrawingEffect) override {
        ID2D1SolidColorBrush* brush = defaultBrush;
        if (clientDrawingEffect) clientDrawingEffect->QueryInterface(__uuidof(ID2D1SolidColorBrush), (void**)&brush);
        rend->DrawGlyphRun(D2D1::Point2F(baselineOriginX, baselineOriginY), glyphRun, brush, measuringMode);
        if (clientDrawingEffect && brush != defaultBrush) brush->Release();
        return S_OK;
    }
    IFACEMETHOD(DrawUnderline)(void*, FLOAT, FLOAT, DWRITE_UNDERLINE const*, IUnknown*) override { return E_NOTIMPL; }
    IFACEMETHOD(DrawStrikethrough)(void*, FLOAT, FLOAT, DWRITE_STRIKETHROUGH const*, IUnknown*) override { return E_NOTIMPL; }
    IFACEMETHOD(DrawInlineObject)(void*, FLOAT, FLOAT, IDWriteInlineObject*, BOOL, BOOL, IUnknown*) override { return E_NOTIMPL; }
    IFACEMETHOD(IsPixelSnappingDisabled)(void*, BOOL* disabled) override { *disabled = FALSE; return S_OK; }
    IFACEMETHOD(GetCurrentTransform)(void*, DWRITE_MATRIX* m) override { rend->GetTransform((D2D1_MATRIX_3X2_F*)m); return S_OK; }
    IFACEMETHOD(GetPixelsPerDip)(void*, FLOAT* pixelsPerDip) override { *pixelsPerDip = 1.0f; return S_OK; }
    IFACEMETHODIMP_(ULONG) AddRef() { return 1; }
    IFACEMETHODIMP_(ULONG) Release() { return 1; }
    IFACEMETHODIMP QueryInterface(REFIID riid, void** ppv) {
        if (riid == __uuidof(IDWriteTextRenderer) || riid == __uuidof(IDWritePixelSnapping) || riid == __uuidof(IUnknown)) { *ppv = this; return S_OK; }
        *ppv = NULL; return E_NOINTERFACE;
    }
};
#pragma optimize("s", on)
struct CustomDialogButton {
    int id = 0;
    std::wstring text;
    int width = 0;
    int height = 0;
    int x = 0;
    int y = 0;
    HWND hwnd = NULL;
    bool isDefault = false;
    bool isCancel = false;
};

struct CustomTaskDialogData {
    HWND hDlg = NULL;
    HWND hwndParent = NULL;
    bool isDarkMode = false;
    UINT dpi = 96;

    std::wstring title;
    std::wstring instruction;
    std::wstring content;
    bool hasContent = false;

    HICON hIcon = NULL;
    int iconSize = 32;

    HFONT hFontInstruction = NULL;
    HFONT hFontContent = NULL;
    HFONT hFontButton = NULL;

    int padX = 0;
    int padY = 0;
    int textLeft = 0;
    int iconTextGap = 0;
    int textGap = 0;

    int instW = 0;
    int instH = 0;
    int contentW = 0;
    int contentH = 0;

    int upperHeight = 0;
    int lowerHeight = 0;
    int clientWidth = 0;
    int clientHeight = 0;

    std::vector<CustomDialogButton> buttons;
    int resultId = 0;
    int cancelId = IDCANCEL;
    HWND hDefaultBtn = NULL;
};

static std::wstring GetStandardButtonText(int id) {
    UINT resId = 0;
    switch (id) {
    case IDOK: resId = IDS_BTN_OK; break;
    case IDYES: resId = IDS_BTN_YES; break;
    case IDNO: resId = IDS_BTN_NO; break;
    case IDCANCEL: resId = IDS_BTN_CANCEL; break;
    }
    if (resId != 0) {
        std::wstring s = GetResString(resId);
        if (!s.empty()) return s;
    }
    switch (id) {
    case IDOK: return L"OK";
    case IDYES: return L"縺ｯ縺・&Y)";
    case IDNO: return L"縺・＞縺・&N)";
    case IDCANCEL: return L"繧ｭ繝｣繝ｳ繧ｻ繝ｫ";
    case IDRETRY: return L"蜀崎ｩｦ陦・&R)";
    case IDCLOSE: return L"髢峨§繧・&C)";
    default: return L"";
    }
}

static LRESULT CALLBACK DarkButtonSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) {
    CustomTaskDialogData* pData = (CustomTaskDialogData*)dwRefData;
    switch (uMsg) {
    case WM_MOUSEMOVE: {
        BOOL isHovered = (BOOL)(INT_PTR)GetPropW(hWnd, L"MiuHover");
        if (!isHovered) {
            SetPropW(hWnd, L"MiuHover", (HANDLE)(INT_PTR)1);
            TRACKMOUSEEVENT tme = { sizeof(TRACKMOUSEEVENT), TME_LEAVE, hWnd, 0 };
            TrackMouseEvent(&tme);
            InvalidateRect(hWnd, NULL, FALSE);
        }
        break;
    }
    case WM_MOUSELEAVE: {
        SetPropW(hWnd, L"MiuHover", (HANDLE)(INT_PTR)0);
        InvalidateRect(hWnd, NULL, FALSE);
        break;
    }
    case WM_LBUTTONDOWN: {
        SetPropW(hWnd, L"MiuPressed", (HANDLE)(INT_PTR)1);
        InvalidateRect(hWnd, NULL, FALSE);
        break;
    }
    case WM_LBUTTONUP: {
        SetPropW(hWnd, L"MiuPressed", (HANDLE)(INT_PTR)0);
        InvalidateRect(hWnd, NULL, FALSE);
        break;
    }
    case WM_SETFOCUS:
    case WM_KILLFOCUS: {
        InvalidateRect(hWnd, NULL, FALSE);
        break;
    }
    case WM_ERASEBKGND:
        return 1;
    case WM_PAINT: {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hWnd, &ps);
        RECT rc;
        GetClientRect(hWnd, &rc);

        HDC memDC = CreateCompatibleDC(hdc);
        HBITMAP memBmp = CreateCompatibleBitmap(hdc, rc.right, rc.bottom);
        HBITMAP oldBmp = (HBITMAP)SelectObject(memDC, memBmp);

        COLORREF parentBg = (COLORREF)(INT_PTR)GetPropW(hWnd, L"MiuParentBg");
        if (parentBg == 0) parentBg = RGB(32, 32, 32);
        HBRUSH hbrBg = CreateSolidBrush(parentBg);
        FillRect(memDC, &rc, hbrBg);
        DeleteObject(hbrBg);

        BOOL isHovered = (BOOL)(INT_PTR)GetPropW(hWnd, L"MiuHover");
        BOOL isPressed = (BOOL)(INT_PTR)GetPropW(hWnd, L"MiuPressed");
        if (SendMessageW(hWnd, BM_GETSTATE, 0, 0) & BST_PUSHED) {
            isPressed = TRUE;
        }
        bool isFocused = (GetFocus() == hWnd);
        bool isDefault = (GetWindowLongPtrW(hWnd, GWL_STYLE) & BS_DEFPUSHBUTTON) != 0;

        COLORREF bgCol;
        COLORREF borderCol;
        if (isPressed) {
            bgCol = RGB(40, 40, 40);
            borderCol = RGB(80, 80, 80);
        } else if (isHovered) {
            bgCol = RGB(65, 65, 65);
            borderCol = RGB(120, 120, 120);
        } else {
            bgCol = RGB(50, 50, 50);
            borderCol = isDefault ? RGB(0, 120, 215) : RGB(85, 85, 85);
        }

        if (isFocused && !isPressed) {
            borderCol = RGB(76, 194, 255);
        }

        HBRUSH hbrBtn = CreateSolidBrush(bgCol);
        HPEN hPen = CreatePen(PS_SOLID, 1, borderCol);
        HBRUSH oldBrush = (HBRUSH)SelectObject(memDC, hbrBtn);
        HPEN oldPen = (HPEN)SelectObject(memDC, hPen);

        UINT propDpi = (UINT)(UINT_PTR)GetPropW(GetParent(hWnd), L"MiuDlgDpi");
        UINT dpi = pData ? pData->dpi : (propDpi ? propDpi : GetDpiForWindow(hWnd));
        if (dpi == 0) dpi = 96;
        int radius = MulDiv(4, dpi, 96);
        RoundRect(memDC, rc.left, rc.top, rc.right, rc.bottom, radius * 2, radius * 2);

        SelectObject(memDC, oldBrush);
        SelectObject(memDC, oldPen);
        DeleteObject(hbrBtn);
        DeleteObject(hPen);

        WCHAR text[256];
        GetWindowTextW(hWnd, text, ARRAYSIZE(text));
        HFONT hFont = pData ? pData->hFontButton : (HFONT)SendMessageW(hWnd, WM_GETFONT, 0, 0);
        if (hFont) SelectObject(memDC, hFont);
        SetBkMode(memDC, TRANSPARENT);
        SetTextColor(memDC, isPressed ? RGB(200, 200, 200) : RGB(255, 255, 255));
        DrawTextW(memDC, text, -1, &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);

        BitBlt(hdc, 0, 0, rc.right, rc.bottom, memDC, 0, 0, SRCCOPY);
        SelectObject(memDC, oldBmp);
        DeleteObject(memBmp);
        DeleteDC(memDC);

        EndPaint(hWnd, &ps);
        return 0;
    }
    case WM_NCDESTROY:
        RemovePropW(hWnd, L"MiuHover");
        RemovePropW(hWnd, L"MiuPressed");
        RemovePropW(hWnd, L"MiuParentBg");
        RemoveWindowSubclass(hWnd, DarkButtonSubclassProc, uIdSubclass);
        break;
    }
    return DefSubclassProc(hWnd, uMsg, wParam, lParam);
}

static LRESULT CALLBACK DarkCheckboxSubclass(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) {
    switch (uMsg) {
    case WM_MOUSEMOVE: {
        BOOL isHovered = (BOOL)(INT_PTR)GetPropW(hWnd, L"MiuHover");
        if (!isHovered) {
            SetPropW(hWnd, L"MiuHover", (HANDLE)(INT_PTR)1);
            TRACKMOUSEEVENT tme = { sizeof(TRACKMOUSEEVENT), TME_LEAVE, hWnd, 0 };
            TrackMouseEvent(&tme);
            InvalidateRect(hWnd, NULL, FALSE);
        }
        break;
    }
    case WM_MOUSELEAVE: {
        SetPropW(hWnd, L"MiuHover", (HANDLE)(INT_PTR)0);
        InvalidateRect(hWnd, NULL, FALSE);
        break;
    }
    case WM_LBUTTONUP:
    case WM_KEYUP: {
        LRESULT res = DefSubclassProc(hWnd, uMsg, wParam, lParam);
        InvalidateRect(hWnd, NULL, FALSE);
        return res;
    }
    case BM_SETCHECK: {
        LRESULT res = DefSubclassProc(hWnd, uMsg, wParam, lParam);
        InvalidateRect(hWnd, NULL, FALSE);
        return res;
    }
    case WM_SETFOCUS:
    case WM_KILLFOCUS: {
        InvalidateRect(hWnd, NULL, FALSE);
        break;
    }
    case WM_ERASEBKGND:
        return 1;
    case WM_PAINT: {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hWnd, &ps);
        RECT rc;
        GetClientRect(hWnd, &rc);

        HDC memDC = CreateCompatibleDC(hdc);
        HBITMAP memBmp = CreateCompatibleBitmap(hdc, rc.right, rc.bottom);
        HBITMAP oldBmp = (HBITMAP)SelectObject(memDC, memBmp);

        COLORREF parentBg = (COLORREF)(INT_PTR)GetPropW(hWnd, L"MiuParentBg");
        if (parentBg == 0) parentBg = RGB(32, 32, 32);
        HBRUSH hbrBg = CreateSolidBrush(parentBg);
        FillRect(memDC, &rc, hbrBg);
        DeleteObject(hbrBg);

        BOOL isChecked = (SendMessageW(hWnd, BM_GETCHECK, 0, 0) == BST_CHECKED);
        BOOL isHovered = (BOOL)(INT_PTR)GetPropW(hWnd, L"MiuHover");
        bool isFocused = (GetFocus() == hWnd);

        UINT propDpi = (UINT)(UINT_PTR)GetPropW(GetParent(hWnd), L"MiuDlgDpi");
        UINT dpi = propDpi ? propDpi : GetDpiForWindow(hWnd);
        if (dpi == 0) dpi = 96;

        int boxSize = MulDiv(14, dpi, 96);
        int boxY = (rc.bottom - boxSize) / 2;
        int boxX = 0;

        RECT rcBox = { boxX, boxY, boxX + boxSize, boxY + boxSize };

        COLORREF boxBg = isChecked ? (isHovered ? RGB(0, 140, 240) : RGB(0, 120, 215)) : (isHovered ? RGB(45, 45, 45) : RGB(35, 35, 35));
        COLORREF boxBorder = isFocused ? RGB(76, 194, 255) : (isHovered ? RGB(140, 140, 140) : RGB(100, 100, 100));

        HBRUSH hbrBox = CreateSolidBrush(boxBg);
        HPEN hPenBox = CreatePen(PS_SOLID, 1, boxBorder);
        HBRUSH oldBr = (HBRUSH)SelectObject(memDC, hbrBox);
        HPEN oldP = (HPEN)SelectObject(memDC, hPenBox);

        int r = MulDiv(2, dpi, 96);
        RoundRect(memDC, rcBox.left, rcBox.top, rcBox.right, rcBox.bottom, r * 2, r * 2);

        SelectObject(memDC, oldBr);
        SelectObject(memDC, oldP);
        DeleteObject(hbrBox);
        DeleteObject(hPenBox);

        if (isChecked) {
            HPEN hCheckPen = CreatePen(PS_SOLID, MulDiv(2, dpi, 96), RGB(255, 255, 255));
            HPEN oldCp = (HPEN)SelectObject(memDC, hCheckPen);

            int x1 = rcBox.left + MulDiv(3, dpi, 96);
            int y1 = rcBox.top + MulDiv(7, dpi, 96);
            int x2 = rcBox.left + MulDiv(6, dpi, 96);
            int y2 = rcBox.top + MulDiv(10, dpi, 96);
            int x3 = rcBox.left + MulDiv(11, dpi, 96);
            int y3 = rcBox.top + MulDiv(4, dpi, 96);

            MoveToEx(memDC, x1, y1, NULL);
            LineTo(memDC, x2, y2);
            LineTo(memDC, x3, y3);

            SelectObject(memDC, oldCp);
            DeleteObject(hCheckPen);
        }

        WCHAR text[256];
        GetWindowTextW(hWnd, text, ARRAYSIZE(text));
        HFONT hFont = (HFONT)SendMessageW(hWnd, WM_GETFONT, 0, 0);
        if (hFont) SelectObject(memDC, hFont);
        SetBkMode(memDC, TRANSPARENT);
        SetTextColor(memDC, RGB(230, 230, 230));

        RECT rcText = { rcBox.right + MulDiv(6, dpi, 96), 0, rc.right, rc.bottom };
        DrawTextW(memDC, text, -1, &rcText, DT_LEFT | DT_VCENTER | DT_SINGLELINE);

        if (isFocused) {
            RECT rcFocus = rcText;
            DrawTextW(memDC, text, -1, &rcFocus, DT_CALCRECT | DT_LEFT | DT_VCENTER | DT_SINGLELINE);
            InflateRect(&rcFocus, 1, 1);
            DrawFocusRect(memDC, &rcFocus);
        }

        BitBlt(hdc, 0, 0, rc.right, rc.bottom, memDC, 0, 0, SRCCOPY);
        SelectObject(memDC, oldBmp);
        DeleteObject(memBmp);
        DeleteDC(memDC);

        EndPaint(hWnd, &ps);
        return 0;
    }
    case WM_NCDESTROY:
        RemovePropW(hWnd, L"MiuHover");
        RemovePropW(hWnd, L"MiuParentBg");
        RemoveWindowSubclass(hWnd, DarkCheckboxSubclass, uIdSubclass);
        break;
    }
    return DefSubclassProc(hWnd, uMsg, wParam, lParam);
}

static void SyncEditImePosition(HWND hWnd) {
    if (!hWnd) return;
    HIMC hIMC = ImmGetContext(hWnd);
    if (!hIMC) return;
    DWORD selStart = 0, selEnd = 0;
    SendMessageW(hWnd, EM_GETSEL, (WPARAM)&selStart, (LPARAM)&selEnd);
    POINT pt = { 4, 1 };
    LRESULT charPos = SendMessageW(hWnd, EM_POSFROMCHAR, selStart, 0);
    if (charPos != -1) {
        pt.x = (short)LOWORD(charPos);
        pt.y = (short)HIWORD(charPos);
    } else if (!GetCaretPos(&pt)) {
        pt.x = 4;
        pt.y = 1;
    }
    if (pt.x < 1) pt.x = 1;
    if (pt.y < 1) pt.y = 1;
    COMPOSITIONFORM cf = {};
    cf.dwStyle = CFS_POINT;
    cf.ptCurrentPos = pt;
    ImmSetCompositionWindow(hIMC, &cf);
    HFONT hFont = (HFONT)SendMessageW(hWnd, WM_GETFONT, 0, 0);
    LOGFONTW lf = {};
    if (hFont && GetObjectW(hFont, sizeof(lf), &lf)) {
        ImmSetCompositionFontW(hIMC, &lf);
    }
    RECT rcClient = {};
    GetClientRect(hWnd, &rcClient);
    CANDIDATEFORM cdf = {};
    cdf.dwIndex = 0;
    cdf.dwStyle = CFS_CANDIDATEPOS;
    cdf.ptCurrentPos.x = pt.x;
    cdf.ptCurrentPos.y = rcClient.bottom;
    ImmSetCandidateWindow(hIMC, &cdf);
    ImmReleaseContext(hWnd, hIMC);
}

static LRESULT CALLBACK DialogEditImeSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData) {
    if (uMsg == WM_NCDESTROY) {
        RemoveWindowSubclass(hWnd, DialogEditImeSubclassProc, uIdSubclass);
        return DefSubclassProc(hWnd, uMsg, wParam, lParam);
    }
    if ((uMsg == WM_KEYDOWN && wParam == VK_PROCESSKEY) || uMsg == WM_IME_STARTCOMPOSITION) {
        DWORD selStart = 0, selEnd = 0;
        SendMessageW(hWnd, EM_GETSEL, (WPARAM)&selStart, (LPARAM)&selEnd);
        if (selStart < selEnd) {
            SendMessageW(hWnd, EM_REPLACESEL, TRUE, (LPARAM)L"");
        }
        SyncEditImePosition(hWnd);
    } else if (uMsg == WM_PAINT || uMsg == WM_SETFOCUS || uMsg == WM_LBUTTONUP || uMsg == WM_KEYUP || (uMsg == WM_IME_COMPOSITION && (lParam & GCS_RESULTSTR))) {
        LRESULT res = DefSubclassProc(hWnd, uMsg, wParam, lParam);
        if (GetFocus() == hWnd) {
            SyncEditImePosition(hWnd);
        }
        return res;
    }
    return DefSubclassProc(hWnd, uMsg, wParam, lParam);
}

static void ApplyDialogTheme(HWND hDlg, bool isDarkMode) {
    if (!hDlg) return;
    BOOL dark = isDarkMode;
    DwmSetWindowAttribute(hDlg, 20 /* DWMWA_USE_IMMERSIVE_DARK_MODE */, &dark, sizeof(dark));
    EnableDarkModeForWindow(hDlg, isDarkMode);

    HWND hChild = GetWindow(hDlg, GW_CHILD);
    while (hChild) {
        WCHAR className[64];
        GetClassNameW(hChild, className, ARRAYSIZE(className));
        LONG_PTR style = GetWindowLongPtrW(hChild, GWL_STYLE);

        if (_wcsicmp(className, L"Button") == 0) {
            DWORD btnType = (style & BS_TYPEMASK);
            if (btnType == BS_CHECKBOX || btnType == BS_AUTOCHECKBOX) {
                if (isDarkMode) {
                    SetWindowSubclass(hChild, DarkCheckboxSubclass, (UINT_PTR)GetDlgCtrlID(hChild), 0);
                } else {
                    RemoveWindowSubclass(hChild, DarkCheckboxSubclass, (UINT_PTR)GetDlgCtrlID(hChild));
                    SetWindowTheme(hChild, NULL, NULL);
                }
            } else if (btnType == BS_PUSHBUTTON || btnType == BS_DEFPUSHBUTTON) {
                if (isDarkMode) {
                    SetWindowSubclass(hChild, DarkButtonSubclassProc, (UINT_PTR)GetDlgCtrlID(hChild), 0);
                } else {
                    RemoveWindowSubclass(hChild, DarkButtonSubclassProc, (UINT_PTR)GetDlgCtrlID(hChild));
                    SetWindowTheme(hChild, NULL, NULL);
                }
            }
        } else if (_wcsicmp(className, L"Edit") == 0) {
            SetWindowSubclass(hChild, DialogEditImeSubclassProc, (UINT_PTR)GetDlgCtrlID(hChild), 0);
            if (isDarkMode) {
                SetWindowTheme(hChild, L"DarkMode_CFD", NULL);
            } else {
                SetWindowTheme(hChild, NULL, NULL);
            }
        }
        hChild = GetWindow(hChild, GW_HWNDNEXT);
    }
}

static LRESULT CALLBACK CustomTaskDialogWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
    CustomTaskDialogData* pData = (CustomTaskDialogData*)GetWindowLongPtrW(hWnd, GWLP_USERDATA);

    switch (message) {
    case WM_NCCREATE: {
        CREATESTRUCTW* cs = (CREATESTRUCTW*)lParam;
        pData = (CustomTaskDialogData*)cs->lpCreateParams;
        pData->hDlg = hWnd;
        SetWindowLongPtrW(hWnd, GWLP_USERDATA, (LONG_PTR)pData);
        return DefWindowProcW(hWnd, message, wParam, lParam);
    }
    case WM_CREATE: {
        if (!pData) return -1;
        if (pData->isDarkMode) {
            BOOL dark = TRUE;
            DwmSetWindowAttribute(hWnd, 20 /* DWMWA_USE_IMMERSIVE_DARK_MODE */, &dark, sizeof(dark));
            EnableDarkModeForWindow(hWnd, TRUE);
        }
        for (auto& btn : pData->buttons) {
            DWORD btnStyle = WS_CHILD | WS_VISIBLE | WS_TABSTOP;
            if (btn.isDefault) btnStyle |= BS_DEFPUSHBUTTON;
            else btnStyle |= BS_PUSHBUTTON;

            btn.hwnd = CreateWindowExW(
                0, L"BUTTON", btn.text.c_str(),
                btnStyle,
                btn.x, btn.y, btn.width, btn.height,
                hWnd, (HMENU)(INT_PTR)btn.id,
                GetModuleHandle(NULL), NULL
            );
            SendMessageW(btn.hwnd, WM_SETFONT, (WPARAM)pData->hFontButton, TRUE);

            if (btn.isDefault) {
                pData->hDefaultBtn = btn.hwnd;
            }

            if (pData->isDarkMode) {
                SetPropW(btn.hwnd, L"MiuParentBg", (HANDLE)(INT_PTR)RGB(43, 43, 43));
                SetWindowSubclass(btn.hwnd, DarkButtonSubclassProc, (UINT_PTR)btn.id, (DWORD_PTR)pData);
            }
        }
        return 0;
    }
    case WM_ERASEBKGND:
        return 1;
    case WM_PRINTCLIENT:
    case WM_PAINT: {
        if (!pData) break;
        PAINTSTRUCT ps;
        HDC hdc = (message == WM_PRINTCLIENT) ? (HDC)wParam : BeginPaint(hWnd, &ps);
        RECT rcClient;
        GetClientRect(hWnd, &rcClient);

        HDC memDC = CreateCompatibleDC(hdc);
        HBITMAP memBmp = CreateCompatibleBitmap(hdc, rcClient.right, rcClient.bottom);
        HBITMAP oldBmp = (HBITMAP)SelectObject(memDC, memBmp);

        COLORREF upperBgCol  = pData->isDarkMode ? RGB(32, 32, 32) : RGB(255, 255, 255);
        COLORREF lowerBgCol  = pData->isDarkMode ? RGB(43, 43, 43) : RGB(240, 240, 240);
        COLORREF sepCol      = pData->isDarkMode ? RGB(56, 56, 56) : RGB(223, 223, 223);
        COLORREF instTextCol = pData->isDarkMode ? RGB(76, 194, 255) : RGB(0, 51, 153);
        COLORREF contTextCol = pData->isDarkMode ? RGB(224, 224, 224) : RGB(0, 0, 0);

        RECT rcUpper = { 0, 0, rcClient.right, pData->upperHeight };
        HBRUSH hbrUpper = CreateSolidBrush(upperBgCol);
        FillRect(memDC, &rcUpper, hbrUpper);
        DeleteObject(hbrUpper);

        RECT rcSep = { 0, pData->upperHeight, rcClient.right, pData->upperHeight + 1 };
        HBRUSH hbrSep = CreateSolidBrush(sepCol);
        FillRect(memDC, &rcSep, hbrSep);
        DeleteObject(hbrSep);

        RECT rcLower = { 0, pData->upperHeight + 1, rcClient.right, rcClient.bottom };
        HBRUSH hbrLower = CreateSolidBrush(lowerBgCol);
        FillRect(memDC, &rcLower, hbrLower);
        DeleteObject(hbrLower);

        if (pData->hIcon) {
            DrawIconEx(memDC, pData->padX, pData->padY, pData->hIcon, pData->iconSize, pData->iconSize, 0, NULL, DI_NORMAL);
        }

        SetBkMode(memDC, TRANSPARENT);
        SelectObject(memDC, pData->hFontInstruction);
        SetTextColor(memDC, instTextCol);
        RECT rcInst = { pData->textLeft, pData->padY, rcClient.right - pData->padX, pData->padY + pData->instH };
        DrawTextW(memDC, pData->instruction.c_str(), -1, &rcInst, DT_WORDBREAK | DT_EDITCONTROL | DT_NOPREFIX | DT_LEFT);

        if (pData->hasContent) {
            SelectObject(memDC, pData->hFontContent);
            SetTextColor(memDC, contTextCol);
            int contY = pData->padY + pData->instH + pData->textGap;
            RECT rcCont = { pData->textLeft, contY, rcClient.right - pData->padX, contY + pData->contentH };
            DrawTextW(memDC, pData->content.c_str(), -1, &rcCont, DT_WORDBREAK | DT_EDITCONTROL | DT_NOPREFIX | DT_LEFT);
        }

        BitBlt(hdc, 0, 0, rcClient.right, rcClient.bottom, memDC, 0, 0, SRCCOPY);
        SelectObject(memDC, oldBmp);
        DeleteObject(memBmp);
        DeleteDC(memDC);

        if (message == WM_PAINT) EndPaint(hWnd, &ps);
        return 0;
    }
    case WM_CTLCOLORBTN:
    case WM_CTLCOLORDLG:
    case WM_CTLCOLORSTATIC: {
        if (!pData) break;
        if (pData->isDarkMode) {
            static HBRUSH hbrDarkLower = CreateSolidBrush(RGB(43, 43, 43));
            SetBkColor((HDC)wParam, RGB(43, 43, 43));
            SetTextColor((HDC)wParam, RGB(255, 255, 255));
            return (LRESULT)hbrDarkLower;
        } else {
            return (LRESULT)GetSysColorBrush(COLOR_BTNFACE);
        }
    }
    case WM_COMMAND: {
        if (!pData) break;
        int id = LOWORD(wParam);
        if (HIWORD(wParam) == BN_CLICKED || lParam != 0) {
            pData->resultId = id;
            DestroyWindow(hWnd);
            return 0;
        }
        break;
    }
    case WM_CLOSE: {
        if (!pData) break;
        pData->resultId = pData->cancelId;
        DestroyWindow(hWnd);
        return 0;
    }
    }
    return DefWindowProcW(hWnd, message, wParam, lParam);
}

static int ShowCustomTaskDialog(HWND hwndParent, const wchar_t* title, const wchar_t* instruction, const wchar_t* content, TASKDIALOG_COMMON_BUTTON_FLAGS buttons, PCWSTR icon, bool isDarkMode) {
    CustomTaskDialogData data;
    data.hwndParent = hwndParent;
    data.isDarkMode = isDarkMode;
    data.title = title ? title : L"";
    data.instruction = instruction ? instruction : L"";
    data.content = content ? content : L"";
    data.hasContent = !data.content.empty();

    static const wchar_t* s_className = L"MiuCustomTaskDialog";
    static bool s_registered = false;
    if (!s_registered) {
        WNDCLASSEXW wc = { sizeof(WNDCLASSEXW) };
        wc.style = CS_HREDRAW | CS_VREDRAW;
        wc.lpfnWndProc = CustomTaskDialogWndProc;
        wc.hInstance = GetModuleHandle(NULL);
        wc.hCursor = LoadCursor(NULL, IDC_ARROW);
        wc.hbrBackground = NULL;
        wc.lpszClassName = s_className;
        RegisterClassExW(&wc);
        s_registered = true;
    }

    UINT dpi = 96;
    if (hwndParent) dpi = GetDpiForWindow(hwndParent);
    if (dpi == 0) {
        HDC hdcScreen = GetDC(NULL);
        dpi = GetDeviceCaps(hdcScreen, LOGPIXELSX);
        ReleaseDC(NULL, hdcScreen);
    }
    if (dpi == 0) dpi = 96;

    data.dpi = dpi;
    data.padX = MulDiv(18, dpi, 96);
    data.padY = MulDiv(18, dpi, 96);
    data.iconTextGap = MulDiv(16, dpi, 96);
    data.textGap = MulDiv(10, dpi, 96);
    data.iconSize = MulDiv(32, dpi, 96);

    LPCWSTR sysIconId = NULL;
    if (icon == TD_WARNING_ICON || icon == (PCWSTR)MAKEINTRESOURCEW(32515)) {
        sysIconId = IDI_WARNING;
    } else if (icon == TD_ERROR_ICON || icon == (PCWSTR)MAKEINTRESOURCEW(32513)) {
        sysIconId = IDI_ERROR;
    } else if (icon == TD_INFORMATION_ICON || icon == (PCWSTR)MAKEINTRESOURCEW(32516)) {
        sysIconId = IDI_INFORMATION;
    } else if (icon == TD_SHIELD_ICON) {
        sysIconId = IDI_SHIELD;
    } else if (IS_INTRESOURCE(icon)) {
        sysIconId = (LPCWSTR)icon;
    }

    if (sysIconId) {
        data.hIcon = (HICON)LoadImageW(NULL, sysIconId, IMAGE_ICON, data.iconSize, data.iconSize, LR_SHARED);
        if (!data.hIcon) {
            data.hIcon = LoadIconW(NULL, sysIconId);
        }
    }

    LOGFONTW lfInst = {};
    LOGFONTW lfContent = {};
    LOGFONTW lfBtn = {};

    using fnOpenThemeDataForDpi = HTHEME(WINAPI*)(HWND, LPCWSTR, UINT);
    HMODULE hUx = GetModuleHandleW(L"uxtheme.dll");
    if (!hUx) hUx = LoadLibraryExW(L"uxtheme.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);
    fnOpenThemeDataForDpi pfnOpenThemeDataForDpi = hUx ? (fnOpenThemeDataForDpi)GetProcAddress(hUx, "OpenThemeDataForDpi") : nullptr;

    HTHEME hTheme = pfnOpenThemeDataForDpi ? pfnOpenThemeDataForDpi(NULL, L"TaskDialog", dpi) : (hUx ? OpenThemeData(NULL, L"TaskDialog") : NULL);
    if (hTheme) {
        GetThemeFont(hTheme, NULL, 2 /* TDLG_MAININSTRUCTIONPANE */, 0, 210 /* TMT_FONT */, &lfInst);
        GetThemeFont(hTheme, NULL, 4 /* TDLG_CONTENTPANE */, 0, 210 /* TMT_FONT */, &lfContent);
        GetThemeFont(hTheme, NULL, 10 /* TDLG_BUTTONSECTION */, 0, 210 /* TMT_FONT */, &lfBtn);
        CloseThemeData(hTheme);
    }

    if (lfInst.lfFaceName[0] == L'\0') {
        NONCLIENTMETRICSW ncm = { sizeof(ncm) };
        SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0);
        lfInst = ncm.lfMessageFont;
        lfInst.lfHeight = MulDiv(lfInst.lfHeight, 4, 3);
        lfContent = ncm.lfMessageFont;
        lfBtn = ncm.lfMessageFont;
    }

    if (!pfnOpenThemeDataForDpi && dpi != 96) {
        lfInst.lfHeight = MulDiv(lfInst.lfHeight, dpi, 96);
        lfContent.lfHeight = MulDiv(lfContent.lfHeight, dpi, 96);
        lfBtn.lfHeight = MulDiv(lfBtn.lfHeight, dpi, 96);
    }

    data.hFontInstruction = CreateFontIndirectW(&lfInst);
    data.hFontContent = CreateFontIndirectW(&lfContent);
    data.hFontButton = CreateFontIndirectW(&lfBtn);

    if (buttons & TDCBF_YES_BUTTON) {
        data.buttons.push_back({ IDYES, GetStandardButtonText(IDYES) });
    }
    if (buttons & TDCBF_NO_BUTTON) {
        data.buttons.push_back({ IDNO, GetStandardButtonText(IDNO) });
    }
    if (buttons & TDCBF_OK_BUTTON) {
        data.buttons.push_back({ IDOK, GetStandardButtonText(IDOK) });
    }
    if (buttons & TDCBF_RETRY_BUTTON) {
        data.buttons.push_back({ IDRETRY, GetStandardButtonText(IDRETRY) });
    }
    if (buttons & TDCBF_CANCEL_BUTTON) {
        data.buttons.push_back({ IDCANCEL, GetStandardButtonText(IDCANCEL), 0, 0, 0, 0, NULL, false, true });
    }
    if (buttons & TDCBF_CLOSE_BUTTON) {
        data.buttons.push_back({ IDCLOSE, GetStandardButtonText(IDCLOSE) });
    }

    if (data.buttons.empty()) {
        data.buttons.push_back({ IDOK, GetStandardButtonText(IDOK) });
    }

    data.buttons[0].isDefault = true;

    data.cancelId = IDCANCEL;
    bool hasCancel = false;
    for (auto& btn : data.buttons) {
        if (btn.id == IDCANCEL) {
            btn.isCancel = true;
            data.cancelId = IDCANCEL;
            hasCancel = true;
            break;
        }
    }
    if (!hasCancel) {
        for (auto& btn : data.buttons) {
            if (btn.id == IDNO) {
                btn.isCancel = true;
                data.cancelId = IDNO;
                hasCancel = true;
                break;
            }
        }
    }
    if (!hasCancel) {
        data.cancelId = data.buttons.back().id;
        data.buttons.back().isCancel = true;
    }

    HDC hdcScreen = GetDC(NULL);
    HFONT hOldFont = (HFONT)SelectObject(hdcScreen, data.hFontButton);

    int minBtnWidth = MulDiv(75, dpi, 96);
    int btnHeight = MulDiv(24, dpi, 96);
    int btnGap = MulDiv(8, dpi, 96);

    int totalButtonsWidth = 0;
    for (auto& btn : data.buttons) {
        RECT rcText = { 0, 0, 0, 0 };
        DrawTextW(hdcScreen, btn.text.c_str(), -1, &rcText, DT_CALCRECT | DT_SINGLELINE);
        int textW = rcText.right - rcText.left;
        int textH = rcText.bottom - rcText.top;
        btnHeight = (std::max)(btnHeight, textH + MulDiv(8, dpi, 96));
        btn.width = (std::max)(minBtnWidth, textW + MulDiv(24, dpi, 96));
        btn.height = btnHeight;
        totalButtonsWidth += btn.width;
    }
    for (auto& btn : data.buttons) btn.height = btnHeight;
    totalButtonsWidth += (int)(data.buttons.size() - 1) * btnGap;

    data.textLeft = data.padX;
    if (data.hIcon) {
        data.textLeft = data.padX + data.iconSize + data.iconTextGap;
    }

    int minDlgClientWidth = (std::max)(MulDiv(380, dpi, 96), totalButtonsWidth + data.padX * 2);
    int textAvailWidth = minDlgClientWidth - data.textLeft - data.padX;
    if (textAvailWidth < MulDiv(240, dpi, 96)) textAvailWidth = MulDiv(240, dpi, 96);

    SelectObject(hdcScreen, data.hFontInstruction);
    RECT rcInst = { 0, 0, textAvailWidth, 0 };
    DrawTextW(hdcScreen, data.instruction.c_str(), -1, &rcInst, DT_CALCRECT | DT_WORDBREAK | DT_EDITCONTROL | DT_NOPREFIX);
    data.instW = rcInst.right - rcInst.left;
    data.instH = rcInst.bottom - rcInst.top;

    if (data.hasContent) {
        SelectObject(hdcScreen, data.hFontContent);
        RECT rcCont = { 0, 0, textAvailWidth, 0 };
        DrawTextW(hdcScreen, data.content.c_str(), -1, &rcCont, DT_CALCRECT | DT_WORDBREAK | DT_EDITCONTROL | DT_NOPREFIX);
        data.contentW = rcCont.right - rcCont.left;
        data.contentH = rcCont.bottom - rcCont.top;
    }

    int textRequiredW = (std::max)(data.instW, data.contentW);
    data.clientWidth = (std::max)(minDlgClientWidth, data.textLeft + textRequiredW + data.padX);

    int textTotalH = data.instH + (data.hasContent ? (data.textGap + data.contentH) : 0);
    int contentMinH = (std::max)(data.iconSize, textTotalH);
    data.upperHeight = data.padY + contentMinH + data.padY;

    data.lowerHeight = (std::max)(MulDiv(44, dpi, 96), btnHeight + MulDiv(16, dpi, 96));
    data.clientHeight = data.upperHeight + 1 + data.lowerHeight;

    int btnY = data.upperHeight + 1 + (data.lowerHeight - btnHeight) / 2;
    int currBtnX = data.clientWidth - data.padX - totalButtonsWidth;
    for (auto& btn : data.buttons) {
        btn.x = currBtnX;
        btn.y = btnY;
        currBtnX += btn.width + btnGap;
    }

    SelectObject(hdcScreen, hOldFont);
    ReleaseDC(NULL, hdcScreen);

    DWORD dwStyle = WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_CLIPCHILDREN;
    DWORD dwExStyle = WS_EX_DLGMODALFRAME;
    RECT rcWin = { 0, 0, data.clientWidth, data.clientHeight };
    AdjustWindowRectExForDpi(&rcWin, dwStyle, FALSE, dwExStyle, dpi);
    int winW = rcWin.right - rcWin.left;
    int winH = rcWin.bottom - rcWin.top;

    int x = 0, y = 0;
    RECT rcParent;
    if (hwndParent && GetWindowRect(hwndParent, &rcParent)) {
        x = rcParent.left + ((rcParent.right - rcParent.left) - winW) / 2;
        y = rcParent.top + ((rcParent.bottom - rcParent.top) - winH) / 2;
    } else {
        RECT rcWork;
        SystemParametersInfoW(SPI_GETWORKAREA, 0, &rcWork, 0);
        x = rcWork.left + ((rcWork.right - rcWork.left) - winW) / 2;
        y = rcWork.top + ((rcWork.bottom - rcWork.top) - winH) / 2;
    }

    BOOL wasParentEnabled = hwndParent ? IsWindowEnabled(hwndParent) : FALSE;
    if (hwndParent && wasParentEnabled) EnableWindow(hwndParent, FALSE);

    HWND hDlg = CreateWindowExW(
        dwExStyle, s_className, data.title.c_str(),
        dwStyle,
        x, y, winW, winH,
        hwndParent, NULL, GetModuleHandle(NULL), &data
    );

    if (!hDlg) {
        if (hwndParent && wasParentEnabled) EnableWindow(hwndParent, TRUE);
        if (data.hFontInstruction) DeleteObject(data.hFontInstruction);
        if (data.hFontContent) DeleteObject(data.hFontContent);
        if (data.hFontButton) DeleteObject(data.hFontButton);
        return 0;
    }

    ShowWindow(hDlg, SW_SHOW);
    UpdateWindow(hDlg);

    if (data.hDefaultBtn) {
        SetFocus(data.hDefaultBtn);
    }

    MSG msg;
    while (IsWindow(hDlg)) {
        BOOL bRet = GetMessageW(&msg, NULL, 0, 0);
        if (bRet == 0 || bRet == -1) {
            if (bRet == 0) PostQuitMessage((int)msg.wParam);
            break;
        }

        if (msg.message == WM_KEYDOWN) {
            if (msg.wParam == VK_ESCAPE) {
                SendMessageW(hDlg, WM_CLOSE, 0, 0);
                continue;
            }
        }

        if (IsDialogMessageW(hDlg, &msg)) {
            continue;
        }
        TranslateMessage(&msg);
        DispatchMessageW(&msg);
    }

    if (hwndParent && wasParentEnabled) {
        EnableWindow(hwndParent, TRUE);
        SetActiveWindow(hwndParent);
    }

    if (data.hFontInstruction) DeleteObject(data.hFontInstruction);
    if (data.hFontContent) DeleteObject(data.hFontContent);
    if (data.hFontButton) DeleteObject(data.hFontButton);

    return data.resultId;
}

struct Editor {
    HWND hwnd = NULL; HICON hFileIcon = NULL; HICON hAppIcon = NULL; HWND hFindDlg = NULL; PieceTable pt; UndoManager undo;
    std::unique_ptr<MappedFile> fileMap; std::wstring currentFilePath; bool isDirty = false; UINT cfMsDevCol = 0; UINT cfMsDevLine = 0;
    std::regex cachedRegex; bool isRegexDirty = true; bool isRegexValid = false; std::string searchQuery; std::string replaceQuery;
    bool searchMatchCase = false; bool searchWholeWord = false; bool searchRegex = false; bool isReplaceMode = false; bool showHelpPopup = false;
    std::vector<Cursor> cursors; EditBatch pendingPadding; bool isDragging = false; bool isRectSelecting = false; bool isAutoScrolling = false;
    float rectAnchorX = 0; int rectAnchorLine = 0; float rectHeadX = 0; int rectHeadLine = 0;
    bool isDragMovePending = false; bool isDragMoving = false; size_t dragMoveSourceStart = 0; size_t dragMoveSourceEnd = 0; size_t dragMoveDestPos = 0;
    wchar_t highSurrogate = 0; std::string imeComp; int vScrollPos = 0; int vScrollSubLine = 0; int hScrollPos = 0; std::vector<size_t> lineStarts;
    float maxLineWidth = 0.0f; size_t maxLineBytes = 0; int maxLineBytesIdx = -1; float gutterWidth = 50.0f; DWORD lastClickTime = 0; int clickCount = 0; int lastClickX = 0, lastClickY = 0;
    float currentFontSize = 21.0f; DWORD64 zoomPopupEndTime = 0; std::wstring zoomPopupText; bool suppressUI = false;
    ID2D1Factory1* d2dFactory = nullptr; ID2D1DeviceContext* rend = nullptr; IDXGISwapChain1* swapChain = nullptr; ID2D1Bitmap1* targetBitmap = nullptr;
    IDCompositionDevice* dcompDevice = nullptr; IDCompositionTarget* dcompTarget = nullptr; IDWriteFactory* dwFactory = nullptr;
    IDWriteTextFormat* textFormat = nullptr; IDWriteTextFormat* popupTextFormat = nullptr; IDWriteTextFormat* helpTextFormat = nullptr;
    ID2D1StrokeStyle* dotStyle = nullptr; ID2D1StrokeStyle* roundJoinStyle = nullptr;
    D2D1::ColorF background = D2D1::ColorF(1.0f, 1.0f, 1.0f, 1.0f); D2D1::ColorF textColor = D2D1::ColorF(0.0f, 0.0f, 0.0f, 1.0f);
    D2D1::ColorF gutterBg = D2D1::ColorF(0.95f, 0.95f, 0.95f, 1.0f); D2D1::ColorF gutterText = D2D1::ColorF(0.6f, 0.6f, 0.6f, 1.0f);
    D2D1::ColorF selColor = D2D1::ColorF(0.7f, 0.8f, 1.0f, 1.0f); D2D1::ColorF highlightColor = D2D1::ColorF(1.0f, 1.0f, 0.0f, 0.4f);
    float dpiScaleX = 1.0f, dpiScaleY = 1.0f; float lineHeight = 17.5f; float charWidth = 8.0f; bool isFullScreen = false; bool isAlwaysOnTop = false;
    WINDOWPLACEMENT prevPlacement = { sizeof(WINDOWPLACEMENT) }; std::wstring helpTextStr;
    D2D1::ColorF autoHlColor = D2D1::ColorF(0.8f, 0.8f, 0.8f, 0.35f); D2D1::ColorF caretColor = D2D1::ColorF(0.0f, 0.0f, 0.0f, 1.0f);
    int forceTheme = 0; // 0=auto, 1=light, 2=dark
    bool isDarkMode = false; bool isOverwriteMode = false; bool isVScrollDragging = false; bool isHScrollDragging = false;
    float scrollDragOffset = 0.0f; bool isVScrollHover = false; bool isHScrollHover = false; bool isTrackingMouse = false;
    bool wordWrapEnabled = false;
    MiuEncoding currentEncoding = ENC_UTF8_NOBOM; UINT currentCodePage = CP_UTF8; std::string convertedBuffer; std::string newlineStr = "\r\n";
    SyntaxDef currentSyntax;
    std::vector<DWRITE_HIT_TEST_METRICS> renderHitMetrics;
    std::vector<D2D1_RECT_F> renderRawRects;
    std::vector<D2D1_RECT_F> renderMergedRects;
    std::string renderLowerQuery;
    std::string renderLowerText;
    std::wstring currentExtension;
    std::vector<Emmet::Tabstop> emmetTabstops;
    size_t emmetTabstopIdx = 0;
    bool showPreview = false;
    bool webviewInitStarted = false;
    bool isSplitterHover = false;
    bool isSplitterDragging = false;
    float previewSplitRatio = 0.5f;
    HWND hwndPreviewHost = NULL;
    HMODULE hWebViewDll = NULL;
    IUnknown* webviewEnv = nullptr;
    IUnknown* webviewController = nullptr;
    IUnknown* webviewView = nullptr;
    std::wstring lastMappedFolder;
    static constexpr float SPLITTER_DIP_W = 1.0f;
    static constexpr float SB_HIT_WIDTH = 12.0f;
    static constexpr float SB_MIN_WIDTH = 6.0f;
    static constexpr float SB_MAX_WIDTH = 10.0f;
    static constexpr float SB_PADDING = 2.0f;
    static constexpr float SB_MIN_THUMB = 28.0f;
    float getFullDipWidth() const noexcept {
        RECT rc = {};
        if (hwnd) GetClientRect(hwnd, &rc);
        return (rc.right - rc.left) / dpiScaleX;
    }
    float getEditorDipWidth() const noexcept {
        float fullW = getFullDipWidth();
        if (!showPreview) return fullW;
        float splitX = std::floor(fullW * previewSplitRatio);
        float maxSplit = fullW - 120.0f - SPLITTER_DIP_W;
        if (maxSplit < 120.0f) return fullW * 0.5f;
        if (splitX < 120.0f) splitX = 120.0f;
        if (splitX > maxSplit) splitX = maxSplit;
        return splitX;
    }
    void schedulePreviewUpdate() {
        if (showPreview && !suppressUI && hwnd) SetTimer(hwnd, 4, 80, NULL);
    }
    void clearEmmetTabstops() {
        emmetTabstops.clear();
        emmetTabstopIdx = 0;
    }
    void applyBatchToEmmetTabstops(const EditBatch& batch) {
        if (emmetTabstops.empty()) return;
        if (cursors.size() != 1 || emmetTabstopIdx >= emmetTabstops.size()) {
            clearEmmetTabstops();
            return;
        }
        for (const auto& op : batch.ops) {
            auto& cur = emmetTabstops[emmetTabstopIdx];
            if (op.type == EditOp::Erase) {
                size_t len = op.text.size();
                if (op.pos < cur.startOffset || op.pos + len > cur.endOffset) {
                    clearEmmetTabstops();
                    return;
                }
                cur.endOffset -= len;
                for (size_t k = emmetTabstopIdx + 1; k < emmetTabstops.size(); ++k) {
                    if (emmetTabstops[k].startOffset >= op.pos + len) {
                        emmetTabstops[k].startOffset -= len;
                        emmetTabstops[k].endOffset -= len;
                    }
                }
            } else {
                size_t len = op.text.size();
                if (op.pos < cur.startOffset || op.pos > cur.endOffset) {
                    clearEmmetTabstops();
                    return;
                }
                cur.endOffset += len;
                for (size_t k = emmetTabstopIdx + 1; k < emmetTabstops.size(); ++k) {
                    if (emmetTabstops[k].startOffset >= op.pos) {
                        emmetTabstops[k].startOffset += len;
                        emmetTabstops[k].endOffset += len;
                    }
                }
            }
        }
    }
    Emmet::Mode getEmmetModeAndContext(size_t cursorPos, size_t lineStartPos, bool& outInsideCssBlock) {
        outInsideCssBlock = false;
        const std::wstring& ext = currentExtension;
        if (ext == L"css" || ext == L"scss" || ext == L"sass" || ext == L"less" || ext == L"styl" ||
            ext == L"stylus" || ext == L"pcss" || ext == L"postcss" || ext == L"wxss") {
            outInsideCssBlock = true;
            return Emmet::Mode::Css;
        }
        if (ext == L"jsx" || ext == L"tsx") {
            return Emmet::Mode::Jsx;
        }
        if (ext == L"xml" || ext == L"svg" || ext == L"xhtml" || ext == L"xht" || ext == L"xsl" ||
            ext == L"xslt" || ext == L"xsd" || ext == L"rss" || ext == L"atom" || ext == L"mathml" ||
            ext == L"xaml" || ext == L"plist" || ext == L"wsdl") {
            return Emmet::Mode::Xml;
        }
        Emmet::Mode mode = Emmet::Mode::Auto;
        if (ext == L"html" || ext == L"htm" || ext == L"shtml" || ext == L"vue" || ext == L"svelte" ||
            ext == L"astro" || ext == L"php" || ext == L"phtml" || ext == L"erb" || ext == L"ejs" ||
            ext == L"hbs" || ext == L"handlebars" || ext == L"mustache" || ext == L"twig" || ext == L"njk" ||
            ext == L"liquid" || ext == L"latte" || ext == L"ftl" || ext == L"vm" || ext == L"jinja" ||
            ext == L"jinja2" || ext == L"j2" || ext == L"cfm" || ext == L"cfml" || ext == L"cshtml" ||
            ext == L"razor" || ext == L"jsp" || ext == L"asp" || ext == L"aspx" || ext == L"mdx") {
            mode = Emmet::Mode::Html;
        } else if (ext == L"tsv" || ext == L"csv" || ext == L"c" || ext == L"cpp" || ext == L"cc" ||
                   ext == L"cxx" || ext == L"h" || ext == L"hpp" || ext == L"hxx" || ext == L"py" ||
                   ext == L"rb" || ext == L"go" || ext == L"rs" || ext == L"java" || ext == L"cs" ||
                   ext == L"swift" || ext == L"kt" || ext == L"scala" || ext == L"lua" || ext == L"pl" ||
                   ext == L"sh" || ext == L"bash" || ext == L"zsh" || ext == L"bat" || ext == L"cmd" ||
                   ext == L"ps1" || ext == L"sql" || ext == L"json" || ext == L"yaml" || ext == L"yml" ||
                   ext == L"toml" || ext == L"ini" || ext == L"cfg" || ext == L"conf" || ext == L"log") {
            mode = Emmet::Mode::CodeStrict;
        }
        size_t searchLen = std::min(cursorPos, (size_t)32768);
        if (searchLen > 0) {
            std::string pre = pt.getRange(cursorPos - searchLen, searchLen);
            std::string preLower = Emmet::toLowerStr(pre);
            size_t lastStyleOpen = preLower.rfind("<style");
            size_t lastStyleClose = preLower.rfind("</style");
            if (lastStyleOpen != std::string::npos && (lastStyleClose == std::string::npos || lastStyleOpen > lastStyleClose)) {
                size_t gt = preLower.find('>', lastStyleOpen);
                if (gt != std::string::npos) {
                    outInsideCssBlock = true;
                }
            } else if (mode == Emmet::Mode::Auto) {
                size_t checkEnd = (cursorPos >= lineStartPos && searchLen >= (cursorPos - lineStartPos))
                    ? (searchLen - (cursorPos - lineStartPos))
                    : searchLen;
                int braceBalance = 0;
                bool sawHtmlTagAfterOpenBrace = false;
                bool openBraceLooksLikeCode = false;
                for (size_t k = 0; k < checkEnd; ++k) {
                    char ch = pre[k];
                    if (ch == '{') {
                        braceBalance++;
                        sawHtmlTagAfterOpenBrace = false;
                        size_t pNonWs = (k > 0) ? pre.find_last_not_of(" \t\r\n", k - 1) : std::string::npos;
                        size_t lineBegin = (k > 0) ? pre.find_last_of("\r\n", k - 1) : std::string::npos;
                        lineBegin = (lineBegin == std::string::npos) ? 0 : lineBegin + 1;
                        std::string selLine = preLower.substr(lineBegin, k - lineBegin);
                        if (pNonWs != std::string::npos && (pre[pNonWs] == '=' || (pre[pNonWs] == ')' && selLine.find('@') == std::string::npos && selLine.find(':') == std::string::npos))) {
                            openBraceLooksLikeCode = true;
                        } else {
                            openBraceLooksLikeCode = false;
                        }
                    } else if (ch == '}') {
                        if (braceBalance > 0) braceBalance--;
                    } else if (ch == '<' && k + 1 < checkEnd && (Emmet::isAsciiAlpha(pre[k + 1]) || pre[k + 1] == '/')) {
                        sawHtmlTagAfterOpenBrace = true;
                    }
                }
                if (braceBalance > 0 && !sawHtmlTagAfterOpenBrace && !openBraceLooksLikeCode) {
                    outInsideCssBlock = true;
                }
            }
        }
        return mode;
    }
    bool tryExpandEmmet() {
        if (cursors.empty() || isRectSelecting) return false;
        for (const auto& c : cursors) {
            if (c.hasSelection()) return false;
        }
        if (cursors.size() == 1 && !emmetTabstops.empty() && emmetTabstopIdx < emmetTabstops.size()) {
            const auto& cur = emmetTabstops[emmetTabstopIdx];
            if (cursors[0].head < cur.startOffset || cursors[0].head > cur.endOffset) {
                clearEmmetTabstops();
            } else if (cur.startOffset == cur.endOffset) {
                return false;
            }
        }

        struct CursorExpansion {
            int cursorIdx;
            size_t erasePos;
            size_t eraseLen;
            Emmet::ExpandResult result;
        };
        std::vector<CursorExpansion> expansions;
        expansions.reserve(cursors.size());

        for (size_t i = 0; i < cursors.size(); ++i) {
            const Cursor& c = cursors[i];
            int lineIdx = getLineIdx(c.head);
            if (lineIdx < 0 || lineIdx >= (int)lineStarts.size()) return false;
            size_t lineStart = lineStarts[lineIdx];
            size_t lineEnd = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length();
            if (c.head < lineStart || c.head > lineEnd) return false;
            std::string lineText = pt.getRange(lineStart, lineEnd - lineStart);
            while (!lineText.empty() && (lineText.back() == '\n' || lineText.back() == '\r')) {
                lineText.pop_back();
            }
            size_t caretCol = c.head - lineStart;
            if (caretCol == 0 || caretCol > lineText.size()) return false;

            bool insideCssBlock = false;
            Emmet::Mode mode = getEmmetModeAndContext(c.head, lineStart, insideCssBlock);
            Emmet::ExpandResult res = Emmet::expandOnLine(lineText, caretCol, mode, insideCssBlock, newlineStr);
            if (!res.matched) return false;

            size_t erasePos = lineStart + res.abbrStartCol;
            if (cursors.size() == 1 && !emmetTabstops.empty() && emmetTabstopIdx < emmetTabstops.size()) {
                const auto& cur = emmetTabstops[emmetTabstopIdx];
                if (c.head >= cur.startOffset && c.head <= cur.endOffset) {
                    if (erasePos != cur.startOffset) return false;
                    if (res.abbrStartCol > 0 && lineText[res.abbrStartCol - 1] != ' ' && lineText[res.abbrStartCol - 1] != '\t') {
                        bool hasOp = false;
                        for (size_t k = 0; k < res.abbrLen; ++k) {
                            char ch = lineText[res.abbrStartCol + k];
                            if (!Emmet::isAsciiAlpha(ch)) { hasOp = true; break; }
                        }
                        if (!hasOp) return false;
                    }
                }
            }
            expansions.push_back({ (int)i, erasePos, res.abbrLen, std::move(res) });
        }

        commitPadding();
        EditBatch batch;
        batch.beforeCursors = cursors;

        std::sort(expansions.begin(), expansions.end(), [](const CursorExpansion& a, const CursorExpansion& b) {
            return a.erasePos > b.erasePos;
        });

        for (size_t k = 0; k < expansions.size(); ++k) {
            if (k > 0 && expansions[k].erasePos + expansions[k].eraseLen > expansions[k - 1].erasePos) {
                return false;
            }
        }

        for (const auto& exp : expansions) {
            std::string deleted = pt.getRange(exp.erasePos, exp.eraseLen);
            pt.erase(exp.erasePos, exp.eraseLen);
            batch.ops.push_back({ EditOp::Erase, exp.erasePos, deleted });
            pt.insert(exp.erasePos, exp.result.expanded);
            batch.ops.push_back({ EditOp::Insert, exp.erasePos, exp.result.expanded });

            long long delta = (long long)exp.result.expanded.size() - (long long)exp.eraseLen;
            for (size_t ci = 0; ci < cursors.size(); ++ci) {
                if ((int)ci == exp.cursorIdx) continue;
                Cursor& other = cursors[ci];
                if (other.head >= exp.erasePos + exp.eraseLen) other.head = (size_t)((long long)other.head + delta);
                if (other.anchor >= exp.erasePos + exp.eraseLen) other.anchor = (size_t)((long long)other.anchor + delta);
            }

            Cursor& cur = cursors[exp.cursorIdx];
            if (!exp.result.tabstops.empty()) {
                cur.anchor = exp.erasePos + exp.result.tabstops[0].startOffset;
                cur.head = exp.erasePos + exp.result.tabstops[0].endOffset;
            } else {
                cur.anchor = cur.head = exp.erasePos + exp.result.expanded.size();
            }
        }

        if (expansions.size() == 1 && expansions[0].result.tabstops.size() > 1) {
            emmetTabstops.clear();
            size_t basePos = expansions[0].erasePos;
            for (const auto& ts : expansions[0].result.tabstops) {
                emmetTabstops.push_back({ basePos + ts.startOffset, basePos + ts.endOffset });
            }
            emmetTabstopIdx = 0;
        } else {
            clearEmmetTabstops();
        }

        batch.afterCursors = cursors;
        undo.push(batch);
        rebuildLineStarts();
        for (auto& c : cursors) {
            c.desiredX = getXFromPos(c.head);
        }
        ensureCaretVisible();
        updateDirtyFlag();
        if (hwnd) InvalidateRect(hwnd, NULL, FALSE);
        return true;
    }
    bool jumpEmmetTabstop(bool forward) {
        if (emmetTabstops.empty() || cursors.size() != 1) {
            clearEmmetTabstops();
            return false;
        }
        if (emmetTabstopIdx >= emmetTabstops.size()) {
            clearEmmetTabstops();
            return false;
        }
        const auto& cur = emmetTabstops[emmetTabstopIdx];
        if (cursors[0].head < cur.startOffset || cursors[0].head > cur.endOffset) {
            clearEmmetTabstops();
            return false;
        }
        if (forward) {
            if (emmetTabstopIdx + 1 >= emmetTabstops.size()) {
                clearEmmetTabstops();
                return false;
            }
            emmetTabstopIdx++;
        } else {
            if (emmetTabstopIdx == 0) {
                return false;
            }
            emmetTabstopIdx--;
        }
        commitPadding();
        const auto& target = emmetTabstops[emmetTabstopIdx];
        if (target.endOffset > pt.length() || target.startOffset > target.endOffset) {
            clearEmmetTabstops();
            return false;
        }
        cursors[0].anchor = target.startOffset;
        cursors[0].head = target.endOffset;
        cursors[0].desiredX = getXFromPos(cursors[0].head);
        if (forward && emmetTabstopIdx + 1 >= emmetTabstops.size()) {
            clearEmmetTabstops();
        }
        ensureCaretVisible();
        if (hwnd) InvalidateRect(hwnd, NULL, FALSE);
        return true;
    }
    ID2D1SolidColorBrush* keywordBrush = nullptr;
    ID2D1SolidColorBrush* literalBrush = nullptr;
    ID2D1SolidColorBrush* commentBrush = nullptr;
    ID2D1SolidColorBrush* stringBrush = nullptr;
    ID2D1SolidColorBrush* cachedTextBrush = nullptr;
    ID2D1SolidColorBrush* cachedCaretBrush = nullptr;
    ID2D1SolidColorBrush* cachedCaretOverwriteBrush = nullptr;
    ID2D1SolidColorBrush* cachedSelBrush = nullptr;
    ID2D1SolidColorBrush* cachedHlBrush = nullptr;
    ID2D1SolidColorBrush* cachedAutoHlBrush = nullptr;
    ID2D1SolidColorBrush* cachedBracketBrush = nullptr;
    ID2D1SolidColorBrush* cachedWsBrush = nullptr;
    ID2D1SolidColorBrush* cachedGutterBgBrush = nullptr;
    ID2D1SolidColorBrush* cachedGutterTextBrush = nullptr;
    ID2D1SolidColorBrush* cachedSbIdleBrush = nullptr;
    ID2D1SolidColorBrush* cachedSbActiveBrush = nullptr;
    ID2D1SolidColorBrush* cachedSplitBrush = nullptr;
    ID2D1SolidColorBrush* cachedSashBrush = nullptr;
    ID2D1PathGeometry* nlGeoCRLF = nullptr;
    ID2D1PathGeometry* nlGeoLF = nullptr;
    ID2D1PathGeometry* nlGeoCR = nullptr;
    uint32_t editEpoch = 0;
    size_t lastBcVisibleStart = (size_t)-1;
    uint32_t lastBcEpoch = 0;
    bool lastBcResult = false;
    std::vector<ID2D1SolidColorBrush*> regexBrushes;
    FILETIME lastWriteTime = { 0, 0 }; bool isCheckingModification = false;
    void updateFileTime() {
        if (currentFilePath.empty()) { lastWriteTime = { 0, 0 }; return; }
        WIN32_FILE_ATTRIBUTE_DATA fad;
        if (GetFileAttributesExW(currentFilePath.c_str(), GetFileExInfoStandard, &fad)) { lastWriteTime = fad.ftLastWriteTime; }
        else { lastWriteTime = { 0, 0 }; }
    }
    void checkFileModification() {
        if (currentFilePath.empty() || isCheckingModification) return;
        WIN32_FILE_ATTRIBUTE_DATA fad;
        if (GetFileAttributesExW(currentFilePath.c_str(), GetFileExInfoStandard, &fad)) {
            if (CompareFileTime(&lastWriteTime, &fad.ftLastWriteTime) < 0) {
                isCheckingModification = true;
                std::wstring msg = GetResString(IDS_FILE_CHANGED_EXT);
                if (isDirty) msg += GetResString(IDS_FILE_CHANGED_WARN);
                int r = ShowTaskDialog(GetResString(IDS_FILE_CHANGED_TITLE).c_str(), msg.c_str(), currentFilePath.c_str(), TDCBF_YES_BUTTON | TDCBF_NO_BUTTON, TD_INFORMATION_ICON);
                if (r == IDYES) openFileFromPath(currentFilePath);
                else lastWriteTime = fad.ftLastWriteTime;
                isCheckingModification = false;
            }
        }
    }
    void loadSyntaxForExtension(const std::wstring& ext);
    void updateSyntaxBrushes() {
        for (auto b : regexBrushes) b->Release();
        regexBrushes.clear();
        if (rend) {
            for (auto& r : currentSyntax.regexes) {
                ID2D1SolidColorBrush* b = nullptr;
                rend->CreateSolidColorBrush(D2D1::ColorF(r.second.r, r.second.g, r.second.b, r.second.a), &b);
                regexBrushes.push_back(b);
            }
        }
    }
#pragma optimize("t", on)
    bool checkInBlockComment(size_t visibleStart) {
        if (currentSyntax.commentBlockStart.empty() || currentSyntax.commentBlockEnd.empty()) return false;
        if (visibleStart == 0) return false;
        if (visibleStart == lastBcVisibleStart && editEpoch == lastBcEpoch) return lastBcResult;
        size_t maxSearch = std::min((size_t)50000, visibleStart);
        std::string preText = pt.getRange(visibleStart - maxSearch, maxSearch);
        size_t lastOpen = preText.rfind(currentSyntax.commentBlockStart);
        size_t lastClose = preText.rfind(currentSyntax.commentBlockEnd);
        if (lastOpen != std::string::npos) {
            if (lastClose == std::string::npos || lastOpen > lastClose) {
                size_t lastNewline = preText.find_last_of("\r\n", lastOpen);
                size_t startSearchLine = (lastNewline == std::string::npos) ? 0 : lastNewline + 1;
                if (!currentSyntax.commentLine.empty()) {
                    size_t lineCommentPos = preText.find(currentSyntax.commentLine, startSearchLine);
                    if (lineCommentPos != std::string::npos && lineCommentPos < lastOpen) {
                        return false;
                    }
                }
                bool insideString = false;
                for (size_t k = startSearchLine; k < lastOpen; ++k) {
                    if (preText[k] == '"' || preText[k] == '\'') {
                        if (k > 0 && preText[k - 1] == '\\') continue;
                        insideString = !insideString;
                    }
                }
                if (insideString) { lastBcVisibleStart = visibleStart; lastBcEpoch = editEpoch; lastBcResult = false; return false; }
                lastBcVisibleStart = visibleStart; lastBcEpoch = editEpoch; lastBcResult = true;
                return true;
            }
        }
        lastBcVisibleStart = visibleStart; lastBcEpoch = editEpoch; lastBcResult = false;
        return false;
    }
    void applySyntaxHighlighting(IDWriteTextLayout* layout, const std::string& visibleText, size_t visibleStartOffset) {
        if (visibleText.empty()) return;
        bool inBlockComment = checkInBlockComment(visibleStartOffset);
        auto setEffect = [&](size_t utf8Start, size_t utf8Len, ID2D1SolidColorBrush* brush) {
            if (utf8Len == 0 || !brush) return;
            size_t wStart = utf8OffsetToUtf16Count(visibleText, utf8Start);
            size_t wLen = utf8OffsetToUtf16Count(visibleText, utf8Start + utf8Len) - wStart;
            DWRITE_TEXT_RANGE range = { (UINT32)wStart, (UINT32)wLen };
            layout->SetDrawingEffect(brush, range);
        };
        scanSyntaxHighlighting(
            currentSyntax,
            visibleText,
            inBlockComment,
            [&](size_t s, size_t l, int cat) {
                if (cat >= 0 && (size_t)cat < regexBrushes.size()) {
                    setEffect(s, l, regexBrushes[cat]);
                } else if (cat == (int)SyntaxTokenCategory::Comment) {
                    setEffect(s, l, commentBrush);
                } else if (cat == (int)SyntaxTokenCategory::String) {
                    setEffect(s, l, stringBrush);
                } else if (cat == (int)SyntaxTokenCategory::Keyword) {
                    setEffect(s, l, keywordBrush);
                } else if (cat == (int)SyntaxTokenCategory::Literal) {
                    setEffect(s, l, literalBrush);
                }
            }
        );
    }
    void updateSearchQuery(const std::string& newQuery) { if (searchQuery != newQuery) { searchQuery = newQuery; isRegexDirty = true; } }
    void updateSearchFlags(bool matchCase, bool wholeWord, bool regexMode) { if (searchMatchCase != matchCase || searchWholeWord != wholeWord || searchRegex != regexMode) { searchMatchCase = matchCase; searchWholeWord = wholeWord; searchRegex = regexMode; isRegexDirty = true; } }
    void ensureRegexReady() {
        if (searchRegex && isRegexDirty) {
            isRegexValid = false;
            if (!searchQuery.empty() && isSafeUserRegex(searchQuery)) {
                try { std::string actualQuery = preprocessRegexQuery(searchQuery); std::regex_constants::syntax_option_type flags = std::regex_constants::ECMAScript; if (!searchMatchCase) flags |= std::regex_constants::icase; cachedRegex = std::regex(actualQuery, flags); isRegexValid = true; }
                catch (...) { isRegexValid = false; }
            }
            isRegexDirty = false;
        }
    }
    std::string preprocessRegexQuery(const std::string& query) {
        return MiuCore::preprocessRegexQuery(query);
    }
    void detectNewlineStyle(const char* buf, size_t len) {
        newlineStr = MiuCore::DetectLineEnding(buf, len, "\r\n");
    }
    bool checkSystemDarkMode() {
        HKEY hKey; DWORD val = 1; DWORD size = sizeof(DWORD);
        if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize", 0, KEY_READ, &hKey) == ERROR_SUCCESS) { RegQueryValueExW(hKey, L"AppsUseLightTheme", NULL, NULL, (LPBYTE)&val, &size); RegCloseKey(hKey); }
        return (val == 0);
    }
    D2D1::ColorF getWindowsAccentColor(float alpha) {
        DWORD color = 0; bool success = false; HKEY hKey;
        if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\DWM", 0, KEY_READ, &hKey) == ERROR_SUCCESS) { DWORD type, size = sizeof(DWORD); if (RegQueryValueExW(hKey, L"AccentColor", NULL, &type, (LPBYTE)&color, &size) == ERROR_SUCCESS) { success = true; } RegCloseKey(hKey); }
        if (success) { float r = (float)(color & 0xFF) / 255.0f; float g = (float)((color >> 8) & 0xFF) / 255.0f; float b = (float)((color >> 16) & 0xFF) / 255.0f; return D2D1::ColorF(r, g, b, alpha); }
        return D2D1::ColorF(0.0f, 0.47f, 0.84f, alpha);
    }
    void updateThemeColors();
    void handleDpiChange(float newDpiX, float newDpiY) { dpiScaleX = newDpiX / 96.0f; dpiScaleY = newDpiY / 96.0f; if (rend) rend->SetDpi(newDpiX, newDpiY); updateFont(currentFontSize); rebuildLineStarts(); if (showPreview) updatePreviewBounds(); if (hwnd) InvalidateRect(hwnd, NULL, FALSE); }
    std::pair<std::string, bool> getHighlightTarget() {
        if (cursors.size() > 1 || cursors.empty()) return { "", false };
        const Cursor& c = cursors.back();
        if (c.hasSelection()) { size_t len = c.end() - c.start(); if (len == 0 || len > 200) return { "", false }; std::string s = pt.getRange(c.start(), len); if (s.empty() || s.find('\n') != std::string::npos || s.find('\r') != std::string::npos) return { "", false }; return { s, false }; }
        size_t pos = c.head; size_t len = pt.length(); if (pos > len) pos = len;
        bool charRight = (pos < len && isWordChar(pt.charAt(pos))); bool charLeft = (pos > 0 && isWordChar(pt.charAt(pos - 1)));
        if (!charRight && !charLeft) return { "", true };
        size_t start = pos; size_t end = pos; if (!charRight && charLeft) start--;
        while (start > 0 && isWordChar(pt.charAt(start - 1))) start--;
        while (end < len && isWordChar(pt.charAt(end))) end++;
        if (end > start) return { pt.getRange(start, end - start), true };
        return { "", true };
    }
    void initGraphics(HWND h);
    void updateFont(float size) {
        size = std::round(size); if (size < 6.0f) size = 6.0f; if (size > 200.0f) size = 200.0f;
        if (textFormat && size == currentFontSize) return; currentFontSize = size;
        if (textFormat) { textFormat->Release(); textFormat = nullptr; }
        dwFactory->CreateTextFormat(L"Consolas", NULL, DWRITE_FONT_WEIGHT_NORMAL, DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_STRETCH_NORMAL, currentFontSize, L"en-us", &textFormat);
        lineHeight = currentFontSize * 1.25f;
        if (textFormat) { textFormat->SetLineSpacing(DWRITE_LINE_SPACING_METHOD_UNIFORM, lineHeight, lineHeight * 0.8f); textFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_LEADING); textFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_NEAR); }
        IDWriteTextLayout* layout = nullptr;
        if (SUCCEEDED(dwFactory->CreateTextLayout(L"0", 1, textFormat, 100.0f, 100.0f, &layout))) { DWRITE_TEXT_METRICS m; layout->GetMetrics(&m); charWidth = m.width; layout->Release(); }
        if (textFormat) textFormat->SetIncrementalTabStop(charWidth * 4.0f);
        rebuildNewlineGeometries();
        updateGutterWidth(); updateScrollBars();
    }
    void releaseCachedRenderBrushes() {
        auto rel = [](ID2D1SolidColorBrush*& b) { if (b) { b->Release(); b = nullptr; } };
        rel(cachedTextBrush); rel(cachedCaretBrush); rel(cachedCaretOverwriteBrush);
        rel(cachedSelBrush); rel(cachedHlBrush); rel(cachedAutoHlBrush);
        rel(cachedBracketBrush); rel(cachedWsBrush); rel(cachedGutterBgBrush);
        rel(cachedGutterTextBrush); rel(cachedSbIdleBrush); rel(cachedSbActiveBrush);
        rel(cachedSplitBrush); rel(cachedSashBrush);
    }
    void releaseNewlineGeometries() {
        if (nlGeoCRLF) { nlGeoCRLF->Release(); nlGeoCRLF = nullptr; }
        if (nlGeoLF) { nlGeoLF->Release(); nlGeoLF = nullptr; }
        if (nlGeoCR) { nlGeoCR->Release(); nlGeoCR = nullptr; }
    }
    void rebuildNewlineGeometries() {
        releaseNewlineGeometries();
        if (!d2dFactory || charWidth <= 0.0f) return;
        float sz = charWidth * 1.0f;
        float halfSz = sz * 0.5f;
        float arrowSize = sz * 0.35f;
        // CRLF geometry centered at (0, 0)
        if (SUCCEEDED(d2dFactory->CreatePathGeometry(&nlGeoCRLF)) && nlGeoCRLF) {
            ID2D1GeometrySink* sink = nullptr;
            if (SUCCEEDED(nlGeoCRLF->Open(&sink)) && sink) {
                float vLineTop = -halfSz; float vLineBottom = halfSz * 0.3f;
                float hLineRight = halfSz * 0.6f; float hLineLeft = -halfSz * 0.6f;
                sink->BeginFigure(D2D1::Point2F(hLineRight, vLineTop), D2D1_FIGURE_BEGIN_HOLLOW);
                sink->AddLine(D2D1::Point2F(hLineRight, vLineBottom));
                sink->AddLine(D2D1::Point2F(hLineLeft, vLineBottom));
                sink->AddLine(D2D1::Point2F(hLineLeft + arrowSize, vLineBottom - arrowSize));
                sink->EndFigure(D2D1_FIGURE_END_OPEN);
                sink->BeginFigure(D2D1::Point2F(hLineLeft, vLineBottom), D2D1_FIGURE_BEGIN_HOLLOW);
                sink->AddLine(D2D1::Point2F(hLineLeft + arrowSize, vLineBottom + arrowSize));
                sink->EndFigure(D2D1_FIGURE_END_OPEN);
                sink->Close(); sink->Release();
            }
        }
        // CR geometry centered at (0, 0)
        if (SUCCEEDED(d2dFactory->CreatePathGeometry(&nlGeoCR)) && nlGeoCR) {
            ID2D1GeometrySink* sink = nullptr;
            if (SUCCEEDED(nlGeoCR->Open(&sink)) && sink) {
                float hLineRight = halfSz * 0.6f; float hLineLeft = -halfSz * 0.6f;
                sink->BeginFigure(D2D1::Point2F(hLineRight, 0.0f), D2D1_FIGURE_BEGIN_HOLLOW);
                sink->AddLine(D2D1::Point2F(hLineLeft, 0.0f));
                sink->AddLine(D2D1::Point2F(hLineLeft + arrowSize, -arrowSize));
                sink->EndFigure(D2D1_FIGURE_END_OPEN);
                sink->BeginFigure(D2D1::Point2F(hLineLeft, 0.0f), D2D1_FIGURE_BEGIN_HOLLOW);
                sink->AddLine(D2D1::Point2F(hLineLeft + arrowSize, arrowSize));
                sink->EndFigure(D2D1_FIGURE_END_OPEN);
                sink->Close(); sink->Release();
            }
        }
        // LF geometry centered at (0, 0)
        if (SUCCEEDED(d2dFactory->CreatePathGeometry(&nlGeoLF)) && nlGeoLF) {
            ID2D1GeometrySink* sink = nullptr;
            if (SUCCEEDED(nlGeoLF->Open(&sink)) && sink) {
                float stemTop = -halfSz * 0.8f; float stemBottom = halfSz * 0.8f;
                sink->BeginFigure(D2D1::Point2F(0.0f, stemTop), D2D1_FIGURE_BEGIN_HOLLOW);
                sink->AddLine(D2D1::Point2F(0.0f, stemBottom));
                sink->AddLine(D2D1::Point2F(-arrowSize, stemBottom - arrowSize));
                sink->EndFigure(D2D1_FIGURE_END_OPEN);
                sink->BeginFigure(D2D1::Point2F(0.0f, stemBottom), D2D1_FIGURE_BEGIN_HOLLOW);
                sink->AddLine(D2D1::Point2F(arrowSize, stemBottom - arrowSize));
                sink->EndFigure(D2D1_FIGURE_END_OPEN);
                sink->Close(); sink->Release();
            }
        }
    }
    void destroyGraphics() {
        releaseCachedRenderBrushes();
        releaseNewlineGeometries();
        if (keywordBrush) { keywordBrush->Release(); keywordBrush = nullptr; }
        if (literalBrush) { literalBrush->Release(); literalBrush = nullptr; }
        if (commentBrush) { commentBrush->Release(); commentBrush = nullptr; }
        if (stringBrush) { stringBrush->Release(); stringBrush = nullptr; }
        for (auto b : regexBrushes) b->Release();
        regexBrushes.clear();
        if (webviewController) { typedef HRESULT(STDMETHODCALLTYPE* PFN_Close)(IUnknown*); ((PFN_Close)((*(void***)webviewController)[24]))(webviewController); webviewController->Release(); webviewController = nullptr; }
        if (webviewView) { webviewView->Release(); webviewView = nullptr; }
        if (webviewEnv) { webviewEnv->Release(); webviewEnv = nullptr; }
        if (hwndPreviewHost) { DestroyWindow(hwndPreviewHost); hwndPreviewHost = NULL; }
        if (hFileIcon) { DestroyIcon(hFileIcon); hFileIcon = NULL; } if (dcompTarget) dcompTarget->Release(); if (dcompDevice) dcompDevice->Release(); if (targetBitmap) targetBitmap->Release(); if (swapChain) swapChain->Release(); if (rend) rend->Release(); if (popupTextFormat) popupTextFormat->Release(); if (helpTextFormat) helpTextFormat->Release(); if (dotStyle) dotStyle->Release(); if (roundJoinStyle) roundJoinStyle->Release(); if (textFormat) textFormat->Release(); if (dwFactory) dwFactory->Release(); if (d2dFactory) d2dFactory->Release();
    }
    void updateTitleBar() {
        if (!hwnd) return;
        std::wstring title;
        if (isAlwaysOnTop) title += L"\xD83D\xDCCC ";
        if (isDirty) title += L"*";
        if (currentFilePath.empty()) {
            title += GetResString(IDS_UNTITLED);
        }
        else {
            std::wstring fileName = currentFilePath;
            size_t lastSlash = currentFilePath.find_last_of(L"\\/");
            if (lastSlash != std::wstring::npos) {
                fileName = currentFilePath.substr(lastSlash + 1);
            }
            title += fileName;
        }
        SetWindowTextW(hwnd, title.c_str());
    }
    void updateWindowIcon() {
        if (!hwnd) return;
        if (hFileIcon) { DestroyIcon(hFileIcon); hFileIcon = NULL; }
        HICON iconForTitleBar = hAppIcon;
        if (!currentFilePath.empty()) { SHFILEINFOW sfi = { 0 }; if (SHGetFileInfoW(currentFilePath.c_str(), 0, &sfi, sizeof(sfi), SHGFI_ICON | SHGFI_SMALLICON)) { hFileIcon = sfi.hIcon; iconForTitleBar = hFileIcon; } }
        SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)iconForTitleBar); SendMessage(hwnd, WM_SETICON, ICON_BIG, (LPARAM)hAppIcon);
    }
    void updateDirtyFlag() { bool newDirty = undo.isModified(); if (isDirty != newDirty) { isDirty = newDirty; updateTitleBar(); } schedulePreviewUpdate(); }
    void updateGutterWidth() {
        if (suppressUI) return; int totalLines = (int)lineStarts.size(); int digits = 1; int tempLines = totalLines;
        while (tempLines >= 10) { tempLines /= 10; digits++; }
        gutterWidth = (float)(digits * charWidth) + (charWidth * 1.0f);
    }
    bool canFastAdjustLineStarts(const EditBatch& batch) const noexcept {
        if (lineStarts.empty() || batch.ops.size() != 1) return false;
        const EditOp& op = batch.ops[0];
        if (op.text.empty()) return false;
        for (char c : op.text) {
            if (c == '\n' || c == '\r') return false;
        }
        if (op.pos > 0 && pt.charAt(op.pos - 1) == '\r') return false;
        size_t afterPos = (op.type == EditOp::Insert) ? (op.pos + op.text.size()) : op.pos;
        if (afterPos < pt.length() && pt.charAt(afterPos) == '\n') return false;
        return true;
    }
    float measureLineWidth(int lineIdx, size_t len) {
        if (lineIdx < 0 || lineIdx >= (int)lineStarts.size() || len == 0) return charWidth * 2.0f;
        if (len <= 4096 && dwFactory && textFormat) {
            size_t start = lineStarts[lineIdx];
            std::string lineStr = pt.getRange(start, len);
            if (!lineStr.empty() && lineStr.back() == '\n') lineStr.pop_back();
            if (!lineStr.empty() && lineStr.back() == '\r') lineStr.pop_back();
            if (lineStr.empty()) return charWidth * 2.0f;
            std::wstring wLine = UTF8ToW(lineStr);
            IDWriteTextLayout* layout = nullptr;
            HRESULT hr = dwFactory->CreateTextLayout(wLine.c_str(), (UINT32)wLine.size(), textFormat, 100000.0f, (FLOAT)lineHeight, &layout);
            float w = charWidth * 2.0f;
            if (SUCCEEDED(hr) && layout) {
                DWRITE_TEXT_METRICS metrics;
                if (SUCCEEDED(layout->GetMetrics(&metrics))) {
                    w = metrics.widthIncludingTrailingWhitespace + charWidth * 2.0f;
                }
                layout->Release();
            }
            return w;
        }
        return len * charWidth + charWidth * 2.0f;
    }
    void adjustLineStartsSingleLine(size_t editPos, ptrdiff_t delta) {
        editEpoch++;
        int lineIdx = getLineIdx(editPos);
        size_t n = lineStarts.size();
        for (size_t k = (size_t)lineIdx + 1; k < n; ++k) {
            lineStarts[k] = (size_t)((ptrdiff_t)lineStarts[k] + delta);
        }
        size_t start = lineStarts[lineIdx];
        size_t end = (lineIdx + 1 < (int)n) ? lineStarts[lineIdx + 1] : pt.length();
        size_t len = (end > start) ? (end - start) : 0;
        if (delta >= 0) {
            if (len >= maxLineBytes) {
                maxLineBytes = len;
                maxLineBytesIdx = lineIdx;
            }
            float w = measureLineWidth(lineIdx, len);
            if (w > maxLineWidth) maxLineWidth = w;
        } else {
            size_t maxB = 0;
            int maxIdx = -1;
            size_t totalLen = pt.length();
            for (size_t k = 0; k < n; ++k) {
                size_t s = lineStarts[k];
                size_t e = (k + 1 < n) ? lineStarts[k + 1] : totalLen;
                size_t l = (e > s) ? (e - s) : 0;
                if (l > maxB) { maxB = l; maxIdx = (int)k; }
            }
            maxLineBytes = maxB;
            maxLineBytesIdx = maxIdx;
            maxLineWidth = (maxIdx >= 0) ? measureLineWidth(maxIdx, maxB) : (charWidth * 2.0f);
        }
        updateScrollBars();
    }
    void rebuildLineStarts() {
        editEpoch++;
        size_t maxBytes = 0; int maxBytesLineIdx = -1;
        MiuCore::scanPieceTableLineStartsSIMD(pt, lineStarts, maxBytes, maxBytesLineIdx);
        maxLineBytes = maxBytes;
        maxLineBytesIdx = maxBytesLineIdx;
        maxLineWidth = (maxBytesLineIdx >= 0) ? measureLineWidth(maxBytesLineIdx, maxBytes) : (charWidth * 2.0f);
        updateGutterWidth(); updateScrollBars();
    }
    int getLineIdx(size_t pos) { if (lineStarts.empty()) return 0; auto it = std::upper_bound(lineStarts.begin(), lineStarts.end(), pos); int idx = (int)std::distance(lineStarts.begin(), it) - 1; if (idx < 0) idx = 0; if (idx >= (int)lineStarts.size()) idx = (int)lineStarts.size() - 1; return idx; }
    float getXFromPos(size_t pos, bool affinity = false) {
        int lineIdx = getLineIdx(pos); size_t start = lineStarts[lineIdx]; size_t end = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length(); size_t len = (end > start) ? (end - start) : 0;
        std::string lineStr = pt.getRange(start, len); std::wstring wLine = UTF8ToW(lineStr); IDWriteTextLayout* layout = nullptr;
        float clientW = getEditorDipWidth() - gutterWidth; if (clientW < 0) clientW = 0;
        float layoutWidth = wordWrapEnabled ? clientW : 10000000.0f;
        HRESULT hr = dwFactory->CreateTextLayout(wLine.c_str(), (UINT32)wLine.size(), textFormat, layoutWidth, (FLOAT)lineHeight * 100.0f, &layout); float x = 0;
        if (SUCCEEDED(hr) && layout) {
            if (wordWrapEnabled) layout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP); else layout->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP);
            size_t utf8Len = (pos >= start) ? (pos - start) : 0; if (utf8Len > lineStr.size()) utf8Len = lineStr.size(); std::string subUtf8 = lineStr.substr(0, utf8Len); std::wstring subUtf16 = UTF8ToW(subUtf8); UINT32 u16Idx = (UINT32)subUtf16.size(); if (u16Idx > wLine.size()) u16Idx = (UINT32)wLine.size();
            DWRITE_HIT_TEST_METRICS m; FLOAT px, py;
            if (affinity && u16Idx > 0) {
                layout->HitTestTextPosition(u16Idx - 1, TRUE, &px, &py, &m);
            } else {
                layout->HitTestTextPosition(u16Idx, FALSE, &px, &py, &m);
            }
            x = px; layout->Release();
        }
        return x;
    }
    size_t getPosFromLineAndX(int lineIdx, float targetX) {
        if (lineIdx < 0 || lineIdx >= (int)lineStarts.size()) return cursors.empty() ? 0 : cursors.back().head;
        size_t start = lineStarts[lineIdx]; size_t end = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length(); size_t len = (end > start) ? (end - start) : 0;
        std::string lineStr = pt.getRange(start, len); std::wstring wLine = UTF8ToW(lineStr); IDWriteTextLayout* layout = nullptr;
        float clientW = getEditorDipWidth() - gutterWidth; if (clientW < 0) clientW = 0;
        float layoutWidth = wordWrapEnabled ? clientW : 10000000.0f;
        HRESULT hr = dwFactory->CreateTextLayout(wLine.c_str(), (UINT32)wLine.size(), textFormat, layoutWidth, (FLOAT)lineHeight * 100.0f, &layout); size_t resultPos = start;
        if (SUCCEEDED(hr) && layout) {
            if (wordWrapEnabled) layout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP); else layout->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP);
            BOOL isTrailing, isInside; DWRITE_HIT_TEST_METRICS m; layout->HitTestPoint(targetX, 1.0f, &isTrailing, &isInside, &m); size_t local = m.textPosition; if (isTrailing) local += m.length; size_t limit = wLine.size(); if (limit > 0 && wLine.back() == L'\n') limit--; if (limit > 0 && wLine[limit - 1] == L'\r') limit--; if (local > limit) local = limit; std::wstring wSub = wLine.substr(0, local); std::string sub = WToUTF8(wSub); resultPos = start + sub.size(); layout->Release();
        }
        return resultPos;
    }
    size_t moveVisualUpDown(size_t pos, float desiredX, bool up, bool currentAffinity, bool& outAffinity) {
        outAffinity = false;
        if (!wordWrapEnabled) {
            int l = getLineIdx(pos);
            if (up) {
                if (l > 0) return getPosFromLineAndX(l - 1, desiredX);
                return pos;
            } else {
                if (l + 1 < (int)lineStarts.size()) return getPosFromLineAndX(l + 1, desiredX);
                return pos;
            }
        }
        float clientW = getEditorDipWidth() - gutterWidth;
        if (clientW < 10.0f) clientW = 10.0f;
        if (pos > pt.length()) pos = pt.length();
        int curLineIdx = getLineIdx(pos);
        size_t curStart = lineStarts[curLineIdx];
        size_t curEnd = (curLineIdx + 1 < (int)lineStarts.size()) ? lineStarts[curLineIdx + 1] : pt.length();
        size_t curLen = (curEnd > curStart) ? (curEnd - curStart) : 0;
        std::string curLineStr = pt.getRange(curStart, curLen);
        if (!curLineStr.empty() && curLineStr.back() == '\n') curLineStr.pop_back();
        if (!curLineStr.empty() && curLineStr.back() == '\r') curLineStr.pop_back();
        std::wstring curWLine = UTF8ToW(curLineStr);

        IDWriteTextLayout* curLayout = nullptr;
        HRESULT hr = dwFactory->CreateTextLayout(curWLine.c_str(), (UINT32)curWLine.size(), textFormat, clientW, (FLOAT)lineHeight * 1000.0f, &curLayout);
        if (FAILED(hr) || !curLayout) {
            outAffinity = currentAffinity;
            return pos;
        }
        curLayout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP);

        DWRITE_TEXT_METRICS curTm;
        curLayout->GetMetrics(&curTm);
        UINT32 curLineCount = curTm.lineCount;
        if (curLineCount == 0) curLineCount = 1;
        std::vector<DWRITE_LINE_METRICS> curLineMetrics(curLineCount);
        UINT32 curActual = 0;
        curLayout->GetLineMetrics(curLineMetrics.data(), curLineCount, &curActual);
        if (curActual == 0) curActual = 1;

        std::vector<UINT32> curVisualStarts(curActual);
        std::vector<UINT32> curVisualEnds(curActual);
        UINT32 cum = 0;
        for (UINT32 i = 0; i < curActual; ++i) {
            curVisualStarts[i] = cum;
            cum += curLineMetrics[i].length;
            curVisualEnds[i] = cum;
        }

        size_t utf8Off = (pos >= curStart) ? (pos - curStart) : 0;
        if (utf8Off > curLineStr.size()) utf8Off = curLineStr.size();
        UINT32 u16Idx = (UINT32)utf8OffsetToUtf16Count(curLineStr, utf8Off);
        if (u16Idx > curWLine.size()) u16Idx = (UINT32)curWLine.size();

        int curVisualLine = 0;
        for (UINT32 i = 0; i < curActual; ++i) {
            if (currentAffinity && i > 0 && u16Idx == curVisualStarts[i]) {
                curVisualLine = (int)i - 1;
                break;
            }
            if (i == curActual - 1 || u16Idx < curVisualEnds[i]) {
                curVisualLine = (int)i;
                break;
            }
        }

        int targetLineIdx = curLineIdx;
        int targetVisualLine = -1;

        if (up) {
            if (curVisualLine > 0) {
                targetVisualLine = curVisualLine - 1;
            } else {
                if (curLineIdx == 0) {
                    curLayout->Release();
                    outAffinity = currentAffinity;
                    return pos;
                }
                targetLineIdx = curLineIdx - 1;
            }
        } else {
            if (curVisualLine + 1 < (int)curActual) {
                targetVisualLine = curVisualLine + 1;
            } else {
                if (curLineIdx + 1 >= (int)lineStarts.size()) {
                    curLayout->Release();
                    outAffinity = currentAffinity;
                    return pos;
                }
                targetLineIdx = curLineIdx + 1;
                targetVisualLine = 0;
            }
        }

        IDWriteTextLayout* targetLayout = nullptr;
        std::wstring targetWLine;
        size_t targetStart = 0;
        UINT32 targetLineCount = 0;
        std::vector<DWRITE_LINE_METRICS> targetLineMetrics;
        std::vector<UINT32> targetVisualStarts;
        std::vector<UINT32> targetVisualEnds;

        if (targetLineIdx == curLineIdx) {
            targetLayout = curLayout;
            targetWLine = curWLine;
            targetStart = curStart;
            targetLineCount = curActual;
            targetLineMetrics = curLineMetrics;
            targetVisualStarts = curVisualStarts;
            targetVisualEnds = curVisualEnds;
        } else {
            curLayout->Release();
            curLayout = nullptr;

            targetStart = lineStarts[targetLineIdx];
            size_t targetEnd = (targetLineIdx + 1 < (int)lineStarts.size()) ? lineStarts[targetLineIdx + 1] : pt.length();
            size_t targetLen = (targetEnd > targetStart) ? (targetEnd - targetStart) : 0;
            std::string targetLineStr = pt.getRange(targetStart, targetLen);
            if (!targetLineStr.empty() && targetLineStr.back() == '\n') targetLineStr.pop_back();
            if (!targetLineStr.empty() && targetLineStr.back() == '\r') targetLineStr.pop_back();
            targetWLine = UTF8ToW(targetLineStr);

            hr = dwFactory->CreateTextLayout(targetWLine.c_str(), (UINT32)targetWLine.size(), textFormat, clientW, (FLOAT)lineHeight * 1000.0f, &targetLayout);
            if (FAILED(hr) || !targetLayout) {
                outAffinity = currentAffinity;
                return pos;
            }
            targetLayout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP);

            DWRITE_TEXT_METRICS tTm;
            targetLayout->GetMetrics(&tTm);
            targetLineCount = tTm.lineCount;
            if (targetLineCount == 0) targetLineCount = 1;

            targetLineMetrics.resize(targetLineCount);
            UINT32 tActual = 0;
            targetLayout->GetLineMetrics(targetLineMetrics.data(), targetLineCount, &tActual);
            targetLineCount = tActual;
            if (targetLineCount == 0) targetLineCount = 1;

            targetVisualStarts.resize(targetLineCount);
            targetVisualEnds.resize(targetLineCount);
            UINT32 tCum = 0;
            for (UINT32 i = 0; i < targetLineCount; ++i) {
                targetVisualStarts[i] = tCum;
                tCum += targetLineMetrics[i].length;
                targetVisualEnds[i] = tCum;
            }

            if (up) {
                targetVisualLine = (int)targetLineCount - 1;
            } else {
                targetVisualLine = 0;
            }
        }

        if (targetVisualLine < 0) targetVisualLine = 0;
        if (targetVisualLine >= (int)targetLineCount) targetVisualLine = (int)targetLineCount - 1;

        float targetY = targetVisualLine * lineHeight + lineHeight * 0.5f;
        BOOL isTrailing = FALSE, isInside = FALSE;
        DWRITE_HIT_TEST_METRICS hitM = {};
        targetLayout->HitTestPoint(desiredX, targetY, &isTrailing, &isInside, &hitM);

        UINT32 localU16 = hitM.textPosition;
        if (isTrailing) localU16 += hitM.length;

        UINT32 minU16 = targetVisualStarts[targetVisualLine];
        UINT32 maxU16 = targetVisualEnds[targetVisualLine];

        if (localU16 < minU16) localU16 = minU16;
        if (localU16 > maxU16) localU16 = maxU16;

        if (localU16 == targetVisualEnds[targetVisualLine] && targetVisualLine < (int)targetLineCount - 1 && targetVisualEnds[targetVisualLine] > minU16) {
            outAffinity = true;
        } else {
            outAffinity = false;
        }

        std::wstring wSub = targetWLine.substr(0, localU16);
        std::string sub = WToUTF8(wSub);
        size_t resultPos = targetStart + sub.size();

        targetLayout->Release();
        return resultPos;
    }
    size_t getLogicalLineStart(size_t pos) {
        if (lineStarts.empty()) return 0;
        int l = getLineIdx(pos);
        return lineStarts[l];
    }
    size_t getLogicalLineEnd(size_t pos) {
        if (lineStarts.empty()) return 0;
        int l = getLineIdx(pos);
        size_t start = lineStarts[l];
        size_t nextStart = (l + 1 < (int)lineStarts.size()) ? lineStarts[l + 1] : pt.length();
        size_t end = nextStart;
        if (end > start && pt.charAt(end - 1) == '\n') end--;
        if (end > start && pt.charAt(end - 1) == '\r') end--;
        return end;
    }
    size_t moveVisualHome(size_t pos, bool currentAffinity, bool& outAffinity) {
        outAffinity = false;
        size_t logicalStart = getLogicalLineStart(pos);
        if (!wordWrapEnabled) return logicalStart;

        float clientW = getEditorDipWidth() - gutterWidth;
        if (clientW < 10.0f) clientW = 10.0f;
        if (pos > pt.length()) pos = pt.length();

        int curLineIdx = getLineIdx(pos);
        size_t curStart = lineStarts[curLineIdx];
        size_t curEnd = (curLineIdx + 1 < (int)lineStarts.size()) ? lineStarts[curLineIdx + 1] : pt.length();
        size_t curLen = (curEnd > curStart) ? (curEnd - curStart) : 0;
        std::string curLineStr = pt.getRange(curStart, curLen);
        if (!curLineStr.empty() && curLineStr.back() == '\n') curLineStr.pop_back();
        if (!curLineStr.empty() && curLineStr.back() == '\r') curLineStr.pop_back();
        std::wstring curWLine = UTF8ToW(curLineStr);
        if (curWLine.empty()) return logicalStart;

        IDWriteTextLayout* curLayout = nullptr;
        HRESULT hr = dwFactory->CreateTextLayout(curWLine.c_str(), (UINT32)curWLine.size(), textFormat, clientW, (FLOAT)lineHeight * 1000.0f, &curLayout);
        if (FAILED(hr) || !curLayout) return logicalStart;
        curLayout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP);

        DWRITE_TEXT_METRICS curTm;
        curLayout->GetMetrics(&curTm);
        UINT32 curLineCount = curTm.lineCount;
        if (curLineCount == 0) curLineCount = 1;
        std::vector<DWRITE_LINE_METRICS> curLineMetrics(curLineCount);
        UINT32 curActual = 0;
        curLayout->GetLineMetrics(curLineMetrics.data(), curLineCount, &curActual);
        if (curActual == 0) curActual = 1;

        std::vector<UINT32> curVisualStarts(curActual);
        std::vector<UINT32> curVisualEnds(curActual);
        UINT32 cum = 0;
        for (UINT32 i = 0; i < curActual; ++i) {
            curVisualStarts[i] = cum;
            cum += curLineMetrics[i].length;
            curVisualEnds[i] = cum;
        }

        size_t utf8Off = (pos >= curStart) ? (pos - curStart) : 0;
        if (utf8Off > curLineStr.size()) utf8Off = curLineStr.size();
        UINT32 u16Idx = (UINT32)utf8OffsetToUtf16Count(curLineStr, utf8Off);
        if (u16Idx > curWLine.size()) u16Idx = (UINT32)curWLine.size();

        int curVisualLine = 0;
        for (UINT32 i = 0; i < curActual; ++i) {
            if (currentAffinity && i > 0 && u16Idx == curVisualStarts[i]) {
                curVisualLine = (int)i - 1;
                break;
            }
            if (i == curActual - 1 || u16Idx < curVisualEnds[i]) {
                curVisualLine = (int)i;
                break;
            }
        }

        UINT32 startU16 = curVisualStarts[curVisualLine];
        std::wstring wSub = curWLine.substr(0, startU16);
        size_t visualStart = curStart + WToUTF8(wSub).size();

        curLayout->Release();

        if (pos <= visualStart && !currentAffinity) {
            return logicalStart;
        }
        return visualStart;
    }
    size_t moveVisualEnd(size_t pos, bool currentAffinity, bool& outAffinity) {
        outAffinity = false;
        size_t logicalEnd = getLogicalLineEnd(pos);
        if (!wordWrapEnabled) return logicalEnd;

        float clientW = getEditorDipWidth() - gutterWidth;
        if (clientW < 10.0f) clientW = 10.0f;
        if (pos > pt.length()) pos = pt.length();

        int curLineIdx = getLineIdx(pos);
        size_t curStart = lineStarts[curLineIdx];
        size_t curEnd = (curLineIdx + 1 < (int)lineStarts.size()) ? lineStarts[curLineIdx + 1] : pt.length();
        size_t curLen = (curEnd > curStart) ? (curEnd - curStart) : 0;
        std::string curLineStr = pt.getRange(curStart, curLen);
        if (!curLineStr.empty() && curLineStr.back() == '\n') curLineStr.pop_back();
        if (!curLineStr.empty() && curLineStr.back() == '\r') curLineStr.pop_back();
        std::wstring curWLine = UTF8ToW(curLineStr);
        if (curWLine.empty()) return logicalEnd;

        IDWriteTextLayout* curLayout = nullptr;
        HRESULT hr = dwFactory->CreateTextLayout(curWLine.c_str(), (UINT32)curWLine.size(), textFormat, clientW, (FLOAT)lineHeight * 1000.0f, &curLayout);
        if (FAILED(hr) || !curLayout) return logicalEnd;
        curLayout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP);

        DWRITE_TEXT_METRICS curTm;
        curLayout->GetMetrics(&curTm);
        UINT32 curLineCount = curTm.lineCount;
        if (curLineCount == 0) curLineCount = 1;
        std::vector<DWRITE_LINE_METRICS> curLineMetrics(curLineCount);
        UINT32 curActual = 0;
        curLayout->GetLineMetrics(curLineMetrics.data(), curLineCount, &curActual);
        if (curActual == 0) curActual = 1;

        std::vector<UINT32> curVisualStarts(curActual);
        std::vector<UINT32> curVisualEnds(curActual);
        UINT32 cum = 0;
        for (UINT32 i = 0; i < curActual; ++i) {
            curVisualStarts[i] = cum;
            cum += curLineMetrics[i].length;
            curVisualEnds[i] = cum;
        }

        size_t utf8Off = (pos >= curStart) ? (pos - curStart) : 0;
        if (utf8Off > curLineStr.size()) utf8Off = curLineStr.size();
        UINT32 u16Idx = (UINT32)utf8OffsetToUtf16Count(curLineStr, utf8Off);
        if (u16Idx > curWLine.size()) u16Idx = (UINT32)curWLine.size();

        int curVisualLine = 0;
        for (UINT32 i = 0; i < curActual; ++i) {
            if (currentAffinity && i > 0 && u16Idx == curVisualStarts[i]) {
                curVisualLine = (int)i - 1;
                break;
            }
            if (i == curActual - 1 || u16Idx < curVisualEnds[i]) {
                curVisualLine = (int)i;
                break;
            }
        }

        UINT32 endU16 = curVisualEnds[curVisualLine];
        std::wstring wSub = curWLine.substr(0, endU16);
        size_t visualEnd = curStart + WToUTF8(wSub).size();

        curLayout->Release();

        if (pos >= visualEnd) {
            outAffinity = false;
            return logicalEnd;
        }
        if ((UINT32)curVisualLine + 1 < curActual) {
            outAffinity = true;
        } else {
            outAffinity = false;
        }
        return visualEnd;
    }
    bool isVisualLineWrapBoundary(size_t nextPos, size_t curPos) {
        if (!wordWrapEnabled) return false;
        int curLine = getLineIdx(curPos);
        int nextLine = getLineIdx(nextPos);
        if (curLine != nextLine) return false;

        size_t curStart = lineStarts[curLine];
        size_t curEnd = (curLine + 1 < (int)lineStarts.size()) ? lineStarts[curLine + 1] : pt.length();
        size_t curLen = (curEnd > curStart) ? (curEnd - curStart) : 0;
        if (curLen == 0) return false;

        float clientW = getEditorDipWidth() - gutterWidth;
        if (clientW < 10.0f) clientW = 10.0f;
        if ((float)curLen * (8.0f * charWidth) < clientW) return false;

        std::string curLineStr = pt.getRange(curStart, curLen);
        if (!curLineStr.empty() && curLineStr.back() == '\n') curLineStr.pop_back();
        if (!curLineStr.empty() && curLineStr.back() == '\r') curLineStr.pop_back();
        std::wstring curWLine = UTF8ToW(curLineStr);
        if (curWLine.empty()) return false;

        IDWriteTextLayout* curLayout = nullptr;
        HRESULT hr = dwFactory->CreateTextLayout(curWLine.c_str(), (UINT32)curWLine.size(), textFormat, clientW, (FLOAT)lineHeight * 1000.0f, &curLayout);
        if (FAILED(hr) || !curLayout) return false;
        curLayout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP);

        DWRITE_TEXT_METRICS curTm;
        curLayout->GetMetrics(&curTm);
        UINT32 curLineCount = curTm.lineCount;
        if (curLineCount <= 1) {
            curLayout->Release();
            return false;
        }

        std::vector<DWRITE_LINE_METRICS> curLineMetrics(curLineCount);
        UINT32 curActual = 0;
        curLayout->GetLineMetrics(curLineMetrics.data(), curLineCount, &curActual);
        curLayout->Release();
        if (curActual <= 1) return false;

        size_t nextUtf8Off = (nextPos >= curStart) ? (nextPos - curStart) : 0;
        if (nextUtf8Off > curLineStr.size()) nextUtf8Off = curLineStr.size();
        UINT32 targetU16 = (UINT32)utf8OffsetToUtf16Count(curLineStr, nextUtf8Off);

        UINT32 cum = 0;
        for (UINT32 i = 0; i < curActual; ++i) {
            if (i > 0 && targetU16 == cum) {
                return true;
            }
            cum += curLineMetrics[i].length;
        }
        return false;
    }
    int getLineVisualCount(int lineIdx) {
        if (!wordWrapEnabled) return 1;
        if (lineIdx < 0 || lineIdx >= (int)lineStarts.size()) return 1;
        size_t curStart = lineStarts[lineIdx];
        size_t curEnd = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length();
        size_t curLen = (curEnd > curStart) ? (curEnd - curStart) : 0;
        if (curLen == 0) return 1;
        float clientW = getEditorDipWidth() - gutterWidth;
        if (clientW < 10.0f) clientW = 10.0f;
        if ((float)curLen * charWidth < clientW) return 1;
        std::string curLineStr = pt.getRange(curStart, curLen);
        if (!curLineStr.empty() && curLineStr.back() == '\n') curLineStr.pop_back();
        if (!curLineStr.empty() && curLineStr.back() == '\r') curLineStr.pop_back();
        if (curLineStr.empty()) return 1;
        std::wstring curWLine = UTF8ToW(curLineStr);
        IDWriteTextLayout* curLayout = nullptr;
        HRESULT hr = dwFactory->CreateTextLayout(curWLine.c_str(), (UINT32)curWLine.size(), textFormat, clientW, 1000000.0f, &curLayout);
        if (FAILED(hr) || !curLayout) return 1;
        curLayout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP);
        DWRITE_TEXT_METRICS curTm;
        curLayout->GetMetrics(&curTm);
        curLayout->Release();
        UINT32 count = curTm.lineCount;
        return (count > 0) ? (int)count : 1;
    }
    void scrollVisualLines(int deltaLines) {
        if (deltaLines == 0) return;
        if (!wordWrapEnabled) {
            vScrollSubLine = 0;
            vScrollPos += deltaLines;
            int maxV = std::max(0, (int)lineStarts.size() - 1);
            if (vScrollPos < 0) vScrollPos = 0;
            if (vScrollPos > maxV) vScrollPos = maxV;
            updateScrollBars();
            return;
        }
        if (deltaLines > 0) {
            while (deltaLines > 0) {
                int lineCount = getLineVisualCount(vScrollPos);
                int availableInCur = lineCount - 1 - vScrollSubLine;
                if (deltaLines <= availableInCur) {
                    vScrollSubLine += deltaLines;
                    deltaLines = 0;
                } else {
                    if (vScrollPos + 1 >= (int)lineStarts.size()) {
                        vScrollSubLine = std::max(0, lineCount - 1);
                        break;
                    }
                    deltaLines -= (availableInCur + 1);
                    vScrollPos++;
                    vScrollSubLine = 0;
                }
            }
        } else {
            int toScroll = -deltaLines;
            while (toScroll > 0) {
                if (vScrollSubLine >= toScroll) {
                    vScrollSubLine -= toScroll;
                    toScroll = 0;
                } else {
                    toScroll -= (vScrollSubLine + 1);
                    if (vScrollPos > 0) {
                        vScrollPos--;
                        int prevCount = getLineVisualCount(vScrollPos);
                        vScrollSubLine = std::max(0, prevCount - 1);
                    } else {
                        vScrollSubLine = 0;
                        break;
                    }
                }
            }
        }
        updateScrollBars();
    }
    void updateScrollBars() {
        if (suppressUI || !hwnd) return; RECT rc; GetClientRect(hwnd, &rc); float clientH = (rc.bottom - rc.top) / dpiScaleY; float clientW = getEditorDipWidth() - gutterWidth; if (clientW < 0) clientW = 0;
        int maxH = (wordWrapEnabled || maxLineWidth <= clientW) ? 0 : std::max(0, (int)(maxLineWidth - clientW + charWidth * 4.0f)); if (hScrollPos > maxH) hScrollPos = maxH; if (hScrollPos < 0) hScrollPos = 0;
        int maxV = std::max(0, (int)lineStarts.size() - 1); if (vScrollPos > maxV) { vScrollPos = maxV; vScrollSubLine = 0; } if (vScrollPos < 0) { vScrollPos = 0; vScrollSubLine = 0; }
        if (vScrollSubLine < 0) vScrollSubLine = 0;
        if (!wordWrapEnabled) vScrollSubLine = 0;
    }
    bool getVScrollMetrics(float clientW, float clientH, bool hasHScroll, float& trackH, float& thumbY, float& thumbH, float& maxScroll, bool& singleLineWrap) const noexcept {
        singleLineWrap = false;
        if (lineStarts.empty() || clientH <= SB_PADDING * 2.0f || lineHeight <= 0.0f) return false;
        float viewportLines = clientH / lineHeight;
        float total = (float)lineStarts.size();
        float currentV = (float)vScrollPos;
        if (wordWrapEnabled) {
            if (lineStarts.size() == 1) {
                int count = const_cast<Editor*>(this)->getLineVisualCount(0);
                if (count > 1) {
                    singleLineWrap = true;
                    total = (float)count;
                    currentV = (float)vScrollSubLine;
                }
            } else if (total <= viewportLines && vScrollPos == 0 && vScrollSubLine == 0) {
                int visSum = 0;
                for (size_t i = 0; i < lineStarts.size(); ++i) {
                    visSum += const_cast<Editor*>(this)->getLineVisualCount((int)i);
                    if ((float)visSum > viewportLines) break;
                }
                if ((float)visSum <= viewportLines) return false;
            }
        }
        if (total <= viewportLines && vScrollPos == 0 && vScrollSubLine == 0) return false;
        maxScroll = std::max(1.0f, total - 1.0f);
        trackH = std::max(0.0f, clientH - (SB_PADDING * 2.0f) - (hasHScroll ? SB_HIT_WIDTH : 0.0f));
        float virtualTotal = std::max(viewportLines, total + viewportLines - 1.0f);
        thumbH = std::round(trackH * (viewportLines / virtualTotal));
        if (thumbH < SB_MIN_THUMB) thumbH = SB_MIN_THUMB;
        if (thumbH > trackH) thumbH = trackH;
        float progress = std::min(1.0f, std::max(0.0f, currentV / maxScroll));
        thumbY = SB_PADDING + std::round((trackH - thumbH) * progress);
        return trackH > 0.0f;
    }
    bool getHScrollMetrics(float clientW, float clientH, bool hasVScroll, float& trackW, float& thumbX, float& thumbW, float& maxScroll) const noexcept {
        if (wordWrapEnabled || clientW <= SB_PADDING * 2.0f) return false;
        float visible = std::max(1.0f, clientW - gutterWidth);
        if (maxLineWidth <= visible && hScrollPos <= 0) return false;
        float total = std::max(visible + 1.0f, maxLineWidth + charWidth * 4.0f);
        maxScroll = std::max(1.0f, total - visible);
        trackW = std::max(0.0f, clientW - (SB_PADDING * 2.0f) - (hasVScroll ? SB_HIT_WIDTH : 0.0f));
        thumbW = std::round(trackW * (visible / total));
        if (thumbW < SB_MIN_THUMB) thumbW = SB_MIN_THUMB;
        if (thumbW > trackW) thumbW = trackW;
        float progress = std::min(1.0f, std::max(0.0f, (float)hScrollPos / maxScroll));
        thumbX = SB_PADDING + std::round((trackW - thumbW) * progress);
        return trackW > 0.0f;
    }
    void getScrollBarLayout(float clientW, float clientH, bool& hasV, float& vTrackH, float& thumbY, float& thumbH, float& vMaxScroll, bool& singleLineWrap, bool& hasH, float& hTrackW, float& thumbX, float& thumbW, float& hMaxScroll) const noexcept {
        bool prelimH = !wordWrapEnabled && (maxLineWidth > std::max(1.0f, clientW - gutterWidth) || hScrollPos > 0);
        hasV = getVScrollMetrics(clientW, clientH, prelimH, vTrackH, thumbY, thumbH, vMaxScroll, singleLineWrap);
        hasH = getHScrollMetrics(clientW, clientH, hasV, hTrackW, thumbX, thumbW, hMaxScroll);
    }
    void getCaretPoint(float& x, float& y) { if (cursors.empty()) { x = 0; y = 0; return; } const auto& mainCursor = cursors.back(); size_t pos = mainCursor.head; int line = getLineIdx(pos); float docY = line * lineHeight; float localX = getXFromPos(pos, mainCursor.affinity); x = (localX - hScrollPos + gutterWidth) * dpiScaleX; y = (docY - (vScrollPos * lineHeight) - (wordWrapEnabled ? (float)vScrollSubLine * lineHeight : 0.0f)) * dpiScaleY; }
    void ensureCaretVisible() {
        if (cursors.empty()) return; Cursor& mainCursor = cursors.back(); RECT rc; GetClientRect(hwnd, &rc); float clientH = (rc.bottom - rc.top) / dpiScaleY; float clientW = getEditorDipWidth(); int linesVisible = (int)(clientH / lineHeight); int caretLine = getLineIdx(mainCursor.head);
        if (vScrollPos < 0) vScrollPos = 0;
        if (!wordWrapEnabled) {
            vScrollSubLine = 0;
            if (caretLine < vScrollPos) vScrollPos = caretLine; else if (caretLine >= vScrollPos + linesVisible - 1) vScrollPos = caretLine - linesVisible + 2;
        }
        else {
            if (caretLine < vScrollPos) {
                vScrollPos = caretLine;
                vScrollSubLine = 0;
            }
            else {
                int searchStartLine = std::max(vScrollPos, caretLine - linesVisible);
                if (searchStartLine > vScrollPos) {
                    vScrollPos = searchStartLine;
                    vScrollSubLine = 0;
                }
            }
            size_t startPos = lineStarts[vScrollPos]; size_t endLine = caretLine + 1; if (endLine > lineStarts.size()) endLine = lineStarts.size();
            size_t endPos = (endLine < lineStarts.size()) ? lineStarts[endLine] : pt.length();
            if (endPos > startPos) {
                std::string chunk; pt.getRange(startPos, endPos - startPos, chunk); std::wstring wchunk; UTF8ToW(chunk, wchunk);
                IDWriteTextLayout* layout = nullptr; float w = clientW - gutterWidth; if (w < 10.0f) w = 10.0f;
                if (SUCCEEDED(dwFactory->CreateTextLayout(wchunk.c_str(), (UINT32)wchunk.size(), textFormat, w, 1000000.0f, &layout))) {
                    layout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP);
                    size_t relHead = mainCursor.head - startPos; UINT32 u16Head = (UINT32)utf8OffsetToUtf16Count(chunk, relHead);
                    DWRITE_HIT_TEST_METRICS m; FLOAT px, py;
                    if (mainCursor.affinity && u16Head > 0) {
                        layout->HitTestTextPosition(u16Head - 1, TRUE, &px, &py, &m);
                    } else {
                        layout->HitTestTextPosition(u16Head, FALSE, &px, &py, &m);
                    }
                    py = std::floor((py + lineHeight * 0.5f) / lineHeight) * lineHeight;
                    float caretViewY = py - (float)vScrollSubLine * lineHeight;
                    if (caretViewY < 0.0f) {
                        int targetSub = (int)(py / lineHeight);
                        vScrollSubLine = std::max(0, targetSub);
                    }
                    else {
                        float bottomMargin = lineHeight * 1.5f;
                        if (caretViewY + lineHeight > clientH || py + bottomMargin - (float)vScrollSubLine * lineHeight > clientH) {
                            float newTopY = py + bottomMargin - clientH;
                            if (newTopY > py) newTopY = py;
                            if (newTopY > 0.0f) {
                                int newVScroll = vScrollPos;
                                int newSubLine = 0;
                                for (int i = caretLine; i >= vScrollPos; --i) {
                                    size_t lineRelPos = lineStarts[i] - startPos; UINT32 lineU16 = (UINT32)utf8OffsetToUtf16Count(chunk, lineRelPos);
                                    DWRITE_HIT_TEST_METRICS mm; FLOAT px2, py2; layout->HitTestTextPosition(lineU16, FALSE, &px2, &py2, &mm);
                                    py2 = std::floor((py2 + lineHeight * 0.5f) / lineHeight) * lineHeight;
                                    if (py2 <= newTopY) {
                                        newVScroll = i;
                                        float diff = newTopY - py2;
                                        newSubLine = (int)std::ceil(diff / lineHeight);
                                        break;
                                    }
                                }
                                vScrollPos = newVScroll;
                                vScrollSubLine = std::max(0, newSubLine);
                            }
                        }
                    }
                    layout->Release();
                }
            }
            else {
                vScrollSubLine = 0;
            }
        }
        if (vScrollPos < 0) vScrollPos = 0;
        if (vScrollSubLine < 0) vScrollSubLine = 0;
        float visibleTextW = clientW - gutterWidth; if (visibleTextW < charWidth) visibleTextW = charWidth; float caretX = getXFromPos(mainCursor.head, mainCursor.affinity); float margin = charWidth * 2.0f;
        if (!wordWrapEnabled) {
            if (caretX < hScrollPos + margin) hScrollPos = (int)(caretX - margin); else if (caretX > hScrollPos + visibleTextW - margin) hScrollPos = (int)(caretX - visibleTextW + margin);
            if (hScrollPos < 0) hScrollPos = 0;
            float requiredWidth = caretX + margin;
            if (requiredWidth > maxLineWidth) maxLineWidth = requiredWidth;
        }
        else { hScrollPos = 0; }
        updateScrollBars(); InvalidateRect(hwnd, NULL, FALSE);
    }
    std::string textBuffer;
    std::wstring wtextBuffer;
    void buildVisibleText(int numLines, std::string& out) {
        out.clear();
        if (lineStarts.empty() || vScrollPos >= (int)lineStarts.size()) return;
        size_t startPos = lineStarts[vScrollPos]; int targetLine = vScrollPos + numLines; size_t endPos = (targetLine < (int)lineStarts.size()) ? lineStarts[targetLine] : pt.length(); if (endPos < startPos) return;
        pt.getRange(startPos, endPos - startPos, out);
    }
    std::vector<uint32_t> visibleUtf16Offsets;
    const char* visibleUtf16CachePtr = nullptr;
    size_t visibleUtf16CacheSize = 0;
    bool visibleAllAscii = false;
    void buildVisibleUtf16Map(const std::string& utf8str) {
        size_t n = utf8str.size();
        visibleUtf16CachePtr = utf8str.data();
        visibleUtf16CacheSize = n;
        const char* p = utf8str.data();
        size_t idx = 0;
        __m128i maskAcc = _mm_setzero_si128();
        while (idx + 16 <= n) {
            maskAcc = _mm_or_si128(maskAcc, _mm_loadu_si128((const __m128i*)(p + idx)));
            idx += 16;
        }
        int highBits = _mm_movemask_epi8(maskAcc);
        while (idx < n) {
            if ((unsigned char)p[idx] >= 0x80) { highBits = 1; break; }
            idx++;
        }
        if (highBits == 0) {
            visibleAllAscii = true;
            return;
        }
        visibleAllAscii = false;
        visibleUtf16Offsets.resize(n + 1);
        uint32_t count = 0;
        size_t i = 0;
        while (i < n) {
            visibleUtf16Offsets[i] = count;
            unsigned char c = (unsigned char)p[i];
            if (c < 0x80) { i += 1; count += 1; }
            else if ((c & 0xE0) == 0xC0) {
                if (i + 1 <= n) visibleUtf16Offsets[i + 1] = count + 1;
                i += 2; count += 1;
            }
            else if ((c & 0xF0) == 0xE0) {
                if (i + 1 <= n) visibleUtf16Offsets[i + 1] = count + 1;
                if (i + 2 <= n) visibleUtf16Offsets[i + 2] = count + 1;
                i += 3; count += 1;
            }
            else if ((c & 0xF8) == 0xF0) {
                if (i + 1 <= n) visibleUtf16Offsets[i + 1] = count + 2;
                if (i + 2 <= n) visibleUtf16Offsets[i + 2] = count + 2;
                if (i + 3 <= n) visibleUtf16Offsets[i + 3] = count + 2;
                i += 4; count += 2;
            }
            else { i += 1; count += 1; }
        }
        visibleUtf16Offsets[n] = count;
    }
    size_t utf8OffsetToUtf16Count(const std::string& utf8str, size_t maxOffset) {
        if (utf8str.data() == visibleUtf16CachePtr && utf8str.size() == visibleUtf16CacheSize) {
            size_t clamped = (maxOffset < visibleUtf16CacheSize) ? maxOffset : visibleUtf16CacheSize;
            if (visibleAllAscii) return clamped;
            return visibleUtf16Offsets[clamped];
        }
        size_t count = 0; size_t i = 0;
        while (i < maxOffset && i < utf8str.size()) {
            unsigned char c = (unsigned char)utf8str[i];
            if (c < 0x80) { i += 1; count += 1; }
            else if ((c & 0xE0) == 0xC0) { i += 2; count += 1; }
            else if ((c & 0xF0) == 0xE0) { i += 3; count += 1; }
            else if ((c & 0xF8) == 0xF0) { i += 4; count += 2; }
            else { i += 1; count += 1; }
        }
        return count;
    }
    size_t getDocPosFromPoint(int x, int y) {
        float dipX = x / dpiScaleX; float dipY = y / dpiScaleY; if (dipX < gutterWidth) dipX = gutterWidth; float virtualX = dipX - gutterWidth + hScrollPos; float virtualY = dipY + (wordWrapEnabled ? (float)vScrollSubLine * lineHeight : 0.0f);
        RECT rc; GetClientRect(hwnd, &rc); float clientH = (rc.bottom - rc.top) / dpiScaleY; float clientW = getEditorDipWidth() - gutterWidth;
        int linesVisible = (int)(clientH / lineHeight) + 2; buildVisibleText(linesVisible + (wordWrapEnabled ? vScrollSubLine : 0), textBuffer); UTF8ToW(textBuffer, wtextBuffer); float layoutWidth = wordWrapEnabled ? clientW : (maxLineWidth + clientW);
        IDWriteTextLayout* layout = nullptr; HRESULT hr = dwFactory->CreateTextLayout(wtextBuffer.c_str(), (UINT32)wtextBuffer.size(), textFormat, layoutWidth, 1000000.0f, &layout); size_t resultPos = 0; size_t visibleStartOffset = (vScrollPos < (int)lineStarts.size()) ? lineStarts[vScrollPos] : pt.length();
        if (SUCCEEDED(hr) && layout) {
            if (wordWrapEnabled) layout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP); else layout->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP);
            BOOL isTrailing, isInside; DWRITE_HIT_TEST_METRICS metrics; layout->HitTestPoint(virtualX, virtualY, &isTrailing, &isInside, &metrics); UINT32 utf16Index = metrics.textPosition; if (isTrailing) utf16Index += metrics.length; if (utf16Index > wtextBuffer.size()) utf16Index = (UINT32)wtextBuffer.size(); std::wstring wsub = wtextBuffer.substr(0, utf16Index); std::string sub = WToUTF8(wsub); resultPos = visibleStartOffset + sub.size(); layout->Release();
        }
        if (resultPos > pt.length()) resultPos = pt.length(); return resultPos;
    }
    bool isWordChar(char c) { return MiuCore::isWordChar(c); }
    void mergeCursors() {
        if (cursors.empty()) return;
        std::sort(cursors.begin(), cursors.end(), [](const Cursor& a, const Cursor& b) {
            if (a.start() != b.start()) return a.start() < b.start();
            return a.end() < b.end();
        });
        std::vector<Cursor> merged; merged.push_back(cursors[0]);
        for (size_t i = 1; i < cursors.size(); ++i) {
            Cursor& prev = merged.back(); Cursor& curr = cursors[i];
            bool overlaps = (prev.hasSelection() && curr.hasSelection()) ? (curr.start() < prev.end()) : (curr.start() <= prev.end());
            if (overlaps) {
                size_t newStart = std::min(prev.start(), curr.start());
                size_t newEnd = std::max(prev.end(), curr.end());
                bool prevForward = prev.head >= prev.anchor;
                prev.anchor = prevForward ? newStart : newEnd;
                prev.head = prevForward ? newEnd : newStart;
            } else merged.push_back(curr);
        }
        cursors = merged;
    }
    void selectWordAt(size_t pos, bool addSelection = false) {
        if (pos < pt.length() && !isWordChar(pt.charAt(pos)) && pos > 0 && isWordChar(pt.charAt(pos - 1))) {
            pos--;
        }
        size_t start = pos, end = pos;
        if (pos < pt.length()) {
            char c = pt.charAt(pos);
            if (c == '\r') {
                if (pos + 1 < pt.length() && pt.charAt(pos + 1) == '\n') end = pos + 2;
                else end = pos + 1;
            } else if (c == '\n') {
                if (pos > 0 && pt.charAt(pos - 1) == '\r') { start = pos - 1; end = pos + 1; }
                else end = pos + 1;
            } else {
                bool targetType = isWordChar(c);
                while (start > 0) { char p = pt.charAt(start - 1); if (isWordChar(p) != targetType || p == '\n' || p == '\r') break; start--; }
                size_t len = pt.length();
                while (end < len) { char p = pt.charAt(end); if (isWordChar(p) != targetType || p == '\n' || p == '\r') break; end++; }
            }
        }
        Cursor newCur = { end, start, getXFromPos(end) };
        if (addSelection) {
            std::vector<Cursor> kept;
            for (const auto& existing : cursors) {
                if (existing.hasSelection()) kept.push_back(existing);
            }
            kept.push_back(newCur);
            cursors = std::move(kept);
            mergeCursors();
        } else {
            cursors.clear();
            cursors.push_back(newCur);
        }
    }
    void selectLineAt(size_t pos, bool addSelection = false) {
        int lineIdx = getLineIdx(pos);
        size_t start = lineStarts[lineIdx];
        size_t end = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length();
        Cursor newCur = { end, start, getXFromPos(end) };
        if (addSelection) {
            std::vector<Cursor> kept;
            for (const auto& existing : cursors) {
                if (existing.hasSelection()) kept.push_back(existing);
            }
            kept.push_back(newCur);
            cursors = std::move(kept);
            mergeCursors();
        } else {
            cursors.clear();
            cursors.push_back(newCur);
        }
    }
    size_t moveWordLeft(size_t pos) {
        if (pos == 0) return 0; size_t curr = pos; if (curr >= 2 && pt.charAt(curr - 1) == '\n' && pt.charAt(curr - 2) == '\r') return curr - 2; if (curr >= 1 && (pt.charAt(curr - 1) == '\n' || pt.charAt(curr - 1) == '\r')) return curr - 1;
        while (curr > 0) { char c = pt.charAt(curr - 1); if (c == '\n' || c == '\r' || !isspace((unsigned char)c)) break; curr--; }
        if (curr == 0) return 0; char prev = pt.charAt(curr - 1); if (prev == '\n' || prev == '\r') return curr; bool type = isWordChar(prev);
        while (curr > 0) { char c = pt.charAt(curr - 1); if (c == '\n' || c == '\r' || isspace((unsigned char)c) || isWordChar(c) != type) break; curr--; } return curr;
    }
    size_t moveWordRight(size_t pos) {
        size_t len = pt.length(); if (pos >= len) return len; size_t curr = pos;
        if (pt.charAt(curr) == '\r') { if (curr + 1 < len && pt.charAt(curr + 1) == '\n') return curr + 2; return curr + 1; }
        if (pt.charAt(curr) == '\n') return curr + 1;
        if (!isspace((unsigned char)pt.charAt(curr))) { bool type = isWordChar(pt.charAt(curr)); while (curr < len) { char c = pt.charAt(curr); if (c == '\n' || c == '\r' || isspace((unsigned char)c) || isWordChar(c) != type) break; curr++; } }
        while (curr < len) { char c = pt.charAt(curr); if (c == '\n' || c == '\r' || !isspace((unsigned char)c)) break; curr++; } return curr;
    }
    size_t moveCaretVisual(size_t pos, bool forward) {
        size_t len = pt.length(); if (pos == 0 && !forward) return 0; if (pos >= len && forward) return len;
        if (forward) { char c = pt.charAt(pos); if (c == '\r') { if (pos + 1 < len && pt.charAt(pos + 1) == '\n') return pos + 2; return pos + 1; } if (c == '\n') return pos + 1; }
        else { if (pos > 0) { char prev = pt.charAt(pos - 1); if (prev == '\n') { if (pos > 1 && pt.charAt(pos - 2) == '\r') return pos - 2; return pos - 1; } if (prev == '\r') return pos - 1; } }
        int lineIdx = getLineIdx(pos); size_t lineStart = lineStarts[lineIdx]; size_t nextLineStart = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : len; size_t lineEnd = nextLineStart; if (lineEnd > lineStart && pt.charAt(lineEnd - 1) == '\n') lineEnd--; if (lineEnd > lineStart && pt.charAt(lineEnd - 1) == '\r') lineEnd--;
        if (pos < lineStart || pos > lineEnd) return forward ? std::min(pos + 1, len) : std::max(pos - 1, (size_t)0);
        std::string lineUtf8 = pt.getRange(lineStart, lineEnd - lineStart); std::wstring lineUtf16 = UTF8ToW(lineUtf8); size_t offsetInLine = pos - lineStart; std::string preUtf8 = lineUtf8.substr(0, offsetInLine); size_t u16Pos = UTF8ToW(preUtf8).length();
        IDWriteTextLayout* layout = nullptr; HRESULT hr = dwFactory->CreateTextLayout(lineUtf16.c_str(), (UINT32)lineUtf16.length(), textFormat, 10000000.0f, (FLOAT)lineHeight, &layout); size_t newU16Pos = u16Pos;
        if (SUCCEEDED(hr) && layout) {
            UINT32 clusterCount = 0; layout->GetClusterMetrics(NULL, 0, &clusterCount);
            if (clusterCount > 0) {
                std::vector<DWRITE_CLUSTER_METRICS> clusters(clusterCount); layout->GetClusterMetrics(clusters.data(), clusterCount, &clusterCount); size_t currentU16 = 0; bool found = false;
                if (forward) { for (const auto& cm : clusters) { size_t nextU16 = currentU16 + cm.length; if (u16Pos >= currentU16 && u16Pos < nextU16) { newU16Pos = nextU16; found = true; break; } currentU16 = nextU16; } if (!found) newU16Pos = u16Pos; }
                else { for (const auto& cm : clusters) { size_t nextU16 = currentU16 + cm.length; if (u16Pos > currentU16 && u16Pos <= nextU16) { newU16Pos = currentU16; found = true; break; } currentU16 = nextU16; } if (!found && u16Pos > 0) { if (u16Pos == lineUtf16.length()) { size_t c = 0; for (const auto& cm : clusters) { if (c + cm.length == u16Pos) { newU16Pos = c; break; } c += cm.length; } } } }
            } layout->Release();
        }
        if (newU16Pos != u16Pos) { std::wstring preNewW = lineUtf16.substr(0, newU16Pos); size_t newOffset = WToUTF8(preNewW).length(); return lineStart + newOffset; }
        return forward ? std::min(pos + 1, len) : std::max(pos - 1, (size_t)0);
    }
    size_t findText(size_t startPos, const std::string& query, bool forward, bool matchCase, bool wholeWord, bool isRegex, size_t* outLen = nullptr) {
        if (query.empty()) return std::string::npos; size_t len = pt.length(); std::string actualQuery = query; if (isRegex) actualQuery = preprocessRegexQuery(query);
        if (isRegex) {
            if (!isSafeUserRegex(query)) return std::string::npos;
            std::string fullText = pt.getRange(0, len);
            try {
                std::regex_constants::syntax_option_type flags = std::regex_constants::ECMAScript; if (!matchCase) flags |= std::regex_constants::icase; std::regex re(actualQuery, flags); std::smatch m; size_t foundPos = std::string::npos; size_t foundLen = 0; bool startsWithCaret = (!query.empty() && query[0] == '^'); bool endsWithDollar = (!query.empty() && query.back() == '$');
                if (forward) {
                    if (startPos > fullText.size()) startPos = 0; size_t searchStartIdx = startPos; std::regex_constants::match_flag_type searchFlags = std::regex_constants::match_default;
                    if (searchStartIdx > 0) { searchFlags |= std::regex_constants::match_not_bol; char prevChar = fullText[searchStartIdx - 1]; if (prevChar == '\n') { searchStartIdx--; if (searchStartIdx > 0 && fullText[searchStartIdx - 1] == '\r') searchStartIdx--; } else if (prevChar == '\r') searchStartIdx--; }
                    std::string::const_iterator searchStartIter = fullText.begin() + searchStartIdx;
                    while (std::regex_search(searchStartIter, fullText.cend(), m, re, searchFlags)) {
                        size_t currentMatchPos = searchStartIdx + m.position(); size_t currentMatchLen = m.length(); size_t anchorLen = 0;
                        if (startsWithCaret && m.size() > 1 && m[1].matched) anchorLen = m.length(1);
                        size_t contentPos = currentMatchPos + anchorLen; size_t contentLen = currentMatchLen - anchorLen; bool isValid = false; if (contentPos >= startPos) isValid = true;
                        if (isValid && endsWithDollar) { bool isAtLineEnd = false; size_t checkPos = contentPos + contentLen; if (checkPos >= fullText.size()) isAtLineEnd = true; else { char c = fullText[checkPos]; if (c == '\r' || c == '\n') { isAtLineEnd = true; if (contentLen == 0 && c == '\n' && checkPos > 0 && fullText[checkPos - 1] == '\r') isAtLineEnd = false; } } if (!isAtLineEnd) isValid = false; }
                        if (isValid) { foundPos = contentPos; foundLen = contentLen; if (startsWithCaret && endsWithDollar && foundLen == 0 && foundPos == fullText.size() && !fullText.empty()) { bool isAfterNewline = false; if (foundPos > 0) { char c = fullText[foundPos - 1]; if (c == '\r' || c == '\n') isAfterNewline = true; } if (!isAfterNewline) isValid = false; } if (isValid) break; }
                        size_t step = currentMatchLen; if (step == 0) { bool isBolCaret = (startsWithCaret && !(searchFlags & std::regex_constants::match_not_bol)); if (isBolCaret) step = 0; else step = MiuCore::utf8CharLenAt(fullText, currentMatchPos); } if (step == 0 && (searchFlags & std::regex_constants::match_not_bol)) step = MiuCore::utf8CharLenAt(fullText, currentMatchPos);
                        size_t dist = std::distance(searchStartIter, fullText.cend()); if ((size_t)m.position() + step > dist) break; size_t advance = m.position() + step; std::advance(searchStartIter, advance); searchStartIdx += advance; searchFlags |= std::regex_constants::match_not_bol;
                    }
                    if (foundPos == std::string::npos && startPos > 0) {
                        if (std::regex_search(fullText.cbegin(), fullText.cend(), m, re)) {
                            size_t mPos = m.position(); size_t mLen = m.length(); size_t aLen = 0; if (startsWithCaret && m.size() > 1 && m[1].matched) aLen = m.length(1); bool split = false; if (startsWithCaret && aLen == 1 && mPos < fullText.size() && fullText[mPos] == '\r') { if (mPos + 1 < fullText.size() && fullText[mPos + 1] == '\n') split = true; }
                            if (!split) {
                                size_t cPos = mPos + aLen; size_t cLen = mLen - aLen; bool valid = true; if (endsWithDollar) { size_t check = cPos + cLen; if (check < fullText.size()) { char c = fullText[check]; if (c == '\r' || c == '\n') { if (cLen == 0 && c == '\n' && check > 0 && fullText[check - 1] == '\r') valid = false; } else valid = false; } }
                                if (startsWithCaret && endsWithDollar && cLen == 0 && cPos == fullText.size() && !fullText.empty()) { bool isAfterNL = false; if (cPos > 0) { char c = fullText[cPos - 1]; if (c == '\r' || c == '\n') isAfterNL = true; } if (!isAfterNL) valid = false; }
                                if (valid) { foundPos = cPos; foundLen = cLen; }
                            }
                        }
                    }
                }
                else {
                    auto words_begin = std::sregex_iterator(fullText.begin(), fullText.end(), re); auto words_end = std::sregex_iterator(); size_t bestPos = std::string::npos; size_t bestLen = 0; size_t limit = (startPos == 0) ? len : startPos;
                    for (auto i = words_begin; i != words_end; ++i) {
                        size_t mPos = i->position(); size_t mLen = i->length(); size_t aLen = 0; if (startsWithCaret && i->size() > 1 && (*i)[1].matched) aLen = i->length(1);
                        if (startsWithCaret && aLen == 1 && mPos < fullText.size() && fullText[mPos] == '\r') { if (mPos + 1 < fullText.size() && fullText[mPos + 1] == '\n') continue; }
                        size_t contentStart = mPos + aLen; size_t contentLen = mLen - aLen; if (!MiuCore::isUtf8CharBoundary(fullText, mPos) || !MiuCore::isUtf8CharBoundary(fullText, contentStart)) continue; if (endsWithDollar) { bool isAtEnd = (contentStart + contentLen >= fullText.size()); if (!isAtEnd) { char c = fullText[contentStart + contentLen]; if (c == '\r' || c == '\n') { if (contentLen == 0 && c == '\n' && contentStart + contentLen > 0 && fullText[contentStart + contentLen - 1] == '\r') continue; } else continue; } }
                        if (startsWithCaret && endsWithDollar && contentLen == 0 && contentStart == fullText.size() && !fullText.empty()) { bool isAfterNL = false; if (contentStart > 0) { char c = fullText[contentStart - 1]; if (c == '\r' || c == '\n') isAfterNL = true; } if (!isAfterNL) continue; }
                        if (contentStart < limit) { bestPos = contentStart; bestLen = contentLen; }
                    }
                    if (bestPos != std::string::npos) { foundPos = bestPos; foundLen = bestLen; }
                }
                if (foundPos != std::string::npos) { if (outLen) *outLen = foundLen; return foundPos; }
            }
            catch (...) { return std::string::npos; }
            return std::string::npos;
        }
        size_t qLen = query.length(); if (outLen) *outLen = qLen;
        if (qLen == 0 || qLen > len) return std::string::npos;
        auto toLower = [](char c) noexcept -> char { return (c >= 'A' && c <= 'Z') ? (char)(c + ('a' - 'A')) : c; };
        auto toUpper = [](char c) noexcept -> char { return (c >= 'a' && c <= 'z') ? (char)(c - ('a' - 'A')) : c; };
        char fLow = matchCase ? query[0] : toLower(query[0]);
        char fUp  = matchCase ? query[0] : toUpper(query[0]);
        char lLow = matchCase ? query[qLen - 1] : toLower(query[qLen - 1]);
        char lUp  = matchCase ? query[qLen - 1] : toUpper(query[qLen - 1]);
        const __m128i v_fLow = _mm_set1_epi8(fLow);
        const __m128i v_fUp  = _mm_set1_epi8(fUp);
        const __m128i v_lLow = _mm_set1_epi8(lLow);
        const __m128i v_lUp  = _mm_set1_epi8(lUp);
        const char* qData = query.data();
        const bool g_hasAVX2 = IsProcessorFeaturePresent(PF_AVX2_INSTRUCTIONS_AVAILABLE) != 0;

        auto checkTrailingGrapheme = [&](size_t nextPos) -> bool {
            if (nextPos < len) {
                unsigned char b1 = (unsigned char)pt.charAt(nextPos);
                if (b1 == 0xE2 && nextPos + 2 < len) {
                    unsigned char b2 = (unsigned char)pt.charAt(nextPos + 1);
                    unsigned char b3 = (unsigned char)pt.charAt(nextPos + 2);
                    if (b2 == 0x80 && b3 == 0x8D) return false;
                } else if (b1 == 0xEF && nextPos + 2 < len) {
                    unsigned char b2 = (unsigned char)pt.charAt(nextPos + 1);
                    unsigned char b3 = (unsigned char)pt.charAt(nextPos + 2);
                    if (b2 == 0xB8 && b3 == 0x8F) return false;
                } else if (b1 == 0xF0 && nextPos + 3 < len) {
                    unsigned char b2 = (unsigned char)pt.charAt(nextPos + 1);
                    unsigned char b3 = (unsigned char)pt.charAt(nextPos + 2);
                    unsigned char b4 = (unsigned char)pt.charAt(nextPos + 3);
                    if (b2 == 0x9F && b3 == 0x8F && (b4 >= 0xBB && b4 <= 0xBF)) return false;
                }
            }
            return true;
        };

        auto verifyMatchAt = [&](size_t cur) -> bool {
            for (size_t i = 0; i < qLen; ++i) {
                char c1 = pt.charAt(cur + i);
                char c2 = qData[i];
                if (!matchCase) { c1 = toLower(c1); c2 = toLower(c2); }
                if (c1 != c2) return false;
            }
            if (wholeWord) {
                if (cur > 0 && isWordChar(pt.charAt(cur - 1))) return false;
                if (cur + qLen < len && isWordChar(pt.charAt(cur + qLen))) return false;
            }
            return checkTrailingGrapheme(cur + qLen);
        };

        auto verifyCandidateFast = [&](const char* buf, size_t pLen, size_t pGlobal, size_t local) -> bool {
            size_t cand = pGlobal + local;
            if (local + qLen <= pLen) {
                if (matchCase) {
                    if (qLen > 1 && std::memcmp(buf + local + 1, qData + 1, qLen - 1) != 0) return false;
                } else {
                    for (size_t i = 1; i < qLen; ++i) {
                        if (toLower(buf[local + i]) != toLower(qData[i])) return false;
                    }
                }
                if (wholeWord) {
                    char prevC = (local > 0) ? buf[local - 1] : ((cand > 0) ? pt.charAt(cand - 1) : 0);
                    if (cand > 0 && isWordChar(prevC)) return false;
                    char nextC = (local + qLen < pLen) ? buf[local + qLen] : ((cand + qLen < len) ? pt.charAt(cand + qLen) : 0);
                    if (cand + qLen < len && isWordChar(nextC)) return false;
                }
                if (local + qLen < pLen) {
                    unsigned char b1 = (unsigned char)buf[local + qLen];
                    if (b1 < 0x80) return true;
                }
                return checkTrailingGrapheme(cand + qLen);
            }
            return verifyMatchAt(cand);
        };

        size_t maxStart = len - qLen;
        if (forward) {
            if (startPos > maxStart) return std::string::npos;
            size_t pGlobal = 0;
            for (const auto& p : pt.pieces) {
                size_t pEnd = pGlobal + p.len;
                if (pEnd <= startPos) { pGlobal = pEnd; continue; }
                if (pGlobal > maxStart) break;
                size_t scanFrom = (startPos > pGlobal) ? (startPos - pGlobal) : 0;
                size_t scanTo = (pEnd - 1 > maxStart) ? (maxStart - pGlobal + 1) : p.len;
                const char* buf = p.isOriginal ? (pt.origPtr + p.start) : (pt.addBuf.data() + p.start);
                size_t local = scanFrom;
                if (g_hasAVX2 && qLen >= 2) {
                    const __m256i v256_fLow = _mm256_set1_epi8(fLow);
                    const __m256i v256_fUp  = _mm256_set1_epi8(fUp);
                    const __m256i v256_lLow = _mm256_set1_epi8(lLow);
                    const __m256i v256_lUp  = _mm256_set1_epi8(lUp);
                    while (local + 32 <= scanTo && local + qLen - 1 + 32 <= p.len) {
                        __m256i chF = _mm256_loadu_si256((const __m256i*)(buf + local));
                        __m256i chL = _mm256_loadu_si256((const __m256i*)(buf + local + qLen - 1));
                        __m256i eqF = _mm256_or_si256(_mm256_cmpeq_epi8(chF, v256_fLow), _mm256_cmpeq_epi8(chF, v256_fUp));
                        __m256i eqL = _mm256_or_si256(_mm256_cmpeq_epi8(chL, v256_lLow), _mm256_cmpeq_epi8(chL, v256_lUp));
                        unsigned long mask = (unsigned long)(uint32_t)_mm256_movemask_epi8(_mm256_and_si256(eqF, eqL));
                        while (mask != 0) {
                            unsigned long bit = 0;
                            _BitScanForward(&bit, mask);
                            if (verifyCandidateFast(buf, p.len, pGlobal, local + bit)) {
                                _mm256_zeroupper();
                                return pGlobal + local + bit;
                            }
                            mask &= (mask - 1);
                        }
                        local += 32;
                    }
                    _mm256_zeroupper();
                }
                while (local + 16 <= scanTo) {
                    __m128i chunk = _mm_loadu_si128((const __m128i*)(buf + local));
                    __m128i eq = _mm_or_si128(_mm_cmpeq_epi8(chunk, v_fLow), _mm_cmpeq_epi8(chunk, v_fUp));
                    if (qLen >= 2 && local + qLen - 1 + 16 <= p.len) {
                        __m128i chunkL = _mm_loadu_si128((const __m128i*)(buf + local + qLen - 1));
                        __m128i eqL = _mm_or_si128(_mm_cmpeq_epi8(chunkL, v_lLow), _mm_cmpeq_epi8(chunkL, v_lUp));
                        eq = _mm_and_si128(eq, eqL);
                    }
                    unsigned long mask = (unsigned long)_mm_movemask_epi8(eq);
                    while (mask != 0) {
                        unsigned long bit = 0;
                        _BitScanForward(&bit, mask);
                        if (verifyCandidateFast(buf, p.len, pGlobal, local + bit)) return pGlobal + local + bit;
                        mask &= (mask - 1);
                    }
                    local += 16;
                }
                while (local < scanTo) {
                    char c = buf[local];
                    if ((c == fLow || c == fUp) && verifyCandidateFast(buf, p.len, pGlobal, local)) {
                        return pGlobal + local;
                    }
                    local++;
                }
                pGlobal = pEnd;
            }
        } else {
            if (startPos == 0) return std::string::npos;
            size_t maxCand = std::min(startPos - 1, maxStart);
            size_t pGlobal = pt.length();
            for (size_t pi = pt.pieces.size(); pi-- > 0; ) {
                const auto& p = pt.pieces[pi];
                pGlobal -= p.len;
                if (pGlobal > maxCand || p.len == 0) continue;
                size_t scanEnd = (maxCand + 1 < pGlobal + p.len) ? (maxCand + 1 - pGlobal) : p.len;
                const char* buf = p.isOriginal ? (pt.origPtr + p.start) : (pt.addBuf.data() + p.start);
                size_t localEnd = scanEnd;
                if (g_hasAVX2 && qLen >= 2) {
                    const __m256i v256_fLow = _mm256_set1_epi8(fLow);
                    const __m256i v256_fUp  = _mm256_set1_epi8(fUp);
                    const __m256i v256_lLow = _mm256_set1_epi8(lLow);
                    const __m256i v256_lUp  = _mm256_set1_epi8(lUp);
                    while (localEnd >= 32 && (localEnd - 32) + qLen - 1 + 32 <= p.len) {
                        size_t blk = localEnd - 32;
                        __m256i chF = _mm256_loadu_si256((const __m256i*)(buf + blk));
                        __m256i chL = _mm256_loadu_si256((const __m256i*)(buf + blk + qLen - 1));
                        __m256i eqF = _mm256_or_si256(_mm256_cmpeq_epi8(chF, v256_fLow), _mm256_cmpeq_epi8(chF, v256_fUp));
                        __m256i eqL = _mm256_or_si256(_mm256_cmpeq_epi8(chL, v256_lLow), _mm256_cmpeq_epi8(chL, v256_lUp));
                        unsigned long mask = (unsigned long)(uint32_t)_mm256_movemask_epi8(_mm256_and_si256(eqF, eqL));
                        while (mask != 0) {
                            unsigned long bit = 0;
                            _BitScanReverse(&bit, mask);
                            if (verifyCandidateFast(buf, p.len, pGlobal, blk + bit)) {
                                _mm256_zeroupper();
                                return pGlobal + blk + bit;
                            }
                            mask &= ~(1UL << bit);
                        }
                        localEnd = blk;
                    }
                    _mm256_zeroupper();
                }
                while (localEnd >= 16) {
                    size_t blk = localEnd - 16;
                    __m128i chunk = _mm_loadu_si128((const __m128i*)(buf + blk));
                    __m128i eq = _mm_or_si128(_mm_cmpeq_epi8(chunk, v_fLow), _mm_cmpeq_epi8(chunk, v_fUp));
                    if (qLen >= 2 && blk + qLen - 1 + 16 <= p.len) {
                        __m128i chunkL = _mm_loadu_si128((const __m128i*)(buf + blk + qLen - 1));
                        __m128i eqL = _mm_or_si128(_mm_cmpeq_epi8(chunkL, v_lLow), _mm_cmpeq_epi8(chunkL, v_lUp));
                        eq = _mm_and_si128(eq, eqL);
                    }
                    unsigned long mask = (unsigned long)_mm_movemask_epi8(eq);
                    while (mask != 0) {
                        unsigned long bit = 0;
                        _BitScanReverse(&bit, mask);
                        if (verifyCandidateFast(buf, p.len, pGlobal, blk + bit)) return pGlobal + blk + bit;
                        mask &= ~(1UL << bit);
                    }
                    localEnd = blk;
                }
                while (localEnd > 0) {
                    localEnd--;
                    char c = buf[localEnd];
                    if ((c == fLow || c == fUp) && verifyCandidateFast(buf, p.len, pGlobal, localEnd)) {
                        return pGlobal + localEnd;
                    }
                }
            }
        }
        return std::string::npos;
    }
    void findNext(bool forward) {
        if (searchQuery.empty()) { showFindDialog(false); return; }
        size_t currentCursorPos = forward ? (cursors.empty() ? 0 : cursors.back().end()) : (cursors.empty() ? 0 : cursors.back().start());
        size_t searchStart = currentCursorPos; bool hasWrapped = false;
        while (true) {
            size_t matchLen = 0; size_t pos = findText(searchStart, searchQuery, forward, searchMatchCase, searchWholeWord, searchRegex, &matchLen);
            if (pos == std::string::npos) {
                if (forward && !hasWrapped) { searchStart = 0; hasWrapped = true; continue; }
                else if (!forward && !hasWrapped) { searchStart = pt.length(); hasWrapped = true; continue; }
                MessageBeep(MB_ICONWARNING); return;
            }
            size_t matchEnd = pos + matchLen;
            if (forward) {
                if (!hasWrapped && matchEnd <= currentCursorPos) {
                    size_t nextStart = searchStart + MiuCore::utf8CharLenAt(pt, searchStart);
                    if (searchStart + 1 < pt.length() && pt.charAt(searchStart) == '\r' && pt.charAt(searchStart + 1) == '\n') nextStart = searchStart + 2;
                    searchStart = nextStart; if (searchStart > pt.length()) { searchStart = 0; hasWrapped = true; } continue;
                }
            }
            cursors.clear(); cursors.push_back({ matchEnd, pos, getXFromPos(matchEnd) }); ensureCaretVisible(); updateTitleBar(); break;
        }
    }
    void replaceNext() {
        if (cursors.empty() || searchQuery.empty()) return; Cursor& c = cursors.back(); if (!c.hasSelection()) { findNext(true); return; }
        size_t len = c.end() - c.start(); size_t start = c.start(); std::string selText = pt.getRange(start, len); bool match = false; std::string replacement = replaceQuery;
        if (searchRegex) {
            try {
                std::string actualQuery = preprocessRegexQuery(searchQuery); std::regex_constants::syntax_option_type flags = std::regex_constants::ECMAScript;
                if (!searchMatchCase) flags |= std::regex_constants::icase; std::regex re(actualQuery, flags); std::smatch m; std::string rawFmt = UnescapeString(replaceQuery, newlineStr); std::string fmt;
                bool startsWithCaret = (!searchQuery.empty() && searchQuery[0] == '^');
                for (size_t i = 0; i < rawFmt.size(); ++i) {
                    if (rawFmt[i] == '$') {
                        fmt += '$'; if (i + 1 < rawFmt.size()) {
                            if (isdigit((unsigned char)rawFmt[i + 1])) {
                                i++; int grp = 0; while (i < rawFmt.size() && isdigit((unsigned char)rawFmt[i])) { grp = grp * 10 + (rawFmt[i] - '0'); i++; } i--;
                                if (startsWithCaret && grp > 0) grp++; fmt += std::to_string(grp);
                            }
                            else { fmt += rawFmt[i + 1]; i++; }
                        }
                    }
                    else fmt += rawFmt[i];
                }
                if (std::regex_match(selText, m, re)) match = true;
                else if (start > 0) {
                    int backStep = 0; if (pt.charAt(start - 1) == '\n') { backStep = 1; if (start > 1 && pt.charAt(start - 2) == '\r') backStep = 2; }
                    else if (pt.charAt(start - 1) == '\r') backStep = 1;
                    if (backStep > 0) { std::string extendedText = pt.getRange(start - backStep, len + backStep); if (std::regex_match(extendedText, m, re)) match = true; }
                }
                if (match) replacement = m.format(fmt);
            }
            catch (...) {}
        }
        else {
            if (len == searchQuery.length()) {
                match = true; for (size_t i = 0; i < len; ++i) {
                    char c1 = selText[i]; char c2 = searchQuery[i]; if (!searchMatchCase) { c1 = (c1 >= 'A' && c1 <= 'Z') ? c1 + ('a' - 'A') : c1; c2 = (c2 >= 'A' && c2 <= 'Z') ? c2 + ('a' - 'A') : c2; }
                    if (c1 != c2) { match = false; break; }
                }
            }
            if (match) replacement = replaceQuery;
        }
        if (match) {
            commitPadding(); EditBatch batch; batch.beforeCursors = cursors; pt.erase(start, len); batch.ops.push_back({ EditOp::Erase, start, selText });
            pt.insert(start, replacement); batch.ops.push_back({ EditOp::Insert, start, replacement }); cursors.clear(); cursors.push_back({ start + replacement.size(), start, getXFromPos(start + replacement.size()) });
            batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); findNext(true);
        }
        else findNext(true);
    }
    void replaceAll() {
        if (searchQuery.empty()) return; struct Match { size_t start; size_t len; std::string replacementText; }; std::vector<Match> matches; size_t docLen = pt.length(); ensureRegexReady();
        if (searchRegex) {
            if (isRegexValid) {
                std::string fullText = pt.getRange(0, docLen); std::string rawFmt = UnescapeString(replaceQuery, newlineStr); std::string fmt;
                bool startsWithCaret = (!searchQuery.empty() && searchQuery[0] == '^'); bool endsWithDollar = (!searchQuery.empty() && searchQuery.back() == '$');
                for (size_t i = 0; i < rawFmt.size(); ++i) {
                    if (rawFmt[i] == '$') { fmt += '$'; if (i + 1 < rawFmt.size()) { if (isdigit((unsigned char)rawFmt[i + 1])) { i++; int grp = 0; while (i < rawFmt.size() && isdigit((unsigned char)rawFmt[i])) { grp = grp * 10 + (rawFmt[i] - '0'); i++; } i--; if (startsWithCaret && grp > 0) grp++; fmt += std::to_string(grp); } else { fmt += rawFmt[i + 1]; i++; } } }
                    else fmt += rawFmt[i];
                }
                try {
                    auto searchStart = fullText.cbegin(); std::smatch m; size_t currentOffset = 0; std::regex_constants::match_flag_type flags = std::regex_constants::match_default;
                    while (std::regex_search(searchStart, fullText.cend(), m, cachedRegex, flags)) {
                        size_t matchPos = currentOffset + m.position(); size_t matchLen = m.length(); size_t anchorLen = 0;
                        if (startsWithCaret && m.size() > 1 && m[1].matched) anchorLen = m.length(1);
                        size_t contentPos = matchPos + anchorLen; size_t contentLen = matchLen - anchorLen;
                        if (endsWithDollar) { if (contentLen > 0) { if (fullText[contentPos + contentLen - 1] == '\n') { contentLen--; if (contentLen > 0 && fullText[contentPos + contentLen - 1] == '\r') contentLen--; } else if (fullText[contentPos + contentLen - 1] == '\r') { contentLen--; } } }
                        bool isValid = true;
                        if (endsWithDollar) { bool isAtLineEnd = false; size_t checkPos = contentPos + contentLen; if (checkPos >= fullText.size()) isAtLineEnd = true; else { char c = fullText[checkPos]; if (c == '\r' || c == '\n') { isAtLineEnd = true; if (contentLen == 0 && c == '\n' && checkPos > 0 && fullText[checkPos - 1] == '\r') isAtLineEnd = false; } } if (!isAtLineEnd) isValid = false; }
                        if (isValid && startsWithCaret && endsWithDollar && contentLen == 0 && contentPos == fullText.size() && !fullText.empty()) { bool isAfterNewline = false; if (contentPos > 0) { char c = fullText[contentPos - 1]; if (c == '\r' || c == '\n') isAfterNewline = true; } if (!isAfterNewline) isValid = false; }
                        if (isValid && !matches.empty()) { const auto& last = matches.back(); if (last.start == contentPos && last.len == 0 && contentLen == 0) isValid = false; }
                        if (isValid) { std::string rText = m.format(fmt); matches.push_back({ contentPos, contentLen, rText }); }
                        size_t step = matchLen; if (step == 0) { bool isBolCaret = (startsWithCaret && !(flags & std::regex_constants::match_not_bol)); if (isBolCaret) step = 0; else step = MiuCore::utf8CharLenAt(fullText, matchPos); }
                        if (step == 0 && (flags & std::regex_constants::match_not_bol)) step = MiuCore::utf8CharLenAt(fullText, matchPos); size_t relativeAdvance = m.position() + step; size_t remaining = std::distance(searchStart, fullText.cend());
                        if (relativeAdvance > remaining) break; std::advance(searchStart, relativeAdvance); currentOffset += relativeAdvance; flags |= std::regex_constants::match_not_bol;
                    }
                    if (startsWithCaret && fullText.empty()) { bool alreadyMatched = !matches.empty(); if (!alreadyMatched) matches.push_back({ 0, 0, fmt }); }
                }
                catch (...) { return; }
            }
        }
        else {
            size_t currentPos = 0;
            while (true) { size_t matchLen = 0; size_t pos = findText(currentPos, searchQuery, true, searchMatchCase, searchWholeWord, false, &matchLen); if (pos == std::string::npos || pos < currentPos) break; matches.push_back({ pos, matchLen, replaceQuery }); currentPos = pos + matchLen; if (currentPos > docLen) break; }
        }
        if (matches.empty()) { MessageBeep(MB_ICONASTERISK); return; }
        commitPadding(); EditBatch batch; batch.beforeCursors = cursors;
        if (matches.size() <= 16) {
            for (auto it = matches.rbegin(); it != matches.rend(); ++it) {
                size_t start = it->start; size_t len = it->len; if (start + len > pt.length()) continue;
                std::string deleted = pt.getRange(start, len); pt.erase(start, len); batch.ops.push_back({ EditOp::Erase, start, deleted }); pt.insert(start, it->replacementText); batch.ops.push_back({ EditOp::Insert, start, it->replacementText });
            }
        } else {
            batch.ops.reserve(matches.size() * 2);
            for (auto it = matches.rbegin(); it != matches.rend(); ++it) {
                size_t start = it->start; size_t len = it->len; if (start + len > pt.length()) continue;
                std::string deleted = pt.getRange(start, len);
                batch.ops.push_back({ EditOp::Erase, start, std::move(deleted) });
                batch.ops.push_back({ EditOp::Insert, start, it->replacementText });
            }
            std::vector<Piece> newPieces;
            newPieces.reserve(pt.pieces.size() + matches.size() * 2 + 4);
            size_t pIdx = 0, pOff = 0, docCur = 0;
            auto advanceTo = [&](size_t targetDocPos, bool emit) {
                while (docCur < targetDocPos && pIdx < pt.pieces.size()) {
                    const Piece& cp = pt.pieces[pIdx];
                    size_t avail = cp.len - pOff;
                    size_t take = std::min(avail, targetDocPos - docCur);
                    if (emit && take > 0) {
                        newPieces.push_back({ cp.isOriginal, cp.start + pOff, take });
                    }
                    docCur += take;
                    pOff += take;
                    if (pOff >= cp.len) { pIdx++; pOff = 0; }
                }
            };
            size_t newTotalLen = 0;
            for (const auto& m : matches) {
                if (m.start < docCur || m.start + m.len > pt.length()) continue;
                advanceTo(m.start, true);
                advanceTo(m.start + m.len, false);
                if (!m.replacementText.empty()) {
                    size_t addStart = pt.addBuf.size();
                    pt.addBuf.append(m.replacementText);
                    newPieces.push_back({ false, addStart, m.replacementText.size() });
                }
            }
            advanceTo(pt.length(), true);
            for (const auto& np : newPieces) newTotalLen += np.len;
            pt.pieces = std::move(newPieces);
            pt.totalLength = newTotalLen;
            pt.cachedIdx = 0;
            pt.cachedStart = 0;
        }
        size_t finalMatchIdx = matches.size() - 1; long long offsetBeforeFinal = 0; for (size_t i = 0; i < finalMatchIdx; ++i) { offsetBeforeFinal += (long long)matches[i].replacementText.size() - (long long)matches[i].len; }
        size_t lastReplaceStart = (size_t)((long long)matches.back().start + offsetBeforeFinal); size_t lastReplaceEnd = lastReplaceStart + matches.back().replacementText.size();
        cursors.clear(); cursors.push_back({ lastReplaceEnd, lastReplaceStart, getXFromPos(lastReplaceEnd) }); batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE);
        ShowTaskDialog(GetResString(IDS_REPLACE_DONE).c_str(), (std::to_wstring(matches.size()) + GetResString(IDS_REPLACE_COUNT)).c_str(), nullptr, TDCBF_OK_BUTTON, TD_INFORMATION_ICON);
        if (hFindDlg && IsWindowVisible(hFindDlg)) SetFocus(hFindDlg);
    }
    static HFONT EnsureDialogFontForDpi(HWND hDlg, UINT dpi) {
        SetPropW(hDlg, L"MiuDlgDpi", (HANDLE)(UINT_PTR)dpi);
        HFONT hOldProp = (HFONT)GetPropW(hDlg, L"MiuDlgFont");
        int targetHeight = -MulDiv(9, (int)dpi, 72);
        HFONT hCurFont = hOldProp ? hOldProp : (HFONT)SendMessageW(hDlg, WM_GETFONT, 0, 0);
        LOGFONTW lf = {};
        if (hCurFont && GetObjectW(hCurFont, sizeof(lf), &lf) && lf.lfHeight == targetHeight) {
            return hCurFont;
        }
        if (lf.lfFaceName[0] == L'\0') {
            wcscpy_s(lf.lfFaceName, L"Segoe UI");
            lf.lfWeight = FW_NORMAL;
            lf.lfCharSet = DEFAULT_CHARSET;
            lf.lfQuality = CLEARTYPE_QUALITY;
        }
        lf.lfHeight = targetHeight;
        lf.lfWidth = 0;
        HFONT hNewFont = CreateFontIndirectW(&lf);
        if (hNewFont) {
            SendMessageW(hDlg, WM_SETFONT, (WPARAM)hNewFont, FALSE);
            HWND hChild = GetWindow(hDlg, GW_CHILD);
            while (hChild) {
                SendMessageW(hChild, WM_SETFONT, (WPARAM)hNewFont, FALSE);
                hChild = GetWindow(hChild, GW_HWNDNEXT);
            }
            if (hOldProp && hOldProp != hNewFont) DeleteObject(hOldProp);
            SetPropW(hDlg, L"MiuDlgFont", (HANDLE)hNewFont);
            return hNewFont;
        }
        return hCurFont;
    }
    static void MeasureDialogText(HDC hdc, const std::wstring& text, int& outW, int& outH);
    static void AdjustAndPositionDialog(HWND hDlg, HWND hwndParent, int clientW, int clientH, UINT dpi, bool recenter);
    static void LayoutFindDialog(HWND hDlg, UINT overrideDpi = 0, bool recenter = false);
    void updateFindReplaceUI(HWND dlg, bool replaceMode);
    static INT_PTR CALLBACK FindDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
    void showFindDialog(bool replaceMode);
    void gotoLine(int lineOneBased) { int totalLines = (int)lineStarts.size(); if (totalLines == 0) return; int target = lineOneBased; if (target < 1) target = 1; if (target > totalLines) target = totalLines; int lineIdx = target - 1; size_t newPos = lineStarts[lineIdx]; rollbackPadding(); cursors.clear(); cursors.push_back({ newPos, newPos, getXFromPos(newPos) }); vScrollSubLine = 0; ensureCaretVisible(); updateTitleBar(); InvalidateRect(hwnd, NULL, FALSE); }

    char getMatchingBracketChar(char c) {
        if (c == '(') return ')';
        if (c == '[') return ']';
        if (c == '{') return '}';
        if (c == ')') return '(';
        if (c == ']') return '[';
        if (c == '}') return '{';
        return '\0';
    }

    bool isForwardBracket(char c) { return c == '(' || c == '[' || c == '{'; }

    bool findMatchingBracketFromIter(size_t p, size_t& matchPos) {
        size_t totalLen = pt.length();
        if (p >= totalLen) return false;
        char c = pt.charAt(p);
        char m = getMatchingBracketChar(c);
        if (!m) return false;

        static constexpr size_t MAX_BRACKET_SCAN = 262144;
        int depth = 1;
        if (isForwardBracket(c)) {
            size_t limit = std::min(totalLen, p + 1 + MAX_BRACKET_SCAN);
            const __m128i v_c = _mm_set1_epi8(c);
            const __m128i v_m = _mm_set1_epi8(m);
            size_t pGlobal = 0;
            for (const auto& piece : pt.pieces) {
                size_t pEnd = pGlobal + piece.len;
                if (pEnd <= p + 1) { pGlobal = pEnd; continue; }
                if (pGlobal >= limit) break;
                size_t local = (p + 1 > pGlobal) ? (p + 1 - pGlobal) : 0;
                size_t localEnd = (pEnd > limit) ? (limit - pGlobal) : piece.len;
                const char* buf = piece.isOriginal ? (pt.origPtr + piece.start) : (pt.addBuf.data() + piece.start);
                while (local + 16 <= localEnd) {
                    __m128i chunk = _mm_loadu_si128((const __m128i*)(buf + local));
                    unsigned long mask = (unsigned long)_mm_movemask_epi8(_mm_or_si128(_mm_cmpeq_epi8(chunk, v_c), _mm_cmpeq_epi8(chunk, v_m)));
                    while (mask != 0) {
                        unsigned long bit = 0;
                        _BitScanForward(&bit, mask);
                        char curr = buf[local + bit];
                        if (curr == c) depth++;
                        else if (--depth == 0) { matchPos = pGlobal + local + bit; return true; }
                        mask &= (mask - 1);
                    }
                    local += 16;
                }
                while (local < localEnd) {
                    char curr = buf[local];
                    if (curr == c) depth++;
                    else if (curr == m && --depth == 0) { matchPos = pGlobal + local; return true; }
                    local++;
                }
                pGlobal = pEnd;
            }
        }
        else {
            if (p == 0) return false;
            size_t minPos = (p > MAX_BRACKET_SCAN) ? (p - MAX_BRACKET_SCAN) : 0;
            for (size_t i = p - 1; ; --i) {
                char curr = pt.charAt(i);
                if (curr == c) depth++;
                else if (curr == m) {
                    depth--;
                    if (depth == 0) { matchPos = i; return true; }
                }
                if (i <= minPos) break;
            }
        }
        return false;
    }

    bool getAdjacentBrackets(size_t pos, size_t& p1, size_t& p2) {
        if (pos < pt.length()) {
            if (findMatchingBracketFromIter(pos, p2)) { p1 = pos; return true; }
        }
        if (pos > 0) {
            if (findMatchingBracketFromIter(pos - 1, p2)) { p1 = pos - 1; return true; }
        }
        return false;
    }

    void jumpToMatchingBracket() {
        if (cursors.empty()) return;
        rollbackPadding();
        size_t pos = cursors.back().head;
        size_t p1, p2;
        if (getAdjacentBrackets(pos, p1, p2)) {
            size_t target = p2;
            cursors.clear();
            cursors.push_back({ target, target, getXFromPos(target) });
            ensureCaretVisible();
            updateTitleBar();
            InvalidateRect(hwnd, NULL, FALSE);
        }
    }

    void jumpToFileEdge(bool start, bool select) { size_t target = start ? 0 : pt.length(); if (!select) { cursors.clear(); cursors.push_back({ target, target, getXFromPos(target) }); } else { for (auto& c : cursors) { c.head = target; c.desiredX = getXFromPos(c.head); } } if (start) { vScrollPos = 0; vScrollSubLine = 0; hScrollPos = 0; } ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE); }
    static void LayoutGoToDialog(HWND hDlg, UINT overrideDpi = 0, bool recenter = false);
    static INT_PTR CALLBACK GoToDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
    void showGoToDialog();
    void rollbackPadding() {
        if (pendingPadding.ops.empty()) return;
        for (int i = (int)pendingPadding.ops.size() - 1; i >= 0; --i) { const auto& op = pendingPadding.ops[i]; if (op.type == EditOp::Insert) { pt.erase(op.pos, op.text.size()); size_t len = op.text.size(); for (auto& c : cursors) { if (c.head > op.pos) { if (c.head < op.pos + len) c.head = op.pos; else c.head -= len; } if (c.anchor > op.pos) { if (c.anchor < op.pos + len) c.anchor = op.pos; else c.anchor -= len; } } } }
        pendingPadding.ops.clear(); pendingPadding.beforeCursors.clear(); pendingPadding.afterCursors.clear(); rebuildLineStarts();
    }
    void commitPadding() { if (pendingPadding.ops.empty()) return; undo.push(pendingPadding); pendingPadding.ops.clear(); pendingPadding.beforeCursors.clear(); pendingPadding.afterCursors.clear(); }
    void updateRectSelection() {
        suppressUI = true; if (pendingPadding.ops.empty()) pendingPadding.beforeCursors = cursors; rollbackPadding();
        int startLineIdx = std::min(rectAnchorLine, rectHeadLine); int endLineIdx = std::max(rectAnchorLine, rectHeadLine); if (startLineIdx < 0) startLineIdx = 0; int currentMaxLine = (int)lineStarts.size() - 1;
        if (endLineIdx > currentMaxLine) { int linesToAdd = endLineIdx - currentMaxLine; size_t insertPos = pt.length(); std::string newLines; for (int k = 0; k < linesToAdd; ++k) newLines += newlineStr; pt.insert(insertPos, newLines); pendingPadding.ops.push_back({ EditOp::Insert, insertPos, newLines }); rebuildLineStarts(); }
        if (endLineIdx >= (int)lineStarts.size()) endLineIdx = (int)lineStarts.size() - 1; float targetAnchorX = rectAnchorX; float targetHeadX = rectHeadX; std::vector<int> lines; for (int i = startLineIdx; i <= endLineIdx; ++i) lines.push_back(i); std::reverse(lines.begin(), lines.end()); cursors.clear(); float requiredX = std::max(targetAnchorX, targetHeadX);
        for (int lineIdx : lines) { size_t start = lineStarts[lineIdx]; size_t nextStart = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length(); size_t end = nextStart; if (end > start && pt.charAt(end - 1) == '\n') end--; if (end > start && pt.charAt(end - 1) == '\r') end--; std::string lineStr = pt.getRange(start, end - start); std::wstring wLine = UTF8ToW(lineStr); float currentWidth = (float)wLine.length() * charWidth; if (requiredX > currentWidth) { int spacesNeeded = (int)((requiredX - currentWidth) / charWidth + 0.5f); if (spacesNeeded > 0) { std::string spaces(spacesNeeded, ' '); pt.insert(end, spaces); pendingPadding.ops.push_back({ EditOp::Insert, end, spaces }); } } }
        if (!pendingPadding.ops.empty()) rebuildLineStarts();
        for (int i = startLineIdx; i <= endLineIdx; ++i) { size_t anc = getPosFromLineAndX(i, targetAnchorX); size_t hd = getPosFromLineAndX(i, targetHeadX); cursors.push_back({ hd, anc, targetHeadX }); } suppressUI = false; rebuildLineStarts(); InvalidateRect(hwnd, NULL, FALSE);
    }
    void performDragMove() {
        if (dragMoveDestPos >= dragMoveSourceStart && dragMoveDestPos <= dragMoveSourceEnd) return; std::string text = pt.getRange(dragMoveSourceStart, dragMoveSourceEnd - dragMoveSourceStart); EditBatch batch; batch.beforeCursors = cursors; pt.erase(dragMoveSourceStart, text.size()); batch.ops.push_back({ EditOp::Erase, dragMoveSourceStart, text }); size_t insertPos = dragMoveDestPos; if (insertPos > dragMoveSourceStart) insertPos -= text.size(); pt.insert(insertPos, text); batch.ops.push_back({ EditOp::Insert, insertPos, text }); cursors.clear(); cursors.push_back({ insertPos + text.size(), insertPos, getXFromPos(insertPos + text.size()) }); batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag();
    }
    void render() {
        if (!rend || !swapChain) return;
        if (!targetBitmap) {
            IDXGISurface* dxgiBackBuffer = nullptr; swapChain->GetBuffer(0, __uuidof(IDXGISurface), (void**)&dxgiBackBuffer);
            if (dxgiBackBuffer) {
                D2D1_BITMAP_PROPERTIES1 bitmapProperties = D2D1::BitmapProperties1(D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW, D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED), 96.0f * dpiScaleX, 96.0f * dpiScaleY);
                rend->CreateBitmapFromDxgiSurface(dxgiBackBuffer, &bitmapProperties, &targetBitmap); dxgiBackBuffer->Release();
            }
        }
        rend->SetTarget(targetBitmap);
        rend->BeginDraw();
        rend->Clear(background);
        RECT rc; GetClientRect(hwnd, &rc); D2D1_SIZE_F size = rend->GetSize(); float fullClientW = size.width; float clientW = showPreview ? getEditorDipWidth() : fullClientW; float clientH = size.height; int linesVisible = (int)(clientH / lineHeight) + 2; buildVisibleText(linesVisible + (wordWrapEnabled ? vScrollSubLine : 0), textBuffer); std::string& text = textBuffer; size_t visibleStartOffset = (vScrollPos < (int)lineStarts.size()) ? lineStarts[vScrollPos] : pt.length(); size_t visibleEndOffset = visibleStartOffset + text.size(); size_t mainCaretPos = cursors.empty() ? 0 : cursors.back().head; size_t caretOffsetInVisible = std::string::npos; if (mainCaretPos >= visibleStartOffset && (mainCaretPos < visibleEndOffset || (mainCaretPos == visibleEndOffset && visibleEndOffset == pt.length()))) caretOffsetInVisible = mainCaretPos - visibleStartOffset; bool hasIME = !imeComp.empty() && caretOffsetInVisible != std::string::npos && caretOffsetInVisible <= text.size(); if (hasIME) text.insert(caretOffsetInVisible, imeComp); UTF8ToW(text, wtextBuffer); buildVisibleUtf16Map(text); float actualClientW = clientW - gutterWidth; if (actualClientW < 0) actualClientW = 0; float layoutWidth = wordWrapEnabled ? actualClientW : (maxLineWidth + clientW); IDWriteTextLayout* layout = nullptr;
        ID2D1SolidColorBrush* caretBrush = isOverwriteMode ? cachedCaretOverwriteBrush : cachedCaretBrush;
        HRESULT hr = dwFactory->CreateTextLayout(wtextBuffer.c_str(), (UINT32)wtextBuffer.size(), textFormat, layoutWidth, 1000000.0f, &layout);
        if (SUCCEEDED(hr) && layout) { if (wordWrapEnabled) layout->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP); else layout->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP); }
        D2D1_MATRIX_3X2_F transform = D2D1::Matrix3x2F::Translation(gutterWidth - (float)hScrollPos, -(wordWrapEnabled ? (float)vScrollSubLine * lineHeight : 0.0f)); float imeCx = 0, imeCy = 0; D2D1_RECT_F textClipRect = D2D1::RectF(gutterWidth, 0, clientW, clientH); rend->PushAxisAlignedClip(textClipRect, D2D1_ANTIALIAS_MODE_ALIASED); rend->SetTransform(transform); ensureRegexReady();
        if (SUCCEEDED(hr) && layout) {
            ID2D1SolidColorBrush* selBrush = cachedSelBrush; ID2D1SolidColorBrush* hlBrush = cachedHlBrush; ID2D1SolidColorBrush* autoHlBrush = cachedAutoHlBrush; auto [autoStr, isWholeWord] = getHighlightTarget();
            if (!autoStr.empty() && autoStr != searchQuery && autoHlBrush) {
                size_t offset = 0; size_t qLen = autoStr.length();
                while ((offset = text.find(autoStr, offset)) != std::string::npos) {
                    bool match = true; if (isWholeWord) { if (offset > 0 && isWordChar(text[offset - 1])) match = false; if (match && (offset + qLen < text.length()) && isWordChar(text[offset + qLen])) match = false; }
                    if (match) { size_t startU16 = utf8OffsetToUtf16Count(text, offset); size_t lenU16 = utf8OffsetToUtf16Count(text, offset + qLen) - startU16; UINT32 count = 0; layout->HitTestTextRange((UINT32)startU16, (UINT32)lenU16, 0, 0, 0, 0, &count); if (count > 0) { renderHitMetrics.resize(count); layout->HitTestTextRange((UINT32)startU16, (UINT32)lenU16, 0, 0, renderHitMetrics.data(), count, &count); for (UINT32 mi = 0; mi < count; ++mi) { const auto& mm = renderHitMetrics[mi]; float top = std::floor((mm.top + lineHeight * 0.5f) / lineHeight) * lineHeight; rend->FillRectangle(D2D1::RectF(mm.left, top, mm.left + mm.width, top + lineHeight), autoHlBrush); } } } offset++;
                }
            }
            size_t p1, p2;
            if (cursors.size() == 1 && cachedBracketBrush && getAdjacentBrackets(cursors[0].head, p1, p2)) {
                ID2D1SolidColorBrush* bracketBrush = cachedBracketBrush;
                auto drawBracketHl = [&](size_t globalPos) {
                    if (globalPos >= visibleStartOffset && globalPos < visibleStartOffset + text.size()) {
                        size_t utf8Off = globalPos - visibleStartOffset;
                        size_t startU16 = utf8OffsetToUtf16Count(text, utf8Off);
                        UINT32 count = 0;
                        layout->HitTestTextRange((UINT32)startU16, 1, 0, 0, 0, 0, &count);
                        if (count > 0) {
                            renderHitMetrics.resize(count);
                            layout->HitTestTextRange((UINT32)startU16, 1, 0, 0, renderHitMetrics.data(), count, &count);
                            for (UINT32 mi = 0; mi < count; ++mi) { const auto& mm = renderHitMetrics[mi];
                                float top = std::floor((mm.top + lineHeight * 0.5f) / lineHeight) * lineHeight;
                                float drawWidth = (mm.width > 0) ? mm.width : charWidth;
                                rend->FillRectangle(D2D1::RectF(mm.left, top, mm.left + drawWidth, top + lineHeight), bracketBrush);
                            }
                        }
                    }
                    };
                drawBracketHl(p1);
                drawBracketHl(p2);
            }
            if (!searchQuery.empty()) {
                if (searchRegex) {
                    if (isRegexValid) {
                        try {
                            bool startsWithCaret = (!searchQuery.empty() && searchQuery[0] == '^'); bool endsWithDollar = (!searchQuery.empty() && searchQuery.back() == '$'); auto searchStart = text.cbegin(); std::smatch m; std::regex_constants::match_flag_type flags = std::regex_constants::match_default;
                            while (std::regex_search(searchStart, text.cend(), m, cachedRegex, flags)) {
                                size_t matchPos = std::distance(text.cbegin(), searchStart) + m.position(); size_t matchLen = m.length(); size_t anchorLen = 0; if (startsWithCaret && m.size() > 1 && m[1].matched) anchorLen = m.length(1); size_t contentPos = matchPos + anchorLen; size_t contentLen = matchLen - anchorLen; bool shouldHighlight = true;
                                if (endsWithDollar) { bool isAtLineEnd = false; if (contentPos + contentLen >= text.size()) isAtLineEnd = true; else { char c = text[contentPos + contentLen]; if (c == '\r' || c == '\n') { isAtLineEnd = true; if (contentLen == 0 && c == '\n' && contentPos + contentLen > 0 && text[contentPos + contentLen - 1] == '\r') isAtLineEnd = false; } } if (!isAtLineEnd) shouldHighlight = false; if (shouldHighlight && contentPos > 0 && contentPos < text.size()) { if (text[contentPos] == '\n' && text[contentPos - 1] == '\r') shouldHighlight = false; } }
                                if (shouldHighlight && startsWithCaret && endsWithDollar && contentLen == 0) { size_t globalPos = visibleStartOffset + contentPos; if (globalPos == pt.length() && pt.length() > 0) { bool isAfterNewline = false; if (globalPos > 0) { char c = pt.charAt(globalPos - 1); if (c == '\r' || c == '\n') isAfterNewline = true; } if (!isAfterNewline) shouldHighlight = false; } }
                                if (shouldHighlight) {
                                    if (contentLen > 0 || (contentLen == 0 && (startsWithCaret || endsWithDollar))) {
                                        size_t startU16 = utf8OffsetToUtf16Count(text, contentPos);
                                        if (contentLen == 0) { FLOAT px, py; DWRITE_HIT_TEST_METRICS m; layout->HitTestTextPosition((UINT32)startU16, FALSE, &px, &py, &m); float top = std::floor((m.top + lineHeight * 0.5f) / lineHeight) * lineHeight; float drawW = (m.width > 0) ? m.width : charWidth; rend->FillRectangle(D2D1::RectF(px, top, px + drawW, top + lineHeight), hlBrush); }
                                        else { size_t lenU16 = utf8OffsetToUtf16Count(text, contentPos + contentLen) - startU16; UINT32 count = 0; layout->HitTestTextRange((UINT32)startU16, (UINT32)lenU16, 0, 0, 0, 0, &count); if (count > 0) { renderHitMetrics.resize(count); layout->HitTestTextRange((UINT32)startU16, (UINT32)lenU16, 0, 0, renderHitMetrics.data(), count, &count); for (UINT32 mi = 0; mi < count; ++mi) { const auto& mm = renderHitMetrics[mi]; float top = std::floor((mm.top + lineHeight * 0.5f) / lineHeight) * lineHeight; float drawWidth = (mm.width > 0) ? mm.width : charWidth; rend->FillRectangle(D2D1::RectF(mm.left, top, mm.left + drawWidth, top + lineHeight), hlBrush); } } }
                                    }
                                }
                                size_t step = matchLen; if (step == 0) { bool isBolCaret = (startsWithCaret && !(flags & std::regex_constants::match_not_bol)); if (isBolCaret) step = 0; else step = MiuCore::utf8CharLenAt(text, matchPos); } if (step == 0 && (flags & std::regex_constants::match_not_bol)) step = MiuCore::utf8CharLenAt(text, matchPos); size_t advance = m.position() + step; if (std::distance(searchStart, text.cend()) < (ptrdiff_t)advance) break; std::advance(searchStart, advance); flags |= std::regex_constants::match_not_bol;
                            }
                        }
                        catch (...) {}
                    }
                }
                else {
                    renderLowerQuery.assign(searchQuery.data(), searchQuery.size()); renderLowerText.assign(text.data(), text.size());
                    if (!searchMatchCase) { for (char& c : renderLowerQuery) if (c >= 'A' && c <= 'Z') c += 32; for (char& c : renderLowerText) if (c >= 'A' && c <= 'Z') c += 32; }
                    size_t offset = 0;
                    while ((offset = renderLowerText.find(renderLowerQuery, offset)) != std::string::npos) {
                        bool match = true; if (searchWholeWord) { if (offset > 0 && isWordChar(text[offset - 1])) match = false; if (match && (offset + renderLowerQuery.length() < text.length()) && isWordChar(text[offset + renderLowerQuery.length()])) match = false; }
                        if (match) { size_t startU16 = utf8OffsetToUtf16Count(text, offset); size_t lenU16 = utf8OffsetToUtf16Count(text, offset + renderLowerQuery.length()) - startU16; UINT32 count = 0; layout->HitTestTextRange((UINT32)startU16, (UINT32)lenU16, 0, 0, 0, 0, &count); if (count > 0) { renderHitMetrics.resize(count); layout->HitTestTextRange((UINT32)startU16, (UINT32)lenU16, 0, 0, renderHitMetrics.data(), count, &count); for (UINT32 mi = 0; mi < count; ++mi) { const auto& mm = renderHitMetrics[mi]; float top = std::floor((mm.top + lineHeight * 0.5f) / lineHeight) * lineHeight; rend->FillRectangle(D2D1::RectF(mm.left, top, mm.left + mm.width, top + lineHeight), hlBrush); } } } offset += 1;
                    }
                }
            }
            ID2D1Geometry* unifiedSelectionGeo = nullptr; renderRawRects.clear(); auto& rawRects = renderRawRects; float hInset = 4.0f; float vInset = 0.0f;
            for (const auto& cursor : cursors) {
                size_t s = cursor.start(); size_t e = cursor.end(); size_t relS = (s > visibleStartOffset) ? s - visibleStartOffset : 0; size_t relE = (e > visibleStartOffset) ? e - visibleStartOffset : 0; if (hasIME) { if (relS >= caretOffsetInVisible) relS += imeComp.size(); if (relE >= caretOffsetInVisible) relE += imeComp.size(); }
                if (relS < text.size() && relS != relE) {
                    if (relE > text.size()) relE = text.size();
                    if (relE > relS) {
                        size_t utf16Start = utf8OffsetToUtf16Count(text, relS); size_t utf16Len = utf8OffsetToUtf16Count(text, relE) - utf16Start; UINT32 count = 0; layout->HitTestTextRange((UINT32)utf16Start, (UINT32)utf16Len, 0, 0, 0, 0, &count);
                        if (count > 0) { renderHitMetrics.resize(count); layout->HitTestTextRange((UINT32)utf16Start, (UINT32)utf16Len, 0, 0, renderHitMetrics.data(), count, &count); for (UINT32 mi = 0; mi < count; ++mi) { const auto& mm = renderHitMetrics[mi]; float top = std::floor((mm.top + lineHeight * 0.5f) / lineHeight) * lineHeight; rawRects.push_back(D2D1::RectF(mm.left, top, mm.left + mm.width, top + lineHeight)); } }
                        for (size_t k = relS; k < relE; ++k) { bool shouldDraw = false; if (text[k] == '\n') shouldDraw = true; else if (text[k] == '\r') { if (k + 1 >= text.size() || text[k + 1] != '\n') shouldDraw = true; } if (shouldDraw) { UINT32 idx16 = (UINT32)utf8OffsetToUtf16Count(text, k); DWRITE_HIT_TEST_METRICS m; FLOAT px, py; layout->HitTestTextPosition(idx16, FALSE, &px, &py, &m); float top = std::floor((m.top + lineHeight * 0.5f) / lineHeight) * lineHeight; rawRects.push_back(D2D1::RectF(px - 0.5f, top, px + charWidth, top + lineHeight)); } }
                    }
                }
            }
            std::sort(rawRects.begin(), rawRects.end(), [](const D2D1_RECT_F& a, const D2D1_RECT_F& b) { if (std::abs(a.top - b.top) > 1.0f) return a.top < b.top; return a.left < b.left; }); renderMergedRects.clear(); auto& mergedRects = renderMergedRects;
            if (!rawRects.empty()) { mergedRects.push_back(rawRects[0]); for (size_t i = 1; i < rawRects.size(); ++i) { D2D1_RECT_F& curr = mergedRects.back(); const D2D1_RECT_F& next = rawRects[i]; bool sameLine = std::abs(curr.top - next.top) < 1.0f; bool touches = next.left <= curr.right + 1.0f; if (sameLine && touches) { curr.right = std::max(curr.right, next.right); curr.bottom = std::max(curr.bottom, next.bottom); } else mergedRects.push_back(next); } }
            if (!mergedRects.empty() && selBrush) { for (const auto& rect : mergedRects) rend->FillRectangle(rect, selBrush); }
            applySyntaxHighlighting(layout, text, visibleStartOffset);
            if (cachedTextBrush) rend->DrawTextLayout(D2D1::Point2F(0.0f, 0.0f), layout, cachedTextBrush, (D2D1_DRAW_TEXT_OPTIONS)0x00000004);
            if (cachedWsBrush && (nlGeoCRLF || nlGeoLF || nlGeoCR)) {
                float strokeWidth = std::max(1.5f, currentFontSize * 0.05f);
                float baseTx = gutterWidth - (float)hScrollPos;
                float baseTy = -(wordWrapEnabled ? (float)vScrollSubLine * lineHeight : 0.0f);
                for (size_t i = 0; i < wtextBuffer.size(); ++i) {
                    wchar_t wc = wtextBuffer[i];
                    if (wc == L'\r' || wc == L'\n') {
                        bool isCR = (wc == L'\r');
                        bool isCRLF = (isCR && i + 1 < wtextBuffer.size() && wtextBuffer[i + 1] == L'\n');
                        FLOAT px, py; DWRITE_HIT_TEST_METRICS m;
                        layout->HitTestTextPosition((UINT32)i, FALSE, &px, &py, &m);
                        py = std::floor((py + lineHeight * 0.5f) / lineHeight) * lineHeight;
                        float cx = px + charWidth * 0.5f;
                        float cy = py + lineHeight * 0.5f;
                        rend->SetTransform(D2D1::Matrix3x2F::Translation(baseTx + cx, baseTy + cy));
                        if (isCRLF) { if (nlGeoCRLF) rend->DrawGeometry(nlGeoCRLF, cachedWsBrush, strokeWidth, roundJoinStyle); i++; }
                        else if (isCR) { if (nlGeoCR) rend->DrawGeometry(nlGeoCR, cachedWsBrush, strokeWidth, roundJoinStyle); }
                        else { if (nlGeoLF) rend->DrawGeometry(nlGeoLF, cachedWsBrush, strokeWidth, roundJoinStyle); }
                    }
                }
                rend->SetTransform(transform);
            }
            if (hasIME && cachedTextBrush) {
                UINT32 imeStart = (UINT32)utf8OffsetToUtf16Count(text, caretOffsetInVisible); std::wstring imeCompWide = UTF8ToW(imeComp); UINT32 imeLen = (UINT32)imeCompWide.size(); UINT32 count = 0; layout->HitTestTextRange(imeStart, imeLen, 0, 0, 0, 0, &count);
                if (count > 0) { renderHitMetrics.resize(count); layout->HitTestTextRange(imeStart, imeLen, 0, 0, renderHitMetrics.data(), count, &count); for (UINT32 mi = 0; mi < count; ++mi) { const auto& mm = renderHitMetrics[mi]; float x = mm.left; float top = std::floor((mm.top + lineHeight * 0.5f) / lineHeight) * lineHeight; float y = std::floor(top + lineHeight - 2.0f) + 0.5f; float w = mm.width; if (dotStyle) rend->DrawLine(D2D1::Point2F(x, y), D2D1::Point2F(x + w, y), cachedTextBrush, 1.5f, dotStyle); else rend->DrawLine(D2D1::Point2F(x, y), D2D1::Point2F(x + w, y), cachedTextBrush, 1.0f); } }
            }
        }
        rend->SetTransform(D2D1::Matrix3x2F::Identity()); rend->PopAxisAlignedClip();
        if (cachedGutterBgBrush) rend->FillRectangle(D2D1::RectF(0, 0, gutterWidth, clientH), cachedGutterBgBrush);
        int startLine = vScrollPos; int endLine = startLine + linesVisible; if (endLine > (int)lineStarts.size()) endLine = (int)lineStarts.size();
        D2D1_RECT_F gutterClipRect = D2D1::RectF(0, 0, gutterWidth, clientH);
        rend->PushAxisAlignedClip(gutterClipRect, D2D1_ANTIALIAS_MODE_ALIASED);
        if (cachedGutterTextBrush && textFormat) {
            textFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_TRAILING);
            float rightEdge = gutterWidth - (charWidth * 0.5f);
            for (int i = startLine; i < endLine; i++) {
                float yPos = (float)((i - startLine)) * lineHeight;
                if (wordWrapEnabled && layout) { size_t lineStartPos = lineStarts[i]; size_t relStart = (lineStartPos >= visibleStartOffset) ? lineStartPos - visibleStartOffset : 0; if (hasIME && relStart > caretOffsetInVisible) relStart += imeComp.size(); if (relStart <= text.size()) { size_t utf16Start = utf8OffsetToUtf16Count(text, relStart); FLOAT px, py; DWRITE_HIT_TEST_METRICS m; layout->HitTestTextPosition((UINT32)utf16Start, FALSE, &px, &py, &m); py = std::floor((py + lineHeight * 0.5f) / lineHeight) * lineHeight; yPos = py - (float)vScrollSubLine * lineHeight; } }
                if (yPos + lineHeight > 0 && yPos < clientH) {
                    wchar_t numBuf[16];
                    int numLen = swprintf_s(numBuf, L"%d", i + 1);
                    if (numLen > 0) {
                        rend->DrawText(numBuf, (UINT32)numLen, textFormat, D2D1::RectF(0.0f, yPos, rightEdge, yPos + lineHeight), cachedGutterTextBrush, (D2D1_DRAW_TEXT_OPTIONS)0x00000004);
                    }
                }
            }
            textFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_LEADING);
        }
        rend->PopAxisAlignedClip();
        bool hasVisibleMainCaret = false;
        if (layout && caretBrush) {
            rend->PushAxisAlignedClip(textClipRect, D2D1_ANTIALIAS_MODE_ALIASED); D2D1_ANTIALIAS_MODE oldMode = rend->GetAntialiasMode(); rend->SetAntialiasMode(D2D1_ANTIALIAS_MODE_ALIASED); rend->SetTransform(transform);
            float subScrollY = wordWrapEnabled ? (float)vScrollSubLine * lineHeight : 0.0f;
            if (isDragMoving && dragMoveDestPos >= visibleStartOffset && (dragMoveDestPos < visibleEndOffset || (dragMoveDestPos == visibleEndOffset && visibleEndOffset == pt.length()))) {
                size_t relPos = dragMoveDestPos - visibleStartOffset;
                if (hasIME && relPos > caretOffsetInVisible) relPos += imeComp.size();
                if (relPos <= text.size()) {
                    DWRITE_HIT_TEST_METRICS m; FLOAT px, py;
                    layout->HitTestTextPosition((UINT32)utf8OffsetToUtf16Count(text, relPos), FALSE, &px, &py, &m);
                    px = std::round(px); py = std::floor((py + lineHeight * 0.5f) / lineHeight) * lineHeight;
                    float screenX = px + gutterWidth - (float)hScrollPos;
                    float screenY = py - subScrollY;
                    if (screenY >= 0.0f && screenY < clientH && screenX + 2.0f > gutterWidth && screenX < clientW) {
                        rend->FillRectangle(D2D1::RectF(px, py, px + 2.0f, py + lineHeight), caretBrush);
                    }
                }
            }
            for (const auto& cursor : cursors) {
                size_t head = cursor.head;
                if (head < visibleStartOffset) continue;
                if (head > visibleEndOffset || (head == visibleEndOffset && visibleEndOffset < pt.length())) continue;
                size_t relHead = head - visibleStartOffset;
                if (hasIME && relHead >= caretOffsetInVisible) relHead += imeComp.size();
                if (relHead <= text.size()) {
                    UINT32 u16Pos = (UINT32)utf8OffsetToUtf16Count(text, relHead);
                    DWRITE_HIT_TEST_METRICS m; FLOAT px, py;
                    if (cursor.affinity && u16Pos > 0) {
                        layout->HitTestTextPosition(u16Pos - 1, TRUE, &px, &py, &m);
                    } else {
                        layout->HitTestTextPosition(u16Pos, FALSE, &px, &py, &m);
                    }
                    px = std::round(px);
                    py = std::floor((py + lineHeight * 0.5f) / lineHeight) * lineHeight;
                    float cw = isOverwriteMode ? ((m.width > 0) ? m.width : charWidth) : 2.0f;
                    float screenX = px + gutterWidth - (float)hScrollPos;
                    float screenY = py - subScrollY;
                    if (screenY >= 0.0f && screenY < clientH && screenX + cw > gutterWidth && screenX < clientW) {
                        rend->FillRectangle(D2D1::RectF(px, py, px + cw, py + lineHeight), caretBrush);
                        if (&cursor == &cursors.back()) { imeCx = px; imeCy = py; hasVisibleMainCaret = true; }
                    }
                }
            }
            rend->SetTransform(D2D1::Matrix3x2F::Identity()); rend->SetAntialiasMode(oldMode); rend->PopAxisAlignedClip();
        }
        visibleUtf16CachePtr = nullptr;
        if (layout) layout->Release();
        if (GetFocus() == hwnd && hasVisibleMainCaret) { HIMC hIMC = ImmGetContext(hwnd);
        if (hIMC) { COMPOSITIONFORM cf = {}; cf.dwStyle = CFS_POINT; cf.ptCurrentPos.x = (LONG)((imeCx + gutterWidth - hScrollPos) * dpiScaleX); cf.ptCurrentPos.y = (LONG)((imeCy - (wordWrapEnabled ? (float)vScrollSubLine * lineHeight : 0.0f)) * dpiScaleY); ImmSetCompositionWindow(hIMC, &cf); CANDIDATEFORM cdf = {}; cdf.dwIndex = 0; cdf.dwStyle = CFS_CANDIDATEPOS; cdf.ptCurrentPos.x = (LONG)((imeCx + gutterWidth - hScrollPos) * dpiScaleX); cdf.ptCurrentPos.y = (LONG)((imeCy - (wordWrapEnabled ? (float)vScrollSubLine * lineHeight : 0.0f) + lineHeight) * dpiScaleY); ImmSetCandidateWindow(hIMC, &cdf); ImmReleaseContext(hwnd, hIMC); } }
        if (GetTickCount64() < zoomPopupEndTime) { D2D1_RECT_F popupRect = D2D1::RectF(clientW / 2 - 80, clientH / 2 - 40, clientW / 2 + 80, clientH / 2 + 40); ID2D1SolidColorBrush* popupBg = nullptr; ID2D1SolidColorBrush* popupText = nullptr; if (isDarkMode) { rend->CreateSolidColorBrush(D2D1::ColorF(0.2f, 0.2f, 0.2f, 0.7f), &popupBg); rend->CreateSolidColorBrush(D2D1::ColorF(1.0f, 1.0f, 1.0f, 1.0f), &popupText); } else { rend->CreateSolidColorBrush(D2D1::ColorF(0.93f, 0.93f, 0.93f, 0.85f), &popupBg); rend->CreateSolidColorBrush(D2D1::ColorF(0.0f, 0.0f, 0.0f, 1.0f), &popupText); } rend->FillRoundedRectangle(D2D1::RoundedRect(popupRect, 10.0f, 10.0f), popupBg); if (popupTextFormat) rend->DrawText(zoomPopupText.c_str(), (UINT32)zoomPopupText.size(), popupTextFormat, popupRect, popupText); popupBg->Release(); popupText->Release(); }
        if (showHelpPopup) {
            float helpW = 500.0f; float helpH = 588.0f;
            D2D1_RECT_F helpRect = D2D1::RectF((fullClientW - helpW) / 2, (clientH - helpH) / 2, (fullClientW + helpW) / 2, (clientH + helpH) / 2);
            ID2D1SolidColorBrush* popupBg = nullptr;
            ID2D1SolidColorBrush* popupText = nullptr;
            ID2D1SolidColorBrush* popupBorder = nullptr;
            if (isDarkMode) {
                rend->CreateSolidColorBrush(D2D1::ColorF(0.2f, 0.2f, 0.2f, 0.7f), &popupBg);
                rend->CreateSolidColorBrush(D2D1::ColorF(1.0f, 1.0f, 1.0f, 1.0f), &popupText);
            } else {
                rend->CreateSolidColorBrush(D2D1::ColorF(0.93f, 0.93f, 0.93f, 0.85f), &popupBg);
                rend->CreateSolidColorBrush(D2D1::ColorF(0.0f, 0.0f, 0.0f, 1.0f), &popupText);
                rend->CreateSolidColorBrush(D2D1::ColorF(0.8f, 0.8f, 0.8f, 1.0f), &popupBorder);
            }
            rend->FillRoundedRectangle(D2D1::RoundedRect(helpRect, 10.0f, 10.0f), popupBg);
            if (popupBorder) {
                rend->DrawRoundedRectangle(D2D1::RoundedRect(helpRect, 10.0f, 10.0f), popupBorder, 1.0f);
                popupBorder->Release();
            }
            IDWriteTextLayout* helpLayout = nullptr;
            if (SUCCEEDED(dwFactory->CreateTextLayout(helpTextStr.c_str(), (UINT32)helpTextStr.size(), helpTextFormat, helpW - 40, helpH - 20, &helpLayout))) {
                rend->DrawTextLayout(D2D1::Point2F(helpRect.left + 20, helpRect.top + 10), helpLayout, popupText, (D2D1_DRAW_TEXT_OPTIONS)0x00000004);
                helpLayout->Release();
            }
            popupBg->Release();
            popupText->Release();
        }
        {
            bool hasV = false, hasH = false, singleLineWrap = false;
            float vTrackH = 0, thumbY = 0, thumbH = 0, vMaxScroll = 1.0f;
            float hTrackW = 0, thumbX = 0, thumbW = 0, hMaxScroll = 1.0f;
            getScrollBarLayout(clientW, clientH, hasV, vTrackH, thumbY, thumbH, vMaxScroll, singleLineWrap, hasH, hTrackW, thumbX, thumbW, hMaxScroll);
            if (hasV || hasH) {
                if (hasV) {
                    bool isActive = isVScrollHover || isVScrollDragging;
                    float currentSize = isActive ? SB_MAX_WIDTH : SB_MIN_WIDTH;
                    ID2D1SolidColorBrush* currentBrush = isActive ? cachedSbActiveBrush : cachedSbIdleBrush;
                    if (currentBrush) {
                        D2D1_RECT_F rect = D2D1::RectF(clientW - currentSize - SB_PADDING, thumbY, clientW - SB_PADDING, thumbY + thumbH);
                        rend->FillRoundedRectangle(D2D1::RoundedRect(rect, currentSize * 0.5f, currentSize * 0.5f), currentBrush);
                    }
                }
                if (hasH) {
                    bool isActive = isHScrollHover || isHScrollDragging;
                    float currentSize = isActive ? SB_MAX_WIDTH : SB_MIN_WIDTH;
                    ID2D1SolidColorBrush* currentBrush = isActive ? cachedSbActiveBrush : cachedSbIdleBrush;
                    if (currentBrush) {
                        D2D1_RECT_F rect = D2D1::RectF(thumbX, clientH - currentSize - SB_PADDING, thumbX + thumbW, clientH - SB_PADDING);
                        rend->FillRoundedRectangle(D2D1::RoundedRect(rect, currentSize * 0.5f, currentSize * 0.5f), currentBrush);
                    }
                }
            }
        }
        if (showPreview && !showHelpPopup) {
            if (cachedSplitBrush) {
                rend->FillRectangle(D2D1::RectF(clientW, 0.0f, clientW + SPLITTER_DIP_W, clientH), cachedSplitBrush);
            }
            if ((isSplitterHover || isSplitterDragging) && cachedSashBrush) {
                rend->FillRectangle(D2D1::RectF(clientW - 3.0f, 0.0f, clientW + SPLITTER_DIP_W, clientH), cachedSashBrush);
            }
        }
        rend->EndDraw();
        swapChain->Present(1, 0);
    }
#pragma optimize("s", on)
    void resizeSwapChain(int w, int h) {
        if (rend && swapChain) { rend->SetTarget(nullptr); if (targetBitmap) { targetBitmap->Release(); targetBitmap = nullptr; } swapChain->ResizeBuffers(2, w, h, DXGI_FORMAT_B8G8R8A8_UNORM, 0); if (showPreview) updatePreviewBounds(); updateScrollBars(); if (hwnd) InvalidateRect(hwnd, NULL, FALSE); }
    }
    void insertAtCursors(const std::string& text) {
        commitPadding(); if (cursors.empty()) return; EditBatch batch; batch.beforeCursors = cursors; std::vector<int> indices(cursors.size());
        for (size_t i = 0; i < cursors.size(); ++i) indices[i] = (int)i;
        std::sort(indices.begin(), indices.end(), [&](int a, int b) {return cursors[a].start() > cursors[b].start(); });
        for (int idx : indices) {
            Cursor& c = cursors[idx];
            if (isOverwriteMode && !c.hasSelection()) { char ch = (c.head < pt.length()) ? pt.charAt(c.head) : 0; if (ch != 0 && ch != '\n' && ch != '\r') { size_t nextPos = moveCaretVisual(c.head, true); size_t charLen = nextPos - c.head; if (charLen > 0) { std::string d = pt.getRange(c.head, charLen); pt.erase(c.head, charLen); batch.ops.push_back({ EditOp::Erase, c.head, d }); for (auto& o : cursors) { if (o.head > c.head) o.head -= charLen; if (o.anchor > c.head) o.anchor -= charLen; } } } }
            if (c.hasSelection()) { size_t s = c.start(); size_t l = c.end() - s; std::string d = pt.getRange(s, l); pt.erase(s, l); batch.ops.push_back({ EditOp::Erase,s,d }); for (auto& o : cursors) { if (o.head > s)o.head -= l; if (o.anchor > s)o.anchor -= l; } c.head = s; c.anchor = s; }
        }
        for (int idx : indices) { Cursor& c = cursors[idx]; size_t p = c.head; pt.insert(p, text); batch.ops.push_back({ EditOp::Insert,p,text }); size_t l = text.size(); for (auto& o : cursors) { if (o.head >= p)o.head += l; if (o.anchor >= p)o.anchor += l; } }
        applyBatchToEmmetTabstops(batch); batch.afterCursors = cursors; undo.push(batch);
        if (cursors.size() == 1 && canFastAdjustLineStarts(batch)) adjustLineStartsSingleLine(batch.ops[0].pos, (ptrdiff_t)batch.ops[0].text.size());
        else rebuildLineStarts();
        ensureCaretVisible(); updateDirtyFlag();
    }
    void deleteForwardAtCursors() {
        commitPadding(); if (cursors.empty()) return; EditBatch batch; batch.beforeCursors = cursors; std::vector<int> indices(cursors.size());
        for (size_t i = 0; i < cursors.size(); ++i) indices[i] = (int)i;
        std::sort(indices.begin(), indices.end(), [&](int a, int b) {return cursors[a].start() > cursors[b].start(); });
        for (int idx : indices) {
            Cursor& c = cursors[idx]; size_t s = c.start(); size_t l = 0;
            if (c.hasSelection()) l = c.end() - s;
            else { if (s + 1 < pt.length() && pt.charAt(s) == '\r' && pt.charAt(s + 1) == '\n') l = 2; else { size_t n = moveCaretVisual(s, true); if (n > s) l = n - s; } }
            if (l > 0 && s + l <= pt.length()) { std::string d = pt.getRange(s, l); pt.erase(s, l); batch.ops.push_back({ EditOp::Erase,s,d }); for (auto& o : cursors) { if (o.head > s) o.head -= l; if (o.anchor > s) o.anchor -= l; } c.head = s; c.anchor = s; }
        }
        applyBatchToEmmetTabstops(batch); batch.afterCursors = cursors; undo.push(batch);
        if (cursors.size() == 1 && canFastAdjustLineStarts(batch)) adjustLineStartsSingleLine(batch.ops[0].pos, -(ptrdiff_t)batch.ops[0].text.size());
        else rebuildLineStarts();
        ensureCaretVisible(); updateDirtyFlag();
    }
    void backspaceAtCursors(bool allowCharDeletion = true) {
        commitPadding(); if (cursors.empty()) return; EditBatch batch; batch.beforeCursors = cursors; std::vector<int> indices(cursors.size());
        for (size_t i = 0; i < cursors.size(); ++i) indices[i] = (int)i;
        std::sort(indices.begin(), indices.end(), [&](int a, int b) {return cursors[a].start() > cursors[b].start(); });
        for (int idx : indices) {
            Cursor& c = cursors[idx]; size_t s = c.start(); size_t l = 0;
            if (c.hasSelection()) l = c.end() - s;
            else if (allowCharDeletion && s > 0) { if (s >= 2 && pt.charAt(s - 1) == '\n' && pt.charAt(s - 2) == '\r') { l = 2; s -= 2; } else { size_t p = moveCaretVisual(s, false); if (p < s) { l = s - p; s = p; } } }
            if (l > 0) { std::string d = pt.getRange(s, l); pt.erase(s, l); batch.ops.push_back({ EditOp::Erase,s,d }); for (auto& o : cursors) { if (o.head > s) o.head -= l; if (o.anchor > s) o.anchor -= l; } c.head = s; c.anchor = s; }
        }
        if (!batch.ops.empty()) {
            applyBatchToEmmetTabstops(batch); batch.afterCursors = cursors; undo.push(batch);
            if (cursors.size() == 1 && canFastAdjustLineStarts(batch)) adjustLineStartsSingleLine(batch.ops[0].pos, -(ptrdiff_t)batch.ops[0].text.size());
            else rebuildLineStarts();
            ensureCaretVisible(); updateDirtyFlag();
        }
    }
    void insertRectangularBlock(const std::string& text) {
        commitPadding(); if (cursors.empty()) return; size_t basePos = cursors.back().head; float baseX = getXFromPos(basePos); int startLine = getLineIdx(basePos); std::vector<std::string> lines;
        for (size_t linePos = 0; linePos < text.size(); ) {
            size_t eol = linePos;
            while (eol < text.size() && text[eol] != '\n' && text[eol] != '\r') eol++;
            lines.push_back(text.substr(linePos, eol - linePos));
            if (eol < text.size()) {
                if (text[eol] == '\r' && eol + 1 < text.size() && text[eol + 1] == '\n') eol += 2;
                else eol += 1;
            }
            linePos = eol;
        }
        EditBatch batch; batch.beforeCursors = cursors; std::vector<Cursor> newCursors; size_t accumulatedDelta = 0;
        for (size_t i = 0; i < lines.size(); ++i) {
            int targetLineIdx = startLine + (int)i; std::string content = lines[i];
            if (targetLineIdx >= (int)lineStarts.size()) {
                size_t insertAt = pt.length(); std::string nl = newlineStr; pt.insert(insertAt, nl); batch.ops.push_back({ EditOp::Insert, insertAt, nl }); int spacesNeeded = (int)((baseX) / charWidth + 0.5f); std::string spaces = ""; if (spacesNeeded > 0) spaces = std::string(spacesNeeded, ' '); size_t contentPos = insertAt + nl.size();
                if (!spaces.empty()) { pt.insert(contentPos, spaces); batch.ops.push_back({ EditOp::Insert, contentPos, spaces }); contentPos += spaces.size(); }
                pt.insert(contentPos, content); batch.ops.push_back({ EditOp::Insert, contentPos, content }); size_t endPos = contentPos + content.size(); newCursors.push_back({ endPos, contentPos, baseX + (float)UTF8ToW(content).length() * charWidth });
            }
            else {
                size_t lineStart = lineStarts[targetLineIdx] + accumulatedDelta; size_t scanPos = lineStart; size_t maxLen = pt.length();
                while (scanPos < maxLen && pt.charAt(scanPos) != '\n' && pt.charAt(scanPos) != '\r') scanPos++; size_t lineEnd = scanPos;
                std::string currentLineStr = pt.getRange(lineStart, lineEnd - lineStart); std::wstring wCurrentLine = UTF8ToW(currentLineStr); size_t insertOffset = wCurrentLine.length(); float actualLineWidth = 0.0f; IDWriteTextLayout* layout = nullptr; HRESULT hr = dwFactory->CreateTextLayout(wCurrentLine.c_str(), (UINT32)wCurrentLine.size(), textFormat, 10000.0f, (FLOAT)lineHeight, &layout);
                if (SUCCEEDED(hr) && layout) { BOOL isTrailing, isInside; DWRITE_HIT_TEST_METRICS m; layout->HitTestPoint(baseX, 1.0f, &isTrailing, &isInside, &m); size_t u16Pos = m.textPosition; if (isTrailing) u16Pos += m.length; std::string pre = WToUTF8(wCurrentLine.substr(0, u16Pos)); insertOffset = pre.size(); DWRITE_TEXT_METRICS tm; if (SUCCEEDED(layout->GetMetrics(&tm))) actualLineWidth = tm.widthIncludingTrailingWhitespace; else actualLineWidth = (float)wCurrentLine.length() * charWidth; layout->Release(); }
                else actualLineWidth = (float)wCurrentLine.length() * charWidth;
                size_t insertPos = lineStart + insertOffset; std::string spaces = ""; if (insertPos == lineEnd && baseX > actualLineWidth + 1.0f) { int spacesNeeded = (int)((baseX - actualLineWidth) / charWidth + 0.5f); if (spacesNeeded > 0) spaces = std::string(spacesNeeded, ' '); }
                size_t addedBytes = 0; if (!spaces.empty()) { pt.insert(insertPos, spaces); batch.ops.push_back({ EditOp::Insert, insertPos, spaces }); insertPos += spaces.size(); addedBytes += spaces.size(); }
                pt.insert(insertPos, content); batch.ops.push_back({ EditOp::Insert, insertPos, content }); addedBytes += content.size(); accumulatedDelta += addedBytes; size_t endPos = insertPos + content.size(); newCursors.push_back({ endPos, insertPos, baseX + (float)UTF8ToW(content).length() * charWidth });
            }
        }
        cursors = newCursors; batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE);
    }
    void convertCase(bool toUpper) {
        commitPadding(); if (cursors.empty()) return; EditBatch batch; batch.beforeCursors = cursors; bool isChanged = false; std::vector<int> indices(cursors.size()); for (size_t i = 0; i < cursors.size(); ++i) indices[i] = (int)i; std::sort(indices.begin(), indices.end(), [&](int a, int b) { return cursors[a].start() > cursors[b].start(); });
        for (int idx : indices) { Cursor& c = cursors[idx]; if (!c.hasSelection()) continue; size_t start = c.start(); size_t len = c.end() - start; std::string text = pt.getRange(start, len); std::wstring wText = UTF8ToW(text); if (toUpper) CharUpperBuffW(&wText[0], (DWORD)wText.size()); else CharLowerBuffW(&wText[0], (DWORD)wText.size()); std::string newText = WToUTF8(wText); if (text == newText) continue; isChanged = true; pt.erase(start, len); batch.ops.push_back({ EditOp::Erase, start, text }); pt.insert(start, newText); batch.ops.push_back({ EditOp::Insert, start, newText }); long long diff = (long long)newText.size() - (long long)len; if (c.head > c.anchor) { c.head = start + newText.size(); c.anchor = start; } else { c.head = start; c.anchor = start + newText.size(); } if (diff != 0) { for (size_t k = 0; k < cursors.size(); ++k) { if ((int)k == idx) continue; Cursor& other = cursors[k]; if (other.start() > start) { if (other.head > start) other.head = (size_t)((long long)other.head + diff); if (other.anchor > start) other.anchor = (size_t)((long long)other.anchor + diff); } } } }
        if (isChanged) { batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE); }
    }
    std::vector<int> getSelectedLineIndices() { std::vector<int> lines; for (const auto& c : cursors) { int startLine = getLineIdx(c.start()); int endLine = getLineIdx(c.end()); if (c.hasSelection() && c.end() > c.start()) { if (c.end() > 0 && (pt.charAt(c.end() - 1) == '\n' || pt.charAt(c.end() - 1) == '\r')) { if (endLine > startLine) endLine--; } } for (int i = startLine; i <= endLine; ++i) lines.push_back(i); } std::sort(lines.begin(), lines.end()); lines.erase(std::unique(lines.begin(), lines.end()), lines.end()); return lines; }
    void duplicateLines(bool up) {
        commitPadding(); if (cursors.empty()) return; std::vector<int> lines = getSelectedLineIndices(); if (lines.empty()) return; EditBatch batch; batch.beforeCursors = cursors; std::string blockText; size_t blockStart = lineStarts[lines.front()]; size_t blockEnd = (lines.back() + 1 < (int)lineStarts.size()) ? lineStarts[lines.back() + 1] : pt.length(); blockText = pt.getRange(blockStart, blockEnd - blockStart); size_t insertPos;
        if (up) {
            if (blockText.empty() || (blockText.back() != '\n' && blockText.back() != '\r')) blockText += newlineStr;
            insertPos = blockStart;
        } else {
            insertPos = blockEnd;
            if (blockText.empty()) {
                blockText = newlineStr;
            } else if (blockText.back() != '\n' && blockText.back() != '\r') {
                pt.insert(blockEnd, newlineStr);
                batch.ops.push_back({ EditOp::Insert, blockEnd, newlineStr });
                insertPos += newlineStr.length();
            }
        }
        pt.insert(insertPos, blockText); batch.ops.push_back({ EditOp::Insert, insertPos, blockText }); batch.afterCursors.clear(); size_t newSelectionStart = insertPos; size_t newSelectionEnd = insertPos + blockText.size(); batch.afterCursors.push_back({ newSelectionEnd, newSelectionStart, getXFromPos(newSelectionEnd) }); cursors = batch.afterCursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE);
    }
    void moveLines(bool up) {
        commitPadding(); if (cursors.empty()) return; std::vector<int> lines = getSelectedLineIndices(); if (lines.empty()) return; if (up && lines.front() == 0) return; if (!up && lines.back() >= (int)lineStarts.size() - 1) return; int startLine = lines.front(); int endLine = lines.back(); size_t rangeStart = lineStarts[startLine]; size_t rangeEnd = (endLine + 1 < (int)lineStarts.size()) ? lineStarts[endLine + 1] : pt.length(); std::string textToMove = pt.getRange(rangeStart, rangeEnd - rangeStart); bool isLastLineNoNewline = (rangeEnd == pt.length()) && (textToMove.empty() || (textToMove.back() != '\n' && textToMove.back() != '\r')); EditBatch batch; batch.beforeCursors = cursors;
        if (up) {
            int targetLineIdx = startLine - 1; size_t targetStart = lineStarts[targetLineIdx]; size_t targetEnd = rangeStart; std::string lineAbove = pt.getRange(targetStart, targetEnd - targetStart); long long diff = -(long long)(rangeStart - targetStart);
            if (isLastLineNoNewline) { textToMove += newlineStr; if (!lineAbove.empty() && lineAbove.back() == '\n') { lineAbove.pop_back(); if (!lineAbove.empty() && lineAbove.back() == '\r') lineAbove.pop_back(); } else if (!lineAbove.empty() && lineAbove.back() == '\r') { lineAbove.pop_back(); } }
            size_t deleteLen = rangeEnd - targetStart; std::string deletedAll = pt.getRange(targetStart, deleteLen); pt.erase(targetStart, deleteLen); batch.ops.push_back({ EditOp::Erase, targetStart, deletedAll }); std::string newText = textToMove + lineAbove; pt.insert(targetStart, newText); batch.ops.push_back({ EditOp::Insert, targetStart, newText });
            for (auto& c : cursors) { c.head = (size_t)((long long)c.head + diff); c.anchor = (size_t)((long long)c.anchor + diff); c.desiredX = getXFromPos(c.head); }
        }
        else {
            int targetLineIdx = endLine + 1; size_t targetStart = rangeEnd; size_t targetEnd = (targetLineIdx + 1 < (int)lineStarts.size()) ? lineStarts[targetLineIdx + 1] : pt.length(); std::string lineBelow = pt.getRange(targetStart, targetEnd - targetStart);
            if (targetEnd == pt.length() && (lineBelow.empty() || (lineBelow.back() != '\n' && lineBelow.back() != '\r'))) { lineBelow += newlineStr; if (!textToMove.empty() && textToMove.back() == '\n') { textToMove.pop_back(); if (!textToMove.empty() && textToMove.back() == '\r') textToMove.pop_back(); } else if (!textToMove.empty() && textToMove.back() == '\r') { textToMove.pop_back(); } }
            size_t deleteLen = targetEnd - rangeStart; std::string deletedAll = pt.getRange(rangeStart, deleteLen); pt.erase(rangeStart, deleteLen); batch.ops.push_back({ EditOp::Erase, rangeStart, deletedAll }); std::string newText = lineBelow + textToMove; pt.insert(rangeStart, newText); batch.ops.push_back({ EditOp::Insert, rangeStart, newText }); long long diff = (long long)lineBelow.size();
            for (auto& c : cursors) { c.head = (size_t)((long long)c.head + diff); c.anchor = (size_t)((long long)c.anchor + diff); c.desiredX = getXFromPos(c.head); }
        }
        batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE);
    }
    void addCursor(bool up) {
        clearEmmetTabstops(); rollbackPadding();
        if (cursors.empty() || lineStarts.empty()) return;
        int targetLine = -1;
        if (up) {
            size_t minLineIdx = lineStarts.size();
            size_t topIdx = 0;
            for (size_t i = 0; i < cursors.size(); ++i) {
                size_t l = getLineIdx(cursors[i].head);
                if (l < minLineIdx) {
                    minLineIdx = l;
                    topIdx = i;
                }
            }
            if (minLineIdx == 0) return;
            targetLine = (int)minLineIdx - 1;
            const auto& refCursor = cursors[topIdx];
            size_t newHead = getPosFromLineAndX(targetLine, refCursor.desiredX);
            size_t newAnchor = newHead;
            if (refCursor.hasSelection()) {
                float anchorX = getXFromPos(refCursor.anchor);
                newAnchor = getPosFromLineAndX(targetLine, anchorX);
            }
            cursors.push_back({ newHead, newAnchor, refCursor.desiredX });
        } else {
            int maxLineIdx = -1;
            size_t bottomIdx = 0;
            for (size_t i = 0; i < cursors.size(); ++i) {
                int l = (int)getLineIdx(cursors[i].head);
                if (l > maxLineIdx) {
                    maxLineIdx = l;
                    bottomIdx = i;
                }
            }
            if (maxLineIdx < 0 || maxLineIdx + 1 >= (int)lineStarts.size()) return;
            targetLine = maxLineIdx + 1;
            const auto& refCursor = cursors[bottomIdx];
            size_t newHead = getPosFromLineAndX(targetLine, refCursor.desiredX);
            size_t newAnchor = newHead;
            if (refCursor.hasSelection()) {
                float anchorX = getXFromPos(refCursor.anchor);
                newAnchor = getPosFromLineAndX(targetLine, anchorX);
            }
            cursors.push_back({ newHead, newAnchor, refCursor.desiredX });
        }
        mergeCursors();
        ensureCaretVisible();
        if (up && targetLine >= 0 && targetLine < vScrollPos) {
            vScrollPos = targetLine;
            updateScrollBars();
        }
        InvalidateRect(hwnd, NULL, FALSE);
    }
    void setClipboard(const std::string& text, bool isLineCopy, bool isRectCopy) {
        if (text.empty()) return;
        if (OpenClipboard(hwnd)) { EmptyClipboard(); std::wstring w = UTF8ToW(text); HGLOBAL h = GlobalAlloc(GMEM_MOVEABLE, (w.size() + 1) * sizeof(wchar_t)); if (h) { void* p = GlobalLock(h); memcpy(p, w.c_str(), (w.size() + 1) * sizeof(wchar_t)); GlobalUnlock(h); SetClipboardData(CF_UNICODETEXT, h); } if (isLineCopy) { HGLOBAL hLine = GlobalAlloc(GMEM_MOVEABLE, 1); if (hLine) SetClipboardData(cfMsDevLine, hLine); } if (isRectCopy) { HGLOBAL hCol = GlobalAlloc(GMEM_MOVEABLE, 1); if (hCol) SetClipboardData(cfMsDevCol, hCol); } CloseClipboard(); }
    }
    void copyToClipboard() {
        bool hasSelection = false; for (const auto& c : cursors) { if (c.hasSelection()) { hasSelection = true; break; } } std::string t;
        if (hasSelection) { std::vector<Cursor> s = cursors; std::sort(s.begin(), s.end(), [](const Cursor& a, const Cursor& b) { return a.start() < b.start(); }); for (size_t i = 0; i < s.size(); ++i) { if (s[i].hasSelection()) { std::string part = pt.getRange(s[i].start(), s[i].end() - s[i].start()); t += part; if (i < s.size() - 1 && !part.empty() && part.back() != '\n' && part.back() != '\r') t += "\r\n"; } } setClipboard(t, false, cursors.size() > 1); }
        else { std::vector<int> processedLines; std::vector<Cursor> s = cursors; std::sort(s.begin(), s.end(), [](const Cursor& a, const Cursor& b) { return a.head < b.head; }); for (const auto& c : s) { int lineIdx = getLineIdx(c.head); bool dup = false; for (int p : processedLines) if (p == lineIdx) dup = true; if (dup) continue; processedLines.push_back(lineIdx); size_t start = lineStarts[lineIdx]; size_t end = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length(); std::string lineText = pt.getRange(start, end - start); t += lineText; if (lineIdx == (int)lineStarts.size() - 1) { if (lineText.empty() || (lineText.back() != '\n' && lineText.back() != '\r')) t += newlineStr; } } setClipboard(t, true, false); }
    }
    void cutToClipboard() { bool hasSelection = false; for (const auto& c : cursors) { if (c.hasSelection()) { hasSelection = true; break; } } if (hasSelection) { copyToClipboard(); insertAtCursors(""); } else { std::string t; std::vector<int> processedLines; std::vector<Cursor> s = cursors; std::sort(s.begin(), s.end(), [](const Cursor& a, const Cursor& b) { return a.head < b.head; }); for (const auto& c : s) { int lineIdx = getLineIdx(c.head); bool dup = false; for (int p : processedLines) if (p == lineIdx) dup = true; if (dup) continue; processedLines.push_back(lineIdx); size_t start = lineStarts[lineIdx]; size_t end = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length(); std::string lineText = pt.getRange(start, end - start); t += lineText; if (lineIdx == (int)lineStarts.size() - 1) { if (lineText.empty() || (lineText.back() != '\n' && lineText.back() != '\r')) t += newlineStr; } } setClipboard(t, true, false); deleteLines(); } }
    void deleteLines() {
        rollbackPadding(); std::vector<Cursor> originalCursors = cursors; std::vector<Cursor> delRanges; bool hasSelection = false; for (const auto& c : cursors) if (c.hasSelection()) hasSelection = true;
        if (hasSelection) { for (const auto& c : cursors) { int sLine = getLineIdx(c.start()); int eLine = getLineIdx(c.end()); if (c.hasSelection() && c.end() > 0 && (pt.charAt(c.end() - 1) == '\n' || pt.charAt(c.end() - 1) == '\r') && eLine > sLine) eLine--; size_t start = lineStarts[sLine]; size_t end = (eLine + 1 < (int)lineStarts.size()) ? lineStarts[eLine + 1] : pt.length(); if (end == pt.length() && start > 0) { char prev = pt.charAt(start - 1); if (prev == '\n') { start--; if (start > 0 && pt.charAt(start - 1) == '\r') start--; } else if (prev == '\r') start--; } delRanges.push_back({ end, start, 0.0f }); } }
        else { for (const auto& c : cursors) { int lineIdx = getLineIdx(c.head); size_t start = lineStarts[lineIdx]; size_t end = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length(); if (end == pt.length() && start > 0) { char prev = pt.charAt(start - 1); if (prev == '\n') { start--; if (start > 0 && pt.charAt(start - 1) == '\r') start--; } else if (prev == '\r') start--; } delRanges.push_back({ end, start, 0.0f }); } }
        cursors = delRanges; mergeCursors(); insertAtCursors(""); if (!undo.undoStack.empty()) undo.undoStack.back().beforeCursors = originalCursors;
    }
    void pasteFromClipboard() {
        if (!IsClipboardFormatAvailable(CF_UNICODETEXT)) return;
        if (OpenClipboard(hwnd)) {
            bool isRect = IsClipboardFormatAvailable(cfMsDevCol); bool isLine = IsClipboardFormatAvailable(cfMsDevLine); HGLOBAL h = GetClipboardData(CF_UNICODETEXT);
            if (h) {
                const wchar_t* p = (const wchar_t*)GlobalLock(h);
                if (p) {
                    std::wstring w(p); GlobalUnlock(h); std::string rawUtf8 = WToUTF8(w);
                    std::string utf8; utf8.reserve(rawUtf8.size());
                    for (size_t ni = 0; ni < rawUtf8.size(); ++ni) {
                        if (rawUtf8[ni] == '\r') { if (ni + 1 < rawUtf8.size() && rawUtf8[ni + 1] == '\n') ++ni; utf8 += newlineStr; }
                        else if (rawUtf8[ni] == '\n') { utf8 += newlineStr; }
                        else { utf8.push_back(rawUtf8[ni]); }
                    }
                    if (isRect) insertRectangularBlock(utf8);
                    else if (isLine) {
                        bool hasAnySelection = false; for (const auto& c : cursors) if (c.hasSelection()) hasAnySelection = true;
                        if (hasAnySelection) insertAtCursors(utf8);
                        else { rollbackPadding(); rebuildLineStarts(); std::vector<size_t> relativeOffsets; for (auto& c : cursors) { int lineIdx = getLineIdx(c.head); size_t lineStart = lineStarts[lineIdx]; relativeOffsets.push_back((c.head > lineStart) ? (c.head - lineStart) : 0); c.head = lineStart; c.anchor = lineStart; } insertAtCursors(utf8); for (size_t i = 0; i < cursors.size(); ++i) { if (i < relativeOffsets.size()) { cursors[i].head += relativeOffsets[i]; cursors[i].anchor = cursors[i].head; cursors[i].desiredX = getXFromPos(cursors[i].head); } } ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE); }
                    }
                    else insertAtCursors(utf8);
                }
            } CloseClipboard();
        }
    }
    void doInsert(size_t pos, const std::string& s) { cursors.clear(); cursors.push_back({ pos, pos, getXFromPos(pos) }); insertAtCursors(s); }
    void performUndo() { clearEmmetTabstops(); rollbackPadding(); if (!undo.canUndo())return; EditBatch b = undo.popUndo(); for (int i = (int)b.ops.size() - 1; i >= 0; --i) { const auto& o = b.ops[i]; if (o.type == EditOp::Insert)pt.erase(o.pos, o.text.size()); else pt.insert(o.pos, o.text); }cursors = b.beforeCursors; rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); }
    void performRedo() { clearEmmetTabstops(); rollbackPadding(); if (!undo.canRedo())return; EditBatch b = undo.popRedo(); for (const auto& o : b.ops) { if (o.type == EditOp::Insert)pt.insert(o.pos, o.text); else pt.erase(o.pos, o.text.size()); }cursors = b.afterCursors; rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); }
    int ShowTaskDialog(const wchar_t* title, const wchar_t* instruction, const wchar_t* content, TASKDIALOG_COMMON_BUTTON_FLAGS buttons, PCWSTR icon) { return ShowCustomTaskDialog(hwnd, title, instruction, content, buttons, icon, isDarkMode); }
    bool checkUnsavedChanges() { if (!isDirty)return true; int r = ShowTaskDialog(GetResString(IDS_CONFIRM_TITLE).c_str(), GetResString(IDS_SAVE_PROMPT).c_str(), currentFilePath.empty() ? GetResString(IDS_UNTITLED).c_str() : currentFilePath.c_str(), TDCBF_YES_BUTTON | TDCBF_NO_BUTTON | TDCBF_CANCEL_BUTTON, TD_WARNING_ICON); if (r == IDCANCEL) return false; if (r == IDYES) { if (currentFilePath.empty()) return saveFileAs(); else return saveFile(currentFilePath); } return true; }
    bool openFile() { if (!checkUnsavedChanges()) return false; WCHAR f[MAX_PATH] = { 0 }; OPENFILENAMEW o = { 0 }; o.lStructSize = sizeof(o); o.hwndOwner = hwnd; o.lpstrFile = f; o.nMaxFile = MAX_PATH; o.lpstrFilter = L"All\0*.*\0Text\0*.txt\0"; o.nFilterIndex = 1; o.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST; std::wstring initialDir; if (!currentFilePath.empty()) { size_t lastSlash = currentFilePath.find_last_of(L"\\/"); if (lastSlash != std::wstring::npos) { initialDir = currentFilePath.substr(0, lastSlash); o.lpstrInitialDir = initialDir.c_str(); } } SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)hAppIcon); if (GetOpenFileNameW(&o)) return openFileFromPath(f); updateWindowIcon(); return false; }
    bool writeContentToHandle(HANDLE h) {
        std::string contentUtf8; size_t totalLen = pt.length(); if (totalLen > 0) contentUtf8 = pt.getRange(0, totalLen); bool ok = true; DWORD w = 0;
        if (currentEncoding == ENC_UTF16LE || currentEncoding == ENC_UTF16BE) {
            std::wstring wStr = Utf8ToUtf16(contentUtf8); unsigned char bomLE[] = { 0xFF, 0xFE }; unsigned char bomBE[] = { 0xFE, 0xFF };
            if (currentEncoding == ENC_UTF16LE) WriteFile(h, bomLE, 2, &w, NULL);
            else { WriteFile(h, bomBE, 2, &w, NULL); SwapBytes(&wStr[0], wStr.size()); }
            DWORD bytesToWrite = (DWORD)(wStr.size() * sizeof(wchar_t));
            if (!WriteFile(h, wStr.data(), bytesToWrite, &w, NULL) || w != bytesToWrite) ok = false;
        }
        else if (currentEncoding == ENC_LOCAL) {
            std::string localStr = Utf8ToLocal(contentUtf8, currentCodePage);
            if (!localStr.empty()) { if (!WriteFile(h, localStr.data(), (DWORD)localStr.size(), &w, NULL) || w != localStr.size()) ok = false; }
            else if (!contentUtf8.empty()) { if (!WriteFile(h, contentUtf8.data(), (DWORD)contentUtf8.size(), &w, NULL) || w != contentUtf8.size()) ok = false; }
        }
        else {
            if (currentEncoding == ENC_UTF8_BOM) { unsigned char bom[] = { 0xEF, 0xBB, 0xBF }; WriteFile(h, bom, 3, &w, NULL); }
            if (!contentUtf8.empty()) { if (!WriteFile(h, contentUtf8.data(), (DWORD)contentUtf8.size(), &w, NULL) || w != contentUtf8.size()) ok = false; }
        }
        return ok;
    }
    bool saveFileElevated(const std::wstring& p, const std::wstring& existingTempFile = L"");
    bool saveFile(const std::wstring& p);
    bool saveFileAs();
    uint32_t calcSampleHash(size_t start, size_t len) const noexcept {
        size_t docLen = pt.length();
        if (start > docLen) return 0;
        if (start + len > docLen) len = docLen - start;
        uint32_t h = 2166136261u ^ (uint32_t)(len & 0xFFFFFFFFu);
        size_t headSample = std::min(len, (size_t)64);
        for (size_t i = 0; i < headSample; ++i) {
            h ^= (uint8_t)pt.charAt(start + i);
            h *= 16777619u;
        }
        if (len > 64) {
            size_t tailSample = std::min(len - 64, (size_t)64);
            size_t tailStart = start + len - tailSample;
            for (size_t i = 0; i < tailSample; ++i) {
                h ^= (uint8_t)pt.charAt(tailStart + i);
                h *= 16777619u;
            }
        }
        return h;
    }
    size_t sanitizeUtf8Pos(size_t pos) const noexcept {
        size_t len = pt.length();
        if (pos >= len) return len;
        size_t steps = 0;
        while (pos > 0 && steps < 4 && (((unsigned char)pt.charAt(pos) & 0xC0) == 0x80)) {
            pos--;
            steps++;
        }
        if (pos > 0 && pos < len && pt.charAt(pos - 1) == '\r' && pt.charAt(pos) == '\n') {
            pos--;
        }
        return pos;
    }
    size_t resolveLineColSafe(uint32_t lineIdx, uint32_t colBytes) const noexcept {
        if (lineStarts.empty()) return 0;
        size_t clampedLine = std::min((size_t)lineIdx, lineStarts.size() - 1);
        size_t start = lineStarts[clampedLine];
        size_t end = (clampedLine + 1 < lineStarts.size()) ? lineStarts[clampedLine + 1] : pt.length();
        while (end > start && (pt.charAt(end - 1) == '\n' || pt.charAt(end - 1) == '\r')) {
            end--;
        }
        size_t maxCol = end - start;
        size_t target = start + std::min((size_t)colBytes, maxCol);
        size_t sanitized = sanitizeUtf8Pos(target);
        if (sanitized < start) sanitized = start;
        if (sanitized > end) sanitized = end;
        return sanitized;
    }
    void saveCurrentViewState();
    void restoreViewState(const std::wstring& path);
    void newFile() { if (!checkUnsavedChanges()) return; if (!currentFilePath.empty()) saveCurrentViewState(); pt.initEmpty(); currentFilePath.clear(); newlineStr = "\r\n"; undo.clear(); pendingPadding.ops.clear(); pendingPadding.beforeCursors.clear(); pendingPadding.afterCursors.clear(); clearEmmetTabstops(); isRectSelecting = false; isDirty = false; currentEncoding = ENC_UTF8_NOBOM; convertedBuffer.clear(); cursors.clear(); cursors.push_back({ 0,0,0.0f }); vScrollPos = 0; vScrollSubLine = 0; hScrollPos = 0; fileMap.reset(); rebuildLineStarts(); loadSyntaxForExtension(L""); updateSyntaxBrushes(); updateTitleBar(); updateWindowIcon(); lastWriteTime = { 0, 0 }; schedulePreviewUpdate(); InvalidateRect(hwnd, NULL, FALSE); }
    void selectNextOccurrence() { if (cursors.empty()) return; Cursor c = cursors.back(); if (!c.hasSelection()) { size_t targetPos = c.head; if (targetPos > 0) { char currChar = pt.charAt(targetPos); char prevChar = pt.charAt(targetPos - 1); if (!isWordChar(currChar) && isWordChar(prevChar)) targetPos--; } selectWordAt(targetPos); InvalidateRect(hwnd, NULL, FALSE); return; } size_t start = c.start(); size_t len = c.end() - start; std::string query = pt.getRange(start, len); size_t nextPos = findText(std::max(c.head, c.anchor), query, true, true, false, false); if (nextPos == std::string::npos) nextPos = findText(0, query, true, true, false, false); if (nextPos != std::string::npos) { for (const auto& cur : cursors) { if (cur.start() == nextPos) return; } cursors.push_back({ nextPos + len, nextPos, getXFromPos(nextPos + len) }); ensureCaretVisible(); InvalidateRect(hwnd, NULL, FALSE); } }
    bool openFileFromPath(const std::wstring& path, bool manageViewState = true);
    void indentLines(bool forceLineIndent = false) {
        bool hasSelection = false; for (const auto& c : cursors) if (c.hasSelection()) hasSelection = true; if (!hasSelection && !forceLineIndent) { insertAtCursors("\t"); return; }
        commitPadding(); std::vector<int> lines = getSelectedLineIndices(); if (lines.empty()) return; EditBatch batch; batch.beforeCursors = cursors; std::sort(lines.rbegin(), lines.rend());
        for (int lineIdx : lines) { size_t pos = lineStarts[lineIdx]; std::string indentStr = "\t"; pt.insert(pos, indentStr); batch.ops.push_back({ EditOp::Insert, pos, indentStr }); for (auto& c : cursors) { if (c.hasSelection()) { if (c.head > pos) c.head += indentStr.size(); if (c.anchor > pos) c.anchor += indentStr.size(); } else { if (c.head >= pos) c.head += indentStr.size(); if (c.anchor >= pos) c.anchor += indentStr.size(); } c.desiredX = getXFromPos(c.head); } }
        batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE);
    }
    void unindentLines() {
        commitPadding(); std::vector<int> lines = getSelectedLineIndices(); if (lines.empty()) return; EditBatch batch; batch.beforeCursors = cursors; std::sort(lines.rbegin(), lines.rend());
        for (int lineIdx : lines) { size_t pos = lineStarts[lineIdx]; if (pos >= pt.length()) continue; char c = pt.charAt(pos); size_t eraseLen = 0; if (c == '\t') eraseLen = 1; else if (c == ' ') eraseLen = 1; if (eraseLen > 0) { std::string deleted = pt.getRange(pos, eraseLen); pt.erase(pos, eraseLen); batch.ops.push_back({ EditOp::Erase, pos, deleted }); for (auto& c : cursors) { if (c.head > pos) c.head -= std::min(c.head - pos, eraseLen); if (c.anchor > pos) c.anchor -= std::min(c.anchor - pos, eraseLen); c.desiredX = getXFromPos(c.head); } } }
        if (!batch.ops.empty()) { batch.afterCursors = cursors; undo.push(batch); rebuildLineStarts(); ensureCaretVisible(); updateDirtyFlag(); InvalidateRect(hwnd, NULL, FALSE); }
    }
    void toggleComment() {
        if (currentSyntax.commentLine.empty() && (currentSyntax.commentBlockStart.empty() || currentSyntax.commentBlockEnd.empty())) {
            return;
        }
        commitPadding();
        std::vector<int> lines = getSelectedLineIndices();
        if (lines.empty()) return;
        EditBatch batch;
        batch.beforeCursors = cursors;

        struct LineCommentInfo {
            int lineIdx;
            size_t lineStart;
            std::string text;
            size_t firstNonWs;
            size_t lastNonWs;
            bool isBlank;
            bool isCommented;
            size_t openRemLen;
            size_t closeRemLen;
        };
        std::vector<LineCommentInfo> infos;
        infos.reserve(lines.size());

        bool useLineComment = !currentSyntax.commentLine.empty();
        const std::string& lineTok = currentSyntax.commentLine;
        const std::string& blkOpen = currentSyntax.commentBlockStart;
        const std::string& blkClose = currentSyntax.commentBlockEnd;
        bool isBat = useLineComment && (_stricmp(lineTok.c_str(), "REM") == 0);

        bool hasNonBlank = false;
        bool allCommented = true;
        size_t minIndent = SIZE_MAX;

        for (int lineIdx : lines) {
            if (lineIdx < 0 || lineIdx >= (int)lineStarts.size()) continue;
            size_t start = lineStarts[lineIdx];
            size_t end = (lineIdx + 1 < (int)lineStarts.size()) ? lineStarts[lineIdx + 1] : pt.length();
            std::string s = pt.getRange(start, end - start);
            while (!s.empty() && (s.back() == '\n' || s.back() == '\r')) s.pop_back();
            size_t f = 0;
            while (f < s.size() && (s[f] == ' ' || s[f] == '\t')) f++;
            size_t l = s.size();
            while (l > f && (s[l - 1] == ' ' || s[l - 1] == '\t')) l--;
            bool blank = (f >= s.size());
            bool commented = false;
            size_t openRem = 0;
            size_t closeRem = 0;

            if (!blank) {
                hasNonBlank = true;
                if (f < minIndent) minIndent = f;
                if (useLineComment) {
                    if (isBat) {
                        if (f + 2 <= s.size() && s.compare(f, 2, "::") == 0) {
                            commented = true;
                            openRem = (f + 2 < s.size() && s[f + 2] == ' ') ? 3 : 2;
                        } else if (f + 3 <= s.size() && _strnicmp(s.c_str() + f, "REM", 3) == 0 && (f + 3 == s.size() || s[f + 3] == ' ' || s[f + 3] == '\t')) {
                            commented = true;
                            openRem = (f + 3 < s.size() && s[f + 3] == ' ') ? 4 : 3;
                        }
                    } else if (f + lineTok.size() <= s.size() && s.compare(f, lineTok.size(), lineTok) == 0) {
                        commented = true;
                        openRem = (f + lineTok.size() < s.size() && s[f + lineTok.size()] == ' ') ? (lineTok.size() + 1) : lineTok.size();
                    }
                } else {
                    if (l - f >= blkOpen.size() + blkClose.size() &&
                        s.compare(f, blkOpen.size(), blkOpen) == 0 &&
                        s.compare(l - blkClose.size(), blkClose.size(), blkClose) == 0) {
                        commented = true;
                        openRem = (f + blkOpen.size() < l - blkClose.size() && s[f + blkOpen.size()] == ' ') ? (blkOpen.size() + 1) : blkOpen.size();
                        size_t closePos = l - blkClose.size();
                        closeRem = (closePos > f + openRem && s[closePos - 1] == ' ') ? (blkClose.size() + 1) : blkClose.size();
                    }
                }
                if (!commented) allCommented = false;
            }
            infos.push_back({ lineIdx, start, std::move(s), f, l, blank, commented, openRem, closeRem });
        }

        if (!hasNonBlank) allCommented = false;

        auto applyInsert = [&](size_t pos, const std::string& ins, bool advanceCaretAtPos) {
            pt.insert(pos, ins);
            batch.ops.push_back({ EditOp::Insert, pos, ins });
            size_t len = ins.size();
            for (auto& c : cursors) {
                if (c.hasSelection()) {
                    if (c.head > pos) c.head += len;
                    if (c.anchor > pos) c.anchor += len;
                } else {
                    if (advanceCaretAtPos ? (c.head >= pos) : (c.head > pos)) {
                        c.head += len;
                        c.anchor = c.head;
                    }
                }
            }
        };

        auto applyErase = [&](size_t pos, size_t rem) {
            if (rem == 0) return;
            std::string deleted = pt.getRange(pos, rem);
            pt.erase(pos, rem);
            batch.ops.push_back({ EditOp::Erase, pos, deleted });
            for (auto& c : cursors) {
                if (c.head > pos) c.head = (c.head >= pos + rem) ? (c.head - rem) : pos;
                if (c.anchor > pos) c.anchor = (c.anchor >= pos + rem) ? (c.anchor - rem) : pos;
            }
        };

        for (auto it = infos.rbegin(); it != infos.rend(); ++it) {
            const auto& info = *it;
            if (allCommented) {
                if (info.isBlank || !info.isCommented) continue;
                if (useLineComment) {
                    applyErase(info.lineStart + info.firstNonWs, info.openRemLen);
                } else {
                    size_t closeErasePos = info.lineStart + info.lastNonWs - info.closeRemLen;
                    applyErase(closeErasePos, info.closeRemLen);
                    applyErase(info.lineStart + info.firstNonWs, info.openRemLen);
                }
            } else {
                if (hasNonBlank && info.isBlank) continue;
                if (useLineComment) {
                    size_t indentOffset = hasNonBlank ? std::min(info.firstNonWs, minIndent) : info.text.size();
                    std::string ins = lineTok + " ";
                    applyInsert(info.lineStart + indentOffset, ins, true);
                } else {
                    if (!info.isBlank) {
                        std::string closeIns = " " + blkClose;
                        applyInsert(info.lineStart + info.lastNonWs, closeIns, false);
                        size_t indentOffset = std::min(info.firstNonWs, minIndent);
                        std::string openIns = blkOpen + " ";
                        applyInsert(info.lineStart + indentOffset, openIns, true);
                    } else {
                        size_t pos = info.lineStart + info.text.size();
                        std::string closeIns = " " + blkClose;
                        applyInsert(pos, closeIns, false);
                        std::string openIns = blkOpen + " ";
                        applyInsert(pos, openIns, true);
                    }
                }
            }
        }

        if (!batch.ops.empty()) {
            for (auto& c : cursors) {
                c.desiredX = getXFromPos(c.head, c.affinity);
            }
            batch.afterCursors = cursors;
            undo.push(batch);
            rebuildLineStarts();
            ensureCaretVisible();
            updateDirtyFlag();
            InvalidateRect(hwnd, NULL, FALSE);
        }
    }
    void insertNewlineWithAutoIndent() {
        commitPadding(); if (cursors.empty()) return; EditBatch batch; batch.beforeCursors = cursors; std::vector<int> indices(cursors.size()); for (size_t i = 0; i < cursors.size(); ++i) indices[i] = (int)i; std::sort(indices.begin(), indices.end(), [&](int a, int b) { return cursors[a].start() > cursors[b].start(); });
        for (int idx : indices) {
            Cursor& c = cursors[idx];
            size_t start = c.start();
            bool hadSel = c.hasSelection();
            if (hadSel) {
                size_t len = c.end() - start;
                std::string deleted = pt.getRange(start, len);
                pt.erase(start, len);
                batch.ops.push_back({ EditOp::Erase, start, deleted });
                for (auto& o : cursors) {
                    if (o.head > start) o.head -= len;
                    if (o.anchor > start) o.anchor -= len;
                }
                c.head = start;
                c.anchor = start;
            }
            int lineIdx = getLineIdx(start);
            size_t lineStart = lineStarts[lineIdx];
            std::string indentStr = "";
            size_t p = lineStart;
            size_t maxLen = pt.length();
            while (p < maxLen && p < start) {
                char ch = pt.charAt(p);
                if (ch == ' ' || ch == '\t') {
                    indentStr += ch;
                    p++;
                } else if (p + 2 < start && (unsigned char)ch == 0xE3 &&
                           (unsigned char)pt.charAt(p + 1) == 0x80 && (unsigned char)pt.charAt(p + 2) == 0x80) {
                    indentStr += "\xE3\x80\x80";
                    p += 3;
                } else {
                    break;
                }
            }
            bool betweenMatchingTags = false;
            if (!hadSel && start > lineStart && start + 3 < maxLen &&
                pt.charAt(start - 1) == '>' && pt.charAt(start) == '<' && pt.charAt(start + 1) == '/' &&
                (start < 2 || (pt.charAt(start - 2) != '/' && pt.charAt(start - 2) != '-'))) {
                size_t closeEnd = std::min(maxLen, start + (size_t)128);
                std::string afterStr = pt.getRange(start + 2, closeEnd - (start + 2));
                size_t closeNameLen = 0;
                while (closeNameLen < afterStr.size() && Emmet::isIdentChar(afterStr[closeNameLen])) {
                    closeNameLen++;
                }
                if (closeNameLen > 0) {
                    size_t gtPos = closeNameLen;
                    while (gtPos < afterStr.size() && (afterStr[gtPos] == ' ' || afterStr[gtPos] == '\t')) gtPos++;
                    if (gtPos < afterStr.size() && afterStr[gtPos] == '>') {
                        std::string closeTagName = Emmet::toLowerStr(afterStr.substr(0, closeNameLen));
                        std::string beforeLine = pt.getRange(lineStart, start - lineStart);
                        int lastOpenLt = -1;
                        char q = 0;
                        for (size_t k = 0; k + 1 < beforeLine.size(); ++k) {
                            char kc = beforeLine[k];
                            if (q != 0) {
                                if (kc == '\\' && k + 1 < beforeLine.size()) { k++; continue; }
                                if (kc == q) q = 0;
                            } else {
                                if (kc == '"' || kc == '\'') q = kc;
                                else if (kc == '<' && k + 1 < beforeLine.size() && Emmet::isAsciiAlpha(beforeLine[k + 1])) {
                                    lastOpenLt = (int)k;
                                } else if (kc == '>' && lastOpenLt != -1) {
                                    lastOpenLt = -1;
                                }
                            }
                        }
                        if (lastOpenLt != -1) {
                            size_t openNameStart = (size_t)lastOpenLt + 1;
                            size_t openNameLen = 0;
                            while (openNameStart + openNameLen < beforeLine.size() &&
                                   Emmet::isIdentChar(beforeLine[openNameStart + openNameLen])) {
                                openNameLen++;
                            }
                            if (openNameLen == closeNameLen &&
                                Emmet::toLowerStr(beforeLine.substr(openNameStart, openNameLen)) == closeTagName) {
                                betweenMatchingTags = true;
                            }
                        }
                    }
                }
            }
            std::string beforeCaret = betweenMatchingTags ? (newlineStr + indentStr + "\t") : (newlineStr + indentStr);
            std::string afterCaret = betweenMatchingTags ? (newlineStr + indentStr) : "";
            std::string textToInsert = beforeCaret + afterCaret;
            pt.insert(start, textToInsert);
            batch.ops.push_back({ EditOp::Insert, start, textToInsert });
            size_t totalInsLen = textToInsert.size();
            size_t caretAdvance = beforeCaret.size();
            for (auto& o : cursors) {
                if (&o == &c) continue;
                if (o.head >= start) o.head += totalInsLen;
                if (o.anchor >= start) o.anchor += totalInsLen;
            }
            c.head = start + caretAdvance;
            c.anchor = start + caretAdvance;
        }
        applyBatchToEmmetTabstops(batch);
        if (!emmetTabstops.empty() && cursors.size() == 1 && emmetTabstopIdx < emmetTabstops.size()) {
            if (emmetTabstopIdx + 1 >= emmetTabstops.size() - 1) {
                clearEmmetTabstops();
            } else {
                emmetTabstops[emmetTabstopIdx].startOffset = cursors[0].head;
            }
        }
        batch.afterCursors = cursors;
        undo.push(batch);
        rebuildLineStarts();
        for (auto& c : cursors) {
            c.desiredX = getXFromPos(c.head);
        }
        ensureCaretVisible();
        updateDirtyFlag();
        InvalidateRect(hwnd, NULL, FALSE);
    }
    void toggleFullScreen() {
        if (!hwnd) return; DWORD style = GetWindowLong(hwnd, GWL_STYLE);
        if (!isFullScreen) { if (GetWindowPlacement(hwnd, &prevPlacement)) { MONITORINFO mi = { sizeof(mi) }; if (GetMonitorInfo(MonitorFromWindow(hwnd, MONITOR_DEFAULTTOPRIMARY), &mi)) { SetWindowLong(hwnd, GWL_STYLE, style & ~WS_OVERLAPPEDWINDOW); SetWindowPos(hwnd, isAlwaysOnTop ? HWND_TOPMOST : HWND_TOP, mi.rcMonitor.left, mi.rcMonitor.top, mi.rcMonitor.right - mi.rcMonitor.left, mi.rcMonitor.bottom - mi.rcMonitor.top, SWP_NOOWNERZORDER | SWP_FRAMECHANGED); isFullScreen = true; } } }
        else { SetWindowLong(hwnd, GWL_STYLE, style | WS_OVERLAPPEDWINDOW); SetWindowPlacement(hwnd, &prevPlacement); SetWindowPos(hwnd, isAlwaysOnTop ? HWND_TOPMOST : HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOOWNERZORDER | SWP_FRAMECHANGED); isFullScreen = false; }
    }
    void toggleAlwaysOnTop() {
        if (!hwnd) return;
        isAlwaysOnTop = !isAlwaysOnTop;
        SetWindowPos(hwnd, isAlwaysOnTop ? HWND_TOPMOST : HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOOWNERZORDER);
        updateTitleBar();
    }
    struct WV2Handler { const void* const* lpVtbl; Editor* ed; };
    static HRESULT STDMETHODCALLTYPE wv2_QI(WV2Handler* self, REFIID, void** ppv);
    static ULONG STDMETHODCALLTYPE wv2_AddRefRelease(WV2Handler*);
    static HRESULT STDMETHODCALLTYPE wv2_EnvInvoke(WV2Handler* self, HRESULT err, IUnknown* env);
    static HRESULT STDMETHODCALLTYPE wv2_AccelInvoke(WV2Handler* self, IUnknown*, IUnknown* args);
    static HRESULT STDMETHODCALLTYPE wv2_NavInvoke(WV2Handler* self, IUnknown*, IUnknown* args);
    static HRESULT STDMETHODCALLTYPE wv2_PermInvoke(WV2Handler* self, IUnknown*, IUnknown* args);
    static HRESULT STDMETHODCALLTYPE wv2_NewWinInvoke(WV2Handler* self, IUnknown*, IUnknown* args);
    static HRESULT STDMETHODCALLTYPE wv2_CtrlInvoke(WV2Handler* self, HRESULT err, IUnknown* ctrl);
    void updatePreviewBounds();
    static std::wstring findWebView2Dll();
    void initWebView2Async();
    static std::string escapeHtmlBasic(const std::string& s);
    static std::string formatMarkdownInline(const std::string& s, int depth = 0);
    static std::string convertMarkdownToHtml(const std::string& md, int depth = 0);
    void updatePreviewContent();
    void togglePreview();
} g_editor;

#pragma optimize("s", on)
void Editor::initGraphics(HWND h) {
        hwnd = h; RECT rc; GetClientRect(hwnd, &rc); UINT width = rc.right - rc.left; UINT height = rc.bottom - rc.top;
        ID3D11Device* d3dDevice = nullptr; ID3D11DeviceContext* d3dContext = nullptr; UINT creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
        D3D_FEATURE_LEVEL featureLevels[] = { D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0 };
        D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, creationFlags, featureLevels, ARRAYSIZE(featureLevels), D3D11_SDK_VERSION, &d3dDevice, nullptr, &d3dContext);
        IDXGIDevice* dxgiDevice = nullptr; d3dDevice->QueryInterface(__uuidof(IDXGIDevice), (void**)&dxgiDevice);
        D2D1_FACTORY_OPTIONS options = {}; D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, __uuidof(ID2D1Factory1), &options, (void**)&d2dFactory);
        ID2D1Device* d2dDevice = nullptr; d2dFactory->CreateDevice(dxgiDevice, &d2dDevice); d2dDevice->CreateDeviceContext(D2D1_DEVICE_CONTEXT_OPTIONS_NONE, &rend);
        IDXGIFactory2* dxgiFactory = nullptr; CreateDXGIFactory2(0, __uuidof(IDXGIFactory2), (void**)&dxgiFactory);
        DXGI_SWAP_CHAIN_DESC1 description = {}; description.Format = DXGI_FORMAT_B8G8R8A8_UNORM; description.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; description.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; description.BufferCount = 2; description.SampleDesc.Count = 1; description.AlphaMode = DXGI_ALPHA_MODE_PREMULTIPLIED; description.Scaling = DXGI_SCALING_STRETCH; description.Width = width; description.Height = height;
        dxgiFactory->CreateSwapChainForComposition(dxgiDevice, &description, nullptr, &swapChain);
        DCompositionCreateDevice(dxgiDevice, __uuidof(IDCompositionDevice), (void**)&dcompDevice); dcompDevice->CreateTargetForHwnd(hwnd, FALSE, &dcompTarget);
        IDCompositionVisual* dcompVisual = nullptr; dcompDevice->CreateVisual(&dcompVisual); dcompVisual->SetContent(swapChain); dcompTarget->SetRoot(dcompVisual); dcompDevice->Commit();
        if (dcompVisual) dcompVisual->Release(); if (dxgiFactory) dxgiFactory->Release(); if (d2dDevice) d2dDevice->Release(); if (dxgiDevice) dxgiDevice->Release(); if (d3dContext) d3dContext->Release(); if (d3dDevice) d3dDevice->Release();
        DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), reinterpret_cast<IUnknown**>(&dwFactory));
        UINT dpi = GetDpiForWindow(hwnd); if (dpi == 0) dpi = 96; FLOAT dpix = (FLOAT)dpi; FLOAT dpiy = (FLOAT)dpi; dpiScaleX = dpix / 96.0f; dpiScaleY = dpiy / 96.0f; rend->SetDpi(dpix, dpiy);
        dwFactory->CreateTextFormat(L"Segoe UI", NULL, DWRITE_FONT_WEIGHT_BOLD, DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_STRETCH_NORMAL, 24.0f, L"en-us", &popupTextFormat);
        if (popupTextFormat) { popupTextFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_CENTER); popupTextFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_CENTER); }
        helpTextStr = APP_VERSION + GetResString(IDS_HELP_TEXT);
        dwFactory->CreateTextFormat(L"Consolas", NULL, DWRITE_FONT_WEIGHT_NORMAL, DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_STRETCH_NORMAL, 16.0f, L"en-us", &helpTextFormat);
        if (helpTextFormat) { helpTextFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_LEADING); helpTextFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_NEAR); }
        float dashes[] = { 2.0f, 2.0f }; D2D1_STROKE_STYLE_PROPERTIES props = D2D1::StrokeStyleProperties(D2D1_CAP_STYLE_FLAT, D2D1_CAP_STYLE_FLAT, D2D1_CAP_STYLE_FLAT, D2D1_LINE_JOIN_MITER, 10.0f, D2D1_DASH_STYLE_CUSTOM, 0.0f); d2dFactory->CreateStrokeStyle(&props, dashes, 2, &dotStyle);
        D2D1_STROKE_STYLE_PROPERTIES roundProps = D2D1::StrokeStyleProperties(D2D1_CAP_STYLE_ROUND, D2D1_CAP_STYLE_ROUND, D2D1_CAP_STYLE_ROUND, D2D1_LINE_JOIN_ROUND, 10.0f, D2D1_DASH_STYLE_SOLID, 0.0f); d2dFactory->CreateStrokeStyle(&roundProps, nullptr, 0, &roundJoinStyle);
        cfMsDevCol = RegisterClipboardFormatW(L"MSDEVColumnSelect"); cfMsDevLine = RegisterClipboardFormatW(L"MSDEVLineSelect");
        hAppIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON1));
        loadSyntaxForExtension(L"");
        updateThemeColors(); updateFont(currentFontSize); rebuildLineStarts(); cursors.push_back({ 0, 0, 0.0f }); updateTitleBar(); updateWindowIcon();
    }

void Editor::loadSyntaxForExtension(const std::wstring& ext) {
    loadSyntaxDefForExtension(ext, currentSyntax, currentExtension);
}

void Editor::updateThemeColors() {
        if (forceTheme == 1) isDarkMode = false;
        else if (forceTheme == 2) isDarkMode = true;
        else isDarkMode = checkSystemDarkMode();
        D2D1::ColorF accent = getWindowsAccentColor(0.5f); bool isTransparencyEnabled = true; HKEY hKey; DWORD val = 1; DWORD size = sizeof(DWORD);
        if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize", 0, KEY_READ, &hKey) == ERROR_SUCCESS) { if (RegQueryValueExW(hKey, L"EnableTransparency", NULL, NULL, (LPBYTE)&val, &size) == ERROR_SUCCESS) { isTransparencyEnabled = (val != 0); } RegCloseKey(hKey); }
        int backdropValue = DWMSBT_TRANSIENTWINDOW; bool isMicaEnabled = false;
        if (isTransparencyEnabled) { HRESULT hrMica = DwmSetWindowAttribute(hwnd, DWMWA_SYSTEMBACKDROP_TYPE, &backdropValue, sizeof(backdropValue)); isMicaEnabled = SUCCEEDED(hrMica); }
        float bgAlpha = isMicaEnabled ? 0.0f : 1.0f;
        if (keywordBrush) { keywordBrush->Release(); keywordBrush = nullptr; }
        if (literalBrush) { literalBrush->Release(); literalBrush = nullptr; }
        if (commentBrush) { commentBrush->Release(); commentBrush = nullptr; }
        if (stringBrush) { stringBrush->Release(); stringBrush = nullptr; }
        for (auto b : regexBrushes) b->Release();
        regexBrushes.clear();

        if (isDarkMode) {
            background = D2D1::ColorF(0.0f, 0.0f, 0.0f, bgAlpha); textColor = D2D1::ColorF(1.0f, 1.0f, 1.0f, 1.0f); gutterBg = D2D1::ColorF(0.0f, 0.0f, 0.0f, bgAlpha); gutterText = D2D1::ColorF(0.33f, 0.33f, 0.33f, 1.0f); selColor = accent; caretColor = D2D1::ColorF(1.0f, 1.0f, 1.0f, 1.0f); autoHlColor = D2D1::ColorF(0.35f, 0.35f, 0.35f, 0.5f); highlightColor = D2D1::ColorF(0.4f, 0.4f, 0.0f, 0.6f);
            if (rend) {
                rend->CreateSolidColorBrush(D2D1::ColorF(0.33f, 0.61f, 0.83f), &keywordBrush);
                rend->CreateSolidColorBrush(D2D1::ColorF(0.85f, 0.43f, 0.43f), &literalBrush);
                rend->CreateSolidColorBrush(D2D1::ColorF(0.38f, 0.62f, 0.38f), &commentBrush);
                rend->CreateSolidColorBrush(D2D1::ColorF(0.80f, 0.56f, 0.35f), &stringBrush);
                for (auto& r : currentSyntax.regexes) {
                    ID2D1SolidColorBrush* b = nullptr;
                    rend->CreateSolidColorBrush(D2D1::ColorF(r.second.r, r.second.g, r.second.b, r.second.a), &b);
                    regexBrushes.push_back(b);
                }
            }
        }
        else {
            background = D2D1::ColorF(1.0f, 1.0f, 1.0f, bgAlpha); textColor = D2D1::ColorF(0.0f, 0.0f, 0.0f, 1.0f); gutterBg = D2D1::ColorF(1.0f, 1.0f, 1.0f, bgAlpha); gutterText = D2D1::ColorF(0.66f, 0.66f, 0.66f, 1.0f); selColor = accent; caretColor = D2D1::ColorF(0.0f, 0.0f, 0.0f, 1.0f); autoHlColor = D2D1::ColorF(0.85f, 0.85f, 0.85f, 0.5f); highlightColor = D2D1::ColorF(1.0f, 1.0f, 0.0f, 0.4f);
            if (rend) {
                rend->CreateSolidColorBrush(D2D1::ColorF(0.0f, 0.0f, 1.0f), &keywordBrush);
                rend->CreateSolidColorBrush(D2D1::ColorF(0.6f, 0.0f, 0.0f), &literalBrush);
                rend->CreateSolidColorBrush(D2D1::ColorF(0.0f, 0.5f, 0.0f), &commentBrush);
                rend->CreateSolidColorBrush(D2D1::ColorF(0.6f, 0.2f, 0.0f), &stringBrush);
                for (auto& r : currentSyntax.regexes) {
                    ID2D1SolidColorBrush* b = nullptr;
                    rend->CreateSolidColorBrush(D2D1::ColorF(r.second.r, r.second.g, r.second.b, r.second.a), &b);
                    regexBrushes.push_back(b);
                }
            }
        }
        releaseCachedRenderBrushes();
        if (rend) {
            rend->CreateSolidColorBrush(textColor, &cachedTextBrush);
            rend->CreateSolidColorBrush(caretColor, &cachedCaretBrush);
            rend->CreateSolidColorBrush(D2D1::ColorF(caretColor.r, caretColor.g, caretColor.b, 0.5f), &cachedCaretOverwriteBrush);
            rend->CreateSolidColorBrush(selColor, &cachedSelBrush);
            rend->CreateSolidColorBrush(highlightColor, &cachedHlBrush);
            rend->CreateSolidColorBrush(autoHlColor, &cachedAutoHlBrush);
            rend->CreateSolidColorBrush(D2D1::ColorF(0.5f, 0.5f, 0.5f, 0.4f), &cachedBracketBrush);
            D2D1_COLOR_F wsColor = isDarkMode ? D2D1::ColorF(1.0f, 1.0f, 1.0f, 0.18f) : D2D1::ColorF(0.50f, 0.50f, 0.50f, 0.2f);
            rend->CreateSolidColorBrush(wsColor, &cachedWsBrush);
            rend->CreateSolidColorBrush(gutterBg, &cachedGutterBgBrush);
            rend->CreateSolidColorBrush(gutterText, &cachedGutterTextBrush);
            rend->CreateSolidColorBrush(D2D1::ColorF(128.0f / 255.0f, 128.0f / 255.0f, 128.0f / 255.0f, 0.38f), &cachedSbIdleBrush);
            rend->CreateSolidColorBrush(D2D1::ColorF(128.0f / 255.0f, 128.0f / 255.0f, 128.0f / 255.0f, 0.62f), &cachedSbActiveBrush);
            D2D1_COLOR_F borderCol = isDarkMode ? D2D1::ColorF(1.0f, 1.0f, 1.0f, 0.05f) : D2D1::ColorF(0.0f, 0.0f, 0.0f, 0.06f);
            rend->CreateSolidColorBrush(borderCol, &cachedSplitBrush);
            D2D1_COLOR_F sashCol = isDarkMode ? D2D1::ColorF(1.0f, 1.0f, 1.0f, 0.025f) : D2D1::ColorF(0.0f, 0.0f, 0.0f, 0.03f);
            rend->CreateSolidColorBrush(sashCol, &cachedSashBrush);
        }
        BOOL dark = isDarkMode; DwmSetWindowAttribute(hwnd, 20, &dark, sizeof(dark));
        if (isDarkMode) SetWindowTheme(hwnd, L"DarkMode_Explorer", NULL); else SetWindowTheme(hwnd, L"Explorer", NULL);
        EnableDarkModeForWindow(hwnd, isDarkMode);
        ApplyMenuTheme(isDarkMode);
        if (hFindDlg && IsWindow(hFindDlg)) {
            ApplyDialogTheme(hFindDlg, isDarkMode);
            InvalidateRect(hFindDlg, NULL, TRUE);
        }
        if (showPreview) schedulePreviewUpdate();
        if (hwnd) { SetWindowPos(hwnd, NULL, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED | SWP_NOACTIVATE); InvalidateRect(hwnd, NULL, TRUE); }
    }

void Editor::MeasureDialogText(HDC hdc, const std::wstring& text, int& outW, int& outH) {
        RECT rc1 = { 0, 0, 0, 0 };
        DrawTextW(hdc, text.c_str(), -1, &rc1, DT_CALCRECT | DT_SINGLELINE);
        RECT rc2 = { 0, 0, 0, 0 };
        DrawTextW(hdc, text.c_str(), -1, &rc2, DT_CALCRECT | DT_SINGLELINE | DT_NOPREFIX);
        SIZE sz = { 0, 0 };
        GetTextExtentPoint32W(hdc, text.c_str(), (int)text.size(), &sz);
        TEXTMETRICW tm = {};
        GetTextMetricsW(hdc, &tm);
        outW = (std::max)({ (int)(rc1.right - rc1.left), (int)(rc2.right - rc2.left), (int)sz.cx });
        outH = (std::max)({ (int)(rc1.bottom - rc1.top), (int)(rc2.bottom - rc2.top), (int)sz.cy, (int)(tm.tmHeight + tm.tmExternalLeading) });
    }
void Editor::AdjustAndPositionDialog(HWND hDlg, HWND hwndParent, int clientW, int clientH, UINT dpi, bool recenter) {
        DWORD style = (DWORD)GetWindowLongPtrW(hDlg, GWL_STYLE);
        DWORD exStyle = (DWORD)GetWindowLongPtrW(hDlg, GWL_EXSTYLE);
        RECT rcWin = { 0, 0, clientW, clientH };
        AdjustWindowRectExForDpi(&rcWin, style, FALSE, exStyle, dpi);
        int winW = rcWin.right - rcWin.left;
        int winH = rcWin.bottom - rcWin.top;
        RECT rcDlg;
        GetWindowRect(hDlg, &rcDlg);
        int x = rcDlg.left;
        int y = rcDlg.top;
        if (recenter && hwndParent) {
            RECT rcParent;
            GetWindowRect(hwndParent, &rcParent);
            x = rcParent.left + ((rcParent.right - rcParent.left) - winW) / 2;
            y = rcParent.top + ((rcParent.bottom - rcParent.top) - winH) / 2;
        }
        SetWindowPos(hDlg, NULL, x, y, winW, winH, SWP_NOZORDER | SWP_NOACTIVATE);
    }
void Editor::LayoutFindDialog(HWND hDlg, UINT overrideDpi, bool recenter) {
        Editor* pThis = (Editor*)GetWindowLongPtr(hDlg, GWLP_USERDATA);
        LANGID testLang = (LANGID)(UINT_PTR)GetPropW(hDlg, L"MiuLangId");
        if (testLang) SetThreadUILanguage(testLang);
        UINT dpi = overrideDpi;
        if (dpi == 0 && pThis && pThis->hwnd) dpi = GetDpiForWindow(pThis->hwnd);
        if (dpi == 0) dpi = GetDpiForWindow(hDlg);
        if (dpi == 0) dpi = 96;
        HFONT hDlgFont = EnsureDialogFontForDpi(hDlg, dpi);

        std::wstring sFindLbl = GetResString(IDS_FIND_LABEL);
        std::wstring sRepLbl  = GetResString(IDS_REPLACE_LABEL);
        std::wstring sCase    = GetResString(IDS_FIND_CASE);
        std::wstring sWord    = GetResString(IDS_FIND_WORD);
        std::wstring sRegex   = GetResString(IDS_FIND_REGEX);
        std::wstring sNextBtn = GetResString(IDS_FIND_NEXT);
        std::wstring sRepBtn  = GetResString(IDS_REPLACE_BTN);
        std::wstring sAllBtn  = GetResString(IDS_REPLACE_ALL_BTN);
        std::wstring sFindCap = GetResString(IDS_FIND_TITLE);
        std::wstring sRepCap  = GetResString(IDS_REPLACE_TITLE);

        SetDlgItemTextW(hDlg, IDC_FIND_LABEL, sFindLbl.c_str());
        SetDlgItemTextW(hDlg, IDC_REPLACE_LABEL, sRepLbl.c_str());
        SetDlgItemTextW(hDlg, IDC_FIND_CASE, sCase.c_str());
        SetDlgItemTextW(hDlg, IDC_FIND_WORD, sWord.c_str());
        SetDlgItemTextW(hDlg, IDC_FIND_REGEX, sRegex.c_str());
        SetDlgItemTextW(hDlg, IDC_FIND_NEXT, sNextBtn.c_str());
        SetDlgItemTextW(hDlg, IDC_REPLACE_BTN, sRepBtn.c_str());
        SetDlgItemTextW(hDlg, IDC_REPLACE_ALL_BTN, sAllBtn.c_str());

        HDC hdc = GetDC(hDlg);
        HFONT hFont = hDlgFont;
        HFONT hOldFont = hFont ? (HFONT)SelectObject(hdc, hFont) : NULL;

        int findLblW, findLblH, repLblW, repLblH, caseW, caseH, wordW, wordH, regexW, regexH;
        int nextBtnW, nextBtnH, repBtnW, repBtnH, allBtnW, allBtnH, findCapW, findCapH, repCapW, repCapH;
        MeasureDialogText(hdc, sFindLbl, findLblW, findLblH);
        MeasureDialogText(hdc, sRepLbl, repLblW, repLblH);
        MeasureDialogText(hdc, sCase, caseW, caseH);
        MeasureDialogText(hdc, sWord, wordW, wordH);
        MeasureDialogText(hdc, sRegex, regexW, regexH);
        MeasureDialogText(hdc, sNextBtn, nextBtnW, nextBtnH);
        MeasureDialogText(hdc, sRepBtn, repBtnW, repBtnH);
        MeasureDialogText(hdc, sAllBtn, allBtnW, allBtnH);
        MeasureDialogText(hdc, sFindCap, findCapW, findCapH);
        MeasureDialogText(hdc, sRepCap, repCapW, repCapH);

        if (hOldFont) SelectObject(hdc, hOldFont);
        ReleaseDC(hDlg, hdc);

        int marginX = MulDiv(10, dpi, 96);
        int marginY = MulDiv(10, dpi, 96);
        int gapX    = MulDiv(8, dpi, 96);
        int rowGapY = MulDiv(6, dpi, 96);
        int maxTextH = (std::max)({ findLblH, repLblH, caseH, wordH, regexH, nextBtnH, repBtnH, allBtnH, MulDiv(15, dpi, 96) });

        int labelPadW = MulDiv(10, dpi, 96);
        int labelW = (std::max)({ MulDiv(56, dpi, 96), findLblW + labelPadW, repLblW + labelPadW });
        int labelH = maxTextH + MulDiv(4, dpi, 96);
        int editH  = (std::max)(MulDiv(23, dpi, 96), maxTextH + MulDiv(8, dpi, 96));

        int checkX = marginX + MulDiv(4, dpi, 96);
        int checkBoxAndGapW = MulDiv(28, dpi, 96);
        int checkReqW = (std::max)({ caseW, wordW, regexW }) + checkBoxAndGapW;
        int checkH = (std::max)(MulDiv(20, dpi, 96), maxTextH + MulDiv(6, dpi, 96));

        int btnPadW = MulDiv(24, dpi, 96);
        int wReplaceAll = (std::max)(MulDiv(88, dpi, 96), allBtnW + btnPadW);
        int wReplace    = (std::max)(MulDiv(76, dpi, 96), repBtnW + btnPadW);
        int wFindNext   = (std::max)(MulDiv(92, dpi, 96), nextBtnW + btnPadW);
        int btnH        = (std::max)(MulDiv(25, dpi, 96), maxTextH + MulDiv(8, dpi, 96));
        int buttonsTotalW = wReplaceAll + gapX + wReplace + gapX + wFindNext;

        int minEditW = MulDiv(180, dpi, 96);
        int titleReqW = (std::max)(findCapW, repCapW) + MulDiv(100, dpi, 96);
        int clientW = (std::max)({
            MulDiv(340, dpi, 96),
            marginX + labelW + gapX + minEditW + marginX,
            checkX + checkReqW + marginX,
            marginX + buttonsTotalW + marginX,
            titleReqW
        });

        int editX = marginX + labelW + gapX;
        int editW = clientW - editX - marginX;
        int y1 = marginY;
        int label1Y = y1 + (editH - findLblH) / 2;
        int y2 = y1 + editH + rowGapY;
        int label2Y = y2 + (editH - repLblH) / 2;
        int yCase = y2 + editH + MulDiv(8, dpi, 96);
        int checkGapY = MulDiv(4, dpi, 96);
        int yWord = yCase + checkH + checkGapY;
        int yRegex = yWord + checkH + checkGapY;
        int checkW = clientW - checkX - marginX;
        int yBtn = yRegex + checkH + MulDiv(10, dpi, 96);
        int xFindNext = clientW - marginX - wFindNext;
        int xReplace  = xFindNext - gapX - wReplace;
        int xReplaceAll = xReplace - gapX - wReplaceAll;
        int clientH = yBtn + btnH + marginY;

        DWORD swpFlags = SWP_NOZORDER | SWP_NOACTIVATE;
        SetWindowPos(GetDlgItem(hDlg, IDC_FIND_LABEL), NULL, marginX, label1Y, labelW, labelH, swpFlags);
        SetWindowPos(GetDlgItem(hDlg, IDC_FIND_EDIT), NULL, editX, y1, editW, editH, swpFlags);
        SetWindowPos(GetDlgItem(hDlg, IDC_REPLACE_LABEL), NULL, marginX, label2Y, labelW, labelH, swpFlags);
        SetWindowPos(GetDlgItem(hDlg, IDC_REPLACE_EDIT), NULL, editX, y2, editW, editH, swpFlags);
        SetWindowSubclass(GetDlgItem(hDlg, IDC_FIND_EDIT), DialogEditImeSubclassProc, IDC_FIND_EDIT, 0);
        SetWindowSubclass(GetDlgItem(hDlg, IDC_REPLACE_EDIT), DialogEditImeSubclassProc, IDC_REPLACE_EDIT, 0);
        SetWindowPos(GetDlgItem(hDlg, IDC_FIND_CASE), NULL, checkX, yCase, checkW, checkH, swpFlags);
        SetWindowPos(GetDlgItem(hDlg, IDC_FIND_WORD), NULL, checkX, yWord, checkW, checkH, swpFlags);
        SetWindowPos(GetDlgItem(hDlg, IDC_FIND_REGEX), NULL, checkX, yRegex, checkW, checkH, swpFlags);
        SetWindowPos(GetDlgItem(hDlg, IDC_REPLACE_ALL_BTN), NULL, xReplaceAll, yBtn, wReplaceAll, btnH, swpFlags);
        SetWindowPos(GetDlgItem(hDlg, IDC_REPLACE_BTN), NULL, xReplace, yBtn, wReplace, btnH, swpFlags);
        SetWindowPos(GetDlgItem(hDlg, IDC_FIND_NEXT), NULL, xFindNext, yBtn, wFindNext, btnH, swpFlags);

        AdjustAndPositionDialog(hDlg, pThis ? pThis->hwnd : NULL, clientW, clientH, dpi, recenter);
    }
void Editor::updateFindReplaceUI(HWND dlg, bool replaceMode) {
        if (!dlg) return; isReplaceMode = replaceMode; int show = replaceMode ? SW_SHOW : SW_HIDE; ShowWindow(GetDlgItem(dlg, IDC_REPLACE_LABEL), show); ShowWindow(GetDlgItem(dlg, IDC_REPLACE_EDIT), show); ShowWindow(GetDlgItem(dlg, IDC_REPLACE_BTN), show); ShowWindow(GetDlgItem(dlg, IDC_REPLACE_ALL_BTN), show); SetWindowTextW(dlg, replaceMode ? GetResString(IDS_REPLACE_TITLE).c_str() : GetResString(IDS_FIND_TITLE).c_str());
    }
INT_PTR CALLBACK Editor::FindDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
        Editor* pThis = (Editor*)GetWindowLongPtr(hDlg, GWLP_USERDATA);
        switch (message) {
        case WM_INITDIALOG:
            pThis = (Editor*)lParam; SetWindowLongPtr(hDlg, GWLP_USERDATA, (LONG_PTR)pThis);
            if (pThis && pThis->isDarkMode) {
                ApplyDialogTheme(hDlg, true);
            }
            SetDlgItemTextW(hDlg, IDC_FIND_EDIT, UTF8ToW(pThis->searchQuery).c_str()); SetDlgItemTextW(hDlg, IDC_REPLACE_EDIT, UTF8ToW(pThis->replaceQuery).c_str()); CheckDlgButton(hDlg, IDC_FIND_CASE, pThis->searchMatchCase ? BST_CHECKED : BST_UNCHECKED); CheckDlgButton(hDlg, IDC_FIND_WORD, pThis->searchWholeWord ? BST_CHECKED : BST_UNCHECKED); CheckDlgButton(hDlg, IDC_FIND_REGEX, pThis->searchRegex ? BST_CHECKED : BST_UNCHECKED);
            LayoutFindDialog(hDlg, 0, true);
            pThis->updateFindReplaceUI(hDlg, pThis->isReplaceMode); SetFocus(GetDlgItem(hDlg, IDC_FIND_EDIT)); SendMessage(GetDlgItem(hDlg, IDC_FIND_EDIT), EM_SETSEL, 0, -1); SyncEditImePosition(GetDlgItem(hDlg, IDC_FIND_EDIT)); return FALSE;
        case WM_DPICHANGED:
            PostMessageW(hDlg, WM_THEMECHANGED, wParam, 0);
        case WM_THEMECHANGED:
            LayoutFindDialog(hDlg, HIWORD(wParam), false);
            if (pThis) pThis->updateFindReplaceUI(hDlg, pThis->isReplaceMode);
            InvalidateRect(hDlg, NULL, TRUE);
            return TRUE;
        case WM_NCDESTROY: {
            HFONT hFont = (HFONT)RemovePropW(hDlg, L"MiuDlgFont");
            if (hFont) DeleteObject(hFont);
            RemovePropW(hDlg, L"MiuDlgDpi");
            RemovePropW(hDlg, L"MiuLangId");
            break;
        }
        case WM_CTLCOLORDLG:
            if (pThis && pThis->isDarkMode) {
                static HBRUSH hbrDark = CreateSolidBrush(RGB(32, 32, 32));
                return (INT_PTR)hbrDark;
            }
            break;
        case WM_CTLCOLORSTATIC:
            if (pThis && pThis->isDarkMode) {
                HDC hdc = (HDC)wParam;
                SetBkMode(hdc, TRANSPARENT);
                SetTextColor(hdc, RGB(230, 230, 230));
                static HBRUSH hbrDark = CreateSolidBrush(RGB(32, 32, 32));
                return (INT_PTR)hbrDark;
            }
            break;
        case WM_CTLCOLOREDIT:
            if (pThis && pThis->isDarkMode) {
                HDC hdc = (HDC)wParam;
                SetBkColor(hdc, RGB(30, 30, 30));
                SetTextColor(hdc, RGB(255, 255, 255));
                static HBRUSH hbrDarkEdit = CreateSolidBrush(RGB(30, 30, 30));
                return (INT_PTR)hbrDarkEdit;
            }
            break;
        case WM_ACTIVATE: if (LOWORD(wParam) == WA_ACTIVE || LOWORD(wParam) == WA_CLICKACTIVE) { HWND hEdit = GetDlgItem(hDlg, IDC_FIND_EDIT); if (hEdit) { SetFocus(hEdit); SendMessage(hEdit, EM_SETSEL, 0, -1); SyncEditImePosition(hEdit); } } return FALSE;
        case WM_COMMAND:
            if (LOWORD(wParam) == IDC_FIND_CASE || LOWORD(wParam) == IDC_FIND_WORD || LOWORD(wParam) == IDC_FIND_REGEX) { bool bCase = IsDlgButtonChecked(hDlg, IDC_FIND_CASE) == BST_CHECKED; bool bWord = IsDlgButtonChecked(hDlg, IDC_FIND_WORD) == BST_CHECKED; bool bRegex = IsDlgButtonChecked(hDlg, IDC_FIND_REGEX) == BST_CHECKED; pThis->updateSearchFlags(bCase, bWord, bRegex); InvalidateRect(pThis->hwnd, NULL, FALSE); }
            if (HIWORD(wParam) == EN_CHANGE) { wchar_t wbuf[1024]; if (LOWORD(wParam) == IDC_FIND_EDIT) { GetDlgItemTextW(hDlg, IDC_FIND_EDIT, wbuf, 1024); pThis->updateSearchQuery(WToUTF8(wbuf)); InvalidateRect(pThis->hwnd, NULL, FALSE); } if (LOWORD(wParam) == IDC_REPLACE_EDIT) { GetDlgItemTextW(hDlg, IDC_REPLACE_EDIT, wbuf, 1024); pThis->replaceQuery = WToUTF8(wbuf); } }
            if (LOWORD(wParam) == IDC_FIND_NEXT || LOWORD(wParam) == IDOK) { pThis->findNext(true); return TRUE; }
            if (LOWORD(wParam) == IDC_REPLACE_BTN) { if (!pThis->isReplaceMode) return TRUE; pThis->replaceNext(); return TRUE; }
            if (LOWORD(wParam) == IDC_REPLACE_ALL_BTN) { if (!pThis->isReplaceMode) return TRUE; pThis->replaceAll(); return TRUE; }
            if (LOWORD(wParam) == IDC_FIND_CANCEL || LOWORD(wParam) == IDCANCEL) { DestroyWindow(hDlg); pThis->hFindDlg = NULL; return TRUE; }
            break;
        } return FALSE;
    }
void Editor::showFindDialog(bool replaceMode) {
        isReplaceMode = replaceMode;
        if (hFindDlg) {
            updateFindReplaceUI(hFindDlg, isReplaceMode);
            HWND hFocus = GetFocus();
            if (!hFocus || (hFocus != hFindDlg && !IsChild(hFindDlg, hFocus))) {
                HWND hEdit = GetDlgItem(hFindDlg, IDC_FIND_EDIT);
                if (hEdit) SetFocus(hEdit);
                else SetFocus(hFindDlg);
            } else if (!isReplaceMode && hFocus == GetDlgItem(hFindDlg, IDC_REPLACE_EDIT)) {
                HWND hEdit = GetDlgItem(hFindDlg, IDC_FIND_EDIT);
                if (hEdit) SetFocus(hEdit);
            }
            return;
        }
        auto [candidate, _] = getHighlightTarget(); bool hasSelection = !cursors.empty() && cursors.back().hasSelection(); bool shouldUpdate = false;
        if (hasSelection) { if (!candidate.empty()) shouldUpdate = true; }
        else { if (searchQuery.empty() && !candidate.empty()) shouldUpdate = true; }
        if (shouldUpdate) updateSearchQuery(candidate);
        hFindDlg = CreateDialogParamW(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_FIND_DIALOG), hwnd, FindDlgProc, (LPARAM)this); ShowWindow(hFindDlg, SW_SHOW);
    }

void Editor::LayoutGoToDialog(HWND hDlg, UINT overrideDpi, bool recenter) {
        Editor* pThis = (Editor*)GetWindowLongPtr(hDlg, GWLP_USERDATA);
        LANGID testLang = (LANGID)(UINT_PTR)GetPropW(hDlg, L"MiuLangId");
        if (testLang) SetThreadUILanguage(testLang);
        UINT dpi = overrideDpi;
        if (dpi == 0 && pThis && pThis->hwnd) dpi = GetDpiForWindow(pThis->hwnd);
        if (dpi == 0) dpi = GetDpiForWindow(hDlg);
        if (dpi == 0) dpi = 96;
        HFONT hDlgFont = EnsureDialogFontForDpi(hDlg, dpi);

        std::wstring sTitle  = GetResString(IDS_GOTO_TITLE);
        std::wstring sFmt    = GetResString(IDS_GOTO_LABEL);
        std::wstring sOk     = GetResString(IDS_BTN_OK);
        std::wstring sCancel = GetResString(IDS_BTN_CANCEL);

        int maxLineCount = pThis ? (int)pThis->lineStarts.size() : 1;
        auto formatGotoLabel = [&sFmt](int count) -> std::wstring {
            std::wstring res = sFmt;
            size_t pos = res.find(L"%d");
            if (pos != std::wstring::npos) res.replace(pos, 2, std::to_wstring(count));
            return res;
        };
        std::wstring sLabel = formatGotoLabel(maxLineCount);
        std::wstring sLabelWide = formatGotoLabel((std::max)(maxLineCount, 999999));

        SetWindowTextW(hDlg, sTitle.c_str());
        SetDlgItemTextW(hDlg, IDC_GOTO_LABEL, sLabel.c_str());
        SetDlgItemTextW(hDlg, IDOK, sOk.c_str());
        SetDlgItemTextW(hDlg, IDCANCEL, sCancel.c_str());

        HDC hdc = GetDC(hDlg);
        HFONT hFont = hDlgFont;
        HFONT hOldFont = hFont ? (HFONT)SelectObject(hdc, hFont) : NULL;

        int lblW1, lblH1, lblW2, lblH2, okW, okH, cancelW, cancelH, titleW, titleH;
        MeasureDialogText(hdc, sLabel, lblW1, lblH1);
        MeasureDialogText(hdc, sLabelWide, lblW2, lblH2);
        MeasureDialogText(hdc, sOk, okW, okH);
        MeasureDialogText(hdc, sCancel, cancelW, cancelH);
        MeasureDialogText(hdc, sTitle, titleW, titleH);

        if (hOldFont) SelectObject(hdc, hOldFont);
        ReleaseDC(hDlg, hdc);

        int gotoLblW = (std::max)(lblW1, lblW2);
        int maxTextH = (std::max)({ lblH1, lblH2, okH, cancelH, MulDiv(15, dpi, 96) });

        int marginX = MulDiv(12, dpi, 96);
        int marginY = MulDiv(10, dpi, 96);
        int gapX    = MulDiv(8, dpi, 96);
        int labelH  = maxTextH + MulDiv(4, dpi, 96);
        int editH   = (std::max)(MulDiv(23, dpi, 96), maxTextH + MulDiv(8, dpi, 96));
        int btnPadW = MulDiv(24, dpi, 96);
        int wOk     = (std::max)(MulDiv(76, dpi, 96), okW + btnPadW);
        int wCancel = (std::max)(MulDiv(76, dpi, 96), cancelW + btnPadW);
        int btnH    = (std::max)(MulDiv(25, dpi, 96), maxTextH + MulDiv(8, dpi, 96));

        int clientW = (std::max)({
            MulDiv(250, dpi, 96),
            marginX * 2 + gotoLblW + MulDiv(12, dpi, 96),
            marginX * 2 + wOk + gapX + wCancel,
            titleW + MulDiv(100, dpi, 96)
        });
        int innerW  = clientW - marginX * 2;
        int yLabel  = marginY;
        int yEdit   = yLabel + labelH + MulDiv(4, dpi, 96);
        int yBtn    = yEdit + editH + MulDiv(10, dpi, 96);
        int xCancel = clientW - marginX - wCancel;
        int xOk     = xCancel - gapX - wOk;
        int clientH = yBtn + btnH + marginY;

        DWORD swpFlags = SWP_NOZORDER | SWP_NOACTIVATE;
        SetWindowPos(GetDlgItem(hDlg, IDC_GOTO_LABEL), NULL, marginX, yLabel, innerW, labelH, swpFlags);
        SetWindowPos(GetDlgItem(hDlg, IDC_GOTO_EDIT), NULL, marginX, yEdit, innerW, editH, swpFlags);
        SetWindowSubclass(GetDlgItem(hDlg, IDC_GOTO_EDIT), DialogEditImeSubclassProc, IDC_GOTO_EDIT, 0);
        SetWindowPos(GetDlgItem(hDlg, IDOK), NULL, xOk, yBtn, wOk, btnH, swpFlags);
        SetWindowPos(GetDlgItem(hDlg, IDCANCEL), NULL, xCancel, yBtn, wCancel, btnH, swpFlags);

        AdjustAndPositionDialog(hDlg, pThis ? pThis->hwnd : NULL, clientW, clientH, dpi, recenter);
    }
INT_PTR CALLBACK Editor::GoToDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
        Editor* pThis = (Editor*)GetWindowLongPtr(hDlg, GWLP_USERDATA);
        switch (message) {
        case WM_INITDIALOG:
            pThis = (Editor*)lParam; SetWindowLongPtr(hDlg, GWLP_USERDATA, (LONG_PTR)pThis);
            if (pThis && pThis->isDarkMode) {
                ApplyDialogTheme(hDlg, true);
            }
            LayoutGoToDialog(hDlg, 0, true);
            { size_t curPos = pThis->cursors.empty() ? 0 : pThis->cursors.back().head; int curLine = pThis->getLineIdx(curPos) + 1; SetDlgItemInt(hDlg, IDC_GOTO_EDIT, curLine, FALSE); SetFocus(GetDlgItem(hDlg, IDC_GOTO_EDIT)); SendMessage(GetDlgItem(hDlg, IDC_GOTO_EDIT), EM_SETSEL, 0, -1); } return FALSE;
        case WM_DPICHANGED:
            PostMessageW(hDlg, WM_THEMECHANGED, wParam, 0);
        case WM_THEMECHANGED:
            LayoutGoToDialog(hDlg, HIWORD(wParam), false);
            InvalidateRect(hDlg, NULL, TRUE);
            return TRUE;
        case WM_NCDESTROY: {
            HFONT hFont = (HFONT)RemovePropW(hDlg, L"MiuDlgFont");
            if (hFont) DeleteObject(hFont);
            RemovePropW(hDlg, L"MiuDlgDpi");
            RemovePropW(hDlg, L"MiuLangId");
            break;
        }
        case WM_CTLCOLORDLG:
            if (pThis && pThis->isDarkMode) {
                static HBRUSH hbrDark = CreateSolidBrush(RGB(32, 32, 32));
                return (INT_PTR)hbrDark;
            }
            break;
        case WM_CTLCOLORSTATIC:
            if (pThis && pThis->isDarkMode) {
                HDC hdc = (HDC)wParam;
                SetBkMode(hdc, TRANSPARENT);
                SetTextColor(hdc, RGB(230, 230, 230));
                static HBRUSH hbrDark = CreateSolidBrush(RGB(32, 32, 32));
                return (INT_PTR)hbrDark;
            }
            break;
        case WM_CTLCOLOREDIT:
            if (pThis && pThis->isDarkMode) {
                HDC hdc = (HDC)wParam;
                SetBkColor(hdc, RGB(30, 30, 30));
                SetTextColor(hdc, RGB(255, 255, 255));
                static HBRUSH hbrDarkEdit = CreateSolidBrush(RGB(30, 30, 30));
                return (INT_PTR)hbrDarkEdit;
            }
            break;
        case WM_COMMAND: if (LOWORD(wParam) == IDOK) { BOOL translated = FALSE; int line = GetDlgItemInt(hDlg, IDC_GOTO_EDIT, &translated, FALSE); if (translated) pThis->gotoLine(line); EndDialog(hDlg, IDOK); return TRUE; } if (LOWORD(wParam) == IDCANCEL) { EndDialog(hDlg, IDCANCEL); return TRUE; } break;
        } return FALSE;
    }
void Editor::showGoToDialog() { DialogBoxParamW(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_GOTO_DIALOG), hwnd, GoToDlgProc, (LPARAM)this); }

bool Editor::saveFileElevated(const std::wstring& p, const std::wstring& existingTempFile) {
        if (p.empty() || p.find(L'"') != std::wstring::npos) return false;
        DWORD dstAttr = GetFileAttributesW(p.c_str());
        if (dstAttr != INVALID_FILE_ATTRIBUTES && (dstAttr & FILE_ATTRIBUTE_REPARSE_POINT)) {
            ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), GetResString(IDS_WRITE_ERR).c_str(), p.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
            return false;
        }
        int r = ShowTaskDialog(GetResString(IDS_APP_TITLE).c_str(), GetResString(IDS_ELEVATED_SAVE_PROMPT).c_str(), p.c_str(), TDCBF_YES_BUTTON | TDCBF_NO_BUTTON, TD_SHIELD_ICON);
        if (r != IDYES) {
            return false;
        }
        std::wstring tempPath;
        bool deleteTempOnDone = false;
        if (!existingTempFile.empty()) {
            tempPath = existingTempFile;
            deleteTempOnDone = true;
        } else {
            wchar_t sysTempDir[MAX_PATH] = { 0 };
            wchar_t sysTempFile[MAX_PATH] = { 0 };
            if (GetTempPathW(MAX_PATH, sysTempDir) == 0 || GetTempFileNameW(sysTempDir, L"miu", 0, sysTempFile) == 0) {
                ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), GetResString(IDS_TEMP_FILE_ERR).c_str(), p.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
                return false;
            }
            HANDLE h = CreateFileW(sysTempFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
            if (h == INVALID_HANDLE_VALUE) {
                ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), GetResString(IDS_TEMP_FILE_ERR).c_str(), sysTempFile, TDCBF_OK_BUTTON, TD_ERROR_ICON);
                return false;
            }
            bool ok = writeContentToHandle(h);
            CloseHandle(h);
            if (!ok) {
                DeleteFileW(sysTempFile);
                ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), GetResString(IDS_WRITE_ERR).c_str(), p.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
                return false;
            }
            tempPath = sysTempFile;
            deleteTempOnDone = true;
        }
        if (tempPath.find(L'"') != std::wstring::npos) {
            if (deleteTempOnDone) DeleteFileW(tempPath.c_str());
            return false;
        }
        HANDLE hReadLock = CreateFileW(tempPath.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OPEN_REPARSE_POINT, NULL);
        if (hReadLock == INVALID_HANDLE_VALUE) {
            if (deleteTempOnDone) DeleteFileW(tempPath.c_str());
            ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), GetResString(IDS_TEMP_FILE_ERR).c_str(), tempPath.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
            return false;
        }
        BY_HANDLE_FILE_INFORMATION bhfi = {};
        if (!GetFileInformationByHandle(hReadLock, &bhfi) || (bhfi.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) {
            CloseHandle(hReadLock);
            if (deleteTempOnDone) DeleteFileW(tempPath.c_str());
            return false;
        }
        wchar_t exePath[MAX_PATH] = { 0 };
        GetModuleFileNameW(NULL, exePath, MAX_PATH);
        std::wstring params = L"--elevated-save \"" + tempPath + L"\" \"" + p + L"\"";
        SHELLEXECUTEINFOW sei = { sizeof(sei) };
        sei.cbSize = sizeof(sei);
        sei.fMask = SEE_MASK_NOCLOSEPROCESS;
        sei.hwnd = hwnd;
        sei.lpVerb = L"runas";
        sei.lpFile = exePath;
        sei.lpParameters = params.c_str();
        sei.nShow = SW_HIDE;
        if (!ShellExecuteExW(&sei)) {
            DWORD err = GetLastError();
            CloseHandle(hReadLock);
            if (deleteTempOnDone) DeleteFileW(tempPath.c_str());
            if (err != ERROR_CANCELLED) {
                std::wstring msg = GetResString(IDS_SAVE_ERR) + std::to_wstring(err);
                ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), msg.c_str(), p.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
            }
            return false;
        }
        WaitForSingleObject(sei.hProcess, 30000);
        DWORD exitCode = 1;
        GetExitCodeProcess(sei.hProcess, &exitCode);
        CloseHandle(sei.hProcess);
        CloseHandle(hReadLock);
        if (deleteTempOnDone) DeleteFileW(tempPath.c_str());
        if (exitCode != 0) {
            std::wstring msg = GetResString(IDS_SAVE_ERR) + std::to_wstring(exitCode);
            ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), msg.c_str(), p.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
            return false;
        }
        std::vector<Cursor> savedCursors = cursors; int savedV = vScrollPos; int savedSubV = vScrollSubLine; int savedH = hScrollPos;
        if (fileMap) fileMap->close();
        if (!openFileFromPath(p, false)) {
            ShowTaskDialog(GetResString(IDS_FATAL_ERROR).c_str(), GetResString(IDS_REOPEN_ERR).c_str(), p.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
            return false;
        }
        cursors = savedCursors; vScrollPos = savedV; vScrollSubLine = savedSubV; hScrollPos = savedH;
        updateScrollBars(); ensureCaretVisible(); updateTitleBar(); updateWindowIcon(); updateFileTime();
        saveCurrentViewState();
        return true;
    }
bool Editor::saveFile(const std::wstring& p) {
        std::wstring t = p + L".tmp";
        HANDLE h = CreateFileW(t.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        if (h == INVALID_HANDLE_VALUE) {
            DWORD err = GetLastError();
            if (err == ERROR_ACCESS_DENIED) {
                return saveFileElevated(p);
            }
            ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), GetResString(IDS_TEMP_FILE_ERR).c_str(), t.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
            return false;
        }
        bool ok = writeContentToHandle(h);
        CloseHandle(h);
        if (!ok) {
            DeleteFileW(t.c_str());
            ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), GetResString(IDS_WRITE_ERR).c_str(), p.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
            return false;
        }
        std::vector<Cursor> savedCursors = cursors; int savedV = vScrollPos; int savedSubV = vScrollSubLine; int savedH = hScrollPos;
        std::wstring oldPath = currentFilePath;
        if (!oldPath.empty() && _wcsicmp(oldPath.c_str(), p.c_str()) != 0) {
            saveCurrentViewState();
        }
        if (fileMap && fileMap->isMapped) fileMap->close();
        if (MoveFileExW(t.c_str(), p.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED) == 0) {
            DWORD err = GetLastError();
            if (err == ERROR_ACCESS_DENIED) {
                bool elevRes = saveFileElevated(p, t);
                if (!elevRes) {
                    DeleteFileW(t.c_str());
                }
                return elevRes;
            }
            DeleteFileW(t.c_str());
            std::wstring msg = GetResString(IDS_SAVE_ERR) + std::to_wstring(err);
            ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), msg.c_str(), p.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
            return false;
        }
        if (fileMap) fileMap->close();
        if (!openFileFromPath(p, false)) {
            ShowTaskDialog(GetResString(IDS_FATAL_ERROR).c_str(), GetResString(IDS_REOPEN_ERR).c_str(), p.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON);
            return false;
        }
        cursors = savedCursors; vScrollPos = savedV; vScrollSubLine = savedSubV; hScrollPos = savedH;
        updateScrollBars(); ensureCaretVisible(); updateTitleBar(); updateWindowIcon(); updateFileTime();
        saveCurrentViewState();
        return true;
    }
bool Editor::saveFileAs() {
        WCHAR f[MAX_PATH] = { 0 }; std::wstring initialDir;
        if (!currentFilePath.empty()) {
            std::wstring fileName = currentFilePath;
            size_t lastSlash = currentFilePath.find_last_of(L"\\/");
            if (lastSlash != std::wstring::npos) {
                fileName = currentFilePath.substr(lastSlash + 1);
                if (lastSlash == 2 && currentFilePath[1] == L':') {
                    initialDir = currentFilePath.substr(0, 3);
                } else {
                    initialDir = currentFilePath.substr(0, lastSlash);
                }
            }
            wcsncpy_s(f, MAX_PATH, fileName.c_str(), _TRUNCATE);
        }
        OPENFILENAMEW o = { 0 }; o.lStructSize = sizeof(o); o.hwndOwner = hwnd; o.lpstrFile = f; o.nMaxFile = MAX_PATH;
        o.lpstrFilter = L"All\0*.*\0Text\0*.txt\0"; o.nFilterIndex = 1; o.Flags = OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT;
        if (!initialDir.empty()) o.lpstrInitialDir = initialDir.c_str();
        SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)hAppIcon);
        if (GetSaveFileNameW(&o)) return saveFile(f);
        updateWindowIcon();
        return false;
    }

void Editor::saveCurrentViewState() {
        if (currentFilePath.empty()) return;
        try {
            rollbackPadding();
            FileViewState st = {};
            st.docByteLen = isDirty ? UINT64_MAX : (uint64_t)pt.length();
            st.fileWriteTime = ((uint64_t)lastWriteTime.dwHighDateTime << 32) | (uint64_t)lastWriteTime.dwLowDateTime;
            st.vScrollPos = (int32_t)vScrollPos;
            st.vScrollSubLine = (int32_t)vScrollSubLine;
            st.hScrollPos = (int32_t)hScrollPos;
            st.isRectSelecting = isRectSelecting ? 1 : 0;
            st.rectAnchorLine = (int32_t)rectAnchorLine;
            st.rectHeadLine = (int32_t)rectHeadLine;
            st.rectAnchorX = rectAnchorX;
            st.rectHeadX = rectHeadX;
            size_t totalCursors = cursors.size();
            size_t startIdx = (totalCursors > 16) ? (totalCursors - 16) : 0;
            uint8_t outCount = 0;
            for (size_t i = startIdx; i < totalCursors && outCount < 16; ++i) {
                const Cursor& c = cursors[i];
                SavedCursorEntry& sc = st.cursors[outCount++];
                size_t h = std::min(c.head, pt.length());
                size_t a = std::min(c.anchor, pt.length());
                int hLine = getLineIdx(h);
                int aLine = getLineIdx(a);
                sc.head = (uint64_t)h;
                sc.anchor = (uint64_t)a;
                sc.headLine = (uint32_t)std::max(0, hLine);
                sc.headCol = (uint32_t)((!lineStarts.empty() && h >= lineStarts[sc.headLine]) ? (h - lineStarts[sc.headLine]) : 0);
                sc.anchorLine = (uint32_t)std::max(0, aLine);
                sc.anchorCol = (uint32_t)((!lineStarts.empty() && a >= lineStarts[sc.anchorLine]) ? (a - lineStarts[sc.anchorLine]) : 0);
                size_t s = std::min(h, a);
                size_t e = std::max(h, a);
                sc.selLen = (uint32_t)std::min(e - s, (size_t)0xFFFFFFFFu);
                sc.selHash = (e > s) ? calcSampleHash(s, e - s) : 0;
                sc.desiredX = c.desiredX;
                sc.affinity = c.affinity ? 1 : 0;
            }
            st.cursorCount = outCount;
            if (outCount > 0) {
                size_t mainHead = (size_t)st.cursors[outCount - 1].head;
                size_t ctxStart = (mainHead > 32) ? (mainHead - 32) : 0;
                st.contextHash = calcSampleHash(ctxStart, 64);
            }
            saveFileViewState(currentFilePath, st);
        } catch (...) {}
    }
void Editor::restoreViewState(const std::wstring& path) {
        cursors.clear();
        isRectSelecting = false;
        vScrollPos = 0;
        vScrollSubLine = 0;
        hScrollPos = 0;
        try {
            FileViewState st;
            if (!getFileViewState(path, st) || st.cursorCount == 0) {
                cursors.push_back({ 0, 0, 0.0f });
                return;
            }
            uint8_t count = std::min(st.cursorCount, (uint8_t)16);
            size_t mainHead = (size_t)st.cursors[count - 1].head;
            size_t ctxStart = (mainHead > 32) ? (mainHead - 32) : 0;
            bool exactMatch = (pt.length() == st.docByteLen) &&
                              (mainHead <= pt.length()) &&
                              (calcSampleHash(ctxStart, 64) == st.contextHash);
            if (exactMatch) {
                for (uint8_t i = 0; i < count; ++i) {
                    const SavedCursorEntry& sc = st.cursors[i];
                    size_t h = sanitizeUtf8Pos((size_t)sc.head);
                    size_t a = sanitizeUtf8Pos((size_t)sc.anchor);
                    if (h != a) {
                        size_t s = std::min(h, a);
                        size_t e = std::max(h, a);
                        if ((e - s) != (size_t)sc.selLen || calcSampleHash(s, e - s) != sc.selHash) {
                            a = h;
                        }
                    }
                    bool aff = (sc.affinity != 0);
                    float dx = (sc.desiredX > 0.0f) ? sc.desiredX : ((h == 0) ? 0.0f : getXFromPos(h, aff));
                    cursors.push_back({ h, a, dx, aff });
                }
                int totalLines = (int)lineStarts.size();
                if (st.isRectSelecting && st.rectAnchorLine >= 0 && st.rectAnchorLine < totalLines && st.rectHeadLine >= 0 && st.rectHeadLine < totalLines) {
                    isRectSelecting = true;
                    rectAnchorLine = st.rectAnchorLine;
                    rectHeadLine = st.rectHeadLine;
                    rectAnchorX = st.rectAnchorX;
                    rectHeadX = st.rectHeadX;
                }
                vScrollPos = (int)st.vScrollPos;
                vScrollSubLine = (int)st.vScrollSubLine;
                hScrollPos = (int)st.hScrollPos;
                mergeCursors();
                updateScrollBars();
            } else {
                for (uint8_t i = 0; i < count; ++i) {
                    const SavedCursorEntry& sc = st.cursors[i];
                    size_t h = resolveLineColSafe(sc.headLine, sc.headCol);
                    size_t a = h;
                    if (sc.head != sc.anchor) {
                        size_t candA = resolveLineColSafe(sc.anchorLine, sc.anchorCol);
                        size_t s = std::min(h, candA);
                        size_t e = std::max(h, candA);
                        if ((e - s) == (size_t)sc.selLen && calcSampleHash(s, e - s) == sc.selHash) {
                            a = candA;
                        }
                    }
                    float dx = getXFromPos(h, false);
                    cursors.push_back({ h, a, dx, false });
                }
                mergeCursors();
                int maxLine = std::max(0, (int)lineStarts.size() - 1);
                vScrollPos = std::max(0, std::min((int)st.vScrollPos, maxLine));
                vScrollSubLine = 0;
                hScrollPos = std::max(0, (int)st.hScrollPos);
                updateScrollBars();
                if (!cursors.empty() && hwnd) {
                    RECT rc; GetClientRect(hwnd, &rc);
                    float clientH = (rc.bottom - rc.top) / dpiScaleY;
                    int linesVisible = std::max(1, (int)(clientH / lineHeight));
                    int caretLine = getLineIdx(cursors.back().head);
                    if (caretLine < vScrollPos || caretLine >= vScrollPos + linesVisible) {
                        ensureCaretVisible();
                    }
                }
            }
        } catch (...) {
            cursors.clear();
            isRectSelecting = false;
            vScrollPos = 0;
            vScrollSubLine = 0;
            hScrollPos = 0;
        }
        if (cursors.empty()) {
            cursors.push_back({ 0, 0, 0.0f });
        }
    }

bool Editor::openFileFromPath(const std::wstring& path, bool manageViewState) {
        std::wstring normPath = normalizePath(path);
        const std::wstring& targetPath = normPath.empty() ? path : normPath;
        std::unique_ptr<MappedFile> newMap(new MappedFile());
        if (newMap->open(targetPath.c_str())) {
            if (manageViewState && !currentFilePath.empty()) {
                saveCurrentViewState();
            }
            fileMap = std::move(newMap);
            DetectResult encRes = DetectEncodingEx(fileMap->ptr, fileMap->size); currentEncoding = encRes.type; currentCodePage = encRes.codePage; convertedBuffer.clear(); const char* ptr = fileMap->ptr; size_t size = fileMap->size;
            switch (currentEncoding) {
            case ENC_UTF8_BOM:
                if (size >= 3) { ptr += 3; size -= 3; }
                if (!IsValidUtf8(ptr, size)) { convertedBuffer = SanitizeUtf8(ptr, size); pt.initFromFile(convertedBuffer.data(), convertedBuffer.size()); detectNewlineStyle(convertedBuffer.data(), convertedBuffer.size()); }
                else { pt.initFromFile(ptr, size); detectNewlineStyle(ptr, size); }
                break;
            case ENC_UTF16LE: convertedBuffer = Utf16ToUtf8(ptr, size, false); pt.initFromFile(convertedBuffer.data(), convertedBuffer.size()); detectNewlineStyle(convertedBuffer.data(), convertedBuffer.size()); break;
            case ENC_UTF16BE: convertedBuffer = Utf16ToUtf8(ptr, size, true); pt.initFromFile(convertedBuffer.data(), convertedBuffer.size()); detectNewlineStyle(convertedBuffer.data(), convertedBuffer.size()); break;
            case ENC_LOCAL: convertedBuffer = LocalToUtf8(ptr, size, currentCodePage); pt.initFromFile(convertedBuffer.data(), convertedBuffer.size()); detectNewlineStyle(convertedBuffer.data(), convertedBuffer.size()); break;
            default:
                if (!IsValidUtf8(ptr, size)) { convertedBuffer = SanitizeUtf8(ptr, size); pt.initFromFile(convertedBuffer.data(), convertedBuffer.size()); detectNewlineStyle(convertedBuffer.data(), convertedBuffer.size()); }
                else { pt.initFromFile(ptr, size); detectNewlineStyle(ptr, size); }
                break;
            }
            std::wstring ext = L"";
            size_t slashPos = targetPath.find_last_of(L"\\/");
            std::wstring baseName = (slashPos == std::wstring::npos) ? targetPath : targetPath.substr(slashPos + 1);
            std::wstring lowerBase = baseName;
            for (auto& c : lowerBase) c = std::towlower(c);
            if (lowerBase == L"dockerfile" || lowerBase == L"containerfile" || lowerBase.rfind(L"dockerfile.", 0) == 0 || lowerBase.rfind(L"containerfile.", 0) == 0) ext = L"dockerfile";
            else if (lowerBase == L"makefile" || lowerBase == L"gnumakefile") ext = L"makefile";
            else if (lowerBase == L"cmakelists.txt") ext = L"cmake";
            else if (lowerBase == L".env" || lowerBase.rfind(L".env.", 0) == 0) ext = L"env";
            else if (lowerBase == L".bashrc" || lowerBase == L".bash_profile" || lowerBase == L".zshrc" || lowerBase == L".profile") ext = L"sh";
            else {
                size_t dotPos = baseName.find_last_of(L".");
                if (dotPos != std::wstring::npos) ext = baseName.substr(dotPos + 1);
            }
            loadSyntaxForExtension(ext);
            updateSyntaxBrushes();
            currentFilePath = targetPath; undo.clear(); pendingPadding.ops.clear(); pendingPadding.beforeCursors.clear(); pendingPadding.afterCursors.clear(); clearEmmetTabstops(); isRectSelecting = false; isDirty = false; undo.markSaved();
            lastWriteTime = fileMap->ftWrite;
            showHelpPopup = false;
            rebuildLineStarts();
            if (manageViewState) {
                restoreViewState(currentFilePath);
            } else {
                cursors.clear(); cursors.push_back({ 0, 0, 0.0f }); vScrollPos = 0; vScrollSubLine = 0; hScrollPos = 0;
            }
            if (showPreview) { updatePreviewBounds(); schedulePreviewUpdate(); }
            updateTitleBar(); InvalidateRect(hwnd, NULL, FALSE); updateWindowIcon();
            addToRecentFiles(currentFilePath, true);
            return true;
        }
        else { ShowTaskDialog(GetResString(IDS_ERROR_TITLE).c_str(), GetResString(IDS_OPEN_FAIL).c_str(), path.c_str(), TDCBF_OK_BUTTON, TD_ERROR_ICON); return false; }
    }

HRESULT STDMETHODCALLTYPE Editor::wv2_QI(WV2Handler* self, REFIID, void** ppv) {
    if (!ppv) return E_POINTER;
    *ppv = self;
    return S_OK;
}
ULONG STDMETHODCALLTYPE Editor::wv2_AddRefRelease(WV2Handler*) { return 1; }
HRESULT STDMETHODCALLTYPE Editor::wv2_EnvInvoke(WV2Handler* self, HRESULT err, IUnknown* env) {
    Editor* ed = self->ed;
    if (FAILED(err) || !env) { ed->webviewInitStarted = false; return S_OK; }
    ed->webviewEnv = env;
    env->AddRef();
    static const void* const ctrlVtbl[4] = { (void*)wv2_QI, (void*)wv2_AddRefRelease, (void*)wv2_AddRefRelease, (void*)wv2_CtrlInvoke };
    static WV2Handler ctrlHandler = { ctrlVtbl, nullptr };
    ctrlHandler.ed = ed;
    typedef HRESULT(STDMETHODCALLTYPE* PFN_CreateCtrl)(IUnknown*, HWND, void*);
    ((PFN_CreateCtrl)((*(void***)env)[3]))(env, ed->hwndPreviewHost, &ctrlHandler);
    return S_OK;
}
HRESULT STDMETHODCALLTYPE Editor::wv2_AccelInvoke(WV2Handler* self, IUnknown*, IUnknown* args) {
    if (!args) return S_OK;
    typedef HRESULT(STDMETHODCALLTYPE* PFN_GetInt)(IUnknown*, int*);
    typedef HRESULT(STDMETHODCALLTYPE* PFN_GetUInt)(IUnknown*, UINT*);
    typedef HRESULT(STDMETHODCALLTYPE* PFN_PutBool)(IUnknown*, BOOL);
    int kind = 0, lp = 0; UINT vk = 0;
    ((PFN_GetInt)((*(void***)args)[3]))(args, &kind);
    ((PFN_GetUInt)((*(void***)args)[4]))(args, &vk);
    ((PFN_GetInt)((*(void***)args)[5]))(args, &lp);
    bool isRepeat = (lp & (1 << 30)) != 0;
    bool handled = false;
    UINT fwdMsg = 0;
    HWND hMain = self->ed->hwnd;
    if (kind == 2) {
        if (vk == VK_F4) {
            handled = true;
            if (!isRepeat) PostMessageW(hMain, WM_CLOSE, 0, 0);
        } else if (vk == VK_SPACE) {
            handled = true;
            if (!isRepeat) PostMessageW(hMain, WM_SYSCOMMAND, SC_KEYMENU, VK_SPACE);
        } else if (vk == 'P' || vk == 'T' || vk == 'Z') {
            handled = true;
            if (!isRepeat) fwdMsg = WM_SYSKEYDOWN;
        } else if (vk == VK_LEFT || vk == VK_RIGHT) {
            handled = true;
        }
    } else if (kind == 0) {
        if (vk == VK_F1 || vk == VK_F11) {
            handled = true;
            if (!isRepeat) fwdMsg = WM_KEYDOWN;
        } else if (vk == VK_F3) {
            handled = true;
            fwdMsg = WM_KEYDOWN;
        } else if (vk == VK_F5) {
            handled = true;
            if (!isRepeat) self->ed->schedulePreviewUpdate();
        } else if (vk == VK_ESCAPE) {
            handled = true;
            SetFocus(hMain);
            fwdMsg = WM_KEYDOWN;
        } else if (GetAsyncKeyState(VK_CONTROL) & 0x8000) {
            if (vk == 'S' || vk == 'O' || vk == 'N' || vk == 'W' || vk == VK_F4 ||
                vk == 'F' || vk == 'H' || vk == 'R' || vk == 'G' || vk == 'L' ||
                vk == VK_ADD || vk == VK_OEM_PLUS || vk == VK_SUBTRACT || vk == VK_OEM_MINUS ||
                vk == '0' || vk == VK_NUMPAD0) {
                handled = true;
                if (!isRepeat || vk == VK_ADD || vk == VK_OEM_PLUS || vk == VK_SUBTRACT || vk == VK_OEM_MINUS) fwdMsg = WM_KEYDOWN;
            } else if (vk == 'P' || vk == 'U' || vk == 'J' || vk == 'D') {
                handled = true;
            }
        }
    }
    if (handled) ((PFN_PutBool)((*(void***)args)[8]))(args, TRUE);
    if (fwdMsg) {
        BYTE ks[256];
        if (GetKeyboardState(ks)) {
            ks[VK_CONTROL] = (GetAsyncKeyState(VK_CONTROL) & 0x8000) ? 0x80 : 0;
            ks[VK_SHIFT]   = (GetAsyncKeyState(VK_SHIFT)   & 0x8000) ? 0x80 : 0;
            ks[VK_MENU]    = (GetAsyncKeyState(VK_MENU)    & 0x8000) ? 0x80 : 0;
            SetKeyboardState(ks);
        }
        PostMessageW(hMain, fwdMsg, vk, lp);
    }
    return S_OK;
}
HRESULT STDMETHODCALLTYPE Editor::wv2_NavInvoke(WV2Handler*, IUnknown*, IUnknown* args) {
    if (!args) return S_OK;
    typedef HRESULT(STDMETHODCALLTYPE* PFN_GetUri)(IUnknown*, LPWSTR*);
    typedef HRESULT(STDMETHODCALLTYPE* PFN_PutCancel)(IUnknown*, BOOL);
    LPWSTR uri = nullptr;
    if (SUCCEEDED(((PFN_GetUri)((*(void***)args)[3]))(args, &uri)) && uri) {
        bool allowed = (_wcsnicmp(uri, L"about:blank", 11) == 0 || _wcsnicmp(uri, L"data:text/html", 14) == 0);
        if (!allowed) {
            ((PFN_PutCancel)((*(void***)args)[8]))(args, TRUE);
        }
        CoTaskMemFree(uri);
    }
    return S_OK;
}
HRESULT STDMETHODCALLTYPE Editor::wv2_PermInvoke(WV2Handler*, IUnknown*, IUnknown* args) {
    if (!args) return S_OK;
    typedef HRESULT(STDMETHODCALLTYPE* PFN_PutState)(IUnknown*, int);
    ((PFN_PutState)((*(void***)args)[7]))(args, 2);
    return S_OK;
}
HRESULT STDMETHODCALLTYPE Editor::wv2_NewWinInvoke(WV2Handler*, IUnknown*, IUnknown* args) {
    if (!args) return S_OK;
    typedef HRESULT(STDMETHODCALLTYPE* PFN_PutHandled)(IUnknown*, BOOL);
    ((PFN_PutHandled)((*(void***)args)[6]))(args, TRUE);
    return S_OK;
}
HRESULT STDMETHODCALLTYPE Editor::wv2_CtrlInvoke(WV2Handler* self, HRESULT err, IUnknown* ctrl) {
    Editor* ed = self->ed;
    if (FAILED(err) || !ctrl) {
        static bool retried = false;
        if (!retried && ed->hWebViewDll) {
            retried = true;
            typedef HRESULT(STDAPICALLTYPE* PFN_CreateEnv)(bool, int, PCWSTR, IUnknown*, void*);
            auto pfn = (PFN_CreateEnv)GetProcAddress(ed->hWebViewDll, "CreateWebViewEnvironmentWithOptionsInternal");
            if (pfn) {
                wchar_t tmp[MAX_PATH] = {};
                GetTempPathW(MAX_PATH, tmp);
                std::wstring udf(tmp); udf += L"miu_wv2_"; udf += std::to_wstring(GetCurrentProcessId());
                static const void* const envVtbl[4] = { (void*)wv2_QI, (void*)wv2_AddRefRelease, (void*)wv2_AddRefRelease, (void*)wv2_EnvInvoke };
                static WV2Handler envHandler = { envVtbl, nullptr };
                envHandler.ed = ed;
                if (SUCCEEDED(pfn(true, 0, udf.c_str(), nullptr, &envHandler))) return S_OK;
            }
        }
        ed->webviewInitStarted = false;
        return S_OK;
    }
    ed->webviewController = ctrl;
    ctrl->AddRef();
    typedef HRESULT(STDMETHODCALLTYPE* PFN_GetView)(IUnknown*, IUnknown**);
    ((PFN_GetView)((*(void***)ctrl)[25]))(ctrl, &ed->webviewView);
    static const void* const accelVtbl[4] = { (void*)wv2_QI, (void*)wv2_AddRefRelease, (void*)wv2_AddRefRelease, (void*)wv2_AccelInvoke };
    static WV2Handler accelHandler = { accelVtbl, nullptr };
    accelHandler.ed = ed;
    typedef HRESULT(STDMETHODCALLTYPE* PFN_AddAccel)(IUnknown*, void*, __int64*);
    __int64 tok = 0;
    ((PFN_AddAccel)((*(void***)ctrl)[19]))(ctrl, &accelHandler, &tok);
    if (ed->webviewView) {
        IUnknown* settings = nullptr;
        typedef HRESULT(STDMETHODCALLTYPE* PFN_GetSettings)(IUnknown*, IUnknown**);
        if (SUCCEEDED(((PFN_GetSettings)((*(void***)ed->webviewView)[3]))(ed->webviewView, &settings)) && settings) {
            typedef HRESULT(STDMETHODCALLTYPE* PFN_PutSettingBool)(IUnknown*, BOOL);
            ((PFN_PutSettingBool)((*(void***)settings)[6]))(settings, FALSE);
            ((PFN_PutSettingBool)((*(void***)settings)[8]))(settings, FALSE);
            ((PFN_PutSettingBool)((*(void***)settings)[10]))(settings, FALSE);
            ((PFN_PutSettingBool)((*(void***)settings)[16]))(settings, FALSE);
            settings->Release();
        }
        typedef HRESULT(STDMETHODCALLTYPE* PFN_AddEvt)(IUnknown*, void*, __int64*);
        static const void* const navVtbl[4] = { (void*)wv2_QI, (void*)wv2_AddRefRelease, (void*)wv2_AddRefRelease, (void*)wv2_NavInvoke };
        static WV2Handler navHandler = { navVtbl, nullptr };
        navHandler.ed = ed;
        __int64 navTok = 0;
        ((PFN_AddEvt)((*(void***)ed->webviewView)[7]))(ed->webviewView, &navHandler, &navTok);
        static const void* const frameNavVtbl[4] = { (void*)wv2_QI, (void*)wv2_AddRefRelease, (void*)wv2_AddRefRelease, (void*)wv2_NavInvoke };
        static WV2Handler frameNavHandler = { frameNavVtbl, nullptr };
        frameNavHandler.ed = ed;
        __int64 frameNavTok = 0;
        ((PFN_AddEvt)((*(void***)ed->webviewView)[17]))(ed->webviewView, &frameNavHandler, &frameNavTok);
        static const void* const permVtbl[4] = { (void*)wv2_QI, (void*)wv2_AddRefRelease, (void*)wv2_AddRefRelease, (void*)wv2_PermInvoke };
        static WV2Handler permHandler = { permVtbl, nullptr };
        permHandler.ed = ed;
        __int64 permTok = 0;
        ((PFN_AddEvt)((*(void***)ed->webviewView)[23]))(ed->webviewView, &permHandler, &permTok);
        static const void* const newWinVtbl[4] = { (void*)wv2_QI, (void*)wv2_AddRefRelease, (void*)wv2_AddRefRelease, (void*)wv2_NewWinInvoke };
        static WV2Handler newWinHandler = { newWinVtbl, nullptr };
        newWinHandler.ed = ed;
        __int64 newWinTok = 0;
        ((PFN_AddEvt)((*(void***)ed->webviewView)[44]))(ed->webviewView, &newWinHandler, &newWinTok);
        typedef HRESULT(STDMETHODCALLTYPE* PFN_AddScript)(IUnknown*, LPCWSTR, IUnknown*);
        static const wchar_t* const kAgScrollbarScript =
            L"(()=>{"
            L"window.__miuUpdate=function(h,dk){"
            L"document.documentElement.setAttribute('data-theme',dk?'dark':'light');"
            L"var r=document.getElementById('__miu_root');if(!r)return;"
            L"var t=document.createElement('div');t.innerHTML=h;"
            L"var od=r.querySelectorAll('.pele-diagram'),nd=t.querySelectorAll('.pele-diagram');"
            L"var m=Math.min(od.length,nd.length);"
            L"for(var i=0;i<m;i++){"
            L"if(nd[i].getAttribute('data-empty')==='1'&&od[i].querySelector('svg.pele')){"
            L"nd[i].innerHTML=od[i].innerHTML;nd[i].removeAttribute('data-empty');"
            L"}"
            L"}"
            L"var nc=Array.from(t.childNodes);"
            L"for(var j=0;j<nc.length;j++){"
            L"if(j<r.childNodes.length){if(!r.childNodes[j].isEqualNode(nc[j]))r.replaceChild(nc[j],r.childNodes[j]);}"
            L"else r.appendChild(nc[j]);"
            L"}"
            L"while(r.childNodes.length>nc.length)r.removeChild(r.lastChild);"
            L"};"
            L"const css='html::-webkit-scrollbar,body::-webkit-scrollbar{display:none!important;width:0!important;height:0!important}html,body{scrollbar-width:none!important}*::-webkit-scrollbar{width:6px;height:6px;background:transparent}*::-webkit-scrollbar-track{background:transparent}*::-webkit-scrollbar-thumb{background:rgba(128,128,128,0.38);border-radius:9999px}*::-webkit-scrollbar-thumb:hover,*::-webkit-scrollbar-thumb:active{background:rgba(128,128,128,0.62)}.__ag_sb_v,.__ag_sb_h{position:fixed!important;z-index:2147483647!important;display:flex!important;user-select:none!important;touch-action:none!important;opacity:0;pointer-events:none;transition:opacity 150ms cubic-bezier(0,0,0.2,1)!important;margin:0!important;padding:0!important;border:none!important;background:transparent!important;box-sizing:border-box!important}.__ag_sb_v{top:2px!important;bottom:2px!important;right:2px!important;width:12px!important;justify-content:flex-end!important;flex-direction:row!important}.__ag_sb_h{left:2px!important;right:2px!important;bottom:2px!important;height:12px!important;align-items:flex-end!important;flex-direction:column!important}.__ag_sb_v[data-visible=\"true\"],.__ag_sb_h[data-visible=\"true\"]{opacity:1!important;pointer-events:auto!important}.__ag_sb_vt,.__ag_sb_ht{border-radius:9999px!important;background-color:rgba(128,128,128,0.38)!important;margin:0!important;padding:0!important;border:none!important;flex-shrink:0!important;box-sizing:border-box!important}.__ag_sb_vt{width:6px!important;transition:width 150ms cubic-bezier(0,0,0.2,1),background-color 150ms cubic-bezier(0,0,0.2,1)!important}.__ag_sb_ht{height:6px!important;transition:height 150ms cubic-bezier(0,0,0.2,1),background-color 150ms cubic-bezier(0,0,0.2,1)!important}.__ag_sb_v[data-expanded=\"true\"] .__ag_sb_vt{width:10px!important;background-color:rgba(128,128,128,0.62)!important}.__ag_sb_h[data-expanded=\"true\"] .__ag_sb_ht{height:10px!important;background-color:rgba(128,128,128,0.62)!important}';"
            L"let vT,vTh,hT,hTh,vH=false,hH=false,vD=false,hD=false,vMS=1,vMO=0,vTL=28,hMS=1,hMO=0,hTL=28,dSC=0,dSS=0;"
            L"function upd(){"
            L"if(!vT||!hT)return;"
            L"const doc=document.scrollingElement||document.documentElement;if(!doc)return;"
            L"const cw=doc.clientWidth||window.innerWidth,ch=doc.clientHeight||window.innerHeight;"
            L"const sw=Math.max(doc.scrollWidth,document.body?document.body.scrollWidth:0),sh=Math.max(doc.scrollHeight,document.body?document.body.scrollHeight:0);"
            L"const sx=window.scrollX||doc.scrollLeft||0,sy=window.scrollY||doc.scrollTop||0;"
            L"const hasV=ch>0&&sh>ch+1,hasH=cw>0&&sw>cw+1;"
            L"if(hasV){const tl=Math.max(0,ch-4-(hasH?12:0));vTL=Math.min(tl,Math.max(28,Math.round((ch/sh)*tl)));vMS=Math.max(1,sh-ch);vMO=Math.max(0,tl-vTL);const off=Math.round(Math.min(1,Math.max(0,sy/vMS))*vMO);vTh.style.height=vTL+'px';vTh.style.transform='translate(0px,'+off+'px)';}"
            L"if(hasH){const tl=Math.max(0,cw-4-(hasV?12:0));hTL=Math.min(tl,Math.max(28,Math.round((cw/sw)*tl)));hMS=Math.max(1,sw-cw);hMO=Math.max(0,tl-hTL);const off=Math.round(Math.min(1,Math.max(0,sx/hMS))*hMO);hTh.style.width=hTL+'px';hTh.style.transform='translate('+off+'px,0px)';}"
            L"vT.dataset.visible=hasV?'true':'false';vT.dataset.expanded=(vH||vD)?'true':'false';"
            L"hT.dataset.visible=hasH?'true':'false';hT.dataset.expanded=(hH||hD)?'true':'false';"
            L"}"
            L"function init(){"
            L"if(vT||!document.documentElement)return;"
            L"const st=document.createElement('style');st.textContent=css;(document.head||document.documentElement).appendChild(st);"
            L"vT=document.createElement('div');vT.className='__ag_sb_v';vTh=document.createElement('div');vTh.className='__ag_sb_vt';vT.appendChild(vTh);"
            L"hT=document.createElement('div');hT.className='__ag_sb_h';hTh=document.createElement('div');hTh.className='__ag_sb_ht';hT.appendChild(hTh);"
            L"document.documentElement.appendChild(vT);document.documentElement.appendChild(hT);"
            L"vT.addEventListener('pointerenter',()=>{vH=true;upd();});vT.addEventListener('pointerleave',()=>{vH=false;upd();});"
            L"vT.addEventListener('pointerdown',e=>{if(e.button!==0)return;e.preventDefault();e.stopPropagation();if(e.target===vT&&vMO>0){const r=vT.getBoundingClientRect(),co=Math.min(vMO,Math.max(0,(e.clientY-r.top)-vTL*0.5));window.scrollTo(window.scrollX,(co/vMO)*vMS);upd();}try{vT.setPointerCapture(e.pointerId);}catch(_){}vD=true;dSC=e.clientY;dSS=window.scrollY;upd();});"
            L"vT.addEventListener('pointermove',e=>{if(!vD||vMO<=0)return;window.scrollTo(window.scrollX,dSS+((e.clientY-dSC)/vMO)*vMS);});"
            L"const endV=e=>{if(vD){try{if(vT.hasPointerCapture(e.pointerId))vT.releasePointerCapture(e.pointerId);}catch(_){}vD=false;upd();}};"
            L"vT.addEventListener('pointerup',endV);vT.addEventListener('pointercancel',endV);vT.addEventListener('lostpointercapture',()=>{if(vD){vD=false;upd();}});"
            L"hT.addEventListener('pointerenter',()=>{hH=true;upd();});hT.addEventListener('pointerleave',()=>{hH=false;upd();});"
            L"hT.addEventListener('pointerdown',e=>{if(e.button!==0)return;e.preventDefault();e.stopPropagation();if(e.target===hT&&hMO>0){const r=hT.getBoundingClientRect(),co=Math.min(hMO,Math.max(0,(e.clientX-r.left)-hTL*0.5));window.scrollTo((co/hMO)*hMS,window.scrollY);upd();}try{hT.setPointerCapture(e.pointerId);}catch(_){}hD=true;dSC=e.clientX;dSS=window.scrollX;upd();});"
            L"hT.addEventListener('pointermove',e=>{if(!hD||hMO<=0)return;window.scrollTo(dSS+((e.clientX-dSC)/hMO)*hMS,window.scrollY);});"
            L"const endH=e=>{if(hD){try{if(hT.hasPointerCapture(e.pointerId))hT.releasePointerCapture(e.pointerId);}catch(_){}hD=false;upd();}};"
            L"hT.addEventListener('pointerup',endH);hT.addEventListener('pointercancel',endH);hT.addEventListener('lostpointercapture',()=>{if(hD){hD=false;upd();}});"
            L"if(window.name){const p=window.name.split(',');if(p.length===2)window.scrollTo(+p[0]||0,+p[1]||0);}"
            L"const ro=new ResizeObserver(upd);ro.observe(document.documentElement);if(document.body)ro.observe(document.body);"
            L"upd();"
            L"}"
            L"window.addEventListener('scroll',()=>{window.name=window.scrollX+','+window.scrollY;upd();},{passive:true});"
            L"window.addEventListener('resize',upd,{passive:true});"
            L"window.addEventListener('DOMContentLoaded',init);"
            L"window.addEventListener('load',()=>{init();upd();});"
            L"if(document.readyState!=='loading')init();"
            L"})();";
        ((PFN_AddScript)((*(void***)ed->webviewView)[27]))(ed->webviewView, kAgScrollbarScript, nullptr);
    }
    ed->updatePreviewBounds();
    if (ed->showPreview) ed->updatePreviewContent();
    if (ed->hwnd) SetFocus(ed->hwnd);
    return S_OK;
}
void Editor::updatePreviewBounds() {
    if (!hwndPreviewHost) return;
    if (!showPreview || showHelpPopup) {
        if (webviewController) {
            typedef HRESULT(STDMETHODCALLTYPE* PFN_PutVis)(IUnknown*, BOOL);
            ((PFN_PutVis)((*(void***)webviewController)[4]))(webviewController, FALSE);
        }
        ShowWindow(hwndPreviewHost, SW_HIDE);
        HWND hFocus = GetFocus();
        if (hFocus && hFocus != hwnd && IsChild(hwnd, hFocus)) SetFocus(hwnd);
        return;
    }
    RECT rc = {};
    GetClientRect(hwnd, &rc);
    float splitX = getEditorDipWidth();
    int pxLeft = (int)std::round((splitX + SPLITTER_DIP_W) * dpiScaleX);
    int pxW = std::max(1, (int)rc.right - pxLeft);
    int pxH = std::max(1, (int)rc.bottom);
    SetWindowPos(hwndPreviewHost, HWND_TOP, pxLeft, 0, pxW, pxH, SWP_NOACTIVATE | SWP_SHOWWINDOW);
    if (webviewController) {
        typedef HRESULT(STDMETHODCALLTYPE* PFN_PutBounds)(IUnknown*, RECT);
        typedef HRESULT(STDMETHODCALLTYPE* PFN_PutVis)(IUnknown*, BOOL);
        RECT b = { 0, 0, pxW, pxH };
        ((PFN_PutBounds)((*(void***)webviewController)[6]))(webviewController, b);
        ((PFN_PutVis)((*(void***)webviewController)[4]))(webviewController, TRUE);
    }
}
static bool isTrustedWebView2DllPath(const std::wstring& rawPath, std::wstring& outCanonical) {
    if (rawPath.size() < 4 || rawPath.compare(0, 2, L"\\\\") == 0) return false;
    if (rawPath.find(L"..") != std::wstring::npos) return false;
    wchar_t full[MAX_PATH] = {};
    DWORD len = GetFullPathNameW(rawPath.c_str(), MAX_PATH, full, NULL);
    if (len == 0 || len >= MAX_PATH) return false;
    if (full[1] != L':' || full[2] != L'\\') return false;
    DWORD attr = GetFileAttributesW(full);
    if (attr == INVALID_FILE_ATTRIBUTES || (attr & FILE_ATTRIBUTE_DIRECTORY) || (attr & FILE_ATTRIBUTE_REPARSE_POINT)) return false;
    auto startsWithDir = [&](const wchar_t* envName, const wchar_t* subDir) -> bool {
        wchar_t base[MAX_PATH] = {};
        if (GetEnvironmentVariableW(envName, base, MAX_PATH) == 0) return false;
        std::wstring prefix(base);
        if (!prefix.empty() && prefix.back() != L'\\') prefix += L'\\';
        prefix += subDir;
        return _wcsnicmp(full, prefix.c_str(), prefix.size()) == 0;
    };
    if (startsWithDir(L"ProgramFiles(x86)", L"Microsoft\\") ||
        startsWithDir(L"ProgramFiles", L"Microsoft\\") ||
        startsWithDir(L"ProgramW6432", L"Microsoft\\") ||
        startsWithDir(L"LOCALAPPDATA", L"Microsoft\\Edge")) {
        outCanonical = full;
        return true;
    }
    return false;
}

std::wstring Editor::findWebView2Dll() {
    static const wchar_t* const subKeys[] = {
        L"SOFTWARE\\WOW6432Node\\Microsoft\\EdgeUpdate\\Clients\\{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}",
        L"SOFTWARE\\Microsoft\\EdgeUpdate\\Clients\\{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}",
        L"SOFTWARE\\WOW6432Node\\Microsoft\\EdgeUpdate\\Clients\\{56EB18F8-B008-4CBD-B6D2-8C97FE7E9062}",
        L"SOFTWARE\\Microsoft\\EdgeUpdate\\Clients\\{56EB18F8-B008-4CBD-B6D2-8C97FE7E9062}"
    };
#if defined(_M_X64)
    const wchar_t* archSub = L"\\EBWebView\\x64\\EmbeddedBrowserWebView.dll";
#elif defined(_M_ARM64)
    const wchar_t* archSub = L"\\EBWebView\\arm64\\EmbeddedBrowserWebView.dll";
#else
    const wchar_t* archSub = L"\\EBWebView\\x86\\EmbeddedBrowserWebView.dll";
#endif
    HKEY roots[2] = { HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER };
    for (HKEY r : roots) {
        for (const wchar_t* sk : subKeys) {
            HKEY hk = NULL;
            if (RegOpenKeyExW(r, sk, 0, KEY_READ, &hk) == ERROR_SUCCESS) {
                wchar_t loc[MAX_PATH] = {}, pv[128] = {};
                DWORD szLoc = sizeof(loc), szPv = sizeof(pv);
                if (RegGetValueW(hk, NULL, L"EBWebView", RRF_RT_REG_SZ, NULL, loc, &szLoc) == ERROR_SUCCESS && loc[0]) {
                    std::wstring cand(loc); cand += archSub;
                    std::wstring validPath;
                    if (isTrustedWebView2DllPath(cand, validPath)) { RegCloseKey(hk); return validPath; }
                }
                szLoc = sizeof(loc);
                if (RegGetValueW(hk, NULL, L"location", RRF_RT_REG_SZ, NULL, loc, &szLoc) == ERROR_SUCCESS &&
                    RegGetValueW(hk, NULL, L"pv", RRF_RT_REG_SZ, NULL, pv, &szPv) == ERROR_SUCCESS && loc[0] && pv[0]) {
                    std::wstring cand(loc); cand += L"\\"; cand += pv; cand += archSub;
                    std::wstring validPath;
                    if (isTrustedWebView2DllPath(cand, validPath)) { RegCloseKey(hk); return validPath; }
                }
                RegCloseKey(hk);
            }
        }
    }
    return L"";
}
void Editor::initWebView2Async() {
    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
    if (!hwndPreviewHost) {
        hwndPreviewHost = CreateWindowExW(0, L"STATIC", NULL, WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, 0, 0, 100, 100, hwnd, NULL, GetModuleHandleW(NULL), NULL);
    }
    updatePreviewBounds();
    if (!hWebViewDll) {
        std::wstring dllPath = findWebView2Dll();
        if (!dllPath.empty()) hWebViewDll = LoadLibraryExW(dllPath.c_str(), NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
    }
    if (!hWebViewDll) { webviewInitStarted = false; return; }
    typedef HRESULT(STDAPICALLTYPE* PFN_CreateEnv)(bool, int, PCWSTR, IUnknown*, void*);
    auto pfn = (PFN_CreateEnv)GetProcAddress(hWebViewDll, "CreateWebViewEnvironmentWithOptionsInternal");
    if (!pfn) { webviewInitStarted = false; return; }
    wchar_t appData[MAX_PATH] = {};
    if (!GetEnvironmentVariableW(L"LOCALAPPDATA", appData, MAX_PATH)) GetTempPathW(MAX_PATH, appData);
    std::wstring udf(appData); udf += L"\\miu\\WebView2";
    static const void* const envVtbl[4] = { (void*)wv2_QI, (void*)wv2_AddRefRelease, (void*)wv2_AddRefRelease, (void*)wv2_EnvInvoke };
    static WV2Handler envHandler = { envVtbl, nullptr };
    envHandler.ed = this;
    pfn(true, 0, udf.c_str(), nullptr, &envHandler);
}
std::string Editor::escapeHtmlBasic(const std::string& s) {
    return MiuPreview::escapeHtmlBasic(s);
}
std::string Editor::formatMarkdownInline(const std::string& s, int depth) {
    return MiuPreview::formatMarkdownInline(s, depth);
}
std::string Editor::convertMarkdownToHtml(const std::string& md, int depth) {
    return MiuPreview::convertMarkdownToHtml(md, depth);
}
using MiuPreview::cachedMermaidRenderSvg;
using MiuPreview::looksLikeMermaid;

static uint64_t g_lastPreviewHash = 0;
static size_t g_lastPreviewRawLen = 0;
static bool g_previewMdShellReady = false;
static ULONGLONG g_previewShellNavTick = 0;
static std::wstring g_previewShellFolder;
static std::wstring g_previewShellFilePath;

static bool isSafePreviewFolder(const std::wstring& rawFolder) {
    if (rawFolder.empty()) return false;
    std::wstring norm = rawFolder;
    for (wchar_t& wc : norm) { if (wc == L'/') wc = L'\\'; }
    while (norm.size() > 1 && norm.back() == L'\\') norm.pop_back();
    if (norm.size() <= 3) return false;
    if (norm.size() == 2 && norm[1] == L':') return false;
    wchar_t buf[MAX_PATH] = {};
    if (GetEnvironmentVariableW(L"SystemRoot", buf, MAX_PATH) > 0) {
        std::wstring sr(buf);
        while (sr.size() > 1 && sr.back() == L'\\') sr.pop_back();
        if (_wcsicmp(norm.c_str(), sr.c_str()) == 0) return false;
    }
    if (GetEnvironmentVariableW(L"USERPROFILE", buf, MAX_PATH) > 0) {
        std::wstring up(buf);
        while (up.size() > 1 && up.back() == L'\\') up.pop_back();
        if (_wcsicmp(norm.c_str(), up.c_str()) == 0) return false;
        size_t sl = up.find_last_of(L'\\');
        if (sl != std::wstring::npos && sl > 2) {
            std::wstring usersDir = up.substr(0, sl);
            if (_wcsicmp(norm.c_str(), usersDir.c_str()) == 0) return false;
        }
    }
    if (norm.size() >= 9 && norm[1] == L':' && (_wcsicmp(norm.c_str() + 2, L"\\Windows") == 0 || _wcsicmp(norm.c_str() + 2, L"\\Users") == 0)) {
        return false;
    }
    return true;
}

using MiuPreview::getPreviewCspNonce;

void Editor::updatePreviewContent() {
    if (!showPreview || !webviewView) return;
    std::wstring folder;
    if (!currentFilePath.empty()) {
        size_t sl = currentFilePath.find_last_of(L"\\/");
        if (sl != std::wstring::npos) folder = currentFilePath.substr(0, sl);
    }
    if (!isSafePreviewFolder(folder)) {
        folder.clear();
    }
    if (folder != lastMappedFolder) {
        static const GUID iidView3 = { 0xa0d6df20, 0x3b92, 0x416d, { 0xaa, 0x0c, 0x43, 0x7a, 0x9c, 0x72, 0x78, 0x57 } };
        IUnknown* view3 = nullptr;
        if (SUCCEEDED(webviewView->QueryInterface(iidView3, (void**)&view3)) && view3) {
            if (folder.empty()) {
                typedef HRESULT(STDMETHODCALLTYPE* PFN_ClearHost)(IUnknown*, LPCWSTR);
                ((PFN_ClearHost)((*(void***)view3)[72]))(view3, L"miu.local");
            } else {
                typedef HRESULT(STDMETHODCALLTYPE* PFN_SetHost)(IUnknown*, LPCWSTR, LPCWSTR, int);
                ((PFN_SetHost)((*(void***)view3)[71]))(view3, L"miu.local", folder.c_str(), 2);
            }
            view3->Release();
            lastMappedFolder = folder;
        }
    }
    static constexpr size_t PREVIEW_MAX_BYTES = 524288;
    size_t totalBytes = pt.length();
    bool isTruncated = (totalBytes > PREVIEW_MAX_BYTES);
    std::string raw = pt.getRange(0, std::min(totalBytes, PREVIEW_MAX_BYTES));
    if (isTruncated && !raw.empty()) {
        size_t searchFrom = (raw.size() > 4096) ? (raw.size() - 4096) : 0;
        size_t lastNl = raw.find_last_of("\r\n");
        if (lastNl != std::string::npos && lastNl >= searchFrom) {
            raw.erase(lastNl + 1);
        } else {
            size_t cut = raw.size();
            while (cut > 0 && ((unsigned char)raw[cut - 1] & 0xC0) == 0x80) cut--;
            if (cut > 0) {
                unsigned char lead = (unsigned char)raw[cut - 1];
                size_t expLen = 1;
                if ((lead & 0xE0) == 0xC0) expLen = 2;
                else if ((lead & 0xF0) == 0xE0) expLen = 3;
                else if ((lead & 0xF8) == 0xF0) expLen = 4;
                if (cut - 1 + expLen > raw.size()) cut--;
            }
            raw.erase(cut);
        }
    }
    uint64_t h = 14695981039346656037ULL;
    for (unsigned char c : raw) { h ^= c; h *= 1099511628211ULL; }
    h ^= (uint64_t)(isDarkMode ? 0x100 : 0x200) ^ (uint64_t)(isTruncated ? 0x400 : 0);
    for (wchar_t wc : currentExtension) { h ^= (uint64_t)wc; h *= 1099511628211ULL; }
    for (wchar_t wc : folder) { h ^= (uint64_t)wc; h *= 1099511628211ULL; }
    if (h == g_lastPreviewHash && raw.size() == g_lastPreviewRawLen) {
        return;
    }
    g_lastPreviewHash = h;
    g_lastPreviewRawLen = raw.size();

    std::string truncNotice;
    if (isTruncated) {
        std::string msg = escapeHtmlBasic(WToUTF8(GetResString(IDS_PREVIEW_TRUNCATED)));
        truncNotice = "<div class=\"miu-trunc\">&#x2026; " + msg + "</div>";
    }

    const char* baseTag = folder.empty() ? "" : "<base href=\"https://miu.local/\">";
    const char* const kMdThemeStyle = MiuPreview::getMdThemeStyle();

    std::string lowerHead = Emmet::toLowerStr(raw.substr(0, std::min(raw.size(), (size_t)2048)));
    bool looksLikeHtmlDoc = (lowerHead.find("<!doctype") != std::string::npos || lowerHead.find("<html") != std::string::npos ||
                             lowerHead.find("<head") != std::string::npos || lowerHead.find("<body") != std::string::npos ||
                             lowerHead.find("<script") != std::string::npos || lowerHead.find("<style") != std::string::npos ||
                             lowerHead.find("<svg") != std::string::npos);
    bool isMermaid = (currentExtension == L"mmd" || currentExtension == L"mermaid" ||
                      ((currentExtension.empty() || currentExtension == L"txt") && !looksLikeHtmlDoc && looksLikeMermaid(raw)));
    bool isMd = (!isMermaid && (currentExtension == L"md" || currentExtension == L"markdown" || currentExtension == L"mdx" ||
                 (currentExtension.empty() && !looksLikeHtmlDoc && (raw.find('<') == std::string::npos || raw.find('#') != std::string::npos || raw.find("```") != std::string::npos || raw.find("~~~") != std::string::npos || raw.find("|") != std::string::npos || raw.find("**") != std::string::npos || raw.find("- ") != std::string::npos || raw.find("> ") != std::string::npos || raw.find("$") != std::string::npos))));
    if (isMermaid || isMd) {
        std::string bodyContent;
        if (isMermaid) {
            const std::string& svg = cachedMermaidRenderSvg(raw);
            if (!svg.empty()) {
                bodyContent = "<div class=\"pele-diagram pele-full\">";
                bodyContent += svg;
                bodyContent += "</div>";
            } else {
                bodyContent = "<div class=\"pele-diagram pele-full\" data-empty=\"1\"></div>";
            }
            bodyContent += truncNotice;
        } else {
            bodyContent = convertMarkdownToHtml(raw);
            bodyContent += truncNotice;
        }
        ULONGLONG nowTick = GetTickCount64();
        if (g_previewMdShellReady && g_previewShellFolder == folder && g_previewShellFilePath == currentFilePath && bodyContent.size() < 1048576 && (nowTick - g_previewShellNavTick) > 300) {
            std::wstring wBody = UTF8ToW(bodyContent);
            std::wstring wJs;
            wJs.reserve(wBody.size() + 128);
            wJs += L"(function(h,d){window.__miuUpdate?window.__miuUpdate(h,d):(window.__miuPending={h:h,dk:d});})(\"";
            for (size_t i = 0; i < wBody.size(); ++i) {
                wchar_t wc = wBody[i];
                if (wc == L'\\') wJs += L"\\\\";
                else if (wc == L'"') wJs += L"\\\"";
                else if (wc == L'\n') wJs += L"\\n";
                else if (wc == L'\r') wJs += L"\\r";
                else if (wc == 0x2028) wJs += L"\\u2028";
                else if (wc == 0x2029) wJs += L"\\u2029";
                else wJs += wc;
            }
            wJs += isDarkMode ? L"\",true);" : L"\",false);";
            typedef HRESULT(STDMETHODCALLTYPE* PFN_ExecScript)(IUnknown*, LPCWSTR, IUnknown*);
            ((PFN_ExecScript)((*(void***)webviewView)[29]))(webviewView, wJs.c_str(), nullptr);
            return;
        }
        const std::string& nonce = getPreviewCspNonce();
        std::string html; html.reserve(bodyContent.size() + 2560);
        html += "<!DOCTYPE html><html data-theme=\"";
        html += (isDarkMode ? "dark" : "light");
        html += "\"><head><meta charset=\"utf-8\"><meta http-equiv=\"Content-Security-Policy\" content=\"default-src 'none'; script-src 'nonce-";
        html += nonce;
        html += "'; style-src 'unsafe-inline'; img-src https: http: data:; font-src https: data:; media-src https: http: data:; connect-src 'none'; object-src 'none'; frame-src 'none'; form-action 'none'; base-uri https://miu.local/;\">";
        html += baseTag;
        html += kMdThemeStyle;
        html += "</head><body><div id=\"__miu_root\">";
        html += bodyContent;
        html += "</div><script nonce=\"";
        html += nonce;
        html += "\">(function(){"
            "window.__miuUpdate=function(h,dk){"
            "document.documentElement.setAttribute('data-theme',dk?'dark':'light');"
            "var r=document.getElementById('__miu_root');if(!r)return;"
            "var t=document.createElement('div');t.innerHTML=h;"
            "var od=r.querySelectorAll('.pele-diagram'),nd=t.querySelectorAll('.pele-diagram');"
            "var m=Math.min(od.length,nd.length);"
            "for(var i=0;i<m;i++){"
            "if(nd[i].getAttribute('data-empty')==='1'&&od[i].querySelector('svg.pele')){"
            "nd[i].innerHTML=od[i].innerHTML;nd[i].removeAttribute('data-empty');"
            "}"
            "}"
            "var nc=Array.from(t.childNodes);"
            "for(var j=0;j<nc.length;j++){"
            "if(j<r.childNodes.length){if(!r.childNodes[j].isEqualNode(nc[j]))r.replaceChild(nc[j],r.childNodes[j]);}"
            "else r.appendChild(nc[j]);"
            "}"
            "while(r.childNodes.length>nc.length)r.removeChild(r.lastChild);"
            "};"
            "if(window.__miuPending){var p=window.__miuPending;window.__miuPending=null;window.__miuUpdate(p.h,p.dk);}"
            "})();</script></body></html>";
        std::wstring wHtml = UTF8ToW(html);
        if (wHtml.size() > 950000) {
            wHtml.erase(950000);
            wHtml += L"</div></body></html>";
        }
        typedef HRESULT(STDMETHODCALLTYPE* PFN_NavStr)(IUnknown*, LPCWSTR);
        ((PFN_NavStr)((*(void***)webviewView)[6]))(webviewView, wHtml.c_str());
        g_previewMdShellReady = true;
        g_previewShellNavTick = nowTick;
        g_previewShellFolder = folder;
        g_previewShellFilePath = currentFilePath;
        return;
    }
    g_previewMdShellReady = false;
    std::string html; html.reserve(raw.size() + 1024);
    const char* webDefStyle = isDarkMode
        ? "<style>:where(:root){color-scheme:dark}html::-webkit-scrollbar,body::-webkit-scrollbar{display:none}html,body{scrollbar-width:none}</style>"
        : "<style>html::-webkit-scrollbar,body::-webkit-scrollbar{display:none}html,body{scrollbar-width:none}</style>";
    std::string lower = Emmet::toLowerStr(raw.substr(0, std::min(raw.size(), (size_t)1024)));
    bool hasFullHtml = (lower.find("<html") != std::string::npos || lower.find("<!doctype") != std::string::npos);
    if (hasFullHtml) {
        const char* bTag = (!folder.empty() && lower.find("<base") == std::string::npos) ? baseTag : "";
        size_t hp = lower.find("<head>");
        if (hp != std::string::npos) { html.append(raw, 0, hp + 6); html += bTag; html += webDefStyle; html.append(raw, hp + 6, std::string::npos); }
        else { html += bTag; html += webDefStyle; html += raw; }
        html += truncNotice;
    } else {
        bool isWebExt = (currentExtension.empty() || currentExtension == L"html" || currentExtension == L"htm" || currentExtension == L"xhtml" || currentExtension == L"shtml" || currentExtension == L"svg" || currentExtension == L"xml" || currentExtension == L"vue" || currentExtension == L"svelte" || currentExtension == L"astro" || currentExtension == L"php");
        if (isWebExt || raw.find('<') != std::string::npos) {
            html += "<!DOCTYPE html><html><head><meta charset=\"utf-8\">"; html += baseTag; html += webDefStyle; html += "</head><body>"; html += raw; html += truncNotice; html += "</body></html>";
        } else {
            html += "<!DOCTYPE html><html data-theme=\""; html += (isDarkMode ? "dark" : "light"); html += "\"><head><meta charset=\"utf-8\">"; html += kMdThemeStyle; html += "</head><body><pre>"; html += escapeHtmlBasic(raw); html += "</pre>"; html += truncNotice; html += "</body></html>";
        }
    }
    std::wstring wHtml = UTF8ToW(html);
    if (wHtml.size() > 950000) {
        wHtml.erase(950000);
        wHtml += L"</body></html>";
    }
    typedef HRESULT(STDMETHODCALLTYPE* PFN_NavStr)(IUnknown*, LPCWSTR);
    ((PFN_NavStr)((*(void***)webviewView)[6]))(webviewView, wHtml.c_str());
}
void Editor::togglePreview() {
    if (!hwnd) return;
    showPreview = !showPreview;
    if (showPreview) {
        if (showHelpPopup) showHelpPopup = false;
        g_lastPreviewHash = 0;
        g_lastPreviewRawLen = (size_t)-1;
        g_previewMdShellReady = false;
        if (!webviewController && !webviewInitStarted) {
            webviewInitStarted = true;
            initWebView2Async();
        } else {
            updatePreviewBounds();
            updatePreviewContent();
        }
        if (hwnd) SetFocus(hwnd);
    } else {
        KillTimer(hwnd, 4);
        isSplitterHover = false;
        isSplitterDragging = false;
        updatePreviewBounds();
        SetFocus(hwnd);
    }
    ensureCaretVisible();
    updateScrollBars();
    InvalidateRect(hwnd, NULL, FALSE);
}
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    switch (msg) {
    case WM_COPYDATA: {
        COPYDATASTRUCT* pcds = (COPYDATASTRUCT*)lParam;
        if (pcds && pcds->dwData == 1 && pcds->lpData && pcds->cbData >= sizeof(wchar_t) && pcds->cbData <= 65536) {
            const wchar_t* raw = (const wchar_t*)pcds->lpData;
            size_t maxChars = pcds->cbData / sizeof(wchar_t);
            size_t len = wcsnlen(raw, maxChars);
            if (len > 0 && len < maxChars) {
                std::wstring reqPath(raw, len);
                if (!g_editor.currentFilePath.empty() && _wcsicmp(g_editor.currentFilePath.c_str(), reqPath.c_str()) == 0) {
                    addToRecentFiles(reqPath);
                    return 1;
                }
            }
        }
        return 0;
    }
    case WM_ACTIVATE:
        if (LOWORD(wParam) != WA_INACTIVE) {
            g_editor.checkFileModification();
        }
        return DefWindowProc(hwnd, msg, wParam, lParam);
    case WM_SETCURSOR: {
        if (LOWORD(lParam) == HTCLIENT) {
            POINT pt; GetCursorPos(&pt); ScreenToClient(hwnd, &pt); RECT rc; GetClientRect(hwnd, &rc);
            float mouseX = pt.x / g_editor.dpiScaleX; float mouseY = pt.y / g_editor.dpiScaleY;
            float clientW = g_editor.getEditorDipWidth(); float clientH = (rc.bottom - rc.top) / g_editor.dpiScaleY;
            bool hasV = false, hasH = false, singleLineWrap = false;
            float vTrackH = 0, thumbY = 0, thumbH = 0, vMaxScroll = 1.0f;
            float hTrackW = 0, thumbX = 0, thumbW = 0, hMaxScroll = 1.0f;
            g_editor.getScrollBarLayout(clientW, clientH, hasV, vTrackH, thumbY, thumbH, vMaxScroll, singleLineWrap, hasH, hTrackW, thumbX, thumbW, hMaxScroll);
            float splitHitLeft = clientW - (hasV ? 2.0f : 4.0f);
            if (g_editor.showPreview && (g_editor.isSplitterDragging || (mouseX >= splitHitLeft && mouseX <= clientW + Editor::SPLITTER_DIP_W + 3.0f))) {
                SetCursor(LoadCursor(NULL, IDC_SIZEWE));
                return TRUE;
            }
            bool onVScroll = hasV && (mouseX >= clientW - Editor::SB_PADDING - Editor::SB_HIT_WIDTH && mouseX < (g_editor.showPreview ? splitHitLeft : clientW));
            bool onHScroll = hasH && (mouseY >= clientH - Editor::SB_PADDING - Editor::SB_HIT_WIDTH && mouseX < clientW);
            if (onVScroll || onHScroll || mouseX > clientW) SetCursor(LoadCursor(NULL, IDC_ARROW));
            else SetCursor(LoadCursor(NULL, IDC_IBEAM));
            return TRUE;
        }
        return DefWindowProc(hwnd, msg, wParam, lParam);
    }
    case WM_ERASEBKGND: return 1;
    case WM_CREATE: g_editor.initGraphics(hwnd); DragAcceptFiles(hwnd, TRUE); SetTimer(hwnd, 2, 2000, NULL); break;
    case WM_SETTINGCHANGE: { if (lParam && wcscmp((LPCWSTR)lParam, L"ImmersiveColorSet") == 0) g_editor.updateThemeColors(); break; }
    case WM_DPICHANGED: { float newDpiX = (float)LOWORD(wParam); float newDpiY = (float)HIWORD(wParam); RECT* const prcNewWindow = (RECT*)lParam; SetWindowPos(hwnd, NULL, prcNewWindow->left, prcNewWindow->top, prcNewWindow->right - prcNewWindow->left, prcNewWindow->bottom - prcNewWindow->top, SWP_NOZORDER | SWP_NOACTIVATE); g_editor.handleDpiChange(newDpiX, newDpiY); return 0; }
    case WM_WINDOWPOSCHANGED: if (g_editor.webviewController) { typedef HRESULT(STDMETHODCALLTYPE* PFN_Notify)(IUnknown*); ((PFN_Notify)((*(void***)g_editor.webviewController)[23]))(g_editor.webviewController); } return DefWindowProc(hwnd, msg, wParam, lParam);
    case WM_SIZE: { RECT rc; GetClientRect(hwnd, &rc); int w = rc.right - rc.left; int h = rc.bottom - rc.top; if (w > 0 && h > 0) { g_editor.resizeSwapChain(w, h); g_editor.ensureCaretVisible(); } } break;
    case WM_LBUTTONDOWN: {
        if (GetFocus() != hwnd) SetFocus(hwnd);
        if (g_editor.showHelpPopup) { g_editor.showHelpPopup = false; g_editor.updatePreviewBounds(); InvalidateRect(hwnd, NULL, FALSE); } int x = (short)LOWORD(lParam); int y = (short)HIWORD(lParam); RECT rc; GetClientRect(hwnd, &rc); float clientW = g_editor.getEditorDipWidth(); float clientH = (rc.bottom - rc.top) / g_editor.dpiScaleY; float mouseX = x / g_editor.dpiScaleX; float mouseY = y / g_editor.dpiScaleY;
        bool hasV = false, hasH = false, singleLineWrap = false;
        float vTrackH = 0, thumbY = 0, thumbH = 0, vMaxScroll = 1.0f;
        float hTrackW = 0, thumbX = 0, thumbW = 0, hMaxScroll = 1.0f;
        g_editor.getScrollBarLayout(clientW, clientH, hasV, vTrackH, thumbY, thumbH, vMaxScroll, singleLineWrap, hasH, hTrackW, thumbX, thumbW, hMaxScroll);
        float splitHitLeft = clientW - (hasV ? 2.0f : 4.0f);
        if (g_editor.showPreview && mouseX >= splitHitLeft && mouseX <= clientW + Editor::SPLITTER_DIP_W + 3.0f) {
            g_editor.isSplitterDragging = true;
            if (g_editor.hwndPreviewHost) EnableWindow(g_editor.hwndPreviewHost, FALSE);
            SetCapture(hwnd);
            SetCursor(LoadCursor(NULL, IDC_SIZEWE));
            InvalidateRect(hwnd, NULL, FALSE);
            return 0;
        }
        if (g_editor.showPreview && mouseX > clientW) return 0;
        if (hasV && mouseX >= clientW - Editor::SB_PADDING - Editor::SB_HIT_WIDTH && mouseX < (g_editor.showPreview ? splitHitLeft : clientW) && mouseY >= Editor::SB_PADDING && mouseY <= Editor::SB_PADDING + vTrackH) {
            if (mouseY >= thumbY && mouseY <= thumbY + thumbH) {
                g_editor.scrollDragOffset = mouseY - thumbY;
            } else {
                g_editor.scrollDragOffset = thumbH * 0.5f;
                float scrollableArea = vTrackH - thumbH;
                if (scrollableArea > 0.0f) {
                    float ratio = std::min(1.0f, std::max(0.0f, (mouseY - g_editor.scrollDragOffset - Editor::SB_PADDING) / scrollableArea));
                    if (singleLineWrap) g_editor.vScrollSubLine = (int)std::round(ratio * vMaxScroll);
                    else { g_editor.vScrollPos = (int)std::round(ratio * vMaxScroll); g_editor.vScrollSubLine = 0; }
                    g_editor.updateScrollBars();
                }
            }
            g_editor.isVScrollDragging = true;
            g_editor.isVScrollHover = true;
            SetCapture(hwnd);
            InvalidateRect(hwnd, NULL, FALSE);
            return 0;
        }
        if (hasH && mouseY >= clientH - Editor::SB_PADDING - Editor::SB_HIT_WIDTH && mouseX >= Editor::SB_PADDING && mouseX <= Editor::SB_PADDING + hTrackW) {
            if (mouseX >= thumbX && mouseX <= thumbX + thumbW) {
                g_editor.scrollDragOffset = mouseX - thumbX;
            } else {
                g_editor.scrollDragOffset = thumbW * 0.5f;
                float scrollableArea = hTrackW - thumbW;
                if (scrollableArea > 0.0f) {
                    float ratio = std::min(1.0f, std::max(0.0f, (mouseX - g_editor.scrollDragOffset - Editor::SB_PADDING) / scrollableArea));
                    g_editor.hScrollPos = (int)std::round(ratio * hMaxScroll);
                    g_editor.updateScrollBars();
                }
            }
            g_editor.isHScrollDragging = true;
            g_editor.isHScrollHover = true;
            SetCapture(hwnd);
            InvalidateRect(hwnd, NULL, FALSE);
            return 0;
        }
        SetCapture(hwnd); g_editor.isDragging = true; g_editor.clearEmmetTabstops(); g_editor.rollbackPadding();
        if (abs(x - g_editor.lastClickX) < 5 && abs(y - g_editor.lastClickY) < 5 && (GetMessageTime() - g_editor.lastClickTime < GetDoubleClickTime())) g_editor.clickCount++; else g_editor.clickCount = 1;
        g_editor.lastClickTime = GetMessageTime(); g_editor.lastClickX = x; g_editor.lastClickY = y;
        if (g_editor.clickCount == 1 && !(GetKeyState(VK_SHIFT) & 0x8000) && !(GetKeyState(VK_CONTROL) & 0x8000)) { size_t p = g_editor.getDocPosFromPoint(x, y); bool inSel = false; for (const auto& c : g_editor.cursors) if (c.hasSelection() && p >= c.start() && p < c.end()) inSel = true; if (inSel) { g_editor.isDragMovePending = true; g_editor.dragMoveSourceStart = g_editor.cursors.back().start(); g_editor.dragMoveSourceEnd = g_editor.cursors.back().end(); return 0; } }
        g_editor.isDragMovePending = false; g_editor.isDragMoving = false;
        if (GetKeyState(VK_MENU) & 0x8000) { g_editor.isRectSelecting = true; float vx = x / g_editor.dpiScaleX - g_editor.gutterWidth + g_editor.hScrollPos; size_t p = g_editor.getDocPosFromPoint(x, y); g_editor.rectAnchorX = g_editor.rectHeadX = vx; g_editor.rectAnchorLine = g_editor.rectHeadLine = g_editor.getLineIdx(p); g_editor.updateRectSelection(); }
        else g_editor.isRectSelecting = false;
        if (x / g_editor.dpiScaleX < g_editor.gutterWidth) { int line = 0; if (g_editor.wordWrapEnabled) { size_t p = g_editor.getDocPosFromPoint((int)(g_editor.gutterWidth * g_editor.dpiScaleX + 5), y); line = g_editor.getLineIdx(p); } else { line = g_editor.vScrollPos + (int)(y / g_editor.dpiScaleY / g_editor.lineHeight); } if (line >= 0 && line < (int)g_editor.lineStarts.size()) { size_t s = g_editor.lineStarts[line]; size_t e = (line + 1 < (int)g_editor.lineStarts.size()) ? g_editor.lineStarts[line + 1] : g_editor.pt.length(); g_editor.cursors.clear(); g_editor.cursors.push_back({ e, s, g_editor.getXFromPos(e) }); } }
        else { size_t p = g_editor.getDocPosFromPoint(x, y); bool ctrl = (GetKeyState(VK_CONTROL) & 0x8000) != 0; if (g_editor.clickCount == 2) { g_editor.isDragging = false; g_editor.selectWordAt(p, ctrl); } else if (g_editor.clickCount == 3) { g_editor.isDragging = false; g_editor.selectLineAt(p, ctrl); } else { if (GetKeyState(VK_SHIFT) & 0x8000) { if (!g_editor.cursors.empty()) { g_editor.cursors.back().head = p; g_editor.cursors.back().desiredX = g_editor.getXFromPos(p); } } else if (ctrl) g_editor.cursors.push_back({ p, p, g_editor.getXFromPos(p) }); else { g_editor.cursors.clear(); g_editor.cursors.push_back({ p, p, g_editor.getXFromPos(p) }); } } }
        InvalidateRect(hwnd, NULL, FALSE);
    } break;
    case WM_MOUSEMOVE: {
        if (!g_editor.isTrackingMouse) { TRACKMOUSEEVENT tme = { sizeof(TRACKMOUSEEVENT) }; tme.dwFlags = TME_LEAVE; tme.hwndTrack = hwnd; TrackMouseEvent(&tme); g_editor.isTrackingMouse = true; }
        int x = (short)LOWORD(lParam), y = (short)HIWORD(lParam); RECT rc; GetClientRect(hwnd, &rc); float fullW = (rc.right - rc.left) / g_editor.dpiScaleX; float clientW = g_editor.getEditorDipWidth(); float clientH = (rc.bottom - rc.top) / g_editor.dpiScaleY; float mouseX = x / g_editor.dpiScaleX; float mouseY = y / g_editor.dpiScaleY;
        if (g_editor.isSplitterDragging) {
            if (fullW > 240.0f) {
                float r = (mouseX - Editor::SPLITTER_DIP_W * 0.5f) / fullW;
                if (r < 0.15f) r = 0.15f;
                if (r > 0.85f) r = 0.85f;
                g_editor.previewSplitRatio = r;
                g_editor.updatePreviewBounds();
                g_editor.updateScrollBars();
                InvalidateRect(hwnd, NULL, FALSE);
                UpdateWindow(hwnd);
            }
            return 0;
        }
        bool hasV = false, hasH = false, singleLineWrap = false;
        float vTrackH = 0, thumbY = 0, thumbH = 0, vMaxScroll = 1.0f;
        float hTrackW = 0, thumbX = 0, thumbW = 0, hMaxScroll = 1.0f;
        g_editor.getScrollBarLayout(clientW, clientH, hasV, vTrackH, thumbY, thumbH, vMaxScroll, singleLineWrap, hasH, hTrackW, thumbX, thumbW, hMaxScroll);
        float splitHitLeft = clientW - (hasV ? 2.0f : 4.0f);
        bool prevVHover = g_editor.isVScrollHover; bool prevHHover = g_editor.isHScrollHover; bool prevSpHover = g_editor.isSplitterHover;
        g_editor.isSplitterHover = g_editor.showPreview && (mouseX >= splitHitLeft && mouseX <= clientW + Editor::SPLITTER_DIP_W + 3.0f);
        if (g_editor.isVScrollDragging) { g_editor.isVScrollHover = true; g_editor.isHScrollHover = false; }
        else if (g_editor.isHScrollDragging) { g_editor.isVScrollHover = false; g_editor.isHScrollHover = true; }
        else {
            g_editor.isVScrollHover = !g_editor.isSplitterHover && hasV && (mouseX >= clientW - Editor::SB_PADDING - Editor::SB_HIT_WIDTH && mouseX < (g_editor.showPreview ? splitHitLeft : clientW) && mouseY >= Editor::SB_PADDING && mouseY <= Editor::SB_PADDING + vTrackH);
            g_editor.isHScrollHover = !g_editor.isSplitterHover && hasH && (mouseY >= clientH - Editor::SB_PADDING - Editor::SB_HIT_WIDTH && mouseX >= Editor::SB_PADDING && mouseX <= Editor::SB_PADDING + hTrackW);
        }
        if (prevVHover != g_editor.isVScrollHover || prevHHover != g_editor.isHScrollHover || prevSpHover != g_editor.isSplitterHover) InvalidateRect(hwnd, NULL, FALSE);
        if (g_editor.isVScrollDragging || g_editor.isHScrollDragging) {
            if (g_editor.isVScrollDragging) {
                float scrollableArea = vTrackH - thumbH;
                if (scrollableArea > 0.0f) {
                    float ratio = std::min(1.0f, std::max(0.0f, (mouseY - g_editor.scrollDragOffset - Editor::SB_PADDING) / scrollableArea));
                    if (singleLineWrap) g_editor.vScrollSubLine = (int)std::round(ratio * vMaxScroll);
                    else { g_editor.vScrollPos = (int)std::round(ratio * vMaxScroll); g_editor.vScrollSubLine = 0; }
                }
            } else if (g_editor.isHScrollDragging) {
                float scrollableArea = hTrackW - thumbW;
                if (scrollableArea > 0.0f) {
                    float ratio = std::min(1.0f, std::max(0.0f, (mouseX - g_editor.scrollDragOffset - Editor::SB_PADDING) / scrollableArea));
                    g_editor.hScrollPos = (int)std::round(ratio * hMaxScroll);
                }
            }
            g_editor.updateScrollBars(); InvalidateRect(hwnd, NULL, FALSE); return 0;
        }
        if (g_editor.isDragMovePending) { if (abs(x - g_editor.lastClickX) > 5 || abs(y - g_editor.lastClickY) > 5) { g_editor.isDragMovePending = false; g_editor.isDragMoving = true; SetCursor(LoadCursor(NULL, IDC_ARROW)); } }
        if (g_editor.isDragMoving) { g_editor.dragMoveDestPos = g_editor.getDocPosFromPoint(x, y); InvalidateRect(hwnd, NULL, FALSE); return 0; }
        if (g_editor.isDragging && !g_editor.isDragMovePending) {
            bool outOfBounds = (x < g_editor.gutterWidth * g_editor.dpiScaleX || x > rc.right || y < 0 || y > rc.bottom);
            if (outOfBounds) {
                if (!g_editor.isAutoScrolling) { g_editor.isAutoScrolling = true; SetTimer(hwnd, 3, 30, NULL); }
            }
            else {
                if (g_editor.isAutoScrolling) { g_editor.isAutoScrolling = false; KillTimer(hwnd, 3); }
                if (g_editor.isRectSelecting) { float vx = x / g_editor.dpiScaleX - g_editor.gutterWidth + g_editor.hScrollPos; size_t p = g_editor.getDocPosFromPoint(x, y); g_editor.rectHeadX = vx; g_editor.rectHeadLine = g_editor.getLineIdx(p); g_editor.updateRectSelection(); }
                else { size_t p = g_editor.getDocPosFromPoint(x, y); if (!g_editor.cursors.empty()) { g_editor.cursors.back().head = p; g_editor.cursors.back().desiredX = g_editor.getXFromPos(p); } }
                InvalidateRect(hwnd, NULL, FALSE);
            }
        }
    } break;
    case WM_LBUTTONUP:
        if (g_editor.isSplitterDragging) { g_editor.isSplitterDragging = false; if (g_editor.hwndPreviewHost) EnableWindow(g_editor.hwndPreviewHost, TRUE); ReleaseCapture(); g_editor.updatePreviewBounds(); g_editor.ensureCaretVisible(); InvalidateRect(hwnd, NULL, FALSE); return 0; }
        if (g_editor.isVScrollDragging || g_editor.isHScrollDragging) { g_editor.isVScrollDragging = false; g_editor.isHScrollDragging = false; ReleaseCapture(); InvalidateRect(hwnd, NULL, FALSE); return 0; }
        if (g_editor.isAutoScrolling) { KillTimer(hwnd, 3); g_editor.isAutoScrolling = false; }
        if (g_editor.isDragMovePending) { g_editor.isDragMovePending = false; size_t p = g_editor.getDocPosFromPoint((short)LOWORD(lParam), (short)HIWORD(lParam)); g_editor.cursors.clear(); g_editor.cursors.push_back({ p, p, g_editor.getXFromPos(p) }); InvalidateRect(hwnd, NULL, FALSE); }
        else if (g_editor.isDragMoving) g_editor.performDragMove();
        g_editor.isDragging = false; g_editor.isDragMoving = false; g_editor.mergeCursors(); ReleaseCapture(); break;
    case WM_MOUSELEAVE: { g_editor.isTrackingMouse = false; g_editor.isVScrollHover = false; g_editor.isHScrollHover = false; g_editor.isSplitterHover = false; InvalidateRect(hwnd, NULL, FALSE); return 0; }
    case WM_VSCROLL: { RECT rc; GetClientRect(hwnd, &rc); int page = (int)((rc.bottom / g_editor.dpiScaleY) / g_editor.lineHeight); switch (LOWORD(wParam)) { case SB_LINEUP: g_editor.scrollVisualLines(-1); break; case SB_LINEDOWN: g_editor.scrollVisualLines(1); break; case SB_PAGEUP: g_editor.scrollVisualLines(-page); break; case SB_PAGEDOWN: g_editor.scrollVisualLines(page); break; case SB_THUMBTRACK: { SCROLLINFO si = { sizeof(SCROLLINFO), SIF_TRACKPOS }; GetScrollInfo(hwnd, SB_VERT, &si); g_editor.vScrollPos = si.nTrackPos; g_editor.vScrollSubLine = 0; } break; } if (g_editor.vScrollPos < 0) g_editor.vScrollPos = 0; if (g_editor.vScrollPos > (int)g_editor.lineStarts.size()) g_editor.vScrollPos = (int)g_editor.lineStarts.size(); g_editor.updateScrollBars(); InvalidateRect(hwnd, NULL, FALSE); } break;
    case WM_HSCROLL: { switch (LOWORD(wParam)) { case SB_LINELEFT: g_editor.hScrollPos -= 10; break; case SB_LINERIGHT: g_editor.hScrollPos += 10; break; case SB_PAGELEFT: g_editor.hScrollPos -= 100; break; case SB_PAGERIGHT: g_editor.hScrollPos += 100; break; case SB_THUMBTRACK: { SCROLLINFO si = { sizeof(SCROLLINFO), SIF_TRACKPOS }; GetScrollInfo(hwnd, SB_HORZ, &si); g_editor.hScrollPos = si.nTrackPos; } break; } if (g_editor.hScrollPos < 0) g_editor.hScrollPos = 0; g_editor.updateScrollBars(); InvalidateRect(hwnd, NULL, FALSE); } break;
    case WM_MOUSEWHEEL:
        if (GET_KEYSTATE_WPARAM(wParam) & MK_CONTROL) { float s = (GET_WHEEL_DELTA_WPARAM(wParam) > 0) ? 1.1f : 0.9f; g_editor.updateFont(g_editor.currentFontSize * s); g_editor.rebuildLineStarts(); g_editor.zoomPopupEndTime = GetTickCount64() + 1000; g_editor.zoomPopupText = std::to_wstring((int)g_editor.currentFontSize) + L"px"; SetTimer(hwnd, 1, 1000, NULL); }
        else { int notches = GET_WHEEL_DELTA_WPARAM(wParam) / WHEEL_DELTA; g_editor.scrollVisualLines(-notches * 3); }
        InvalidateRect(hwnd, NULL, FALSE); break;
    case WM_MOUSEHWHEEL: { if (g_editor.wordWrapEnabled) break; int delta = GET_WHEEL_DELTA_WPARAM(wParam); g_editor.hScrollPos += delta; if (g_editor.hScrollPos < 0) g_editor.hScrollPos = 0; if (g_editor.hScrollPos > (int)g_editor.maxLineWidth) g_editor.hScrollPos = (int)g_editor.maxLineWidth; g_editor.updateScrollBars(); InvalidateRect(hwnd, NULL, FALSE); } break;
    case WM_TIMER:
        if (wParam == 1) { KillTimer(hwnd, 1); InvalidateRect(hwnd, NULL, FALSE); }
        else if (wParam == 2) { g_editor.checkFileModification(); }
        else if (wParam == 4) { KillTimer(hwnd, 4); g_editor.updatePreviewContent(); }
        else if (wParam == 5) { KillTimer(hwnd, 5); if (!g_editor.webviewController && !g_editor.webviewInitStarted) { g_editor.webviewInitStarted = true; g_editor.initWebView2Async(); } }
        else if (wParam == 3) {
            if (g_editor.isDragging && g_editor.isAutoScrolling) {
                POINT pt; GetCursorPos(&pt); ScreenToClient(hwnd, &pt); RECT rc; GetClientRect(hwnd, &rc);
                float clientW = (rc.right - rc.left) / g_editor.dpiScaleX;
                bool outOfBounds = (pt.x < g_editor.gutterWidth * g_editor.dpiScaleX || pt.x > rc.right || pt.y < 0 || pt.y > rc.bottom);
                if (outOfBounds) {
                    bool scrolled = false;
                    if (pt.y < 0) { g_editor.scrollVisualLines(-1); scrolled = true; }
                    else if (pt.y > rc.bottom) { g_editor.scrollVisualLines(1); scrolled = true; }
                    if (pt.x < g_editor.gutterWidth * g_editor.dpiScaleX) { if (g_editor.hScrollPos > 0) { g_editor.hScrollPos -= 10; if (g_editor.hScrollPos < 0) g_editor.hScrollPos = 0; scrolled = true; } }
                    else if (pt.x > rc.right) { float visibleW = std::max(0.0f, g_editor.getEditorDipWidth() - g_editor.gutterWidth); int maxH = (g_editor.wordWrapEnabled || g_editor.maxLineWidth <= visibleW) ? 0 : std::max(0, (int)(g_editor.maxLineWidth - visibleW + g_editor.charWidth * 4.0f)); if (g_editor.hScrollPos < maxH) { g_editor.hScrollPos += 10; scrolled = true; } }
                    if (scrolled) g_editor.updateScrollBars();
                    if (g_editor.isRectSelecting) {
                        float vx = pt.x / g_editor.dpiScaleX - g_editor.gutterWidth + g_editor.hScrollPos;
                        float vy = pt.y / g_editor.dpiScaleY + (g_editor.vScrollPos * g_editor.lineHeight);
                        g_editor.rectHeadX = vx; size_t p = g_editor.getDocPosFromPoint(pt.x, pt.y); g_editor.rectHeadLine = g_editor.getLineIdx(p); g_editor.updateRectSelection();
                    }
                    else {
                        size_t p = g_editor.getDocPosFromPoint(pt.x, pt.y);
                        if (!g_editor.cursors.empty()) { g_editor.cursors.back().head = p; g_editor.cursors.back().desiredX = g_editor.getXFromPos(p); }
                    }
                    InvalidateRect(hwnd, NULL, FALSE);
                }
                else { KillTimer(hwnd, 3); g_editor.isAutoScrolling = false; }
            }
            else { KillTimer(hwnd, 3); g_editor.isAutoScrolling = false; }
        }
        break;
    case WM_CHAR: {
        if ((GetKeyState(VK_CONTROL) & 0x8000) && !(GetKeyState(VK_MENU) & 0x8000)) break;
        if (g_editor.showHelpPopup) { g_editor.showHelpPopup = false; InvalidateRect(hwnd, NULL, FALSE); } wchar_t c = (wchar_t)wParam; if (c < 32 && c != 8 && c != 13) break;
        if (c == 8) { g_editor.highSurrogate = 0; bool hadSelection = false; for (const auto& cur : g_editor.cursors) { if (cur.hasSelection()) { hadSelection = true; break; } } g_editor.rollbackPadding(); g_editor.backspaceAtCursors(!hadSelection); if (hadSelection) { for (auto& cur : g_editor.cursors) cur.anchor = cur.head; } InvalidateRect(hwnd, NULL, FALSE); }
        else if (c == 13) { g_editor.highSurrogate = 0; g_editor.insertNewlineWithAutoIndent(); }
        else { if (c >= 0xD800 && c <= 0xDBFF) { g_editor.highSurrogate = c; return 0; } std::wstring s; if (c >= 0xDC00 && c <= 0xDFFF) { if (g_editor.highSurrogate) { s += g_editor.highSurrogate; s += c; g_editor.highSurrogate = 0; } else return 0; } else { g_editor.highSurrogate = 0; s += c; } g_editor.insertAtCursors(WToUTF8(s)); }
    } break;
    case WM_SETFOCUS: InvalidateRect(hwnd, NULL, FALSE); break;
    case WM_IME_STARTCOMPOSITION: g_editor.ensureCaretVisible(); InvalidateRect(hwnd, NULL, FALSE); return 0;
    case WM_IME_COMPOSITION: { HIMC h = ImmGetContext(hwnd); if (h) { if (lParam & GCS_RESULTSTR) { DWORD s = ImmGetCompositionStringW(h, GCS_RESULTSTR, NULL, 0); if (s) { std::vector<wchar_t> b(s / 2); ImmGetCompositionStringW(h, GCS_RESULTSTR, b.data(), s); g_editor.insertAtCursors(WToUTF8(std::wstring(b.begin(), b.end()))); g_editor.imeComp.clear(); } } if (lParam & GCS_COMPSTR) { DWORD s = ImmGetCompositionStringW(h, GCS_COMPSTR, NULL, 0); if (s) { std::vector<wchar_t> b(s / 2); ImmGetCompositionStringW(h, GCS_COMPSTR, b.data(), s); g_editor.imeComp = WToUTF8(std::wstring(b.begin(), b.end())); g_editor.ensureCaretVisible(); } else g_editor.imeComp.clear(); } ImmReleaseContext(hwnd, h); InvalidateRect(hwnd, NULL, FALSE); } return 0; } break;
    case WM_IME_ENDCOMPOSITION: g_editor.imeComp.clear(); InvalidateRect(hwnd, NULL, FALSE); break;
    case WM_IME_SETCONTEXT: lParam &= ~ISC_SHOWUICOMPOSITIONWINDOW; return DefWindowProc(hwnd, msg, wParam, lParam);
    case WM_SYSCHAR:
        if (wParam == 'Z' || wParam == 'z' || wParam == 'T' || wParam == 't' || wParam == 'P' || wParam == 'p') return 0;
        return DefWindowProc(hwnd, msg, wParam, lParam);
    case WM_SYSKEYDOWN:
        if (wParam == 'Z') { g_editor.wordWrapEnabled = !g_editor.wordWrapEnabled; if (g_editor.wordWrapEnabled) g_editor.hScrollPos = 0; else g_editor.vScrollSubLine = 0; g_editor.ensureCaretVisible(); g_editor.updateScrollBars(); InvalidateRect(hwnd, NULL, FALSE); return 0; }
        if (wParam == 'T') { g_editor.toggleAlwaysOnTop(); return 0; }
        if (wParam == 'P') { g_editor.togglePreview(); return 0; }
        if (wParam == VK_UP || wParam == VK_DOWN) {
            bool ctrl = (GetKeyState(VK_CONTROL) & 0x8000) != 0;
            bool shift = (GetKeyState(VK_SHIFT) & 0x8000) != 0;
            if (ctrl) g_editor.addCursor(wParam == VK_UP);
            else if (shift) g_editor.duplicateLines(wParam == VK_UP);
            else g_editor.moveLines(wParam == VK_UP);
            return 0;
        } if (wParam != VK_LEFT && wParam != VK_RIGHT) return DefWindowProc(hwnd, msg, wParam, lParam); break;
    case WM_KEYDOWN:
        if (wParam == VK_APPS || (wParam == VK_F10 && (GetKeyState(VK_SHIFT) & 0x8000))) return DefWindowProc(hwnd, msg, wParam, lParam);
        if (wParam == VK_INSERT) { if (!(GetKeyState(VK_CONTROL) & 0x8000) && !(GetKeyState(VK_SHIFT) & 0x8000)) { g_editor.isOverwriteMode = !g_editor.isOverwriteMode; InvalidateRect(hwnd, NULL, FALSE); return 0; } }
        if (wParam == VK_TAB) { if (GetKeyState(VK_SHIFT) & 0x8000) { if (!g_editor.isRectSelecting && g_editor.jumpEmmetTabstop(false)) return 0; g_editor.unindentLines(); } else { if (g_editor.isRectSelecting) g_editor.insertAtCursors("\t"); else if (g_editor.tryExpandEmmet()) return 0; else if (g_editor.jumpEmmetTabstop(true)) return 0; else g_editor.indentLines(false); } return 0; }
        if (GetKeyState(VK_CONTROL) & 0x8000) {
            switch (wParam) {
            case 'O': g_editor.openFile(); return 0;
            case 'N': case VK_F4: g_editor.newFile(); return 0;
            case 'S': if (GetKeyState(VK_SHIFT) & 0x8000) g_editor.saveFileAs(); else if (g_editor.currentFilePath.empty()) g_editor.saveFileAs(); else g_editor.saveFile(g_editor.currentFilePath); return 0;
            case 'W': PostMessage(hwnd, WM_CLOSE, 0, 0); return 0;
            case 'Z': g_editor.performUndo(); return 0;
            case 'Y': g_editor.performRedo(); return 0;
            case 'C': case VK_INSERT: g_editor.copyToClipboard(); return 0;
            case 'X': g_editor.cutToClipboard(); return 0;
            case 'V': g_editor.pasteFromClipboard(); return 0;
            case 'D': g_editor.selectNextOccurrence(); return 0;
            case 'G': g_editor.showGoToDialog(); return 0;
            case 'L': if (GetKeyState(VK_SHIFT) & 0x8000) g_editor.deleteLines(); else g_editor.showGoToDialog(); return 0;
            case VK_OEM_6: g_editor.indentLines(true); return 0;
            case VK_OEM_4: g_editor.unindentLines(); return 0;
            case VK_OEM_2: case VK_DIVIDE: g_editor.toggleComment(); return 0;
            case 'U': if (GetKeyState(VK_SHIFT) & 0x8000) g_editor.convertCase(false); else g_editor.convertCase(true); return 0;
            case 'B': g_editor.jumpToMatchingBracket(); return 0;
            case 'A': { g_editor.rollbackPadding(); g_editor.cursors.clear(); g_editor.cursors.push_back({ g_editor.pt.length(), 0, 0.0f }); InvalidateRect(hwnd, NULL, FALSE); return 0; }
            case 'K': if (GetKeyState(VK_SHIFT) & 0x8000) { g_editor.deleteLines(); return 0; } break;
            case VK_ADD: case VK_OEM_PLUS: { g_editor.updateFont(g_editor.currentFontSize * 1.1f); g_editor.rebuildLineStarts(); g_editor.zoomPopupEndTime = GetTickCount64() + 1000; g_editor.zoomPopupText = std::to_wstring((int)g_editor.currentFontSize) + L"px"; SetTimer(hwnd, 1, 1000, NULL); InvalidateRect(hwnd, NULL, FALSE); return 0; }
            case VK_SUBTRACT: case VK_OEM_MINUS: { g_editor.updateFont(g_editor.currentFontSize * 0.9f); g_editor.rebuildLineStarts(); g_editor.zoomPopupEndTime = GetTickCount64() + 1000; g_editor.zoomPopupText = std::to_wstring((int)g_editor.currentFontSize) + L"px"; SetTimer(hwnd, 1, 1000, NULL); InvalidateRect(hwnd, NULL, FALSE); return 0; }
            case '0': case VK_NUMPAD0: { g_editor.updateFont(21.0f); g_editor.rebuildLineStarts(); g_editor.zoomPopupEndTime = GetTickCount64() + 1000; g_editor.zoomPopupText = std::to_wstring((int)g_editor.currentFontSize) + L"px"; SetTimer(hwnd, 1, 1000, NULL); InvalidateRect(hwnd, NULL, FALSE); return 0; }
            case VK_UP:
            case VK_DOWN: {
                bool alt = (GetKeyState(VK_MENU) & 0x8000) != 0;
                if (alt) {
                    g_editor.addCursor(wParam == VK_UP);
                } else {
                    bool shift = (GetKeyState(VK_SHIFT) & 0x8000) != 0;
                    g_editor.rollbackPadding();
                    g_editor.jumpToFileEdge(wParam == VK_UP, shift);
                }
                return 0;
            }
            default: break;
            }
        }
        if ((GetKeyState(VK_SHIFT) & 0x8000) && wParam == VK_INSERT) { g_editor.pasteFromClipboard(); return 0; }
        if (wParam == VK_ESCAPE) { g_editor.clearEmmetTabstops(); g_editor.rollbackPadding(); if (!g_editor.cursors.empty()) { Cursor c = g_editor.cursors.back(); c.anchor = c.head; g_editor.cursors.clear(); g_editor.cursors.push_back(c); g_editor.isRectSelecting = false; InvalidateRect(hwnd, NULL, FALSE); } return 0; }
        if (wParam == VK_DELETE) { g_editor.rollbackPadding(); g_editor.isRectSelecting = false; g_editor.deleteForwardAtCursors(); InvalidateRect(hwnd, NULL, FALSE); return 0; }
        if (g_editor.showHelpPopup) { g_editor.showHelpPopup = false; InvalidateRect(hwnd, NULL, FALSE); }
        if (wParam == VK_LEFT || wParam == VK_RIGHT || wParam == VK_UP || wParam == VK_DOWN || wParam == VK_HOME || wParam == VK_END || wParam == VK_PRIOR || wParam == VK_NEXT) {
            bool shift = (GetKeyState(VK_SHIFT) & 0x8000); bool ctrl = (GetKeyState(VK_CONTROL) & 0x8000); bool alt = (GetKeyState(VK_MENU) & 0x8000);
            if (alt && shift && (wParam == VK_LEFT || wParam == VK_RIGHT || wParam == VK_UP || wParam == VK_DOWN)) {
                if (!g_editor.isRectSelecting) {
                    g_editor.isRectSelecting = true;
                    if (g_editor.cursors.size() > 1) {
                        int minLine = (int)g_editor.lineStarts.size();
                        int maxLine = -1;
                        for (const auto& c : g_editor.cursors) {
                            int l = (int)g_editor.getLineIdx(c.head);
                            if (l < minLine) minLine = l;
                            if (l > maxLine) maxLine = l;
                        }
                        if (minLine > maxLine) { minLine = maxLine = 0; }
                        const auto& refCursor = g_editor.cursors.back();
                        if (refCursor.hasSelection()) {
                            g_editor.rectAnchorX = g_editor.getXFromPos(refCursor.anchor);
                            g_editor.rectHeadX = g_editor.getXFromPos(refCursor.head);
                        } else {
                            g_editor.rectAnchorX = g_editor.rectHeadX = (refCursor.desiredX > 0.0f || refCursor.head == g_editor.lineStarts[minLine]) ? refCursor.desiredX : g_editor.getXFromPos(refCursor.head);
                        }
                        g_editor.rectAnchorLine = minLine;
                        g_editor.rectHeadLine = maxLine;
                    } else {
                        size_t p = g_editor.cursors.empty() ? 0 : g_editor.cursors.back().head;
                        g_editor.rectAnchorX = g_editor.rectHeadX = g_editor.getXFromPos(p);
                        g_editor.rectAnchorLine = g_editor.rectHeadLine = g_editor.getLineIdx(p);
                    }
                }
                if (wParam == VK_LEFT || wParam == VK_RIGHT) { int lineIdx = g_editor.rectHeadLine; if (lineIdx < 0) lineIdx = 0; if (lineIdx >= (int)g_editor.lineStarts.size()) lineIdx = (int)g_editor.lineStarts.size() - 1; size_t pos = g_editor.getPosFromLineAndX(lineIdx, g_editor.rectHeadX); float textEndX = g_editor.getXFromPos(pos); bool inVirtualSpace = (g_editor.rectHeadX > textEndX + 1.0f); if (inVirtualSpace) { if (wParam == VK_LEFT) { g_editor.rectHeadX -= g_editor.charWidth; if (g_editor.rectHeadX < textEndX) g_editor.rectHeadX = textEndX; } else g_editor.rectHeadX += g_editor.charWidth; } else { bool forward = (wParam == VK_RIGHT); size_t nextPos = g_editor.moveCaretVisual(pos, forward); g_editor.rectHeadX = g_editor.getXFromPos(nextPos); } }
                if (wParam == VK_UP) { if (g_editor.rectHeadLine > 0) g_editor.rectHeadLine--; } if (wParam == VK_DOWN) { if (g_editor.rectHeadLine + 1 < (int)g_editor.lineStarts.size()) g_editor.rectHeadLine++; } g_editor.updateRectSelection(); InvalidateRect(hwnd, NULL, FALSE); return 0;
            }
            g_editor.rollbackPadding(); g_editor.isRectSelecting = false;
            for (auto& c : g_editor.cursors) {
                if (wParam == VK_LEFT) { c.affinity = false; if (c.hasSelection() && !shift) { c.head = c.start(); c.anchor = c.head; } else { if (ctrl) c.head = g_editor.moveWordLeft(c.head); else c.head = g_editor.moveCaretVisual(c.head, false); if (!shift) c.anchor = c.head; } }
                else if (wParam == VK_RIGHT) {
                    if (c.hasSelection() && !shift) {
                        c.affinity = false;
                        c.head = c.end();
                        c.anchor = c.head;
                    } else {
                        if (ctrl) {
                            c.affinity = false;
                            c.head = g_editor.moveWordRight(c.head);
                            if (!shift) c.anchor = c.head;
                        } else {
                            if (g_editor.wordWrapEnabled) {
                                size_t nextPos = g_editor.moveCaretVisual(c.head, true);
                                bool isWrap = g_editor.isVisualLineWrapBoundary(nextPos, c.head);
                                c.head = nextPos;
                                c.affinity = isWrap;
                                if (!shift) c.anchor = c.head;
                            } else {
                                c.affinity = false;
                                c.head = g_editor.moveCaretVisual(c.head, true);
                                if (!shift) c.anchor = c.head;
                            }
                        }
                    }
                }
                else if (wParam == VK_UP) { c.head = g_editor.moveVisualUpDown(c.head, c.desiredX, true, c.affinity, c.affinity); if (!shift) c.anchor = c.head; }
                else if (wParam == VK_DOWN) { c.head = g_editor.moveVisualUpDown(c.head, c.desiredX, false, c.affinity, c.affinity); if (!shift) c.anchor = c.head; }
                else if (wParam == VK_HOME) { if (ctrl) { c.head = 0; c.affinity = false; } else { if (g_editor.wordWrapEnabled) c.head = g_editor.moveVisualHome(c.head, c.affinity, c.affinity); else { c.affinity = false; size_t p = c.head; while (p > 0 && g_editor.pt.charAt(p - 1) != '\n' && g_editor.pt.charAt(p - 1) != '\r') p--; c.head = p; } } if (!shift) c.anchor = c.head; }
                else if (wParam == VK_END) { if (ctrl) { c.head = g_editor.pt.length(); c.affinity = false; } else { if (g_editor.wordWrapEnabled) c.head = g_editor.moveVisualEnd(c.head, c.affinity, c.affinity); else { c.affinity = false; size_t p = c.head; size_t len = g_editor.pt.length(); while (p < len && g_editor.pt.charAt(p) != '\n' && g_editor.pt.charAt(p) != '\r') p++; c.head = p; } } if (!shift) c.anchor = c.head; c.desiredX = g_editor.getXFromPos(c.head, c.affinity); }
                else if (wParam == VK_PRIOR) { RECT r; GetClientRect(hwnd, &r); int p = (int)((r.bottom / g_editor.dpiScaleY) / g_editor.lineHeight); if (g_editor.wordWrapEnabled) { for (int i = 0; i < p; ++i) c.head = g_editor.moveVisualUpDown(c.head, c.desiredX, true, c.affinity, c.affinity); } else { c.affinity = false; int l = g_editor.getLineIdx(c.head); c.head = g_editor.getPosFromLineAndX(std::max(0, l - p), c.desiredX); } if (!shift) c.anchor = c.head; }
                else if (wParam == VK_NEXT) { RECT r; GetClientRect(hwnd, &r); int p = (int)((r.bottom / g_editor.dpiScaleY) / g_editor.lineHeight); if (g_editor.wordWrapEnabled) { for (int i = 0; i < p; ++i) c.head = g_editor.moveVisualUpDown(c.head, c.desiredX, false, c.affinity, c.affinity); } else { c.affinity = false; int l = g_editor.getLineIdx(c.head); c.head = g_editor.getPosFromLineAndX(std::min((int)g_editor.lineStarts.size() - 1, l + p), c.desiredX); } if (!shift) c.anchor = c.head; }
                if (wParam == VK_LEFT || wParam == VK_RIGHT || wParam == VK_HOME || wParam == VK_END) c.desiredX = g_editor.getXFromPos(c.head, c.affinity);
            }
            g_editor.mergeCursors(); g_editor.ensureCaretVisible(); InvalidateRect(hwnd, NULL, FALSE);
        } break;
    case WM_DROPFILES: { if (g_editor.checkUnsavedChanges()) { HDROP hDrop = (HDROP)wParam; WCHAR file[MAX_PATH]; if (DragQueryFileW(hDrop, 0, file, MAX_PATH) && g_editor.openFileFromPath(file) && g_editor.showHelpPopup) { g_editor.showHelpPopup = false; InvalidateRect(hwnd, NULL, FALSE); } DragFinish(hDrop); } } break;
    case WM_CONTEXTMENU: {
        int xPos = (int)(short)LOWORD(lParam);
        int yPos = (int)(short)HIWORD(lParam);
        RECT rcClient;
        GetClientRect(hwnd, &rcClient);
        if (xPos != -1 || yPos != -1) {
            POINT ptClient = { xPos, yPos };
            ScreenToClient(hwnd, &ptClient);
            if (!PtInRect(&rcClient, ptClient)) {
                return DefWindowProc(hwnd, msg, wParam, lParam);
            }
            if (g_editor.showHelpPopup) {
                g_editor.showHelpPopup = false;
                InvalidateRect(hwnd, NULL, FALSE);
            }
            bool hasSel = false;
            for (const auto& c : g_editor.cursors) {
                if (c.hasSelection()) { hasSel = true; break; }
            }
            float clientW = g_editor.getEditorDipWidth();
            float clientH = (rcClient.bottom - rcClient.top) / g_editor.dpiScaleY;
            float mouseX = ptClient.x / g_editor.dpiScaleX;
            float mouseY = ptClient.y / g_editor.dpiScaleY;
            bool hasV = false, hasH = false, singleLineWrap = false;
            float vTrackH = 0, thumbY = 0, thumbH = 0, vMaxScroll = 1.0f;
            float hTrackW = 0, thumbX = 0, thumbW = 0, hMaxScroll = 1.0f;
            g_editor.getScrollBarLayout(clientW, clientH, hasV, vTrackH, thumbY, thumbH, vMaxScroll, singleLineWrap, hasH, hTrackW, thumbX, thumbW, hMaxScroll);
            bool onScrollbar = (hasV && mouseX >= clientW - Editor::SB_PADDING - Editor::SB_HIT_WIDTH) || (hasH && mouseY >= clientH - Editor::SB_PADDING - Editor::SB_HIT_WIDTH);
            if (!hasSel && g_editor.cursors.size() <= 1 && !g_editor.isRectSelecting && !onScrollbar && mouseX >= g_editor.gutterWidth) {
                g_editor.rollbackPadding();
                size_t p = g_editor.getDocPosFromPoint(ptClient.x, ptClient.y);
                g_editor.cursors.clear();
                g_editor.cursors.push_back({ p, p, g_editor.getXFromPos(p) });
                InvalidateRect(hwnd, NULL, FALSE);
            }
        } else {
            if (g_editor.showHelpPopup) {
                g_editor.showHelpPopup = false;
                InvalidateRect(hwnd, NULL, FALSE);
            }
            POINT ptCaret = { (LONG)(g_editor.gutterWidth * g_editor.dpiScaleX + 10), (LONG)(g_editor.lineHeight * g_editor.dpiScaleY) };
            if (!g_editor.cursors.empty()) {
                const auto& c = g_editor.cursors.back();
                int lineIdx = g_editor.getLineIdx(c.head);
                float caretX = g_editor.gutterWidth + g_editor.getXFromPos(c.head, c.affinity) - (g_editor.wordWrapEnabled ? 0 : g_editor.hScrollPos);
                float caretY = (float)(lineIdx - g_editor.vScrollPos + 1) * g_editor.lineHeight;
                ptCaret.x = std::clamp((LONG)(caretX * g_editor.dpiScaleX), rcClient.left + 4, std::max(rcClient.left + 4, rcClient.right - 4));
                ptCaret.y = std::clamp((LONG)(caretY * g_editor.dpiScaleY), rcClient.top + 4, std::max(rcClient.top + 4, rcClient.bottom - 4));
            }
            ClientToScreen(hwnd, &ptCaret);
            xPos = ptCaret.x;
            yPos = ptCaret.y;
        }

        ApplyMenuTheme(g_editor.isDarkMode);
        EnableDarkModeForWindow(hwnd, g_editor.isDarkMode);

        HMENU hMenu = CreatePopupMenu();
        if (hMenu) {
            bool canUndo = g_editor.undo.canUndo();
            bool canRedo = g_editor.undo.canRedo();
            bool hasSel = false;
            for (const auto& c : g_editor.cursors) {
                if (c.hasSelection()) { hasSel = true; break; }
            }
            bool canPaste = IsClipboardFormatAvailable(CF_UNICODETEXT) != FALSE;
            bool canSelectAll = g_editor.pt.length() > 0;

            AppendMenuW(hMenu, MF_STRING | (canUndo ? MF_ENABLED : MF_GRAYED), IDM_CTX_UNDO, GetResString(IDS_CTX_UNDO).c_str());
            AppendMenuW(hMenu, MF_STRING | (canRedo ? MF_ENABLED : MF_GRAYED), IDM_CTX_REDO, GetResString(IDS_CTX_REDO).c_str());
            AppendMenuW(hMenu, MF_SEPARATOR, 0, NULL);
            AppendMenuW(hMenu, MF_STRING | (hasSel ? MF_ENABLED : MF_GRAYED), IDM_CTX_CUT, GetResString(IDS_CTX_CUT).c_str());
            AppendMenuW(hMenu, MF_STRING | (hasSel ? MF_ENABLED : MF_GRAYED), IDM_CTX_COPY, GetResString(IDS_CTX_COPY).c_str());
            AppendMenuW(hMenu, MF_STRING | (canPaste ? MF_ENABLED : MF_GRAYED), IDM_CTX_PASTE, GetResString(IDS_CTX_PASTE).c_str());
            AppendMenuW(hMenu, MF_SEPARATOR, 0, NULL);
            AppendMenuW(hMenu, MF_STRING | (canSelectAll ? MF_ENABLED : MF_GRAYED), IDM_CTX_SELECT_ALL, GetResString(IDS_CTX_SELECT_ALL).c_str());

            UINT cmd = TrackPopupMenuEx(hMenu, TPM_RIGHTBUTTON | TPM_RETURNCMD | TPM_NONOTIFY, xPos, yPos, hwnd, NULL);
            DestroyMenu(hMenu);

            switch (cmd) {
            case IDM_CTX_UNDO:
                g_editor.performUndo();
                InvalidateRect(hwnd, NULL, FALSE);
                break;
            case IDM_CTX_REDO:
                g_editor.performRedo();
                InvalidateRect(hwnd, NULL, FALSE);
                break;
            case IDM_CTX_CUT:
                g_editor.cutToClipboard();
                InvalidateRect(hwnd, NULL, FALSE);
                break;
            case IDM_CTX_COPY:
                g_editor.copyToClipboard();
                InvalidateRect(hwnd, NULL, FALSE);
                break;
            case IDM_CTX_PASTE:
                g_editor.pasteFromClipboard();
                InvalidateRect(hwnd, NULL, FALSE);
                break;
            case IDM_CTX_SELECT_ALL:
                g_editor.rollbackPadding();
                g_editor.isRectSelecting = false;
                g_editor.cursors.clear();
                g_editor.cursors.push_back({ g_editor.pt.length(), 0, 0.0f });
                InvalidateRect(hwnd, NULL, FALSE);
                break;
            }
        }
        return 0;
    }
    case WM_INITMENU: updateSystemMenu(hwnd); break;
    case WM_INITMENUPOPUP: if ((BOOL)HIWORD(lParam)) updateSystemMenu(hwnd); break;
    case WM_SYSCOMMAND: {
        UINT cmd = (UINT)(wParam & 0xFFF0);
        if (cmd >= IDM_RECENT_BASE && cmd < IDM_RECENT_BASE + (UINT)(MAX_RECENT_MENU_ITEMS * 16)) {
            size_t idx = (cmd - IDM_RECENT_BASE) / 16;
            if (idx < s_sysMenuRecentFiles.size()) {
                std::wstring fileToOpen = s_sysMenuRecentFiles[idx];
                if (g_editor.checkUnsavedChanges()) {
                    if (g_editor.openFileFromPath(fileToOpen)) {
                        if (g_editor.showHelpPopup) {
                            g_editor.showHelpPopup = false;
                        }
                        EnableDarkModeForWindow(hwnd, g_editor.isDarkMode);
    updateSystemMenu(hwnd);
                        InvalidateRect(hwnd, NULL, FALSE);
                    } else {
                        removeFromRecentFiles({ fileToOpen });
                        updateJumpList();
                        updateSystemMenu(hwnd);
                    }
                }
            }
            return 0;
        }
        return DefWindowProc(hwnd, msg, wParam, lParam);
    }
    case WM_CLOSE: if (g_editor.checkUnsavedChanges()) DestroyWindow(hwnd); return 0;
    case WM_PAINT: { PAINTSTRUCT ps; BeginPaint(hwnd, &ps); g_editor.render(); EndPaint(hwnd, &ps); } break;
    case WM_DESTROY: KillTimer(hwnd, 2); KillTimer(hwnd, 3); g_editor.saveCurrentViewState(); g_editor.destroyGraphics(); PostQuitMessage(0); break;
    default: return DefWindowProc(hwnd, msg, wParam, lParam);
    }
    return 0;
}
int WINAPI wWinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPWSTR lpCmdLine, _In_ int nShowCmd) {
    HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);
    SetDllDirectoryW(L"");
    int argc; wchar_t** argv = CommandLineToArgvW(GetCommandLineW(), &argc);
    if (argv && argc >= 2 && _wcsicmp(argv[1], L"--elevated-save") == 0) {
        if (argc >= 4) {
            std::wstring src = argv[2];
            std::wstring dst = argv[3];
            DWORD srcAttr = GetFileAttributesW(src.c_str());
            DWORD dstAttr = GetFileAttributesW(dst.c_str());
            if (srcAttr == INVALID_FILE_ATTRIBUTES || (srcAttr & FILE_ATTRIBUTE_REPARSE_POINT) || (srcAttr & FILE_ATTRIBUTE_DIRECTORY) ||
                (dstAttr != INVALID_FILE_ATTRIBUTES && ((dstAttr & FILE_ATTRIBUTE_REPARSE_POINT) || (dstAttr & FILE_ATTRIBUTE_DIRECTORY)))) {
                LocalFree(argv);
                return ERROR_ACCESS_DENIED;
            }
            BOOL ok = CopyFileW(src.c_str(), dst.c_str(), FALSE);
            if (!ok) {
                if (dstAttr != INVALID_FILE_ATTRIBUTES && (dstAttr & FILE_ATTRIBUTE_READONLY)) {
                    SetFileAttributesW(dst.c_str(), dstAttr & ~FILE_ATTRIBUTE_READONLY);
                    ok = CopyFileW(src.c_str(), dst.c_str(), FALSE);
                }
            }
            DWORD exitCode = ok ? 0 : GetLastError();
            DeleteFileW(src.c_str());
            LocalFree(argv);
            return (int)exitCode;
        }
        LocalFree(argv);
        return ERROR_INVALID_PARAMETER;
    }
    if (!isRunningAsPackagedApp()) {
        SetCurrentProcessExplicitAppUserModelID(L"miu");
    }
    InitDarkMode();
    scheduleShellRecentUpdate(L"");
    // SetThreadUILanguage(MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT));

    SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
    std::wstring fileToOpen;
    bool newWindow = false;
    bool forceF1 = false;
    int customWidth = 0;
    int customHeight = 0;

    for (int i = 1; i < argc; ++i) {
        if (_wcsicmp(argv[i], L"--lang") == 0 && i + 1 < argc) {
            std::wstring l = argv[++i];
            if (_wcsicmp(l.c_str(), L"zh-tw") == 0 || _wcsicmp(l.c_str(), L"zh-hant") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL));
            } else if (_wcsicmp(l.c_str(), L"de") == 0 || _wcsicmp(l.c_str(), L"de-de") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_GERMAN, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"fr") == 0 || _wcsicmp(l.c_str(), L"fr-fr") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_FRENCH, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"es") == 0 || _wcsicmp(l.c_str(), L"es-es") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_SPANISH, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"pt") == 0 || _wcsicmp(l.c_str(), L"pt-br") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_PORTUGUESE, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"ru") == 0 || _wcsicmp(l.c_str(), L"ru-ru") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_RUSSIAN, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"it") == 0 || _wcsicmp(l.c_str(), L"it-it") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_ITALIAN, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"pl") == 0 || _wcsicmp(l.c_str(), L"pl-pl") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_POLISH, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"nl") == 0 || _wcsicmp(l.c_str(), L"nl-nl") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_DUTCH, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"tr") == 0 || _wcsicmp(l.c_str(), L"tr-tr") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_TURKISH, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"en") == 0 || _wcsicmp(l.c_str(), L"en-us") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
            } else if (_wcsicmp(l.c_str(), L"ja") == 0 || _wcsicmp(l.c_str(), L"ja-jp") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_JAPANESE, SUBLANG_DEFAULT));
            } else if (_wcsicmp(l.c_str(), L"zh-cn") == 0 || _wcsicmp(l.c_str(), L"zh-hans") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_CHINESE, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"ko") == 0 || _wcsicmp(l.c_str(), L"ko-kr") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_KOREAN, SUBLANG_NEUTRAL));
            } else if (_wcsicmp(l.c_str(), L"vi") == 0 || _wcsicmp(l.c_str(), L"vi-vn") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_VIETNAMESE, SUBLANG_DEFAULT));
            } else if (_wcsicmp(l.c_str(), L"uk") == 0 || _wcsicmp(l.c_str(), L"uk-ua") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_UKRAINIAN, SUBLANG_DEFAULT));
            } else if (_wcsicmp(l.c_str(), L"id") == 0 || _wcsicmp(l.c_str(), L"id-id") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_INDONESIAN, SUBLANG_DEFAULT));
            } else if (_wcsicmp(l.c_str(), L"cs") == 0 || _wcsicmp(l.c_str(), L"cs-cz") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_CZECH, SUBLANG_DEFAULT));
            } else if (_wcsicmp(l.c_str(), L"sv") == 0 || _wcsicmp(l.c_str(), L"sv-se") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_SWEDISH, SUBLANG_DEFAULT));
            } else if (_wcsicmp(l.c_str(), L"th") == 0 || _wcsicmp(l.c_str(), L"th-th") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_THAI, SUBLANG_DEFAULT));
            } else if (_wcsicmp(l.c_str(), L"hi") == 0 || _wcsicmp(l.c_str(), L"hi-in") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_HINDI, SUBLANG_DEFAULT));
            } else if (_wcsicmp(l.c_str(), L"ro") == 0 || _wcsicmp(l.c_str(), L"ro-ro") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_ROMANIAN, SUBLANG_DEFAULT));
            } else if (_wcsicmp(l.c_str(), L"hu") == 0 || _wcsicmp(l.c_str(), L"hu-hu") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_HUNGARIAN, SUBLANG_DEFAULT));
            } else if (_wcsicmp(l.c_str(), L"el") == 0 || _wcsicmp(l.c_str(), L"el-gr") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_GREEK, SUBLANG_DEFAULT));
            } else if (_wcsicmp(l.c_str(), L"da") == 0 || _wcsicmp(l.c_str(), L"da-dk") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_DANISH, SUBLANG_DEFAULT));
            } else if (_wcsicmp(l.c_str(), L"fi") == 0 || _wcsicmp(l.c_str(), L"fi-fi") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_FINNISH, SUBLANG_DEFAULT));
            } else if (_wcsicmp(l.c_str(), L"nb") == 0 || _wcsicmp(l.c_str(), L"nb-no") == 0 || _wcsicmp(l.c_str(), L"no") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_NORWEGIAN, SUBLANG_DEFAULT));
            } else if (_wcsicmp(l.c_str(), L"ms") == 0 || _wcsicmp(l.c_str(), L"ms-my") == 0) {
                SetThreadUILanguage(MAKELANGID(LANG_MALAY, SUBLANG_DEFAULT));
            }
        } else if (_wcsicmp(argv[i], L"--theme") == 0 && i + 1 < argc) {
            std::wstring t = argv[++i];
            if (_wcsicmp(t.c_str(), L"light") == 0) g_editor.forceTheme = 1;
            else if (_wcsicmp(t.c_str(), L"dark") == 0) g_editor.forceTheme = 2;
        } else if (_wcsicmp(argv[i], L"--f1") == 0) {
            forceF1 = true;
        } else if (_wcsicmp(argv[i], L"--new-window") == 0) {
            newWindow = true;
        } else if (_wcsicmp(argv[i], L"--width") == 0 && i + 1 < argc) {
            customWidth = _wtoi(argv[++i]);
        } else if (_wcsicmp(argv[i], L"--height") == 0 && i + 1 < argc) {
            customHeight = _wtoi(argv[++i]);
        } else if (argv[i][0] != L'-') {
            wchar_t fullPath[MAX_PATH];
            if (GetFullPathNameW(argv[i], MAX_PATH, fullPath, NULL)) {
                fileToOpen = fullPath;
            }
        }
    }

    if (!fileToOpen.empty() && !newWindow) {
        HWND hExisting = NULL;
        HWND hwndEnum = FindWindowExW(NULL, NULL, L"miu", NULL);
        while (hwndEnum != NULL) {
            COPYDATASTRUCT cds;
            cds.dwData = 1;
            cds.cbData = (DWORD)((fileToOpen.length() + 1) * sizeof(wchar_t));
            cds.lpData = (PVOID)fileToOpen.c_str();
            if (SendMessage(hwndEnum, WM_COPYDATA, 0, (LPARAM)&cds) == 1) {
                hExisting = hwndEnum;
                break;
            }
            hwndEnum = FindWindowExW(NULL, hwndEnum, L"miu", NULL);
        }
        if (hExisting) {
            if (IsIconic(hExisting)) ShowWindow(hExisting, SW_RESTORE);
            SetForegroundWindow(hExisting);
            LocalFree(argv);
            return 0;
        }
    }
    WNDCLASS wc = { 0 }; wc.lpfnWndProc = WndProc; wc.hInstance = hInstance; wc.lpszClassName = L"miu"; wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1)); RegisterClass(&wc);
    UINT dpi = GetDpiForSystem(); if (dpi == 0) dpi = 96;
    int initialWidth = customWidth > 0 ? customWidth : MulDiv(800, dpi, 96);
    int initialHeight = customHeight > 0 ? customHeight : MulDiv(640, dpi, 96);
    HWND hwnd = CreateWindowEx(WS_EX_NOREDIRECTIONBITMAP, wc.lpszClassName, L"miu", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, initialWidth, initialHeight, NULL, NULL, hInstance, NULL);
    updateSystemMenu(hwnd);
    if (!hwnd) return 0; ShowWindow(hwnd, nShowCmd);
    if (!fileToOpen.empty()) {
        g_editor.openFileFromPath(fileToOpen);
        if (forceF1) {
            g_editor.showHelpPopup = true;
            InvalidateRect(hwnd, NULL, FALSE);
        }
    }
    else {
        g_editor.showHelpPopup = true;
        InvalidateRect(hwnd, NULL, FALSE);
    }
    LocalFree(argv);
    g_editor.updateTitleBar(); MSG msg;
    while (GetMessage(&msg, NULL, 0, 0)) {
        if (msg.hwnd != hwnd && (!g_editor.hFindDlg || (msg.hwnd != g_editor.hFindDlg && !IsChild(g_editor.hFindDlg, msg.hwnd))) && IsChild(hwnd, msg.hwnd)) {
            if (msg.hwnd == g_editor.hwndPreviewHost && (msg.message == WM_KEYDOWN || msg.message == WM_SYSKEYDOWN || msg.message == WM_SYSCHAR || msg.message == WM_CHAR || msg.message == WM_IME_STARTCOMPOSITION || msg.message == WM_IME_COMPOSITION || msg.message == WM_IME_ENDCOMPOSITION || msg.message == WM_IME_CHAR)) {
                SetFocus(hwnd);
                msg.hwnd = hwnd;
            } else if (msg.message == WM_KEYDOWN || msg.message == WM_SYSKEYDOWN || msg.message == WM_SYSCHAR) {
                msg.hwnd = hwnd;
            }
        }
        if (msg.message == WM_KEYDOWN) {
            if (msg.wParam == VK_F1) { g_editor.showHelpPopup = !g_editor.showHelpPopup; if (g_editor.showPreview) g_editor.updatePreviewBounds(); InvalidateRect(hwnd, NULL, FALSE); continue; }
            if (msg.wParam == VK_F3) { bool shift = (GetKeyState(VK_SHIFT) & 0x8000) != 0; g_editor.findNext(!shift); continue; }
            if (msg.wParam == VK_F11) { g_editor.toggleFullScreen(); continue; }
            if (GetKeyState(VK_CONTROL) & 0x8000) { if (msg.wParam == 'F') { g_editor.showFindDialog(false); continue; } if (msg.wParam == 'H' || msg.wParam == 'R') { g_editor.showFindDialog(true); continue; } }
        }
        if (g_editor.showHelpPopup && (msg.message == WM_KEYDOWN || msg.message == WM_CHAR || msg.message == WM_IME_STARTCOMPOSITION || msg.message == WM_IME_COMPOSITION || msg.message == WM_LBUTTONDOWN)) { if (msg.message == WM_KEYDOWN && msg.wParam == VK_F1) {} else { g_editor.showHelpPopup = false; if (g_editor.showPreview) g_editor.updatePreviewBounds(); InvalidateRect(hwnd, NULL, FALSE); } }
        if (!g_editor.hFindDlg || !IsDialogMessage(g_editor.hFindDlg, &msg)) { TranslateMessage(&msg); DispatchMessage(&msg); }
    }
    return 0;
}