stan-language-server 0.1.0 → 0.2.0

package/dist/server/index.js

@@ -0,0 +1,865 @@
+// src/server/index.ts
+import { TextDocument } from "vscode-languageserver-textdocument";
+import {
+  DiagnosticRefreshRequest,
+  DidChangeConfigurationNotification,
+  DocumentDiagnosticRequest,
+  TextDocumentSyncKind,
+  TextDocuments as TextDocuments3
+} from "vscode-languageserver/node";
+
+// src/handlers/completion.ts
+import {
+  CompletionItemKind
+} from "vscode-languageserver";
+
+// src/language/completion/util.ts
+import TrieSearch from "trie-search";
+var getSearchableItems = (xs, options = {}) => {
+  const searchableItem = new TrieSearch("name", options);
+  searchableItem.addAll(xs);
+  return searchableItem;
+};
+var getTextUpToCursor = (text, position) => {
+  const lines = text.split(`
+`);
+  const currentLine = lines[position.line] || "";
+  return currentLine.substring(0, position.character);
+};
+
+// src/language/completion/providers/keywords.ts
+var ALL_KEYWORDS = [
+  "for",
+  "in",
+  "while",
+  "repeat",
+  "until",
+  "if",
+  "then",
+  "else",
+  "break",
+  "continue",
+  "return",
+  "true",
+  "false",
+  "target",
+  "functions",
+  "data",
+  "transformed",
+  "parameters",
+  "model",
+  "generated",
+  "quantities",
+  "print",
+  "reject",
+  "fatal_error",
+  "profile",
+  "get_lp",
+  "struct",
+  "typedef",
+  "export",
+  "auto",
+  "extern",
+  "var",
+  "static",
+  "array",
+  "lower",
+  "upper",
+  "offset",
+  "multiplier",
+  "tuple",
+  "truncate",
+  "jacobian"
+];
+var getKeywords = () => {
+  return ALL_KEYWORDS.map((keyword) => ({
+    name: keyword
+  }));
+};
+var provideKeywordCompletions = (text, position) => {
+  const textUpToCursor = getTextUpToCursor(text, position);
+  const keywords = getKeywords();
+  const searchableKeywords = getSearchableItems(keywords, {
+    splitOnRegEx: /[\s_]/g,
+    min: 0
+  });
+  const match = textUpToCursor.match(/(?:^|\s)([\w_]+)$/);
+  if (match) {
+    const keywordName = match[1] || "";
+    const completionProposals = searchableKeywords.search(keywordName);
+    return completionProposals;
+  }
+  return [];
+};
+
+// src/language/completion/providers/distributions.ts
+var provideDistributionCompletions = (text, position, distributions) => {
+  const textUpToCursor = getTextUpToCursor(text, position);
+  const distributionItems = distributions.filter((name) => name !== "").map((name) => ({ name }));
+  const searchableDistributions = getSearchableItems(distributionItems, {
+    splitOnRegEx: /[\s_]/g,
+    min: 0
+  });
+  const match = textUpToCursor.match(/.*~\s*([\w_]*)$/);
+  if (match) {
+    const distName = match[1] || "";
+    let completionProposals;
+    if (distName === "") {
+      completionProposals = distributionItems;
+    } else {
+      completionProposals = searchableDistributions.search(distName);
+    }
+    return completionProposals;
+  }
+  return [];
+};
+
+// src/language/completion/providers/datatypes.ts
+var DATATYPES = [
+  "void",
+  "int",
+  "real",
+  "complex",
+  "vector",
+  "row_vector",
+  "matrix",
+  "complex_vector",
+  "complex_row_vector",
+  "complex_matrix",
+  "ordered",
+  "positive_ordered",
+  "simplex",
+  "unit_vector",
+  "sum_to_zero_vector",
+  "cholesky_factor_corr",
+  "cholesky_factor_cov",
+  "corr_matrix",
+  "cov_matrix",
+  "stochastic_column_matrix",
+  "stochastic_row_matrix"
+];
+var getDatatypes = () => {
+  return DATATYPES.map((datatype) => ({
+    name: datatype
+  }));
+};
+var provideDatatypeCompletions = (text, position) => {
+  const textUpToCursor = getTextUpToCursor(text, position);
+  const datatypes = getDatatypes();
+  const searchableDatatypes = getSearchableItems(datatypes, {
+    splitOnRegEx: /[\s_]/g,
+    min: 0
+  });
+  const match = textUpToCursor.match(/(?:^|\s)([\w_]+)$/);
+  if (match) {
+    const typeName = match[1] || "";
+    const completionProposals = searchableDatatypes.search(typeName);
+    return completionProposals;
+  }
+  return [];
+};
+
+// src/handlers/hover.ts
+import { dump_stan_math_signatures } from "stanc3";
+
+// src/language/hover/util.ts
+var isWordChar = (char) => {
+  const code = char.charCodeAt(0);
+  return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 95;
+};
+var isWhitespace = (char) => {
+  return char === " " || char === "\t" || char === `
+` || char === "\r";
+};
+var previousWordBoundary = (text, pos) => {
+  for (let i = pos - 1;i >= 0; i--) {
+    const char = text[i];
+    if (!isWordChar(char)) {
+      return i + 1;
+    }
+  }
+  return 0;
+};
+var wordUntilNextParenthesis = (text, pos) => {
+  let seenSpace = false;
+  for (let i = pos;i < text.length; i++) {
+    const char = text[i];
+    if (char === "(") {
+      return i;
+    }
+    if (isWordChar(char)) {
+      if (seenSpace) {
+        return -1;
+      }
+    } else if (isWhitespace(char)) {
+      seenSpace = true;
+    } else {
+      return -1;
+    }
+  }
+  return -1;
+};
+
+// src/language/hover/distributions.ts
+import { dump_stan_math_distributions } from "stanc3";
+var setupDistributionMap = () => {
+  const distributionToFunctionMap = new Map;
+  const mathDistributions = dump_stan_math_distributions();
+  const distLines = mathDistributions.split(`
+`);
+  for (const line of distLines) {
+    const [name, extensions] = line.split(":", 2);
+    if (!name || !extensions) {
+      continue;
+    }
+    const extension = extensions.split(",", 1)[0]?.trim();
+    distributionToFunctionMap.set(name, `${name}_${extension}`);
+  }
+  return distributionToFunctionMap;
+};
+var tildeBefore = (text, pos) => {
+  for (let i = pos - 1;i >= 0; i--) {
+    const char = text[i];
+    if (char === "~") {
+      return true;
+    } else if (isWhitespace(char)) {
+      continue;
+    } else {
+      return false;
+    }
+  }
+  return false;
+};
+var tryDistributionHover = (text, beginningOfWord, endOfWord) => {
+  if (!tildeBefore(text, beginningOfWord))
+    return null;
+  const distributionToFunctionMap = setupDistributionMap();
+  const dist = text.substring(beginningOfWord, endOfWord).trim();
+  const functionName = distributionToFunctionMap.get(dist);
+  if (!functionName)
+    return null;
+  return functionName;
+};
+
+// src/language/hover/functions.ts
+var tryFunctionHover = (text, beginningOfWord, endOfWord) => {
+  const funcName = text.substring(beginningOfWord, endOfWord).trim();
+  if (!funcName)
+    return null;
+  return funcName;
+};
+
+// src/language/hover/provider.ts
+function provideHover(text, beginningOfWord, endOfWord) {
+  const distributionHover = tryDistributionHover(text, beginningOfWord, endOfWord);
+  if (distributionHover) {
+    return distributionHover;
+  }
+  const functionHover = tryFunctionHover(text, beginningOfWord, endOfWord);
+  if (functionHover) {
+    return functionHover;
+  }
+  return null;
+}
+// src/handlers/hover.ts
+var getDocumentationForFunction = (name) => {
+  return {
+    kind: "markdown",
+    value: `[Jump to Stan Functions Reference index entry for ${name}](https://mc-stan.org/docs/functions-reference/functions_index.html#${name})`
+  };
+};
+var appendCodeblock = (content, code) => {
+  if (!content) {
+    return;
+  }
+  content.value += "\n```stan\n";
+  content.value += code;
+  content.value += "\n```";
+};
+var manual_functions = [
+  "print",
+  "reject",
+  "fatal_error",
+  "target",
+  "dae",
+  "dae_tol",
+  "ode_adams",
+  "ode_adams_tol",
+  "ode_adjoint_tol_ctl",
+  "ode_bdf",
+  "ode_bdf_tol",
+  "ode_ckrk",
+  "ode_ckrk_tol",
+  "ode_rk45",
+  "ode_rk45_tol",
+  "solve_newton",
+  "solve_newton_tol",
+  "solve_powell",
+  "solve_powell_tol",
+  "reduce_sum",
+  "reduce_sum_static"
+];
+var initializeFunctionMarkupMap = () => {
+  const markupLookupMap = new Map;
+  const mathSignatures = dump_stan_math_signatures();
+  const lines = mathSignatures.split(`
+`);
+  for (const line of lines) {
+    const [name] = line.split("(", 1);
+    if (!name) {
+      continue;
+    }
+    if (markupLookupMap.has(name)) {
+      appendCodeblock(markupLookupMap.get(name), line);
+    } else {
+      const doc = getDocumentationForFunction(name);
+      doc.value += `
+
+**Available signatures**:`;
+      appendCodeblock(doc, line);
+      markupLookupMap.set(name, doc);
+    }
+  }
+  for (const func of manual_functions) {
+    markupLookupMap.set(func, getDocumentationForFunction(func));
+  }
+  return markupLookupMap;
+};
+function markupContentToHover(content, document, beginningOfWord, endOfWord) {
+  return {
+    contents: content,
+    range: {
+      start: document.positionAt(beginningOfWord),
+      end: document.positionAt(endOfWord)
+    }
+  };
+}
+var handleHover = (getMarkupLookupFn) => async (document, params) => {
+  const functionMarkupLookup = getMarkupLookupFn();
+  const currentLine = document.getText({
+    start: { line: params.position.line, character: 0 },
+    end: { line: params.position.line + 1, character: 0 }
+  }).trim();
+  if (!currentLine || !currentLine.includes("(")) {
+    return null;
+  }
+  const text = document.getText();
+  const offset = document.offsetAt(params.position);
+  if (!isWordChar(text[offset])) {
+    return null;
+  }
+  const nextParen = wordUntilNextParenthesis(text, offset);
+  if (nextParen === -1) {
+    return null;
+  }
+  const beginningOfWord = previousWordBoundary(text, offset);
+  const hoverName = provideHover(text, beginningOfWord, nextParen);
+  if (hoverName) {
+    const hoverContent = functionMarkupLookup.get(hoverName);
+    if (hoverContent !== undefined) {
+      return markupContentToHover(hoverContent, document, beginningOfWord, nextParen);
+    }
+  }
+  return null;
+};
+var hover_default = handleHover(initializeFunctionMarkupMap);
+
+// src/language/completion/providers/functions.ts
+var provideFunctionCompletions = (text, position, functionSignatures) => {
+  const textUpToCursor = getTextUpToCursor(text, position);
+  const functionNames = functionSignatures.map((line) => line.split("(", 1)[0]?.trim() ?? "").filter((name) => name !== "");
+  const allFunctionNames = [...new Set([...functionNames, ...manual_functions])];
+  const functionItems = allFunctionNames.map((name) => ({ name }));
+  const searchableFunctions = getSearchableItems(functionItems, {
+    splitOnRegEx: /[\s_]/g,
+    min: 0
+  });
+  const match = textUpToCursor.match(/(?:^|\s)([\w_]+)$/);
+  if (match) {
+    const functionName = match[1] || "";
+    const completionProposals = searchableFunctions.search(functionName);
+    return completionProposals;
+  }
+  return [];
+};
+
+// src/language/completion/providers/constraints.ts
+var CONSTRAINTS = [
+  "lower",
+  "upper",
+  "offset",
+  "multiplier",
+  "ordered",
+  "positive_ordered",
+  "simplex",
+  "unit_vector",
+  "sum_to_zero_vector",
+  "cholesky_factor_corr",
+  "cholesky_factor_cov",
+  "corr_matrix",
+  "cov_matrix",
+  "stochastic_column_matrix",
+  "stochastic_row_matrix"
+];
+var getConstraints = () => {
+  return CONSTRAINTS.map((constraint) => ({
+    name: constraint
+  }));
+};
+var provideConstraintCompletions = (text, position) => {
+  const textUpToCursor = getTextUpToCursor(text, position);
+  const constraints = getConstraints();
+  const searchableConstraints = getSearchableItems(constraints, {
+    splitOnRegEx: /[\s_]/g,
+    min: 0
+  });
+  const match = textUpToCursor.match(/(?:^|\s)([\w_]+)$/);
+  if (match) {
+    const constraintName = match[1] || "";
+    const completionProposals = searchableConstraints.search(constraintName);
+    return completionProposals;
+  }
+  return [];
+};
+
+// src/handlers/completion.ts
+import {
+  dump_stan_math_distributions as dump_stan_math_distributions2,
+  dump_stan_math_signatures as dump_stan_math_signatures2
+} from "stanc3";
+function keywordToCompletionItem(keyword) {
+  return {
+    label: keyword.name,
+    kind: CompletionItemKind.Keyword
+  };
+}
+function distributionToCompletionItem(distribution) {
+  return {
+    label: distribution.name,
+    kind: CompletionItemKind.Function
+  };
+}
+function datatypeToCompletionItem(datatype) {
+  return {
+    label: datatype.name,
+    kind: CompletionItemKind.Class
+  };
+}
+function functionToCompletionItem(func) {
+  return {
+    label: func.name,
+    kind: CompletionItemKind.Function
+  };
+}
+function constraintToCompletionItem(constraint) {
+  return {
+    label: constraint.name,
+    kind: CompletionItemKind.Property
+  };
+}
+function convertPosition(position) {
+  return {
+    line: position.line,
+    character: position.character
+  };
+}
+function getDistributionData() {
+  return dump_stan_math_distributions2().split(`
+`).map((line) => line.split(":")[0]?.trim() ?? "").filter((name) => name !== "");
+}
+function getFunctionData() {
+  return dump_stan_math_signatures2().split(`
+`);
+}
+function handleCompletion(params, documents) {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) {
+    return [];
+  }
+  const text = document.getText();
+  const position = convertPosition(params.position);
+  const keywords = provideKeywordCompletions(text, position);
+  const distributions = provideDistributionCompletions(text, position, getDistributionData());
+  const datatypes = provideDatatypeCompletions(text, position);
+  const functions = provideFunctionCompletions(text, position, getFunctionData());
+  const constraints = provideConstraintCompletions(text, position);
+  const allItems = [
+    ...keywords.map(keywordToCompletionItem),
+    ...distributions.map(distributionToCompletionItem),
+    ...datatypes.map(datatypeToCompletionItem),
+    ...functions.map(functionToCompletionItem),
+    ...constraints.map(constraintToCompletionItem)
+  ];
+  return allItems;
+}
+// src/handlers/diagnostics.ts
+import {
+  DiagnosticSeverity as DiagnosticSeverity2
+} from "vscode-languageserver";
+
+// src/language/diagnostics/linter.ts
+function rangeFromMessage(message) {
+  if (!message)
+    return;
+  const start = message.matchAll(/'.*', line (\d+), column (\d+)( to)?/g);
+  const lastMatch = Array.from(start).pop();
+  if (!lastMatch || !lastMatch[1] || !lastMatch[2]) {
+    return;
+  }
+  const startLine = parseInt(lastMatch[1]) - 1;
+  const startColumn = parseInt(lastMatch[2]);
+  let endLine = startLine;
+  let endColumn = startColumn;
+  if (lastMatch[3]) {
+    const end = message.match(/to (line (\d+), )?column (\d+)/);
+    if (end && end[3]) {
+      if (end[1] && end[2]) {
+        endLine = parseInt(end[2]) - 1;
+      }
+      endColumn = parseInt(end[3]);
+    }
+  }
+  return {
+    start: { line: startLine, character: startColumn },
+    end: { line: endLine, character: endColumn }
+  };
+}
+function getWarningMessage(message) {
+  let warning = message.replace(/Warning.*column \d+: /s, "");
+  warning = warning.replace(/\s+/gs, " ");
+  warning = warning.trim();
+  warning = message.includes("included from") ? `Warning in included file:
+` + warning : warning;
+  return warning;
+}
+function getErrorMessage(message) {
+  let error = message;
+  if (message.includes(`------
+`)) {
+    error = error.split(`------
+`)[2] ?? error;
+  }
+  error = error.trim();
+  error = message.includes("included from") ? `Error in included file:
+` + error : error;
+  error = error.includes("given information about") ? error + `
+Try opening the included file and making the Stan language server aware of it.` : error;
+  return error;
+}
+
+// src/constants/index.ts
+var SERVER_ID = "stan-language-server";
+
+// src/language/diagnostics/provider.ts
+function provideDiagnostics(compilerResult) {
+  const diagnostics = [];
+  if (compilerResult.errors) {
+    for (const error of compilerResult.errors) {
+      const range = rangeFromMessage(error);
+      if (range) {
+        diagnostics.push({
+          range,
+          severity: 1 /* Error */,
+          message: getErrorMessage(error),
+          source: SERVER_ID
+        });
+      }
+    }
+  }
+  if (compilerResult.warnings) {
+    for (const warning of compilerResult.warnings) {
+      const range = rangeFromMessage(warning);
+      if (range) {
+        diagnostics.push({
+          range,
+          severity: 2 /* Warning */,
+          message: getWarningMessage(warning),
+          source: SERVER_ID
+        });
+      }
+    }
+  }
+  return diagnostics;
+}
+// src/handlers/compilation/includes.ts
+import { join } from "path";
+import { URI, Utils } from "vscode-uri";
+function getFilenames(fileContent) {
+  const includePattern = /#include\s*[<"]?([^>"\s]*)[>"]?/g;
+  const matches = Array.from(fileContent.matchAll(includePattern));
+  const results = matches.map((match) => match[1] || "");
+  return results;
+}
+function isFilePathError(value) {
+  return typeof value === "object" && value !== null && "msg" in value;
+}
+async function handleIncludes(document, documentManager, workspaceFolders, includePaths, logger, reader) {
+  try {
+    const includeFilenames = getFilenames(document.getText());
+    if (includeFilenames.length === 0) {
+      return {};
+    }
+    const allResults = await Promise.all(includeFilenames.map(async (filename) => {
+      try {
+        const content = await readIncludedFile(document, documentManager, workspaceFolders, includePaths, filename, reader);
+        return [filename, content];
+      } catch (err) {
+        return [filename, { msg: `${err.message}` }];
+      }
+    }));
+    const validResults = allResults.filter(([_, content]) => !isFilePathError(content));
+    return Object.fromEntries(validResults);
+  } catch (error) {
+    logger.warn(`Resolving included files failed: ${error}`);
+    return Promise.resolve({});
+  }
+}
+var readIncludedFile = async (document, documentManager, workspaceFolders, includePaths, filename, reader) => {
+  const currentDir = Utils.dirname(URI.parse(document.uri));
+  let includedFileContent = await readIncludedFileFromWorkspace(documentManager, workspaceFolders, filename, currentDir);
+  if (!isFilePathError(includedFileContent)) {
+    return Promise.resolve(includedFileContent);
+  }
+  if (reader) {
+    includedFileContent = await readIncludedFileFromFileSystem(filename, [
+      currentDir.fsPath,
+      ...includePaths
+    ], reader);
+  }
+  if (!isFilePathError(includedFileContent)) {
+    return Promise.resolve(includedFileContent);
+  }
+  return Promise.resolve({ msg: `File not found: ${filename}` });
+};
+var readIncludedFileFromWorkspace = (documentManager, workspaceFolders, filename, currentDir) => {
+  const searchFolders = [
+    { uri: currentDir.toString(), name: "stan file directory" },
+    ...workspaceFolders
+  ];
+  const paths = searchFolders.map((folder) => folder.uri + "/" + filename);
+  const documents = paths.map((path) => {
+    const doc = documentManager.get(path);
+    return { path, doc };
+  });
+  const includedFile = documents.filter(({ doc }) => doc !== undefined).map(({ doc }) => doc)[0];
+  if (!includedFile) {
+    return Promise.resolve({ msg: `File not found: ${filename}` });
+  }
+  return Promise.resolve(includedFile.getText());
+};
+var readIncludedFileFromFileSystem = async (filename, dirs, fileSystemReader) => {
+  for (const currentDir of dirs) {
+    try {
+      const localPath = join(currentDir, filename);
+      return await fileSystemReader(localPath);
+    } catch (error) {}
+  }
+  return Promise.resolve({ msg: `File not found: ${filename}` });
+};
+
+// src/handlers/compilation/compilation.ts
+import { URI as URI2 } from "vscode-uri";
+import { stanc } from "stanc3";
+var defaultSettings = {
+  maxLineLength: 78,
+  includePaths: []
+};
+async function handleCompilation(document, documentManager, workspaceFolders, settings, logger, reader) {
+  const filename = URI2.parse(document.uri).fsPath;
+  const code = document.getText();
+  const includes = await handleIncludes(document, documentManager, workspaceFolders, settings.includePaths, logger, reader);
+  const stanc_args = [
+    "auto-format",
+    `filename-in-msg=${filename}`,
+    `max-line-length=${settings.maxLineLength}`,
+    "canonicalze=deprecations",
+    "allow-undefined"
+  ];
+  if (filename.endsWith(".stanfunctions")) {
+    stanc_args.push("functions-only");
+  }
+  return Promise.resolve(stanc(filename, code, stanc_args, includes));
+}
+
+// src/handlers/diagnostics.ts
+function stanDiagnosticToLspDiagnostic(stanDiag) {
+  return {
+    range: domainRangeToLspRange(stanDiag.range),
+    severity: domainSeverityToLspSeverity(stanDiag.severity),
+    message: stanDiag.message,
+    source: stanDiag.source ?? SERVER_ID
+  };
+}
+function domainRangeToLspRange(domainRange) {
+  return {
+    start: {
+      line: domainRange.start.line,
+      character: domainRange.start.character
+    },
+    end: {
+      line: domainRange.end.line,
+      character: domainRange.end.character
+    }
+  };
+}
+function domainSeverityToLspSeverity(domainSeverity) {
+  switch (domainSeverity) {
+    case 1:
+      return DiagnosticSeverity2.Error;
+    case 2:
+      return DiagnosticSeverity2.Warning;
+    case 3:
+      return DiagnosticSeverity2.Information;
+    case 4:
+      return DiagnosticSeverity2.Hint;
+    default:
+      return DiagnosticSeverity2.Error;
+  }
+}
+async function handleDiagnostics(params, documents, workspaceFolders, settings, logger, reader) {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) {
+    return [];
+  }
+  const compilerResult = await handleCompilation(document, documents, workspaceFolders, settings, logger, reader);
+  const stanDiagnostics = provideDiagnostics(compilerResult);
+  return stanDiagnostics.map(stanDiagnosticToLspDiagnostic);
+}
+// src/handlers/formatting.ts
+async function handleFormatting(params, documents, workspaceFolders, settings, logger, reader) {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) {
+    return [];
+  }
+  const result = await handleCompilation(document, documents, workspaceFolders, settings, logger, reader);
+  if (result.errors && result.errors.length > 0) {
+    return { errors: result.errors };
+  } else if (result.result) {
+    const range = {
+      start: { line: 0, character: 0 },
+      end: {
+        line: document.lineCount - 1,
+        character: document.getText().length
+      }
+    };
+    return [
+      {
+        range,
+        newText: result.result
+      }
+    ];
+  }
+  return [];
+}
+// src/server/index.ts
+var startLanguageServer = (connection, reader) => {
+  let hasConfigurationCapability = false;
+  let hasWorkspaceFolderCapability = false;
+  connection.onInitialize((params) => {
+    connection.console.info("Initializing Stan language server...");
+    let capabilities = params.capabilities;
+    hasConfigurationCapability = !!(capabilities.workspace && !!capabilities.workspace.configuration);
+    hasWorkspaceFolderCapability = !!(capabilities.workspace && !!capabilities.workspace.workspaceFolders);
+    return {
+      capabilities: {
+        textDocumentSync: TextDocumentSyncKind.Incremental,
+        completionProvider: {
+          triggerCharacters: ["~"],
+          resolveProvider: false
+        },
+        documentFormattingProvider: true,
+        workspace: {
+          workspaceFolders: {
+            supported: hasWorkspaceFolderCapability
+          }
+        },
+        hoverProvider: true,
+        diagnosticProvider: {
+          interFileDependencies: true,
+          workspaceDiagnostics: false
+        }
+      }
+    };
+  });
+  connection.onInitialized(() => {
+    if (hasConfigurationCapability) {
+      connection.client.register(DidChangeConfigurationNotification.type);
+    }
+    connection.console.info("Stan language server is initialized!");
+  });
+  connection.onExit(() => {
+    connection.console.info("Stan language server is exiting...");
+  });
+  let globalSettings = defaultSettings;
+  let documentSettings = new Map;
+  connection.onDidChangeConfiguration((change) => {
+    if (hasConfigurationCapability) {
+      documentSettings.clear();
+    } else {
+      const incomingSettings = change.settings[SERVER_ID] || {};
+      globalSettings = { ...globalSettings, ...incomingSettings };
+    }
+    connection.sendRequest(DiagnosticRefreshRequest.type);
+  });
+  const getDocumentSettings = async (resource) => {
+    if (!hasConfigurationCapability) {
+      return Promise.resolve(globalSettings);
+    }
+    let result = documentSettings.get(resource);
+    if (result !== undefined) {
+      return result;
+    }
+    let clientSettings = await connection.workspace.getConfiguration({
+      scopeUri: resource,
+      section: SERVER_ID
+    }) || {};
+    const docSettings = { ...defaultSettings, ...clientSettings };
+    documentSettings.set(resource, docSettings);
+    return docSettings;
+  };
+  const documents = new TextDocuments3(TextDocument);
+  connection.onCompletion((params) => {
+    return handleCompletion(params, documents);
+  });
+  const getWorkspaceFolders = async () => {
+    if (hasWorkspaceFolderCapability) {
+      return await connection.workspace.getWorkspaceFolders() || [];
+    }
+    return [];
+  };
+  connection.onRequest(DocumentDiagnosticRequest.method, async (params) => {
+    const folders = await getWorkspaceFolders();
+    const settings = await getDocumentSettings(params.textDocument.uri);
+    return {
+      kind: "full",
+      items: await handleDiagnostics(params, documents, folders, settings, connection.console, reader)
+    };
+  });
+  connection.onDocumentFormatting(async (params) => {
+    const folders = await getWorkspaceFolders();
+    const settings = await getDocumentSettings(params.textDocument.uri);
+    const formattingResult = await handleFormatting(params, documents, folders, settings, connection.console, reader);
+    if (Array.isArray(formattingResult)) {
+      return formattingResult;
+    } else {
+      connection.console.error("Formatting errors:");
+      for (const error of formattingResult.errors) {
+        connection.console.error(error);
+      }
+      return [];
+    }
+  });
+  connection.onHover((params) => {
+    const document = documents.get(params.textDocument.uri);
+    if (!document) {
+      return null;
+    }
+    return hover_default(document, params);
+  });
+  documents.listen(connection);
+  connection.listen();
+};
+var server_default = startLanguageServer;
+export {
+  server_default as default
+};