@marko/language-server 0.11.0 → 0.12.2

package/dist/index.mjs

@@ -0,0 +1,822 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/index.ts
+import {
+  createConnection,
+  ProposedFeatures,
+  Range as Range4,
+  Position as Position3,
+  CompletionList as CompletionList6,
+  Diagnostic,
+  DiagnosticSeverity,
+  TextDocuments,
+  TextEdit as TextEdit5,
+  TextDocumentSyncKind
+} from "vscode-languageserver/node";
+import { URI as URI6 } from "vscode-uri";
+import { TextDocument as TextDocument3 } from "vscode-languageserver-textdocument";
+import * as prettier from "prettier";
+import * as markoPrettier from "prettier-plugin-marko";
+import { inspect, isDeepStrictEqual } from "util";
+
+// src/utils/compiler.ts
+import path from "path";
+import { URI } from "vscode-uri";
+import resolveFrom from "resolve-from";
+import lassoPackageRoot from "lasso-package-root";
+import * as builtinCompiler from "@marko/compiler";
+import * as builtinTranslator from "@marko/translator-default";
+builtinCompiler.configure({ translator: builtinTranslator });
+var compilerAndTranslatorForDoc = /* @__PURE__ */ new WeakMap();
+function getCompilerAndTranslatorForDoc(doc) {
+  let compilerAndTranslator = compilerAndTranslatorForDoc.get(doc);
+  if (!compilerAndTranslator) {
+    compilerAndTranslatorForDoc.set(doc, compilerAndTranslator = loadCompiler(path.dirname(URI.parse(doc.uri).fsPath)));
+  }
+  return compilerAndTranslator;
+}
+function getTagLibLookup(document) {
+  try {
+    const { compiler, translator } = getCompilerAndTranslatorForDoc(document);
+    return compiler.taglib.buildLookup(URI.parse(document.uri).fsPath, translator);
+  } catch {
+  }
+}
+function loadCompiler(dir) {
+  const rootDir = lassoPackageRoot.getRootDir(dir);
+  const pkgPath = rootDir && resolveFrom.silent(rootDir, "@marko/compiler/package.json");
+  const pkg = pkgPath && __require(pkgPath);
+  if (pkg && /^5\./.test(pkg.version)) {
+    try {
+      let translator = [].concat(Object.keys(pkg.dependencies), Object.keys(pkg.peerDependencies), Object.keys(pkg.devDependencies)).find((name) => /^marko$|^(@\/marko\/|marko-)translator-/.test(name));
+      if (translator === "marko" || !translator) {
+        translator = __require(resolveFrom(dir, "@marko/compiler/config")).translator;
+      }
+      __require(resolveFrom(dir, translator));
+      return {
+        compiler: __require(resolveFrom(dir, "@marko/compiler")),
+        translator
+      };
+    } catch {
+    }
+  }
+  return {
+    compiler: builtinCompiler,
+    translator: builtinTranslator
+  };
+}
+
+// src/utils/htmljs-parser.ts
+import { createParser } from "htmljs-parser";
+var SUPPORTED_STYLE_LANGS = {
+  css: true,
+  scss: true,
+  less: true
+};
+function parseUntilOffset(options) {
+  const { offset, text, taglib, includeErrors } = options;
+  let result = null;
+  let parentTag = null;
+  const parser = createParser({
+    onError: includeErrors && finish,
+    onScriptlet: finish,
+    onPlaceholder: finish,
+    onOpenTagName(ev) {
+      if (parentTag) {
+        ev.parent = parentTag;
+      }
+      if (!ev.concise) {
+        ev.pos += 1;
+      }
+      ev.endPos = ev.pos + ev.tagName.length;
+      parentTag = ev;
+      finish(ev);
+    },
+    onOpenTag(ev) {
+      ev.parent = parentTag.parent;
+      parentTag = ev;
+      if (ev.tagName === "style") {
+        const firstAttr = ev.attributes[0];
+        const isBlock = firstAttr && firstAttr.name.startsWith("{");
+        if (isBlock) {
+          const content = firstAttr.name.slice(1, -1);
+          const pos = text.indexOf(content, ev.tagNameEndPos);
+          const endPos = pos + content.length;
+          const requestedLanguage = ev.shorthandClassNames && ev.shorthandClassNames[0].rawParts[0] && ev.shorthandClassNames[0].rawParts[0].text;
+          const language = requestedLanguage && SUPPORTED_STYLE_LANGS[requestedLanguage] ? requestedLanguage : "css";
+          finish({
+            type: "styleContent",
+            language,
+            block: true,
+            content: text.slice(pos, endPos),
+            pos,
+            endPos
+          });
+          return;
+        }
+      }
+      let attrEndPos = ev.tagNameEndPos;
+      for (const attr of ev.attributes) {
+        if (!attr.name) {
+          if (attr.value !== void 0) {
+            attrEndPos += attr.value.length;
+          }
+          continue;
+        }
+        if (attr.name.slice(0, 3) === "...") {
+          attrEndPos = attr.argument ? attr.argument.endPos + 1 : attr.endPos;
+          continue;
+        }
+        const attrStartPos = text.indexOf(attr.name, attrEndPos);
+        const match = /:(.*)$/.exec(attr.name);
+        const modifier = match && match[1];
+        let name = attr.name;
+        if (modifier) {
+          name = name.slice(0, name.length - modifier.length - 1);
+          const modifierStartPos = attrStartPos + name.length;
+          const modifierEndPos = modifierStartPos + modifier.length + 1;
+          if (finish({
+            type: "attributeModifier",
+            tag: ev,
+            name,
+            modifier,
+            pos: modifierStartPos,
+            endPos: modifierEndPos
+          })) {
+            return;
+          }
+        }
+        const attrNameEndPos = attrStartPos + name.length;
+        if (finish({
+          type: "attributeName",
+          tag: ev,
+          name,
+          pos: attrStartPos,
+          endPos: attrNameEndPos
+        })) {
+          return;
+        }
+        if (attr.value) {
+          attrEndPos = attr.endPos;
+          const valueStartPos = attr.pos + 1;
+          if (finish({
+            type: "attributeValue",
+            tag: ev,
+            name,
+            value: text.slice(valueStartPos, attrEndPos),
+            pos: valueStartPos,
+            endPos: attr.endPos
+          })) {
+            break;
+          }
+        } else {
+          attrEndPos = attr.argument ? attr.argument.endPos + 1 : attr.endPos;
+        }
+      }
+      finish(ev);
+    },
+    onText(ev) {
+      ev.endPos = parser.pos;
+      ev.pos = ev.endPos - ev.value.length;
+      if (parentTag) {
+        ev.parent = parentTag;
+        if (parentTag.tagName === "style") {
+          finish({
+            type: "styleContent",
+            language: "css",
+            block: false,
+            content: ev.value,
+            pos: ev.pos,
+            endPos: ev.endPos
+          });
+          return;
+        }
+      }
+      finish(ev);
+    },
+    onCloseTag(ev) {
+      parentTag = parentTag && parentTag.parent;
+      finish(ev);
+    }
+  }, {
+    isOpenTagOnly(ev) {
+      const tagDef = taglib.getTag(ev);
+      return tagDef && tagDef.openTagOnly;
+    }
+  });
+  try {
+    parser.parse(`${text}
+`);
+  } catch (err) {
+    return includeErrors ? {
+      type: "error",
+      code: "UNEXPECTED_TOKEN",
+      message: err.message,
+      pos: parser.pos,
+      endPos: parser.pos
+    } : null;
+  }
+  return result;
+  function finish(event) {
+    const { type, pos, endPos } = event;
+    if (!result && (type === "error" || pos != null && pos <= offset && endPos != null && endPos >= offset)) {
+      result = event;
+      parser.end();
+      return true;
+    }
+    return false;
+  }
+}
+
+// src/utils/completions/index.ts
+var completions_exports = {};
+__export(completions_exports, {
+  attributeModifier: () => attributeModifier,
+  attributeName: () => attributeName,
+  closeTag: () => closeTag,
+  openTag: () => openTag,
+  openTagName: () => openTagName,
+  styleContent: () => styleContent
+});
+
+// src/utils/completions/types/attributeModifier.ts
+import {
+  CompletionList,
+  CompletionItemKind
+} from "vscode-languageserver";
+function attributeModifier(_taglib, _document, _params, _event) {
+  return CompletionList.create([
+    {
+      label: "scoped",
+      kind: CompletionItemKind.Keyword,
+      detail: "Use to prefix with a unique ID"
+    },
+    {
+      label: "no-update",
+      kind: CompletionItemKind.Keyword,
+      detail: "Use to skip future updates to this attribute"
+    }
+  ], true);
+}
+
+// src/utils/completions/types/attributeName.ts
+import {
+  CompletionList as CompletionList2,
+  CompletionItemKind as CompletionItemKind2,
+  MarkupKind,
+  InsertTextFormat,
+  TextEdit as TextEdit2
+} from "vscode-languageserver";
+
+// src/utils/utils.ts
+import fs from "fs";
+import { URI as URI2 } from "vscode-uri";
+import {
+  TextEdit,
+  Position,
+  Range
+} from "vscode-languageserver";
+import { TextDocument } from "vscode-languageserver-textdocument";
+var START_OF_FILE = Range.create(Position.create(0, 0), Position.create(0, 0));
+function findNonControlFlowParent(tag) {
+  let parent = tag.parent;
+  while (parent) {
+    if (!/^(?:else-)?if|else|for|while$/.test(parent.tagName)) {
+      return parent;
+    }
+    parent = parent.parent;
+  }
+  return null;
+}
+function rangeFromEvent(document, event) {
+  return Range.create(document.positionAt(event.pos), document.positionAt(event.endPos));
+}
+function createTextDocument(filename) {
+  const uri = URI2.file(filename).toString();
+  const content = fs.readFileSync(filename, "utf-8");
+  return TextDocument.create(uri, "plaintext", 0, content);
+}
+function shiftCompletionRanges(list, offset) {
+  list.items.forEach((item) => {
+    if (item.additionalTextEdits) {
+      item.additionalTextEdits.forEach((edit) => shiftRange(edit.range, offset));
+    }
+    if (item.textEdit) {
+      shiftEdit(item.textEdit, offset);
+    }
+  });
+  return list;
+}
+function shiftEdit(edit, offset) {
+  if (TextEdit.is(edit)) {
+    shiftRange(edit.range, offset);
+  } else {
+    shiftRange(edit.insert, offset);
+    shiftRange(edit.replace, offset);
+  }
+}
+function shiftRange(range, offset) {
+  if (range) {
+    shiftPosition(range.start, offset);
+    shiftPosition(range.end, offset);
+  }
+}
+function shiftPosition(pos, offset) {
+  if (pos.line === 0) {
+    pos.character += offset.character;
+  }
+  pos.line += offset.line;
+  return pos;
+}
+
+// src/utils/completions/types/attributeName.ts
+function attributeName(taglib, document, _params, event) {
+  const completions = [];
+  const attrNameRange = rangeFromEvent(document, event);
+  const tagDef = !event.tag.tagNameExpression && taglib.getTag(event.tag.tagName);
+  const tagName = tagDef && tagDef.name || "*";
+  const nestedTagAttrs = {};
+  const neverAttrs = /* @__PURE__ */ new Set();
+  if (tagDef && tagDef.nestedTags) {
+    for (const key in tagDef.nestedTags) {
+      const nestedTagDef = tagDef.nestedTags[key];
+      nestedTagAttrs[nestedTagDef.targetProperty] = true;
+    }
+  }
+  taglib.forEachAttribute(tagName, (attr) => {
+    if (attr.type === "never") {
+      neverAttrs.add(attr.name);
+    }
+  });
+  taglib.forEachAttribute(tagName, (attr, parent) => {
+    if (attr.deprecated || nestedTagAttrs[attr.name] || attr.name === "*" || neverAttrs.has(attr.name) || attr.name[0] === "_" && /\/node_modules\//.test(attr.filePath || parent.filePath)) {
+      return;
+    }
+    const type = attr.type || (attr.html ? "string" : null);
+    const documentation = {
+      kind: MarkupKind.Markdown,
+      value: attr.description || ""
+    };
+    let label = attr.name;
+    let snippet = attr.name;
+    if (attr.enum) {
+      snippet += `="\${1|${attr.enum.join()}|}"$0`;
+    } else {
+      switch (type) {
+        case "string":
+          snippet += '="$1"$0';
+          break;
+        case "function":
+          snippet += "=($1)$0";
+          break;
+        case "statement":
+        case "boolean":
+        case "flag":
+          break;
+        default:
+          snippet += "=";
+          break;
+      }
+    }
+    const autocomplete = attr.autocomplete && Array.isArray(attr.autocomplete) ? attr.autocomplete[0] : attr.autocomplete;
+    if (autocomplete) {
+      label = autocomplete.displayText || label;
+      snippet = autocomplete.snippet || snippet;
+      if (autocomplete.descriptionMoreURL) {
+        if (documentation.value) {
+          documentation.value += `
+
+`;
+        }
+        documentation.value += `[More Info](${autocomplete.descriptionMoreURL})`;
+      }
+    }
+    completions.push({
+      label,
+      documentation: documentation.value ? documentation : void 0,
+      kind: CompletionItemKind2.Property,
+      insertTextFormat: InsertTextFormat.Snippet,
+      textEdit: TextEdit2.replace(attrNameRange, snippet)
+    });
+  });
+  return CompletionList2.create(completions, true);
+}
+
+// src/utils/completions/types/closeTag.ts
+import {
+  CompletionList as CompletionList3,
+  CompletionItemKind as CompletionItemKind3,
+  InsertTextFormat as InsertTextFormat2,
+  TextEdit as TextEdit3
+} from "vscode-languageserver";
+function closeTag(_taglib, document, _params, event) {
+  if (event.tagName[0] === "$") {
+    return;
+  }
+  const closingTagStr = `</${event.tagName}>`;
+  return CompletionList3.create([
+    {
+      label: closingTagStr,
+      kind: CompletionItemKind3.Class,
+      insertTextFormat: InsertTextFormat2.Snippet,
+      textEdit: TextEdit3.replace(rangeFromEvent(document, event), closingTagStr)
+    }
+  ], true);
+}
+
+// src/utils/completions/types/openTag.ts
+import {
+  CompletionList as CompletionList4,
+  CompletionItemKind as CompletionItemKind4,
+  InsertTextFormat as InsertTextFormat3
+} from "vscode-languageserver";
+function openTag(_taglib, _document, params, event) {
+  const triggerCharacter = params.context && params.context.triggerCharacter;
+  if (triggerCharacter !== ">" || event.openTagOnly || event.selfClosed) {
+    return;
+  }
+  const closingTagStr = `</${event.tagName[0] === "$" ? "" : event.tagName}>`;
+  return CompletionList4.create([
+    {
+      label: closingTagStr,
+      kind: CompletionItemKind4.Class,
+      insertTextFormat: InsertTextFormat3.Snippet,
+      insertText: `
+	$0
+${closingTagStr}`
+    }
+  ], true);
+}
+
+// src/utils/completions/types/openTagName.ts
+import path2 from "path";
+import { URI as URI3 } from "vscode-uri";
+import {
+  CompletionItemKind as CompletionItemKind5,
+  CompletionList as CompletionList5,
+  InsertTextFormat as InsertTextFormat4,
+  MarkupKind as MarkupKind2,
+  TextEdit as TextEdit4
+} from "vscode-languageserver";
+function openTagName(taglib, document, params, event) {
+  const { fsPath: currentTemplateFilePath } = URI3.parse(document.uri);
+  let tags;
+  const triggerCharacter = params.context && params.context.triggerCharacter || event.tagName[0];
+  const isAttributeTag = triggerCharacter === "@";
+  const tagNameRange = rangeFromEvent(document, event);
+  if (isAttributeTag) {
+    const parentTag = findNonControlFlowParent(event);
+    const parentTagDef = parentTag && !parentTag.tagNameExpression && taglib.getTag(parentTag.tagName);
+    tags = parentTagDef && parentTagDef.nestedTags && Object.values(parentTagDef.nestedTags) || [];
+  } else {
+    tags = taglib.getTagsSorted().filter((it) => !it.isNestedTag);
+  }
+  return CompletionList5.create(tags.filter((it) => !it.deprecated).filter((it) => it.name !== "*").filter((it) => /^[^_]/.test(it.name) || !/\/node_modules\//.test(it.filePath)).map((it) => {
+    let label = it.isNestedTag ? `@${it.name}` : it.name;
+    const fileForTag = it.template || it.renderer || it.filePath;
+    const fileURIForTag = URI3.file(fileForTag).toString();
+    const nodeModuleMatch = /\/node_modules\/((?:@[^/]+\/)?[^/]+)/.exec(fileForTag);
+    const nodeModuleName = nodeModuleMatch && nodeModuleMatch[1];
+    const isCoreTag = nodeModuleName === "marko";
+    const documentation = {
+      kind: MarkupKind2.Markdown,
+      value: it.html ? `Built in [<${it.name}>](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/${it.name}) HTML tag.` : nodeModuleName ? isCoreTag ? `Core Marko [<${it.name}>](${fileURIForTag}) tag.` : `Custom Marko tag discovered from the ["${nodeModuleName}"](${fileURIForTag}) npm package.` : `Custom Marko tag discovered from:
+
+[${path2.relative(currentTemplateFilePath, fileForTag)}](${fileURIForTag})`
+    };
+    if (it.description) {
+      documentation.value += `
+
+${it.description}`;
+    }
+    const autocomplete = it.autocomplete && it.autocomplete[0];
+    if (autocomplete) {
+      if (autocomplete.displayText) {
+        label = autocomplete.displayText;
+      }
+      if (autocomplete.description) {
+        documentation.value += `
+
+${autocomplete.description}`;
+      }
+      if (autocomplete.descriptionMoreURL) {
+        documentation.value += `
+
+[More Info](${autocomplete.descriptionMoreURL})`;
+      }
+    }
+    return {
+      label,
+      documentation,
+      kind: CompletionItemKind5.Class,
+      insertTextFormat: InsertTextFormat4.Snippet,
+      textEdit: TextEdit4.replace(tagNameRange, autocomplete && autocomplete.snippet || label)
+    };
+  }), true);
+}
+
+// src/utils/completions/types/styleContent.ts
+import { Position as Position2 } from "vscode-languageserver";
+import { TextDocument as TextDocument2 } from "vscode-languageserver-textdocument";
+import {
+  getCSSLanguageService,
+  getSCSSLanguageService,
+  getLESSLanguageService
+} from "vscode-css-languageservice";
+var services = {
+  css: getCSSLanguageService,
+  scss: getSCSSLanguageService,
+  less: getLESSLanguageService
+};
+function styleContent(_taglib, document, params, event) {
+  const service = services[event.language]();
+  const startPos = document.positionAt(event.pos);
+  const relativePos = shiftPosition(params.position, Position2.create(startPos.line * -1, startPos.character * -1));
+  const contentDocument = TextDocument2.create(document.uri, event.language, document.version, event.content);
+  const completions = service.doComplete(contentDocument, relativePos, service.parseStylesheet(contentDocument));
+  return shiftCompletionRanges(completions, startPos);
+}
+
+// src/utils/definitions/index.ts
+var definitions_exports = {};
+__export(definitions_exports, {
+  attributeName: () => attributeName2,
+  openTagName: () => openTagName2
+});
+
+// src/utils/definitions/types/attributeName.ts
+import { URI as URI4 } from "vscode-uri";
+import {
+  Range as Range2,
+  LocationLink
+} from "vscode-languageserver";
+
+// src/utils/regexp-builder.ts
+function RegExpBuilder(strings, ...expressions) {
+  let i = 0;
+  let src = strings[0].slice(strings[0].indexOf("/") + 1);
+  const secondLastExprIndex = strings.length - 2;
+  for (; i < secondLastExprIndex; i++) {
+    src += escape(expressions[i]) + strings[i + 1];
+  }
+  src += escape(expressions[i]);
+  const lastStr = strings[i + 1];
+  const lastSlashIndex = lastStr.lastIndexOf("/");
+  let flags = "";
+  if (lastSlashIndex === -1) {
+    src += lastStr;
+  } else {
+    flags = lastStr.slice(lastSlashIndex + 1);
+    src += lastStr.slice(0, lastSlashIndex);
+  }
+  return new RegExp(src, flags);
+}
+function escape(val) {
+  return String(val).replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+}
+
+// src/utils/definitions/types/attributeName.ts
+function attributeName2(taglib, document, _params, event) {
+  const tagName = event.tag.tagNameExpression ? void 0 : event.tag.tagName;
+  const tagDef = tagName && taglib.getTag(tagName);
+  const attrDef = taglib.getAttribute(tagName || "*", event.name);
+  let range = START_OF_FILE;
+  if (!attrDef) {
+    return;
+  }
+  const attrEntryFile = attrDef.filePath || tagDef && tagDef.filePath;
+  if (!attrEntryFile) {
+    return;
+  }
+  if (/\/marko(?:-tag)?\.json$/.test(attrEntryFile)) {
+    const tagDefDoc = createTextDocument(attrEntryFile);
+    const match = RegExpBuilder`/"@${event.name}"\s*:\s*[^\r\n,]+/g`.exec(tagDefDoc.getText());
+    if (match && match.index) {
+      range = Range2.create(tagDefDoc.positionAt(match.index), tagDefDoc.positionAt(match.index + match[0].length));
+    }
+  }
+  return [
+    LocationLink.create(URI4.file(attrEntryFile).toString(), range, range, rangeFromEvent(document, event))
+  ];
+}
+
+// src/utils/definitions/types/openTagName.ts
+import { URI as URI5 } from "vscode-uri";
+import {
+  Range as Range3,
+  LocationLink as LocationLink2
+} from "vscode-languageserver";
+function openTagName2(taglib, document, _params, event) {
+  let tagDef;
+  let range = START_OF_FILE;
+  const isAttributeTag = event.tagName[0] === "@";
+  if (isAttributeTag) {
+    const parentTag = findNonControlFlowParent(event);
+    tagDef = parentTag && (parentTag.tagNameExpression ? void 0 : taglib.getTag(parentTag.tagName));
+  } else {
+    tagDef = taglib.getTag(event.tagName);
+  }
+  if (!tagDef) {
+    return;
+  }
+  const tagEntryFile = tagDef.template || tagDef.renderer || tagDef.filePath;
+  if (/\/marko(?:-tag)?\.json$/.test(tagEntryFile)) {
+    const tagDefDoc = createTextDocument(tagEntryFile);
+    const match = RegExpBuilder`/"<${event.tagName}>"\s*:\s*[^\r\n,]+/g`.exec(tagDefDoc.getText());
+    if (match && match.index) {
+      range = Range3.create(tagDefDoc.positionAt(match.index), tagDefDoc.positionAt(match.index + match[0].length));
+    }
+  }
+  return [
+    LocationLink2.create(URI5.file(tagEntryFile).toString(), range, range, rangeFromEvent(document, event))
+  ];
+}
+
+// src/index.ts
+if (typeof __require !== "undefined" && __require.extensions && !(".ts" in __require.extensions)) {
+  __require.extensions[".ts"] = void 0;
+}
+var cacheForCompiler = /* @__PURE__ */ new WeakMap();
+var connection = createConnection(ProposedFeatures.all);
+var prevDiagnostics = /* @__PURE__ */ new WeakMap();
+var diagnosticTimeouts = /* @__PURE__ */ new WeakMap();
+var documents = new TextDocuments(TextDocument3);
+var markoErrorRegExp = /^(.+?)(?:\((\d+)(?:\s*,\s*(\d+))?\))?: (.*)$/gm;
+console.log = (...args) => {
+  connection.console.log(args.map((v) => inspect(v)).join(" "));
+};
+console.error = (...args) => {
+  connection.console.error(args.map((v) => inspect(v)).join(" "));
+};
+process.on("uncaughtException", console.error);
+process.on("unhandledRejection", console.error);
+connection.onInitialize(() => {
+  return {
+    capabilities: {
+      textDocumentSync: TextDocumentSyncKind.Incremental,
+      documentFormattingProvider: true,
+      definitionProvider: true,
+      completionProvider: {
+        triggerCharacters: [".", ":", "<", ">", "@", "/"]
+      }
+    }
+  };
+});
+connection.onInitialized(() => {
+  documents.all().forEach((doc) => queueValidation(doc));
+});
+connection.onCompletion((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  const taglib = getTagLibLookup(doc);
+  if (!taglib)
+    return CompletionList6.create([], true);
+  const event = parseUntilOffset({
+    taglib,
+    offset: doc.offsetAt(params.position),
+    text: doc.getText()
+  });
+  const handler = event && completions_exports[event.type];
+  return handler && handler(taglib, doc, params, event) || CompletionList6.create([], true);
+});
+connection.onDefinition((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  const taglib = getTagLibLookup(doc);
+  if (!taglib)
+    return;
+  const event = parseUntilOffset({
+    taglib,
+    offset: doc.offsetAt(params.position),
+    text: doc.getText()
+  });
+  const handler = event && definitions_exports[event.type];
+  return handler && handler(taglib, doc, params, event);
+});
+connection.onDocumentFormatting(async ({
+  textDocument,
+  options
+}) => {
+  try {
+    const doc = documents.get(textDocument.uri);
+    const { fsPath, scheme } = URI6.parse(textDocument.uri);
+    const text = doc.getText();
+    const formatted = prettier.format(text, __spreadValues({
+      parser: "marko",
+      filepath: fsPath,
+      plugins: [markoPrettier],
+      tabWidth: options.tabSize,
+      useTabs: options.insertSpaces === false
+    }, scheme === "file" ? await prettier.resolveConfig(fsPath, {
+      editorconfig: true
+    }).catch(() => null) : null));
+    return [
+      TextEdit5.replace(Range4.create(doc.positionAt(0), doc.positionAt(text.length)), formatted)
+    ];
+  } catch (e) {
+    displayMessage("Error", inspect(e, { colors: false }));
+  }
+  return [
+    TextEdit5.replace(Range4.create(Position3.create(0, 0), Position3.create(0, 0)), "")
+  ];
+});
+connection.onDidChangeWatchedFiles(() => {
+  const clearedCompilers = /* @__PURE__ */ new Set();
+  for (const doc of documents.all()) {
+    const { compiler } = getCompilerAndTranslatorForDoc(doc);
+    if (!clearedCompilers.has(compiler)) {
+      clearCaches(compiler);
+      clearedCompilers.add(compiler);
+    }
+  }
+});
+documents.onDidChangeContent((change) => {
+  queueValidation(change.document);
+  if (change.document.version > 1) {
+    clearCaches(getCompilerAndTranslatorForDoc(change.document).compiler);
+  }
+});
+function queueValidation(doc) {
+  clearTimeout(diagnosticTimeouts.get(doc));
+  diagnosticTimeouts.set(doc, setTimeout(() => {
+    const prevDiag = prevDiagnostics.get(doc);
+    const nextDiag = doValidate(doc);
+    if (prevDiag && isDeepStrictEqual(prevDiag, nextDiag)) {
+      return;
+    }
+    prevDiagnostics.set(doc, nextDiag);
+    connection.sendDiagnostics({
+      uri: doc.uri,
+      diagnostics: nextDiag
+    });
+  }, 800));
+}
+function doValidate(doc) {
+  const { fsPath, scheme } = URI6.parse(doc.uri);
+  if (scheme !== "file") {
+    return [];
+  }
+  const { compiler, translator } = getCompilerAndTranslatorForDoc(doc);
+  const diagnostics = [];
+  try {
+    compiler.compileSync(doc.getText(), fsPath, {
+      cache: getCacheForCompiler(compiler),
+      output: "source",
+      code: false,
+      translator
+    });
+  } catch (e) {
+    let match;
+    while (match = markoErrorRegExp.exec(e.message)) {
+      const [, fileName, rawLine, rawCol, msg] = match;
+      const line = (parseInt(rawLine, 10) || 1) - 1;
+      const col = (parseInt(rawCol, 10) || 1) - 1;
+      diagnostics.push(Diagnostic.create(Range4.create(line, col, line, col), msg, DiagnosticSeverity.Error, void 0, fileName));
+    }
+  }
+  return diagnostics;
+}
+function clearCaches(compiler) {
+  var _a;
+  (_a = cacheForCompiler.get(compiler)) == null ? void 0 : _a.clear();
+  compiler.taglib.clearCaches();
+}
+function getCacheForCompiler(compiler) {
+  let cache = cacheForCompiler.get(compiler);
+  if (!cache) {
+    cacheForCompiler.set(compiler, cache = /* @__PURE__ */ new Map());
+  }
+  return cache;
+}
+function displayMessage(type, msg) {
+  setImmediate(() => {
+    connection.sendNotification(`show${type}`, msg);
+  });
+}
+documents.listen(connection);
+connection.listen();
+//# sourceMappingURL=index.mjs.map