coc-ltex-plus 0.1.0

package/lib/index.js

@@ -0,0 +1,2319 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  __testHooks: () => __testHooks,
+  activate: () => activate
+});
+module.exports = __toCommonJS(src_exports);
+var import_fs4 = require("fs");
+
+// src/extension.ts
+var import_coc8 = require("coc.nvim");
+
+// src/constants.ts
+var DEFAULT_LANGUAGES = [
+  "bibtex",
+  "context",
+  "context.tex",
+  "html",
+  "latex",
+  "markdown",
+  "mdx",
+  "typst",
+  "org",
+  "quarto",
+  "rsweave",
+  "restructuredtext",
+  "mail",
+  "neorg",
+  "norg",
+  "help"
+];
+var LTEX_LANGUAGE_CODES = [
+  "auto",
+  "ar",
+  "ast-ES",
+  "be-BY",
+  "br-FR",
+  "ca-ES",
+  "ca-ES-valencia",
+  "da-DK",
+  "de",
+  "de-AT",
+  "de-CH",
+  "de-DE",
+  "de-DE-x-simple-language",
+  "el-GR",
+  "en",
+  "en-AU",
+  "en-CA",
+  "en-GB",
+  "en-NZ",
+  "en-US",
+  "en-ZA",
+  "eo",
+  "es",
+  "es-AR",
+  "fa",
+  "fr",
+  "ga-IE",
+  "gl-ES",
+  "it",
+  "ja-JP",
+  "km-KH",
+  "nl",
+  "nl-BE",
+  "pl-PL",
+  "pt",
+  "pt-AO",
+  "pt-BR",
+  "pt-MZ",
+  "pt-PT",
+  "ro-RO",
+  "ru-RU",
+  "sk-SK",
+  "sl-SI",
+  "sv",
+  "ta-IN",
+  "tl-PH",
+  "uk-UA",
+  "zh-CN"
+];
+var PROCESS_SETTING_KEYS = [
+  "ltex.enabled",
+  "ltex.ltex-ls.path",
+  "ltex.ltex-ls.args",
+  "ltex.java.path",
+  "ltex.java.initialHeapSize",
+  "ltex.java.maximumHeapSize"
+];
+var MANAGED_SETTING_NAMES = [
+  "dictionary",
+  "disabledRules",
+  "hiddenFalsePositives"
+];
+var LTEX_RELEASES_URL = "https://github.com/ltex-plus/ltex-ls-plus/releases";
+var LTEX_LATEST_RELEASE_API_URL = "https://api.github.com/repos/ltex-plus/ltex-ls-plus/releases/latest";
+var HTTP_REDIRECT_LIMIT = 5;
+var RELEASE_METADATA_LIMIT_BYTES = 10 * 1024 * 1024;
+var INSTALL_TIMEOUT_MS = 5 * 60 * 1e3;
+var DOWNLOAD_IDLE_TIMEOUT_MS = 30 * 1e3;
+var VERIFY_TIMEOUT_MS = 30 * 1e3;
+var MANAGED_RELEASE_KEY = "managedRelease";
+
+// src/client.ts
+var import_coc3 = require("coc.nvim");
+
+// src/config.ts
+var import_coc2 = require("coc.nvim");
+var import_path2 = require("path");
+
+// src/paths.ts
+var import_coc = require("coc.nvim");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_os = require("os");
+function ltexConfig(resource) {
+  return import_coc.workspace.getConfiguration("ltex", resource);
+}
+function expandHome(pathValue) {
+  return pathValue.replace(/^~(?=$|[\\/])/, (0, import_os.homedir)());
+}
+function normalizePath(pathValue) {
+  if (!pathValue) {
+    return null;
+  }
+  const trimmed = pathValue.trim();
+  return trimmed ? expandHome(trimmed) : null;
+}
+function executableNames(base) {
+  if (process.platform !== "win32") {
+    return [base];
+  }
+  return [`${base}.cmd`, `${base}.bat`, `${base}.exe`, base];
+}
+function isExecutableFile(pathValue) {
+  try {
+    const stat = (0, import_fs.statSync)(pathValue);
+    if (!stat.isFile()) {
+      return false;
+    }
+    (0, import_fs.accessSync)(pathValue, import_fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findInPath(base) {
+  const pathValue = process.env.PATH ?? "";
+  for (const dir of pathValue.split(import_path.delimiter)) {
+    if (!dir) {
+      continue;
+    }
+    for (const name of executableNames(base)) {
+      const candidate = (0, import_path.join)(dir, name);
+      if (isExecutableFile(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+function ltexExecutableCandidates(directory) {
+  const candidates = [];
+  for (const base of ["ltex-ls-plus", "ltex-ls"]) {
+    for (const name of executableNames(base)) {
+      candidates.push((0, import_path.join)(directory, "bin", name), (0, import_path.join)(directory, name));
+    }
+  }
+  return candidates;
+}
+function existingLtexExecutable(directory) {
+  for (const candidate of ltexExecutableCandidates(directory)) {
+    try {
+      if ((0, import_fs.statSync)(candidate).isFile()) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveExecutableFromConfiguredPath(pathValue) {
+  const expanded = expandHome(pathValue);
+  if (!(0, import_path.isAbsolute)(expanded) && !expanded.includes("/") && !expanded.includes("\\")) {
+    return findInPath(expanded);
+  }
+  if (!(0, import_fs.existsSync)(expanded)) {
+    return null;
+  }
+  const stat = (0, import_fs.statSync)(expanded);
+  if (stat.isFile()) {
+    return expanded;
+  }
+  if (!stat.isDirectory()) {
+    return null;
+  }
+  return ltexExecutableCandidates(expanded).find(isExecutableFile) ?? null;
+}
+function managedServerDirectory(storagePath) {
+  return (0, import_path.join)(storagePath, "ltex-ls-plus");
+}
+function managedServerExecutable(storagePath) {
+  return resolveExecutableFromConfiguredPath(managedServerDirectory(storagePath));
+}
+function resolveLtexServer(storagePath) {
+  const configuredPath = normalizePath(ltexConfig().get("ltex-ls.path", ""));
+  if (configuredPath) {
+    const command = resolveExecutableFromConfiguredPath(configuredPath);
+    return command ? { command, source: "configured" } : null;
+  }
+  if (storagePath) {
+    const managed = managedServerExecutable(storagePath);
+    if (managed) {
+      return { command: managed, source: "managed" };
+    }
+  }
+  const system = findInPath("ltex-ls-plus") ?? findInPath("ltex-ls");
+  return system ? { command: system, source: "system" } : null;
+}
+function resolveLtexExecutable(storagePath) {
+  return resolveLtexServer(storagePath)?.command ?? null;
+}
+function ltexPlatformName(platform = process.platform) {
+  switch (platform) {
+    case "darwin":
+      return "mac";
+    case "linux":
+      return "linux";
+    case "win32":
+      return "windows";
+    default:
+      return void 0;
+  }
+}
+function ltexArchName(arch = process.arch) {
+  switch (arch) {
+    case "arm64":
+      return "aarch64";
+    case "x64":
+      return "x64";
+    default:
+      return void 0;
+  }
+}
+function releaseVersionFromTag(tag) {
+  return tag.replace(/^v/i, "");
+}
+function ltexAssetNameForPlatform(version, platform = process.platform, arch = process.arch) {
+  const platformName = ltexPlatformName(platform);
+  const archName = ltexArchName(arch);
+  if (!platformName || !archName) {
+    return void 0;
+  }
+  const archiveType = platformName === "windows" ? "zip" : "tar.gz";
+  return `ltex-ls-plus-${version}-${platformName}-${archName}.${archiveType}`;
+}
+function assetMatchesPlatform(assetName, version, platform = process.platform, arch = process.arch) {
+  const exact = ltexAssetNameForPlatform(version, platform, arch);
+  if (exact && assetName === exact) {
+    return true;
+  }
+  const platformName = ltexPlatformName(platform);
+  const archName = ltexArchName(arch);
+  return !!platformName && !!archName && new RegExp(`^ltex-ls-plus-.+-${platformName}-${archName}\\.(?:tar\\.gz|zip)$`).test(assetName);
+}
+function sha256FromDigest(digest) {
+  const match = digest?.match(/^sha256:([a-f0-9]{64})$/i);
+  return match?.[1].toLowerCase();
+}
+
+// src/config.ts
+function workspaceRoot() {
+  const folders = import_coc2.workspace.workspaceFolders ?? [];
+  if (folders.length > 0) {
+    return import_coc2.Uri.parse(folders[0].uri).fsPath;
+  }
+  if (import_coc2.workspace.root) {
+    return import_coc2.workspace.root;
+  }
+  if (import_coc2.workspace.folderPaths?.[0]) {
+    return import_coc2.workspace.folderPaths[0];
+  }
+  return process.cwd();
+}
+function enabledLanguages() {
+  const enabled = ltexConfig().get("enabled", DEFAULT_LANGUAGES);
+  if (enabled === true) {
+    return [...DEFAULT_LANGUAGES];
+  }
+  if (enabled === false) {
+    return [];
+  }
+  if (!Array.isArray(enabled)) {
+    return [...DEFAULT_LANGUAGES];
+  }
+  return enabled.filter((language) => typeof language === "string" && language.length > 0);
+}
+function documentSelector() {
+  return enabledLanguages().flatMap((language) => [
+    { scheme: "file", language },
+    { scheme: "untitled", language }
+  ]);
+}
+function checkableWorkspaceDocuments(documents = import_coc2.workspace.documents, languages = enabledLanguages()) {
+  const enabled = new Set(languages);
+  const seen = /* @__PURE__ */ new Set();
+  return documents.filter((document) => {
+    const language = document.filetype || document.languageId;
+    if (!enabled.has(language) || seen.has(document.uri) || !isCheckableWorkspaceUri(document.uri)) {
+      return false;
+    }
+    seen.add(document.uri);
+    return true;
+  });
+}
+function isCheckableWorkspaceUri(uriString) {
+  const uri = import_coc2.Uri.parse(uriString);
+  if (uri.scheme === "untitled") {
+    return true;
+  }
+  if (uri.scheme !== "file") {
+    return false;
+  }
+  const folders = import_coc2.workspace.workspaceFolders ?? [];
+  if (folders.length > 0) {
+    return import_coc2.workspace.getWorkspaceFolder(uriString) != null;
+  }
+  const roots = [import_coc2.workspace.root, ...import_coc2.workspace.folderPaths ?? []].filter((root) => typeof root === "string" && root.length > 0);
+  if (roots.length === 0) {
+    return true;
+  }
+  return roots.some((root) => pathContains(root, uri.fsPath));
+}
+function pathContains(root, filePath) {
+  const relativePath = (0, import_path2.relative)((0, import_path2.resolve)(root), (0, import_path2.resolve)(filePath));
+  return relativePath === "" || !!relativePath && !relativePath.startsWith("..") && !(0, import_path2.isAbsolute)(relativePath);
+}
+function serverEnvironment() {
+  const { ELECTRON_RUN_AS_NODE, ...env } = process.env;
+  const javaPath = normalizePath(ltexConfig().get("java.path", ""));
+  if (javaPath) {
+    env.JAVA_HOME = javaPath;
+    env.PATH = `${(0, import_path2.join)(javaPath, "bin")}${import_path2.delimiter}${env.PATH ?? ""}`;
+  }
+  const javaOptions = [];
+  const initialHeapSize = ltexConfig().get("java.initialHeapSize", void 0);
+  const maximumHeapSize = ltexConfig().get("java.maximumHeapSize", void 0);
+  if (typeof initialHeapSize === "number" && Number.isFinite(initialHeapSize) && initialHeapSize > 0) {
+    javaOptions.push(`-Xms${initialHeapSize}m`);
+  }
+  if (typeof maximumHeapSize === "number" && Number.isFinite(maximumHeapSize) && maximumHeapSize > 0) {
+    javaOptions.push(`-Xmx${maximumHeapSize}m`);
+  }
+  if (javaOptions.length > 0) {
+    env.JAVA_OPTS = [env.JAVA_OPTS, ...javaOptions].filter(Boolean).join(" ");
+  }
+  return env;
+}
+
+// src/client.ts
+function createServerOptions(command) {
+  const args = ltexConfig().get("ltex-ls.args", []);
+  const run = {
+    command,
+    args: Array.isArray(args) ? args : [],
+    options: {
+      cwd: workspaceRoot(),
+      env: serverEnvironment(),
+      shell: process.platform === "win32"
+    }
+  };
+  return { run, debug: run };
+}
+function createClient(command, externalSettings, diagnosticsState = { enabled: true }) {
+  const clientOptions = {
+    documentSelector: documentSelector(),
+    synchronize: {
+      configurationSection: "ltex"
+    },
+    initializationOptions: {
+      customCapabilities: {
+        workspaceSpecificConfiguration: true
+      }
+    },
+    outputChannelName: "LTeX+",
+    revealOutputChannelOn: import_coc3.RevealOutputChannelOn.Never,
+    progressOnInitialization: true,
+    middleware: {
+      handleDiagnostics(uri, diagnostics, next) {
+        next(uri, diagnosticsState.enabled ? diagnostics : []);
+      }
+    }
+  };
+  const client = new import_coc3.LanguageClient("ltex", "LTeX+ Language Server", createServerOptions(command), clientOptions);
+  client.onRequest("ltex/workspaceSpecificConfiguration", (params) => {
+    return externalSettings.handleWorkspaceSpecificConfiguration(params);
+  });
+  return client;
+}
+
+// src/diagnostics.ts
+function diagnosticsFromCollection(collection) {
+  const records = [];
+  collection?.forEach((uri, diagnostics) => {
+    for (const diagnostic of diagnostics) {
+      records.push({ uri, diagnostic });
+    }
+  });
+  return records;
+}
+function diagnosticCode(diagnostic) {
+  if (diagnostic.code == null) {
+    return void 0;
+  }
+  return String(diagnostic.code);
+}
+function diagnosticsContextForEntry(entry, diagnostics, document) {
+  if (entry.settingName === "hiddenFalsePositives") {
+    return hiddenFalsePositiveContext(entry, diagnostics, document);
+  }
+  if (entry.settingName === "disabledRules") {
+    return disabledRuleContext(entry, diagnostics);
+  }
+  return {
+    status: "unknown",
+    label: "unknown"
+  };
+}
+function parseHiddenFalsePositiveEntry(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return {};
+  }
+  const parsed = parseHiddenFalsePositiveJson(trimmed);
+  if (parsed.ruleId || parsed.sentence) {
+    return parsed;
+  }
+  const logged = trimmed.match(/\brule\s+['"]([^'"]+)['"].*\bsentence\s+['"]([^'"]+)['"]/i);
+  if (logged) {
+    return {
+      ruleId: logged[1],
+      sentence: logged[2]
+    };
+  }
+  const delimited = trimmed.match(/^([A-Z][A-Z0-9_]+)\s*(?:\t|\||:)\s*(.+)$/);
+  if (delimited) {
+    return {
+      ruleId: delimited[1],
+      sentence: cleanStoredSentence(delimited[2])
+    };
+  }
+  const sentence = cleanStoredSentence(trimmed);
+  return looksLikeSentence(sentence) ? { sentence } : {};
+}
+function parseHiddenFalsePositiveJson(value) {
+  if (!value.startsWith("{")) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(value);
+    const ruleId = firstString(parsed, ["ruleId", "rule", "id"]);
+    const sentence = firstString(parsed, ["sentence", "text", "message", "falsePositive"]);
+    return { ruleId, sentence: sentence ? cleanStoredSentence(sentence) : void 0 };
+  } catch {
+    return {};
+  }
+}
+function firstString(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function cleanStoredSentence(value) {
+  return value.trim().replace(/^['"]|['"]$/g, "").trim();
+}
+function looksLikeSentence(value) {
+  return !/^[A-Z][A-Z0-9_]+$/.test(value) && /[\s.!?;:,]/.test(value);
+}
+function hiddenFalsePositiveContext(entry, diagnostics, document) {
+  const parsed = parseHiddenFalsePositiveEntry(entry.value);
+  if (!parsed.sentence) {
+    const matchedDiagnostic = diagnosticForRule(parsed.ruleId, diagnostics);
+    if (matchedDiagnostic) {
+      return contextFromDiagnostic("matchedDiagnostic", "diagnostic", matchedDiagnostic, parsed.ruleId);
+    }
+    return {
+      status: "unknown",
+      label: "unknown",
+      ruleId: parsed.ruleId
+    };
+  }
+  if (!document) {
+    return {
+      status: "unknown",
+      label: "unknown",
+      ruleId: parsed.ruleId,
+      sentence: parsed.sentence
+    };
+  }
+  const range = sentenceRange(document.content, parsed.sentence);
+  if (!range) {
+    return {
+      status: "obsolete",
+      label: "obsolete",
+      ruleId: parsed.ruleId,
+      sentence: parsed.sentence
+    };
+  }
+  return {
+    status: "active",
+    label: "active",
+    uri: document.uri,
+    range,
+    ruleId: parsed.ruleId,
+    sentence: parsed.sentence,
+    line: document.lines[range.start.line]
+  };
+}
+function disabledRuleContext(entry, diagnostics) {
+  const matchedDiagnostic = diagnosticForRule(entry.value, diagnostics);
+  if (matchedDiagnostic) {
+    return contextFromDiagnostic("matchedDiagnostic", "diagnostic", matchedDiagnostic, entry.value);
+  }
+  return {
+    status: "unknown",
+    label: "no current diagnostic",
+    ruleId: entry.value
+  };
+}
+function diagnosticForRule(ruleId, diagnostics) {
+  if (!ruleId) {
+    return void 0;
+  }
+  return diagnostics.find((record) => diagnosticCode(record.diagnostic) === ruleId);
+}
+function contextFromDiagnostic(status, label, record, ruleId, sentence) {
+  return {
+    status,
+    label,
+    uri: record.uri,
+    range: record.diagnostic.range,
+    ruleId,
+    sentence,
+    message: record.diagnostic.message
+  };
+}
+function sentenceRange(content, sentence) {
+  const exactIndex = content.indexOf(sentence);
+  if (exactIndex >= 0) {
+    return rangeFromOffsets(content, exactIndex, exactIndex + sentence.length);
+  }
+  const pattern = escapeRegExp(sentence).replace(/\s+/g, "\\s+");
+  const match = new RegExp(pattern).exec(content);
+  if (!match) {
+    return void 0;
+  }
+  return rangeFromOffsets(content, match.index, match.index + match[0].length);
+}
+function rangeFromOffsets(content, startOffset, endOffset) {
+  return {
+    start: positionAt(content, startOffset),
+    end: positionAt(content, endOffset)
+  };
+}
+function positionAt(content, offset) {
+  let line = 0;
+  let lineStart = 0;
+  const cappedOffset = Math.max(0, Math.min(offset, content.length));
+  for (let index = 0; index < cappedOffset; index += 1) {
+    if (content.charCodeAt(index) === 10) {
+      line += 1;
+      lineStart = index + 1;
+    }
+  }
+  return {
+    line,
+    character: cappedOffset - lineStart
+  };
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/externalSettings.ts
+var import_coc5 = require("coc.nvim");
+var import_path3 = require("path");
+var import_fs2 = require("fs");
+
+// src/text.ts
+var import_coc4 = require("coc.nvim");
+function uniqueSorted(values) {
+  return Array.from(new Set(values)).sort((a, b) => a.localeCompare(b, void 0, { sensitivity: "base" }));
+}
+function cleanLanguageSpecificEntries(entries) {
+  const negatives = /* @__PURE__ */ new Set();
+  const positives = /* @__PURE__ */ new Set();
+  for (const rawEntry of entries) {
+    let entry = rawEntry.trim();
+    if (!entry) {
+      continue;
+    }
+    if (entry.startsWith("-")) {
+      entry = entry.slice(1);
+      if (positives.has(entry)) {
+        positives.delete(entry);
+      } else {
+        negatives.add(entry);
+      }
+      continue;
+    }
+    positives.add(entry);
+    negatives.delete(entry);
+  }
+  return uniqueSorted([...Array.from(negatives, (entry) => `-${entry}`), ...positives]);
+}
+function mergeLanguageSpecific(target, source) {
+  if (!source) {
+    return;
+  }
+  for (const [language, entries] of Object.entries(source)) {
+    if (!Array.isArray(entries)) {
+      continue;
+    }
+    target[language] = [...target[language] ?? [], ...entries.filter((entry) => typeof entry === "string")];
+  }
+}
+function languageFileSuffix(language) {
+  return language.replace(/[^A-Za-z0-9_-]/g, "");
+}
+function workspaceFolderForUri(uri) {
+  const folder = import_coc4.workspace.getWorkspaceFolder(uri.toString());
+  if (!folder) {
+    return null;
+  }
+  const folderUri = import_coc4.Uri.parse(folder.uri);
+  return folderUri.scheme === "file" ? folderUri.fsPath : null;
+}
+function commentLine(commentString, text) {
+  let template = typeof commentString === "string" ? commentString : "";
+  if (template === "%%s") {
+    template = "% %s";
+  }
+  if (template.includes("%s")) {
+    return template.replace("%s", text);
+  }
+  return `# ${text}`;
+}
+function selectedLineRange(range, cursor) {
+  if (!range) {
+    return { startLine: cursor.line, endLine: cursor.line };
+  }
+  const startLine = Math.min(range.start.line, range.end.line);
+  let endLine = Math.max(range.start.line, range.end.line);
+  if (range.end.character === 0 && endLine > startLine) {
+    endLine -= 1;
+  }
+  return { startLine, endLine };
+}
+function disableHereReplacement(lines, startLine, endLine, commentString) {
+  const indent = lines[startLine]?.match(/^\s*/)?.[0] ?? "";
+  const opening = `${indent}${commentLine(commentString, "LTeX: enabled=false")}`;
+  const closing = `${indent}${commentLine(commentString, "LTeX: enabled=true")}`;
+  const selectedText = lines.slice(startLine, endLine + 1).join("\n");
+  return `${opening}
+${selectedText}
+${closing}
+`;
+}
+function parseExternalFileEntries(contents) {
+  return contents.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+function documentForUri(uri) {
+  const uriString = uri.toString();
+  return import_coc4.workspace.documents.find((document) => document.uri === uriString);
+}
+function splitCommaList(value) {
+  return String(value ?? "").split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function normalizeSpellLanguage(language) {
+  const normalized = language.replace("_", "-");
+  const [base, region] = normalized.split("-", 2);
+  return region ? `${base.toLowerCase()}-${region.toUpperCase()}` : base.toLowerCase();
+}
+function settingTitle(settingName) {
+  switch (settingName) {
+    case "dictionary":
+      return "Dictionary";
+    case "disabledRules":
+      return "Disabled rules";
+    case "hiddenFalsePositives":
+      return "Hidden false positives";
+  }
+}
+function scopeSource(scope) {
+  switch (scope) {
+    case import_coc4.ConfigurationTarget.Global:
+      return "user";
+    case import_coc4.ConfigurationTarget.Workspace:
+      return "workspace";
+    case import_coc4.ConfigurationTarget.WorkspaceFolder:
+      return "workspaceFolder";
+    default:
+      return "workspace";
+  }
+}
+function scopeLabel(scope) {
+  switch (scope) {
+    case import_coc4.ConfigurationTarget.Global:
+      return "user settings";
+    case import_coc4.ConfigurationTarget.Workspace:
+      return "workspace settings";
+    case import_coc4.ConfigurationTarget.WorkspaceFolder:
+      return "workspace folder settings";
+    default:
+      return "settings";
+  }
+}
+function settingsEntryKey(entry) {
+  return [
+    entry.settingName,
+    entry.language,
+    entry.value,
+    entry.source,
+    entry.filePath ?? "",
+    entry.scope ?? ""
+  ].join("\0");
+}
+function singleListEntry(item) {
+  if (Array.isArray(item)) {
+    return void 0;
+  }
+  return item.data?.entry;
+}
+function settingsEntryLabel(entry) {
+  const source = (entry.source === "externalFile" || entry.source === "runtimeDictionary") && entry.filePath ? entry.filePath : entry.sourceLabel;
+  return `${settingTitle(entry.settingName)}	${entry.language}	${entry.value}	${source}`;
+}
+
+// src/externalSettings.ts
+var ExternalSettings = class {
+  constructor(context) {
+    this.context = context;
+    this.contents = /* @__PURE__ */ new Map();
+    this.watchers = /* @__PURE__ */ new Map();
+  }
+  dispose() {
+    for (const watcher of this.watchers.values()) {
+      watcher.close();
+    }
+    this.watchers.clear();
+    this.contents.clear();
+  }
+  async handleWorkspaceSpecificConfiguration(params) {
+    return Promise.all(params.items.map(async (item) => {
+      const uri = import_coc5.Uri.parse(item.scopeUri);
+      const result = {
+        dictionary: await this.mergedSetting(uri, "dictionary"),
+        disabledRules: await this.mergedSetting(uri, "disabledRules"),
+        enabledRules: await this.mergedSetting(uri, "enabledRules"),
+        hiddenFalsePositives: await this.mergedSetting(uri, "hiddenFalsePositives")
+      };
+      const spellLanguage = await this.spellLanguageOverride(uri);
+      if (spellLanguage) {
+        result.language = spellLanguage;
+      }
+      return result;
+    }));
+  }
+  firstExternalFilePath(uri, settingName, scope, language) {
+    const defaultDir = this.defaultDirectory(uri, scope);
+    const configured = this.settingValueForScope(uri, settingName, scope);
+    const explicit = this.explicitFilesForLanguage(configured, language, defaultDir);
+    if (explicit.length > 0) {
+      return explicit[0];
+    }
+    return defaultDir ? (0, import_path3.join)(defaultDir, `ltex.${settingName}.${languageFileSuffix(language)}.txt`) : null;
+  }
+  listEntries(uri) {
+    const entries = /* @__PURE__ */ new Map();
+    for (const settingName of MANAGED_SETTING_NAMES) {
+      for (const scope of [import_coc5.ConfigurationTarget.Global, import_coc5.ConfigurationTarget.Workspace, import_coc5.ConfigurationTarget.WorkspaceFolder]) {
+        for (const entry of [
+          ...this.listExternalEntries(uri, settingName, scope),
+          ...this.listInternalEntries(uri, settingName, scope)
+        ]) {
+          entries.set(settingsEntryKey(entry), entry);
+        }
+      }
+    }
+    for (const entry of this.listRuntimeDictionaryEntries(uri)) {
+      entries.set(settingsEntryKey(entry), entry);
+    }
+    return Array.from(entries.values()).sort((a, b) => {
+      const settingCompare = settingTitle(a.settingName).localeCompare(settingTitle(b.settingName));
+      if (settingCompare !== 0) {
+        return settingCompare;
+      }
+      const languageCompare = a.language.localeCompare(b.language);
+      if (languageCompare !== 0) {
+        return languageCompare;
+      }
+      return a.value.localeCompare(b.value);
+    });
+  }
+  async deleteEntry(entry) {
+    if (entry.readOnly) {
+      return;
+    }
+    if (entry.source === "externalFile" && entry.filePath) {
+      this.updateExternalFileEntry(entry.filePath, entry.value, null);
+      return;
+    }
+    if (entry.scope != null) {
+      await this.updateInternalEntry(entry, null);
+    }
+  }
+  async editEntry(entry, nextValue) {
+    if (entry.readOnly) {
+      return;
+    }
+    const cleanValue = nextValue.trim();
+    if (!cleanValue) {
+      return;
+    }
+    if (entry.source === "externalFile" && entry.filePath) {
+      this.updateExternalFileEntry(entry.filePath, entry.value, cleanValue);
+      return;
+    }
+    if (entry.scope != null) {
+      await this.updateInternalEntry(entry, cleanValue);
+    }
+  }
+  reloadFromOpenDocuments() {
+    this.clearCache();
+    let loaded = 0;
+    const seen = /* @__PURE__ */ new Set();
+    for (const document of import_coc5.workspace.documents) {
+      const uri = import_coc5.Uri.parse(document.uri);
+      for (const settingName of MANAGED_SETTING_NAMES) {
+        for (const filePath of this.externalFilePaths(uri, settingName)) {
+          if (seen.has(filePath)) {
+            continue;
+          }
+          seen.add(filePath);
+          if (this.loadFileContents(filePath) != null) {
+            loaded += 1;
+          }
+        }
+      }
+    }
+    return loaded;
+  }
+  appendToFile(filePath, entries) {
+    const existing = this.contents.get(filePath) ?? this.loadFileContents(filePath) ?? "";
+    const knownEntries = new Set(parseExternalFileEntries(existing));
+    const entriesToAppend = [];
+    for (const entry of entries) {
+      const cleanEntry = entry.trim();
+      if (!cleanEntry || knownEntries.has(cleanEntry)) {
+        continue;
+      }
+      knownEntries.add(cleanEntry);
+      entriesToAppend.push(cleanEntry);
+    }
+    if (entriesToAppend.length === 0) {
+      return;
+    }
+    const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+    const nextContents = `${existing}${prefix}${entriesToAppend.join("\n")}
+`;
+    (0, import_fs2.mkdirSync)((0, import_path3.dirname)(filePath), { recursive: true });
+    (0, import_fs2.writeFileSync)(filePath, nextContents, "utf8");
+    this.contents.set(filePath, nextContents);
+    this.watchFile(filePath);
+  }
+  clearCache() {
+    for (const watcher of this.watchers.values()) {
+      watcher.close();
+    }
+    this.watchers.clear();
+    this.contents.clear();
+  }
+  listExternalEntries(uri, settingName, scope) {
+    const result = [];
+    const configured = this.settingValueForScope(uri, settingName, scope);
+    const defaultDir = this.defaultDirectory(uri, scope);
+    const languages = this.languagesForExternalFiles(configured);
+    for (const language of languages) {
+      for (const filePath of this.externalFilesForLanguage(configured, settingName, language, defaultDir)) {
+        for (const value of this.readEntries(filePath)) {
+          result.push({
+            settingName,
+            language,
+            value,
+            source: "externalFile",
+            sourceLabel: filePath,
+            uri: uri.toString(),
+            filePath
+          });
+        }
+      }
+    }
+    return result;
+  }
+  listInternalEntries(uri, settingName, scope) {
+    const configured = this.settingValueForScope(uri, settingName, scope);
+    const result = [];
+    for (const [language, rawEntries] of Object.entries(configured ?? {})) {
+      if (!Array.isArray(rawEntries)) {
+        continue;
+      }
+      for (const value of rawEntries) {
+        if (typeof value !== "string" || value.startsWith(":")) {
+          continue;
+        }
+        result.push({
+          settingName,
+          language,
+          value,
+          source: scopeSource(scope),
+          sourceLabel: scopeLabel(scope),
+          uri: uri.toString(),
+          scope
+        });
+      }
+    }
+    return result;
+  }
+  externalFilePaths(uri, settingName) {
+    const paths = [];
+    for (const scope of [import_coc5.ConfigurationTarget.Global, import_coc5.ConfigurationTarget.Workspace, import_coc5.ConfigurationTarget.WorkspaceFolder]) {
+      const configured = this.settingValueForScope(uri, settingName, scope);
+      const defaultDir = this.defaultDirectory(uri, scope);
+      for (const language of this.languagesForExternalFiles(configured)) {
+        paths.push(...this.externalFilesForLanguage(configured, settingName, language, defaultDir));
+      }
+    }
+    if (settingName === "dictionary") {
+      paths.push(...this.runtimeDictionaryFilesForReload(uri));
+    }
+    return uniqueSorted(paths);
+  }
+  externalFilesForLanguage(configured, settingName, language, defaultDir) {
+    const files = this.explicitFilesForLanguage(configured, language, defaultDir);
+    if (defaultDir) {
+      files.push((0, import_path3.join)(defaultDir, `ltex.${settingName}.${languageFileSuffix(language)}.txt`));
+    }
+    return uniqueSorted(files);
+  }
+  updateExternalFileEntry(filePath, oldValue, nextValue) {
+    const existing = this.contents.get(filePath) ?? this.loadFileContents(filePath) ?? "";
+    let changed = false;
+    const nextEntries = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry of parseExternalFileEntries(existing)) {
+      const replacement = entry === oldValue ? nextValue : entry;
+      if (entry === oldValue) {
+        changed = true;
+      }
+      if (!replacement || seen.has(replacement)) {
+        continue;
+      }
+      seen.add(replacement);
+      nextEntries.push(replacement);
+    }
+    if (!changed && nextValue) {
+      nextEntries.push(nextValue);
+    }
+    const nextContents = nextEntries.length > 0 ? `${nextEntries.join("\n")}
+` : "";
+    (0, import_fs2.mkdirSync)((0, import_path3.dirname)(filePath), { recursive: true });
+    (0, import_fs2.writeFileSync)(filePath, nextContents, "utf8");
+    this.contents.set(filePath, nextContents);
+    this.watchFile(filePath);
+  }
+  async updateInternalEntry(entry, nextValue) {
+    if (entry.scope == null) {
+      return;
+    }
+    const uri = import_coc5.Uri.parse(entry.uri);
+    const config = ltexConfig(uri.toString());
+    const current = this.settingValueForScope(uri, entry.settingName, entry.scope) ?? {};
+    const next = { ...current };
+    const languageEntries = Array.isArray(next[entry.language]) ? [...next[entry.language]] : [];
+    const updated = languageEntries.map((value) => value === entry.value ? nextValue : value).filter((value) => typeof value === "string" && value.length > 0);
+    next[entry.language] = cleanLanguageSpecificEntries(updated);
+    if (next[entry.language].length === 0) {
+      delete next[entry.language];
+    }
+    await config.update(entry.settingName, next, entry.scope);
+  }
+  async mergedSetting(uri, settingName) {
+    const result = {};
+    for (const scope of [import_coc5.ConfigurationTarget.Global, import_coc5.ConfigurationTarget.Workspace, import_coc5.ConfigurationTarget.WorkspaceFolder]) {
+      mergeLanguageSpecific(result, this.settingForScopeWithExternalFiles(uri, settingName, scope));
+    }
+    if (settingName === "dictionary") {
+      mergeLanguageSpecific(result, await this.runtimeDictionary(uri));
+      if (ltexConfig(uri.toString()).get("dictionary.useSpellFile", false)) {
+        mergeLanguageSpecific(result, await this.spellFileDictionary(uri));
+      }
+    }
+    for (const language of Object.keys(result)) {
+      result[language] = cleanLanguageSpecificEntries(result[language]);
+    }
+    return result;
+  }
+  async runtimeDictionary(uri) {
+    const result = {};
+    for (const language of await this.runtimeDictionaryLanguages(uri)) {
+      for (const file of this.runtimeDictionaryFilesForLanguage(uri, language)) {
+        const entries = this.readEntries(file.filePath);
+        if (entries.length > 0) {
+          result[language] = [...result[language] ?? [], ...entries];
+        }
+      }
+    }
+    return result;
+  }
+  listRuntimeDictionaryEntries(uri) {
+    const result = [];
+    for (const file of this.runtimeDictionaryFilesForList(uri)) {
+      for (const value of this.readEntries(file.filePath)) {
+        result.push({
+          settingName: "dictionary",
+          language: file.appliesToAllLanguages ? "default" : file.language,
+          value,
+          source: "runtimeDictionary",
+          sourceLabel: `${file.filePath} (runtime dictionary)`,
+          uri: uri.toString(),
+          filePath: file.filePath,
+          readOnly: true
+        });
+      }
+    }
+    return result;
+  }
+  runtimeDictionaryFilesForReload(uri) {
+    return this.runtimeDictionaryFilesForList(uri).map((file) => file.filePath);
+  }
+  runtimeDictionaryFilesForList(uri) {
+    const files = [];
+    for (const configuredPath of this.configuredDictionaryExternalFiles(uri)) {
+      const filePath = this.resolveDictionaryExternalPath(uri, configuredPath);
+      if (isDirectory(filePath)) {
+        files.push(...this.runtimeDictionaryDirectoryFiles(filePath, void 0));
+        continue;
+      }
+      const language = languageFromDictionaryFile(filePath);
+      files.push({
+        language: language ?? "default",
+        filePath,
+        appliesToAllLanguages: language == null
+      });
+    }
+    return uniqueRuntimeDictionaryFiles(files);
+  }
+  runtimeDictionaryFilesForLanguage(uri, language) {
+    const files = [];
+    for (const configuredPath of this.configuredDictionaryExternalFiles(uri)) {
+      const filePath = this.resolveDictionaryExternalPath(uri, configuredPath);
+      if (isDirectory(filePath)) {
+        files.push(...this.runtimeDictionaryDirectoryFiles(filePath, language));
+        continue;
+      }
+      const fileLanguage = languageFromDictionaryFile(filePath);
+      if (fileLanguage == null || fileLanguage === language) {
+        files.push({
+          language: fileLanguage ?? language,
+          filePath,
+          appliesToAllLanguages: fileLanguage == null
+        });
+      }
+    }
+    return uniqueRuntimeDictionaryFiles(files);
+  }
+  runtimeDictionaryDirectoryFiles(directory, language) {
+    const files = [];
+    const directories = uniqueSorted([directory, (0, import_path3.join)(directory, "dict")]);
+    for (const dictionaryDirectory of directories) {
+      files.push({
+        language: language ?? "default",
+        filePath: (0, import_path3.join)(dictionaryDirectory, "default.txt"),
+        appliesToAllLanguages: true
+      });
+      for (const targetLanguage of language ? [language] : LTEX_LANGUAGE_CODES) {
+        files.push({
+          language: targetLanguage,
+          filePath: (0, import_path3.join)(dictionaryDirectory, `${languageFileSuffix(targetLanguage)}.txt`),
+          appliesToAllLanguages: false
+        });
+      }
+    }
+    return uniqueRuntimeDictionaryFiles(files);
+  }
+  configuredDictionaryExternalFiles(uri) {
+    const configured = ltexConfig(uri.toString()).get("dictionary.externalFiles", []);
+    if (!Array.isArray(configured)) {
+      return [];
+    }
+    return configured.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+  }
+  resolveDictionaryExternalPath(uri, filePath) {
+    const expanded = expandHome(filePath.trim());
+    if ((0, import_path3.isAbsolute)(expanded)) {
+      return expanded;
+    }
+    return (0, import_path3.resolve)(workspaceFolderForUri(uri) ?? workspaceRoot(), expanded);
+  }
+  async runtimeDictionaryLanguages(uri) {
+    const configuredLanguage = ltexConfig(uri.toString()).get("language", "en-US");
+    if (configuredLanguage === "auto") {
+      return LTEX_LANGUAGE_CODES;
+    }
+    const languages = [configuredLanguage];
+    const motherTongue = ltexConfig(uri.toString()).get("additionalRules.motherTongue", "");
+    if (motherTongue) {
+      languages.push(motherTongue);
+    }
+    const document = documentForUri(uri);
+    if (document) {
+      languages.push(...await this.spellLanguagesForDocument(document));
+    }
+    return uniqueSorted(languages.filter((language) => LTEX_LANGUAGE_CODES.includes(language)));
+  }
+  async spellFileDictionary(uri) {
+    const document = documentForUri(uri);
+    if (!document) {
+      return {};
+    }
+    const spellFileOption = await document.buffer.getOption("spellfile");
+    const spellFiles = splitCommaList(spellFileOption).map((filePath) => {
+      const expanded = expandHome(filePath);
+      return (0, import_path3.isAbsolute)(expanded) ? expanded : (0, import_path3.resolve)(workspaceRoot(), expanded);
+    });
+    if (spellFiles.length === 0) {
+      return {};
+    }
+    const languages = await this.spellLanguagesForDocument(document);
+    const configuredLanguage = ltexConfig(uri.toString()).get("language", "en-US");
+    const targetLanguages = uniqueSorted(languages.length > 0 ? languages : [configuredLanguage]);
+    const words = uniqueSorted(spellFiles.flatMap((filePath) => this.readEntries(filePath)));
+    if (words.length === 0) {
+      return {};
+    }
+    const result = {};
+    for (const language of targetLanguages) {
+      result[language] = words;
+    }
+    return result;
+  }
+  async spellLanguageOverride(uri) {
+    if (!ltexConfig(uri.toString()).get("languageFromSpellLang", false)) {
+      return void 0;
+    }
+    const document = documentForUri(uri);
+    if (!document) {
+      return void 0;
+    }
+    const languages = await this.spellLanguagesForDocument(document);
+    return languages.find((language) => LTEX_LANGUAGE_CODES.includes(language));
+  }
+  async spellLanguagesForDocument(document) {
+    const spellLangOption = await document.buffer.getOption("spelllang");
+    return uniqueSorted(splitCommaList(spellLangOption).map(normalizeSpellLanguage));
+  }
+  settingForScopeWithExternalFiles(uri, settingName, scope) {
+    const result = {};
+    const defaultDir = this.defaultDirectory(uri, scope);
+    const configured = this.settingValueForScope(uri, settingName, scope);
+    const languages = this.languagesForExternalFiles(configured);
+    for (const language of languages) {
+      const files = this.explicitFilesForLanguage(configured, language, defaultDir);
+      if (defaultDir) {
+        files.push((0, import_path3.join)(defaultDir, `ltex.${settingName}.${languageFileSuffix(language)}.txt`));
+      }
+      for (const file of files) {
+        const entries = this.readEntries(file);
+        if (entries.length > 0) {
+          result[language] = [...result[language] ?? [], ...entries];
+        }
+      }
+    }
+    for (const [language, entries] of Object.entries(configured ?? {})) {
+      if (!Array.isArray(entries)) {
+        continue;
+      }
+      const inlineEntries = entries.filter((entry) => typeof entry === "string" && !entry.startsWith(":"));
+      if (inlineEntries.length > 0) {
+        result[language] = [...result[language] ?? [], ...inlineEntries];
+      }
+    }
+    return result;
+  }
+  settingValueForScope(uri, settingName, scope) {
+    const inspect = ltexConfig(uri.toString()).inspect(settingName);
+    if (!inspect) {
+      return void 0;
+    }
+    switch (scope) {
+      case import_coc5.ConfigurationTarget.Global:
+        return inspect.globalValue;
+      case import_coc5.ConfigurationTarget.Workspace:
+        return inspect.workspaceValue;
+      case import_coc5.ConfigurationTarget.WorkspaceFolder:
+        return inspect.workspaceFolderValue;
+      default:
+        return void 0;
+    }
+  }
+  explicitFilesForLanguage(configured, language, defaultDir) {
+    const rawEntries = configured?.[language];
+    const entries = Array.isArray(rawEntries) ? rawEntries : [];
+    return entries.filter((entry) => typeof entry === "string" && entry.startsWith(":")).map((entry) => {
+      const explicitPath = expandHome(entry.slice(1));
+      return (0, import_path3.isAbsolute)(explicitPath) || !defaultDir ? explicitPath : (0, import_path3.resolve)(defaultDir, explicitPath);
+    });
+  }
+  defaultDirectory(uri, scope) {
+    switch (scope) {
+      case import_coc5.ConfigurationTarget.Global:
+        return this.context.storagePath ? (0, import_path3.resolve)(this.context.storagePath) : null;
+      case import_coc5.ConfigurationTarget.Workspace: {
+        const folders = import_coc5.workspace.workspaceFolders ?? [];
+        if (folders.length === 0) {
+          return null;
+        }
+        const folderUri = import_coc5.Uri.parse(folders[0].uri);
+        return folderUri.scheme === "file" ? (0, import_path3.resolve)(folderUri.fsPath, ".vim") : null;
+      }
+      case import_coc5.ConfigurationTarget.WorkspaceFolder: {
+        const folderPath = workspaceFolderForUri(uri);
+        return folderPath ? (0, import_path3.resolve)(folderPath, ".vim") : null;
+      }
+      default:
+        return null;
+    }
+  }
+  languagesForExternalFiles(configured) {
+    const configuredLanguages = configured ? Object.keys(configured).filter((language) => Array.isArray(configured[language])) : [];
+    const activeLanguage = ltexConfig().get("language", "en-US");
+    const motherTongue = ltexConfig().get("additionalRules.motherTongue", "");
+    return uniqueSorted([
+      ...LTEX_LANGUAGE_CODES,
+      ...configuredLanguages,
+      ...activeLanguage ? [activeLanguage] : [],
+      ...motherTongue ? [motherTongue] : []
+    ]);
+  }
+  readEntries(filePath) {
+    const contents = this.contents.get(filePath) ?? this.loadFileContents(filePath);
+    return contents == null ? [] : parseExternalFileEntries(contents);
+  }
+  loadFileContents(filePath) {
+    if (!(0, import_fs2.existsSync)(filePath)) {
+      return null;
+    }
+    try {
+      const contents = (0, import_fs2.readFileSync)(filePath, "utf8");
+      this.contents.set(filePath, contents);
+      this.watchFile(filePath);
+      return contents;
+    } catch (err) {
+      console.error(`Failed to read LTEX external setting file ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+      return null;
+    }
+  }
+  watchFile(filePath) {
+    if (this.watchers.has(filePath)) {
+      return;
+    }
+    try {
+      const watcher = (0, import_fs2.watch)(filePath, () => this.reloadWatchedFile(filePath));
+      this.watchers.set(filePath, watcher);
+    } catch (err) {
+      console.error(`Failed to watch LTEX external setting file ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  reloadWatchedFile(filePath) {
+    if (!(0, import_fs2.existsSync)(filePath)) {
+      this.unwatchFile(filePath);
+      this.contents.delete(filePath);
+      return;
+    }
+    try {
+      this.contents.set(filePath, (0, import_fs2.readFileSync)(filePath, "utf8"));
+    } catch (err) {
+      console.error(`Failed to reload LTEX external setting file ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  unwatchFile(filePath) {
+    const watcher = this.watchers.get(filePath);
+    if (watcher) {
+      watcher.close();
+      this.watchers.delete(filePath);
+    }
+  }
+};
+function isDirectory(filePath) {
+  try {
+    return (0, import_fs2.statSync)(filePath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function languageFromDictionaryFile(filePath) {
+  const name = (0, import_path3.basename)(filePath);
+  if (!name.endsWith(".txt")) {
+    return void 0;
+  }
+  const language = name.slice(0, -".txt".length);
+  return language !== "default" && LTEX_LANGUAGE_CODES.includes(language) ? language : void 0;
+}
+function uniqueRuntimeDictionaryFiles(files) {
+  const result = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    result.set(`${file.language}\0${file.filePath}\0${file.appliesToAllLanguages ? "1" : "0"}`, file);
+  }
+  return Array.from(result.values()).sort((a, b) => {
+    const languageCompare = a.language.localeCompare(b.language);
+    return languageCompare === 0 ? a.filePath.localeCompare(b.filePath) : languageCompare;
+  });
+}
+
+// src/format.ts
+function seconds(value) {
+  return typeof value === "number" && Number.isFinite(value) ? `${value.toFixed(1)}s` : "n/a";
+}
+function percent(value) {
+  return typeof value === "number" && Number.isFinite(value) ? `${(value * 100).toFixed(1)}%` : "n/a";
+}
+function bytes(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return "n/a";
+  }
+  const units = ["B", "KiB", "MiB", "GiB"];
+  let normalized = value;
+  let unitIndex = 0;
+  while (normalized >= 1024 && unitIndex < units.length - 1) {
+    normalized /= 1024;
+    unitIndex += 1;
+  }
+  return `${normalized.toFixed(unitIndex === 0 ? 0 : 1)} ${units[unitIndex]}`;
+}
+
+// src/installer.ts
+var import_coc6 = require("coc.nvim");
+var import_child_process = require("child_process");
+var import_crypto = require("crypto");
+var import_fs3 = require("fs");
+var import_http = require("http");
+var import_https = require("https");
+var import_path4 = require("path");
+var import_promises = require("stream/promises");
+function isRedirect(statusCode) {
+  return statusCode === 301 || statusCode === 302 || statusCode === 303 || statusCode === 307 || statusCode === 308;
+}
+function getUrl(url, callback) {
+  const options = {
+    headers: {
+      "User-Agent": "coc-ltex-plus",
+      Accept: "application/vnd.github+json, application/octet-stream"
+    }
+  };
+  return url.protocol === "http:" ? (0, import_http.get)(url, options, callback) : (0, import_https.get)(url, options, callback);
+}
+async function fetchText(urlString, redirectCount = 0) {
+  return new Promise((resolvePromise, reject) => {
+    const url = new URL(urlString);
+    const request = getUrl(url, (response) => {
+      if (isRedirect(response.statusCode)) {
+        response.resume();
+        const location = response.headers.location;
+        if (!location) {
+          reject(new Error(`Request to ${urlString} redirected without a Location header.`));
+          return;
+        }
+        if (redirectCount >= HTTP_REDIRECT_LIMIT) {
+          reject(new Error(`Request to ${urlString} exceeded ${HTTP_REDIRECT_LIMIT} redirects.`));
+          return;
+        }
+        fetchText(new URL(location, url).toString(), redirectCount + 1).then(resolvePromise, reject);
+        return;
+      }
+      const chunks = [];
+      let received = 0;
+      response.on("data", (chunk) => {
+        received += chunk.length;
+        if (received > RELEASE_METADATA_LIMIT_BYTES) {
+          request.destroy(new Error(`Response from ${urlString} exceeded ${RELEASE_METADATA_LIMIT_BYTES} bytes.`));
+          return;
+        }
+        chunks.push(Buffer.from(chunk));
+      });
+      response.on("end", () => {
+        resolvePromise({
+          statusCode: response.statusCode ?? 0,
+          statusMessage: response.statusMessage ?? "",
+          text: Buffer.concat(chunks).toString("utf8")
+        });
+      });
+    });
+    request.setTimeout(DOWNLOAD_IDLE_TIMEOUT_MS, () => request.destroy(new Error(`Request to ${urlString} timed out.`)));
+    request.on("error", reject);
+  });
+}
+async function downloadFile(urlString, filePath, onProgress, redirectCount = 0) {
+  return new Promise((resolvePromise, reject) => {
+    const url = new URL(urlString);
+    const request = getUrl(url, (response) => {
+      if (isRedirect(response.statusCode)) {
+        response.resume();
+        const location = response.headers.location;
+        if (!location) {
+          reject(new Error(`Download from ${urlString} redirected without a Location header.`));
+          return;
+        }
+        if (redirectCount >= HTTP_REDIRECT_LIMIT) {
+          reject(new Error(`Download from ${urlString} exceeded ${HTTP_REDIRECT_LIMIT} redirects.`));
+          return;
+        }
+        downloadFile(new URL(location, url).toString(), filePath, onProgress, redirectCount + 1).then(resolvePromise, reject);
+        return;
+      }
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(new Error(`Download from ${urlString} failed with HTTP ${response.statusCode ?? "unknown"}.`));
+        return;
+      }
+      const total = response.headers["content-length"] ? Number(response.headers["content-length"]) : void 0;
+      let received = 0;
+      response.on("data", (chunk) => {
+        received += chunk.length;
+        onProgress?.(received, Number.isFinite(total) ? total : void 0);
+      });
+      (0, import_promises.pipeline)(response, (0, import_fs3.createWriteStream)(filePath, { mode: 420 })).then(resolvePromise, reject);
+    });
+    request.setTimeout(DOWNLOAD_IDLE_TIMEOUT_MS, () => request.destroy(new Error(`Download from ${urlString} timed out.`)));
+    request.on("error", reject);
+  });
+}
+async function runProcess(command, args, timeoutMs) {
+  return new Promise((resolvePromise) => {
+    const child = (0, import_child_process.spawn)(command, args, { windowsHide: true });
+    const stdout = [];
+    const stderr = [];
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (!settled) {
+        child.kill();
+      }
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => stdout.push(Buffer.from(chunk)));
+    child.stderr?.on("data", (chunk) => stderr.push(Buffer.from(chunk)));
+    child.on("error", (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolvePromise({ code: null, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8"), error });
+    });
+    child.on("close", (code) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolvePromise({ code, stdout: Buffer.concat(stdout).toString("utf8"), stderr: Buffer.concat(stderr).toString("utf8") });
+    });
+  });
+}
+function processError(result, label) {
+  if (result.code === 0) {
+    return void 0;
+  }
+  const detail = result.error?.message || result.stderr.trim() || result.stdout.trim() || `exit code ${result.code ?? "unknown"}`;
+  return new Error(`${label} failed: ${detail}`);
+}
+async function runProcessOrThrow(command, args, timeoutMs, label) {
+  const result = await runProcess(command, args, timeoutMs);
+  const error = processError(result, label);
+  if (error) {
+    throw error;
+  }
+}
+function parseSemver(value) {
+  const match = value.match(/\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/);
+  if (!match) {
+    return void 0;
+  }
+  const raw = match[0];
+  return {
+    raw,
+    core: raw.split(/[-+]/, 1)[0]
+  };
+}
+async function verifyLtexExecutable(command, releaseTag) {
+  const result = await runProcess(command, ["--version"], VERIFY_TIMEOUT_MS);
+  const error = processError(result, "ltex-ls-plus --version");
+  if (error) {
+    throw error;
+  }
+  const output = `${result.stdout}
+${result.stderr}`.trim();
+  const expected = parseSemver(releaseVersionFromTag(releaseTag));
+  const actual = parseSemver(output);
+  if (expected && actual && expected.core !== actual.core) {
+    throw new Error(`Downloaded ltex-ls-plus version mismatch: expected ${expected.core}, got ${actual.raw}.`);
+  }
+}
+async function sha256File(filePath) {
+  return new Promise((resolvePromise, reject) => {
+    const hash = (0, import_crypto.createHash)("sha256");
+    const stream = (0, import_fs3.createReadStream)(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolvePromise(hash.digest("hex")));
+  });
+}
+async function verifyDownloadedArchive(filePath, release) {
+  if (!release.sha256) {
+    return;
+  }
+  const actual = await sha256File(filePath);
+  if (actual !== release.sha256) {
+    throw new Error(`Downloaded ltex-ls-plus checksum mismatch: expected ${release.sha256}, got ${actual}.`);
+  }
+}
+async function extractArchive(archivePath, targetDir, assetName) {
+  await import_fs3.promises.mkdir(targetDir, { recursive: true });
+  if (assetName.endsWith(".zip")) {
+    if (process.platform === "win32") {
+      await runProcessOrThrow(
+        "powershell.exe",
+        ["-NoProfile", "-NonInteractive", "-Command", "Expand-Archive -LiteralPath $args[0] -DestinationPath $args[1] -Force", archivePath, targetDir],
+        INSTALL_TIMEOUT_MS,
+        "Extracting ltex-ls-plus zip archive"
+      );
+      return;
+    }
+    const unzip = await runProcess("unzip", ["-q", archivePath, "-d", targetDir], INSTALL_TIMEOUT_MS);
+    if (!processError(unzip, "unzip")) {
+      return;
+    }
+    await runProcessOrThrow("tar", ["-xf", archivePath, "-C", targetDir], INSTALL_TIMEOUT_MS, "Extracting ltex-ls-plus zip archive");
+    return;
+  }
+  await runProcessOrThrow("tar", ["-xzf", archivePath, "-C", targetDir], INSTALL_TIMEOUT_MS, "Extracting ltex-ls-plus tar archive");
+}
+async function findExtractedServerDirectory(rootDir) {
+  const rootExecutable = existingLtexExecutable(rootDir);
+  if (rootExecutable) {
+    await import_fs3.promises.chmod(rootExecutable, 493).catch(() => {
+    });
+    return rootDir;
+  }
+  const entries = await import_fs3.promises.readdir(rootDir);
+  for (const entry of entries) {
+    const candidate = (0, import_path4.join)(rootDir, entry);
+    const stat = await import_fs3.promises.stat(candidate).catch(() => void 0);
+    if (!stat?.isDirectory()) {
+      continue;
+    }
+    const executable = existingLtexExecutable(candidate);
+    if (executable) {
+      await import_fs3.promises.chmod(executable, 493).catch(() => {
+      });
+      return candidate;
+    }
+  }
+  throw new Error("Extracted ltex-ls-plus archive did not contain a server directory.");
+}
+async function removePath(pathValue) {
+  if (!pathValue) {
+    return;
+  }
+  await import_fs3.promises.rm(pathValue, { recursive: true, force: true }).catch((err) => {
+    console.error(`Failed to remove ${pathValue}: ${err instanceof Error ? err.message : String(err)}`);
+  });
+}
+function selectReleaseAsset(release) {
+  const version = releaseVersionFromTag(release.tag_name);
+  const exactName = ltexAssetNameForPlatform(version);
+  return release.assets.find((asset) => asset.name === exactName) ?? release.assets.find((asset) => assetMatchesPlatform(asset.name, version));
+}
+async function fetchLatestLtexRelease() {
+  const platformName = ltexPlatformName();
+  const archName = ltexArchName();
+  if (!platformName || !archName) {
+    throw new Error(`Managed ltex-ls-plus install is not available for ${process.platform}/${process.arch}.`);
+  }
+  const response = await fetchText(LTEX_LATEST_RELEASE_API_URL);
+  if (response.statusCode < 200 || response.statusCode >= 300) {
+    throw new Error(`GitHub release request failed with HTTP ${response.statusCode}: ${response.text}`);
+  }
+  const release = JSON.parse(response.text);
+  const asset = selectReleaseAsset(release);
+  if (!asset) {
+    const expected = ltexAssetNameForPlatform(releaseVersionFromTag(release.tag_name)) ?? `${platformName}-${archName}`;
+    throw new Error(`Release ${release.tag_name} does not include a ltex-ls-plus asset for ${process.platform}/${process.arch} (${expected}).`);
+  }
+  return {
+    tag: release.tag_name,
+    assetName: asset.name,
+    url: asset.browser_download_url,
+    sha256: sha256FromDigest(asset.digest)
+  };
+}
+var LtexServerInstaller = class {
+  constructor(context) {
+    this.context = context;
+  }
+  managedRelease() {
+    return this.context.globalState.get(MANAGED_RELEASE_KEY);
+  }
+  async installLatest() {
+    const release = await fetchLatestLtexRelease();
+    await this.installRelease(release);
+    return release;
+  }
+  async updateLatest() {
+    const release = await fetchLatestLtexRelease();
+    if (this.managedRelease() === release.tag && managedServerExecutable(this.context.storagePath)) {
+      return null;
+    }
+    await this.installRelease(release);
+    return release;
+  }
+  async installRelease(release) {
+    if (!(0, import_fs3.existsSync)(this.context.storagePath)) {
+      await import_fs3.promises.mkdir(this.context.storagePath, { recursive: true });
+    }
+    const statusItem = import_coc6.window.createStatusBarItem(0, { progress: true });
+    const tempId = (0, import_crypto.randomBytes)(5).toString("hex");
+    const archivePath = (0, import_path4.join)(this.context.storagePath, `${release.assetName}-${tempId}`);
+    const extractDir = (0, import_path4.join)(this.context.storagePath, `extract-${tempId}`);
+    const backupDir = (0, import_path4.join)(this.context.storagePath, `ltex-ls-plus.backup-${tempId}`);
+    const finalDir = managedServerDirectory(this.context.storagePath);
+    let backupCreated = false;
+    let installed = false;
+    try {
+      statusItem.text = `Downloading ltex-ls-plus ${release.tag}`;
+      statusItem.show();
+      await downloadFile(release.url, archivePath, (received, total) => {
+        statusItem.text = total ? `${(received / total * 100).toFixed(1)}% Downloading ltex-ls-plus ${release.tag}` : `Downloading ltex-ls-plus ${release.tag}`;
+      });
+      statusItem.text = `Verifying ltex-ls-plus ${release.tag}`;
+      await verifyDownloadedArchive(archivePath, release);
+      statusItem.text = `Extracting ltex-ls-plus ${release.tag}`;
+      await extractArchive(archivePath, extractDir, release.assetName);
+      const extractedDir = await findExtractedServerDirectory(extractDir);
+      const executable = existingLtexExecutable(extractedDir);
+      if (!executable) {
+        throw new Error("Extracted ltex-ls-plus server directory is missing bin/ltex-ls-plus.");
+      }
+      statusItem.text = `Testing ltex-ls-plus ${release.tag}`;
+      await verifyLtexExecutable(executable, release.tag);
+      await import_fs3.promises.rename(finalDir, backupDir).then(
+        () => {
+          backupCreated = true;
+        },
+        (err) => {
+          if (err.code !== "ENOENT") {
+            throw err;
+          }
+        }
+      );
+      await import_fs3.promises.rename(extractedDir, finalDir);
+      installed = true;
+      await this.context.globalState.update(MANAGED_RELEASE_KEY, release.tag).catch((err) => {
+        import_coc6.window.showWarningMessage(`ltex-ls-plus ${release.tag} installed, but coc-ltex-plus could not record release metadata.`);
+        console.error(err);
+      });
+    } catch (err) {
+      if (backupCreated) {
+        await removePath(finalDir);
+        await import_fs3.promises.rename(backupDir, finalDir).catch((restoreErr) => {
+          console.error(`Failed to restore previous ltex-ls-plus install: ${restoreErr instanceof Error ? restoreErr.message : String(restoreErr)}`);
+        });
+        backupCreated = false;
+      }
+      throw err;
+    } finally {
+      statusItem.hide();
+      statusItem.dispose();
+      await removePath(archivePath);
+      await removePath(extractDir);
+      if (backupCreated && installed) {
+        await removePath(backupDir);
+      }
+    }
+  }
+};
+
+// src/settingsList.ts
+var import_coc7 = require("coc.nvim");
+var LtexSettingsList = class extends import_coc7.BasicList {
+  constructor(externalSettings, onChanged, diagnosticsProvider = () => []) {
+    super();
+    this.externalSettings = externalSettings;
+    this.onChanged = onChanged;
+    this.diagnosticsProvider = diagnosticsProvider;
+    this.name = "ltexSettings";
+    this.defaultAction = "inspect";
+    this.description = "LTeX dictionaries, disabled rules, and hidden false positives";
+    this.detail = "Inspect, edit, delete, jump to diagnostics, or clean obsolete LTeX settings.";
+    this.addAction("inspect", (item) => this.inspect(item));
+    this.addAction("jump", (item) => this.jump(item));
+    this.addAction("edit", (item) => this.edit(item), { reload: true });
+    this.addAction("delete", (item) => this.delete(item), { reload: true });
+    this.addAction("cleanupObsoleteHiddenFalsePositives", () => this.cleanupObsoleteHiddenFalsePositives(), { reload: true });
+  }
+  get alignColumns() {
+    return true;
+  }
+  async loadItems(_context) {
+    const document = await import_coc7.workspace.document;
+    const diagnostics = this.diagnosticsProvider();
+    const entries = this.externalSettings.listEntries(import_coc7.Uri.parse(document.uri));
+    return entries.map((entry) => {
+      const context = diagnosticsContextForEntry(entry, diagnostics, document);
+      return {
+        label: `${context.label}	${settingsEntryLabel(entry)}`,
+        filterText: `${context.label} ${settingTitle(entry.settingName)} ${entry.language} ${entry.value} ${entry.sourceLabel} ${entry.filePath ?? ""} ${context.message ?? ""} ${context.line ?? ""}`,
+        sortText: `${entry.settingName}:${context.label}:${entry.language}:${entry.value}`,
+        data: { entry, context }
+      };
+    });
+  }
+  inspect(item) {
+    const data = singleListItemData(item);
+    const entry = data?.entry ?? singleListEntry(item);
+    if (!entry) {
+      return;
+    }
+    const context = data?.context;
+    const lines = [
+      `${settingTitle(entry.settingName)} entry`,
+      `Language: ${entry.language}`,
+      `Value: ${entry.value}`,
+      `Source: ${entry.sourceLabel}`
+    ];
+    if (entry.readOnly) {
+      lines.push("Read-only: true");
+    }
+    if (entry.filePath) {
+      lines.push(`File: ${entry.filePath}`);
+    }
+    lines.push(...diagnosticDetailLines(context));
+    import_coc7.window.showInformationMessage(lines.join("\n"));
+  }
+  async jump(item) {
+    const context = singleListItemData(item)?.context;
+    if (!context?.uri || !context.range) {
+      import_coc7.window.showWarningMessage("No current LTeX diagnostic or active hidden false positive location is available for this entry.");
+      return;
+    }
+    await import_coc7.workspace.jumpTo(context.uri, context.range.start);
+  }
+  async edit(item) {
+    const entry = singleListEntry(item);
+    if (!entry) {
+      return;
+    }
+    if (entry.readOnly) {
+      import_coc7.window.showWarningMessage("This LTeX settings entry is read-only.");
+      return;
+    }
+    const nextValue = await import_coc7.window.requestInput(`Edit ${settingTitle(entry.settingName)} entry`, entry.value);
+    if (!nextValue || nextValue.trim() === entry.value) {
+      return;
+    }
+    await this.externalSettings.editEntry(entry, nextValue);
+    await this.onChanged();
+  }
+  async delete(item) {
+    const entry = singleListEntry(item);
+    if (!entry) {
+      return;
+    }
+    if (entry.readOnly) {
+      import_coc7.window.showWarningMessage("This LTeX settings entry is read-only.");
+      return;
+    }
+    const confirmed = await import_coc7.window.showPrompt(`Delete ${settingTitle(entry.settingName)} entry "${entry.value}"?`);
+    if (!confirmed) {
+      return;
+    }
+    await this.externalSettings.deleteEntry(entry);
+    await this.onChanged();
+  }
+  async cleanupObsoleteHiddenFalsePositives() {
+    const document = await import_coc7.workspace.document;
+    const diagnostics = this.diagnosticsProvider();
+    const obsoleteEntries = this.externalSettings.listEntries(import_coc7.Uri.parse(document.uri)).filter((entry) => entry.settingName === "hiddenFalsePositives").filter((entry) => diagnosticsContextForEntry(entry, diagnostics, document).status === "obsolete");
+    if (obsoleteEntries.length === 0) {
+      import_coc7.window.showInformationMessage("No obsolete hidden false positive entries found for the current document.");
+      return;
+    }
+    const confirmed = await import_coc7.window.showPrompt(obsoleteCleanupPrompt(obsoleteEntries));
+    if (!confirmed) {
+      return;
+    }
+    for (const entry of obsoleteEntries) {
+      await this.externalSettings.deleteEntry(entry);
+    }
+    await this.onChanged();
+    import_coc7.window.showInformationMessage(`Deleted ${obsoleteEntries.length} obsolete hidden false positive entr${obsoleteEntries.length === 1 ? "y" : "ies"}.`);
+  }
+};
+function obsoleteCleanupPrompt(entries) {
+  const preview = entries.slice(0, 8).map((entry) => {
+    const source = entry.filePath ?? entry.sourceLabel;
+    return `- ${entry.language}: ${entry.value} (${source})`;
+  });
+  const remaining = entries.length > preview.length ? `
+...and ${entries.length - preview.length} more.` : "";
+  return [
+    `Delete ${entries.length} hidden false positive entr${entries.length === 1 ? "y" : "ies"} not found in the current buffer?`,
+    "Shared entries may still apply to other files.",
+    ...preview,
+    remaining
+  ].filter(Boolean).join("\n");
+}
+function singleListItemData(item) {
+  if (Array.isArray(item)) {
+    return void 0;
+  }
+  return item.data;
+}
+function diagnosticDetailLines(context) {
+  if (!context) {
+    return ["Diagnostic context: unknown"];
+  }
+  const lines = [`Diagnostic context: ${context.label}`];
+  if (context.ruleId) {
+    lines.push(`Rule: ${context.ruleId}`);
+  }
+  if (context.sentence) {
+    lines.push(`Sentence: ${context.sentence}`);
+  }
+  if (context.message) {
+    lines.push(`Diagnostic: ${context.message}`);
+  }
+  if (context.uri && context.range) {
+    lines.push(`Location: ${context.uri}:${context.range.start.line + 1}:${context.range.start.character + 1}`);
+  }
+  if (context.line) {
+    lines.push(`Line: ${context.line}`);
+  }
+  return lines;
+}
+
+// src/extension.ts
+var LtexPlusExtension = class {
+  constructor(context) {
+    this.context = context;
+    this.diagnosticsState = { enabled: true };
+    this.externalSettings = new ExternalSettings(context);
+    this.serverInstaller = new LtexServerInstaller(context);
+  }
+  register() {
+    this.context.subscriptions.push(
+      import_coc8.workspace.onDidChangeConfiguration((event) => this.onConfigurationChange(event)),
+      import_coc8.commands.registerCommand("ltex.activateExtension", () => this.start()),
+      import_coc8.commands.registerCommand("ltex.restart", () => this.restart()),
+      import_coc8.commands.registerCommand("ltex.resetAndRestart", () => this.restart()),
+      import_coc8.commands.registerCommand("ltex.checkCurrentDocument", () => this.checkCurrentDocument()),
+      import_coc8.commands.registerCommand("ltex.checkSelection", () => this.checkSelection()),
+      import_coc8.commands.registerCommand("ltex.checkAllDocumentsInWorkspace", () => this.checkAllDocumentsInWorkspace()),
+      import_coc8.commands.registerCommand("ltex.clearDiagnosticsInCurrentDocument", () => this.clearDiagnosticsInCurrentDocument()),
+      import_coc8.commands.registerCommand("ltex.clearAllDiagnostics", () => this.clearAllDiagnostics()),
+      import_coc8.commands.registerCommand("ltex.toggleDiagnostics", () => this.toggleDiagnostics()),
+      import_coc8.commands.registerCommand("ltex.showStatusInformation", () => this.showStatusInformation()),
+      import_coc8.commands.registerCommand("ltex.serverStatus", () => this.showServerStatus()),
+      import_coc8.commands.registerCommand("ltex.showOutputChannel", () => this.client?.outputChannel.show()),
+      import_coc8.commands.registerCommand("ltex.disableHere", () => this.disableHere()),
+      import_coc8.commands.registerCommand("ltex.reloadExternalSettings", () => this.reloadExternalSettings()),
+      import_coc8.commands.registerCommand("ltex.installServer", () => this.installServer()),
+      import_coc8.commands.registerCommand("ltex.updateServer", () => this.updateServer()),
+      import_coc8.commands.registerCommand("ltex.checkDuplicateServer", () => this.checkDuplicateServerConfig()),
+      import_coc8.commands.registerCommand("_ltex.addToDictionary", (params) => this.addToLanguageSpecificSetting(params, "dictionary", "words")),
+      import_coc8.commands.registerCommand("_ltex.disableRules", (params) => this.addToLanguageSpecificSetting(params, "disabledRules", "ruleIds")),
+      import_coc8.commands.registerCommand(
+        "_ltex.hideFalsePositives",
+        (params) => this.addToLanguageSpecificSetting(params, "hiddenFalsePositives", "falsePositives")
+      ),
+      import_coc8.listManager.registerList(
+        new LtexSettingsList(
+          this.externalSettings,
+          () => this.reloadExternalSettings(false),
+          () => diagnosticsFromCollection(this.client?.diagnostics)
+        )
+      ),
+      import_coc8.Disposable.create(() => {
+        this.externalSettings.dispose();
+        void this.stop().catch((err) => console.error(err));
+      })
+    );
+  }
+  async activate() {
+    this.checkDuplicateServerConfig(false);
+    if (enabledLanguages().length === 0) {
+      return;
+    }
+    await this.start();
+  }
+  async start() {
+    if (this.client?.isRunning()) {
+      return;
+    }
+    const resolved = resolveLtexServer(this.context.storagePath);
+    if (!resolved) {
+      import_coc8.window.showWarningMessage(`ltex-ls-plus was not found. Run :CocCommand ltex.installServer or set "ltex.ltex-ls.path". Releases: ${LTEX_RELEASES_URL}`);
+      return;
+    }
+    this.client = createClient(resolved.command, this.externalSettings, this.diagnosticsState);
+    this.clientRegistration = import_coc8.services.registLanguageClient(this.client);
+    await this.client.onReady();
+  }
+  async restart() {
+    await this.stop();
+    await this.start();
+  }
+  async stop() {
+    const client = this.client;
+    this.client = void 0;
+    this.clientRegistration?.dispose();
+    this.clientRegistration = void 0;
+    if (!client) {
+      return;
+    }
+    if (client.isRunning()) {
+      await client.stop();
+    }
+    await client.dispose();
+  }
+  async onConfigurationChange(event) {
+    const changedProcessSetting = PROCESS_SETTING_KEYS.find((key) => event.affectsConfiguration(key));
+    if (!changedProcessSetting) {
+      return;
+    }
+    if (enabledLanguages().length === 0) {
+      await this.stop();
+      return;
+    }
+    if (!this.client) {
+      await this.start();
+      return;
+    }
+    const restart = await import_coc8.window.showPrompt(`Changing "${changedProcessSetting}" requires restarting LTeX+. Restart now?`);
+    if (restart) {
+      await this.restart();
+    }
+  }
+  async checkCurrentDocument() {
+    const document = await import_coc8.workspace.document;
+    return this.checkDocument(document);
+  }
+  async checkSelection() {
+    const document = await import_coc8.workspace.document;
+    const range = await import_coc8.window.getSelectedRange("v");
+    if (!range) {
+      return false;
+    }
+    return this.checkDocument(document, range);
+  }
+  async checkAllDocumentsInWorkspace() {
+    if (!this.client) {
+      import_coc8.window.showErrorMessage("LTeX+ is not initialized.");
+      return false;
+    }
+    const documents = checkableWorkspaceDocuments(import_coc8.workspace.documents);
+    if (documents.length === 0) {
+      import_coc8.window.showWarningMessage("No open workspace documents match ltex.enabled.");
+      return false;
+    }
+    let checked = 0;
+    let failed = 0;
+    for (const document of documents) {
+      if (await this.checkDocument(document)) {
+        checked += 1;
+      } else {
+        failed += 1;
+      }
+    }
+    if (failed > 0) {
+      import_coc8.window.showWarningMessage(`Checked ${checked} open workspace document${checked === 1 ? "" : "s"} with ${failed} failure${failed === 1 ? "" : "s"}.`);
+      return false;
+    }
+    import_coc8.window.showInformationMessage(`Checked ${checked} open workspace document${checked === 1 ? "" : "s"}.`);
+    return true;
+  }
+  async checkDocument(document, range) {
+    if (!this.client) {
+      import_coc8.window.showErrorMessage("LTeX+ is not initialized.");
+      return false;
+    }
+    const params = {
+      uri: document.uri,
+      codeLanguageId: document.filetype,
+      text: document.content,
+      range
+    };
+    try {
+      await this.client.onReady();
+      const result = await this.client.sendRequest("workspace/executeCommand", {
+        command: "_ltex.checkDocument",
+        arguments: [params]
+      });
+      if (result?.success === false) {
+        import_coc8.window.showErrorMessage(`LTeX+ could not check the document: ${result.errorMessage ?? "unknown error"}`);
+        return false;
+      }
+      return true;
+    } catch (err) {
+      import_coc8.window.showErrorMessage(`LTeX+ could not check the document: ${err instanceof Error ? err.message : String(err)}`);
+      return false;
+    }
+  }
+  async clearDiagnosticsInCurrentDocument() {
+    if (!this.client) {
+      import_coc8.window.showErrorMessage("LTeX+ is not initialized.");
+      return false;
+    }
+    const document = await import_coc8.workspace.document;
+    this.client.diagnostics?.set(document.uri, null);
+    return true;
+  }
+  clearAllDiagnostics() {
+    if (!this.client) {
+      import_coc8.window.showErrorMessage("LTeX+ is not initialized.");
+      return false;
+    }
+    this.client.diagnostics?.clear();
+    return true;
+  }
+  async toggleDiagnostics() {
+    this.diagnosticsState.enabled = !this.diagnosticsState.enabled;
+    if (!this.diagnosticsState.enabled) {
+      this.client?.diagnostics?.clear();
+      import_coc8.window.showInformationMessage("LTeX+ diagnostics disabled for this session.");
+      return false;
+    }
+    import_coc8.window.showInformationMessage("LTeX+ diagnostics enabled for this session.");
+    if (this.client?.isRunning()) {
+      await this.checkCurrentDocument();
+    }
+    return true;
+  }
+  showStatusInformation() {
+    const resolved = resolveLtexServer(this.context.storagePath);
+    const env = serverEnvironment();
+    const languages = enabledLanguages();
+    const status = [
+      `LTeX+ client: ${this.client?.isRunning() ? "running" : "stopped"}`,
+      `Diagnostics: ${this.diagnosticsState.enabled ? "enabled" : "disabled"}`,
+      `Server command: ${resolved?.command ?? "not found"}`,
+      `Server source: ${resolved?.source ?? "none"}`,
+      `Java home override: ${env.JAVA_HOME ?? "none"}`,
+      `JAVA_OPTS: ${env.JAVA_OPTS ?? "none"}`,
+      `Managed release: ${this.serverInstaller.managedRelease() ?? "none"}`,
+      `Enabled filetypes: ${languages.length > 0 ? languages.join(", ") : "none"}`
+    ];
+    const message = status.join("\n");
+    if (this.client) {
+      this.client.outputChannel.appendLine(message);
+      this.client.outputChannel.show();
+    }
+    import_coc8.window.showInformationMessage(message);
+  }
+  async showServerStatus() {
+    if (!this.client) {
+      import_coc8.window.showErrorMessage("LTeX+ is not initialized.");
+      return;
+    }
+    try {
+      await this.client.onReady();
+      const result = await this.client.sendRequest("workspace/executeCommand", {
+        command: "_ltex.getServerStatus",
+        arguments: []
+      });
+      const lines = [
+        "LTeX+ Server Status",
+        `Process ID: ${result.processId ?? "n/a"}`,
+        `Wall-clock duration: ${seconds(result.wallClockDuration)}`,
+        `CPU duration: ${seconds(result.cpuDuration)}`,
+        `CPU usage: ${percent(result.cpuUsage)}`,
+        `Used memory: ${bytes(result.usedMemory)}`,
+        `Total JVM memory: ${bytes(result.totalMemory)}`,
+        `Is checking: ${result.isChecking ? "true" : "false"}`
+      ];
+      if (result.documentUriBeingChecked) {
+        lines.push(`Document URI being checked: ${result.documentUriBeingChecked}`);
+      }
+      this.client.outputChannel.appendLine(lines.join("\n"));
+      this.client.outputChannel.show();
+    } catch (err) {
+      import_coc8.window.showErrorMessage(`Could not get LTeX+ server status: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  async disableHere() {
+    const document = await import_coc8.workspace.document;
+    const cursor = await import_coc8.window.getCursorPosition();
+    const range = await import_coc8.window.getSelectedRange("v");
+    const { startLine, endLine } = selectedLineRange(range, cursor);
+    const commentString = await document.buffer.getOption("commentstring");
+    await document.applyEdits([
+      import_coc8.TextEdit.replace(
+        import_coc8.Range.create(startLine, 0, Math.min(endLine + 1, document.lineCount), 0),
+        disableHereReplacement(document.lines, startLine, endLine, commentString)
+      )
+    ]);
+    import_coc8.window.showInformationMessage("Inserted LTeX disable markers.");
+  }
+  async reloadExternalSettings(showMessage = true) {
+    const loaded = this.externalSettings.reloadFromOpenDocuments();
+    await this.notifyConfigurationChanged();
+    if (showMessage) {
+      import_coc8.window.showInformationMessage(`Reloaded ${loaded} LTeX external setting file${loaded === 1 ? "" : "s"}.`);
+    }
+  }
+  async installServer() {
+    try {
+      const release = await this.serverInstaller.installLatest();
+      import_coc8.window.showInformationMessage(`ltex-ls-plus ${release.tag} installed.`);
+      await this.restartIfManagedServerIsActive();
+    } catch (err) {
+      import_coc8.window.showErrorMessage(`ltex-ls-plus install failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  async updateServer() {
+    try {
+      const release = await this.serverInstaller.updateLatest();
+      if (!release) {
+        import_coc8.window.showInformationMessage(`Managed ltex-ls-plus is already up to date (${this.serverInstaller.managedRelease()}).`);
+        return;
+      }
+      import_coc8.window.showInformationMessage(`ltex-ls-plus ${release.tag} installed.`);
+      await this.restartIfManagedServerIsActive();
+    } catch (err) {
+      import_coc8.window.showErrorMessage(`ltex-ls-plus update failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  async restartIfManagedServerIsActive() {
+    const configuredPath = normalizePath(ltexConfig().get("ltex-ls.path", ""));
+    if (configuredPath) {
+      import_coc8.window.showInformationMessage("Managed ltex-ls-plus was installed, but ltex.ltex-ls.path is still configured and remains active.");
+      return;
+    }
+    await this.restart();
+  }
+  async notifyConfigurationChanged() {
+    if (!this.client) {
+      return;
+    }
+    try {
+      await this.client.onReady();
+      await this.client.sendNotification("workspace/didChangeConfiguration", { settings: { ltex: {} } });
+    } catch (err) {
+      import_coc8.window.showWarningMessage(`Could not notify LTeX+ about settings changes: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  checkDuplicateServerConfig(showSuccess = true) {
+    const languageServerConfig = import_coc8.workspace.getConfiguration("languageserver");
+    const duplicate = languageServerConfig.get("ltex-plus", void 0) ?? languageServerConfig.get("ltex", void 0);
+    if (duplicate) {
+      import_coc8.window.showWarningMessage(
+        "Detected languageserver.ltex-plus/ltex in Coc settings. Remove it to avoid running a second LTEX server beside coc-ltex-plus."
+      );
+      return;
+    }
+    if (showSuccess) {
+      import_coc8.window.showInformationMessage("No duplicate LTEX languageserver configuration detected.");
+    }
+  }
+  addToLanguageSpecificSetting(params, settingName, payloadKey) {
+    const typedParams = params;
+    if (!typedParams?.uri) {
+      return;
+    }
+    const entries = typedParams[payloadKey];
+    if (!entries) {
+      return;
+    }
+    const uri = import_coc8.Uri.parse(typedParams.uri);
+    const configurationTarget = import_coc8.workspace.getConfiguration("ltex.configurationTarget", uri.toString());
+    const target = configurationTarget.get(settingName, "workspaceFolderExternalFile");
+    const scopes = this.scopesForConfigurationTarget(target);
+    if (target.endsWith("ExternalFile")) {
+      this.addToExternalFiles(uri, settingName, scopes, entries);
+    } else {
+      void this.addToInternalSetting(uri, settingName, scopes, entries);
+    }
+    void this.checkCurrentDocument();
+  }
+  scopesForConfigurationTarget(target) {
+    if (target.startsWith("user")) {
+      return [import_coc8.ConfigurationTarget.Global];
+    }
+    if (target.startsWith("workspaceFolder")) {
+      return [import_coc8.ConfigurationTarget.WorkspaceFolder, import_coc8.ConfigurationTarget.Workspace, import_coc8.ConfigurationTarget.Global];
+    }
+    if (target.startsWith("workspace")) {
+      return [import_coc8.ConfigurationTarget.Workspace, import_coc8.ConfigurationTarget.Global];
+    }
+    return [import_coc8.ConfigurationTarget.WorkspaceFolder, import_coc8.ConfigurationTarget.Workspace, import_coc8.ConfigurationTarget.Global];
+  }
+  addToExternalFiles(uri, settingName, scopes, entries) {
+    for (const [language, values] of Object.entries(entries)) {
+      const cleanValues = values.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+      if (cleanValues.length === 0) {
+        continue;
+      }
+      let written = false;
+      for (const scope of scopes) {
+        const filePath = this.externalSettings.firstExternalFilePath(uri, settingName, scope, language);
+        if (!filePath) {
+          continue;
+        }
+        this.externalSettings.appendToFile(filePath, cleanValues);
+        written = true;
+        break;
+      }
+      if (!written) {
+        void this.addToInternalSetting(uri, settingName, scopes, { [language]: cleanValues });
+      }
+    }
+  }
+  async addToInternalSetting(uri, settingName, scopes, entries) {
+    const config = ltexConfig(uri.toString());
+    const current = config.get(settingName, {});
+    const next = { ...current };
+    for (const [language, values] of Object.entries(entries)) {
+      next[language] = cleanLanguageSpecificEntries([...next[language] ?? [], ...values]);
+    }
+    for (const scope of scopes) {
+      try {
+        await config.update(settingName, next, scope);
+        return;
+      } catch (err) {
+        console.error(`Failed to update ltex.${settingName} at scope ${scope}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    import_coc8.window.showErrorMessage(`Could not update ltex.${settingName}.`);
+  }
+};
+
+// src/testHooks.ts
+var __testHooks = {
+  ExternalSettings,
+  assetMatchesPlatform,
+  checkableWorkspaceDocuments,
+  cleanLanguageSpecificEntries,
+  commentLine,
+  diagnosticCode,
+  diagnosticsContextForEntry,
+  disableHereReplacement,
+  expandHome,
+  ltexArchName,
+  ltexAssetNameForPlatform,
+  ltexPlatformName,
+  managedServerDirectory,
+  managedServerExecutable,
+  normalizePath,
+  normalizeSpellLanguage,
+  parseExternalFileEntries,
+  parseHiddenFalsePositiveEntry,
+  releaseVersionFromTag,
+  resolveExecutableFromConfiguredPath,
+  resolveLtexExecutable,
+  resolveLtexServer,
+  selectedLineRange,
+  selectReleaseAsset,
+  serverEnvironment,
+  async mergedSetting(settings, uri, settingName) {
+    const internal = settings;
+    return internal.mergedSetting(uri, settingName);
+  }
+};
+
+// src/index.ts
+async function activate(context) {
+  if (!(0, import_fs4.existsSync)(context.storagePath)) {
+    (0, import_fs4.mkdirSync)(context.storagePath, { recursive: true });
+  }
+  const extension = new LtexPlusExtension(context);
+  extension.register();
+  await extension.activate();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  __testHooks,
+  activate
+});