@marko/language-server 0.12.7 → 0.12.10

package/dist/index.js

@@ -575,7 +575,7 @@ function loadCompilerInfo(dir) {
   const rootDir = import_lasso_package_root.default.getRootDir(dir);
   const pkgPath = rootDir && import_resolve_from.default.silent(rootDir, "@marko/compiler/package.json");
   const pkg = pkgPath && require(pkgPath);
-  const cache2 = /* @__PURE__ */ new Map();
+  const cache3 = /* @__PURE__ */ new Map();
   let translator = builtinTranslator;
   let compiler = builtinCompiler;
   if (pkg && /^5\./.test(pkg.version)) {
@@ -592,16 +592,16 @@ function loadCompilerInfo(dir) {
     }
   }
   return {
-    cache: cache2,
+    cache: cache3,
     get lookup() {
-      let lookup = cache2.get(lookupKey);
+      let lookup = cache3.get(lookupKey);
       if (lookup === void 0) {
         try {
           lookup = compiler.taglib.buildLookup(dir, translator);
         } catch {
           lookup = builtinInfo.lookup;
         }
-        cache2.set(lookupKey, lookup);
+        cache3.set(lookupKey, lookup);
       }
       return lookup;
     },
@@ -625,10 +625,10 @@ function display(type, data) {
 }
 
 // src/service/index.ts
-var import_vscode_languageserver11 = require("vscode-languageserver");
+var import_vscode_languageserver13 = require("vscode-languageserver");
 
 // src/service/marko/complete/index.ts
-var import_vscode_languageserver4 = require("vscode-languageserver");
+var import_vscode_languageserver5 = require("vscode-languageserver");
 
 // src/service/marko/complete/Tag.ts
 var import_vscode_languageserver = require("vscode-languageserver");
@@ -842,18 +842,146 @@ function AttrName({
   return completions;
 }
 
+// src/service/marko/complete/AttrValue.ts
+var import_path4 = __toESM(require("path"));
+var import_vscode_languageserver4 = require("vscode-languageserver");
+
+// src/service/marko/util/is-document-link-attr.ts
+var linkedAttrs = /* @__PURE__ */ new Map([
+  [
+    "src",
+    /* @__PURE__ */ new Set([
+      "audio",
+      "embed",
+      "iframe",
+      "img",
+      "input",
+      "script",
+      "source",
+      "track",
+      "video"
+    ])
+  ],
+  ["href", /* @__PURE__ */ new Set(["a", "area", "link"])],
+  ["data", /* @__PURE__ */ new Set(["object"])],
+  ["poster", /* @__PURE__ */ new Set(["video"])]
+]);
+function isDocumentLinkAttr(doc, tag, attr) {
+  var _a, _b;
+  return tag.nameText && attr.type === 8 /* AttrNamed */ && ((_a = attr.value) == null ? void 0 : _a.type) === 11 /* AttrValue */ && /^['"]$/.test(doc.getText()[attr.value.value.start]) && ((_b = linkedAttrs.get(doc.getText().slice(attr.name.start, attr.name.end))) == null ? void 0 : _b.has(tag.nameText)) || false;
+}
+
+// src/utils/file-system.ts
+var import_path3 = __toESM(require("path"));
+var import_promises = __toESM(require("fs/promises"));
+var import_vscode_css_languageservice = require("vscode-css-languageservice");
+var file_system_default = {
+  stat,
+  readDirectory
+};
+async function stat(fileName) {
+  const stat2 = await import_promises.default.stat(fileName).catch(() => null);
+  let type = import_vscode_css_languageservice.FileType.Unknown;
+  let ctime = 0;
+  let mtime = 0;
+  let size = 0;
+  if (stat2) {
+    if (stat2.isDirectory())
+      type = import_vscode_css_languageservice.FileType.Directory;
+    else if (stat2.isFile())
+      type = import_vscode_css_languageservice.FileType.File;
+    ctime = stat2.ctimeMs;
+    mtime = stat2.mtimeMs;
+    size = stat2.size;
+  }
+  return {
+    type,
+    ctime,
+    mtime,
+    size
+  };
+}
+async function readDirectory(dir) {
+  return (await Promise.all((await import_promises.default.readdir(dir).catch(() => [])).map(async (entry) => [entry, (await stat(import_path3.default.join(dir, entry))).type]))).filter(([, type]) => type !== import_vscode_css_languageservice.FileType.Unknown);
+}
+
+// src/utils/resolve-url.ts
+function resolveUrl(to, base) {
+  try {
+    const baseUrl = new URL(base, "file://");
+    const resolved = new URL(to, baseUrl);
+    const { origin, protocol } = baseUrl;
+    if (resolved.origin === origin && resolved.protocol === protocol) {
+      return resolved.pathname + resolved.search + resolved.hash;
+    }
+    return resolved.toString();
+  } catch {
+    return void 0;
+  }
+}
+
+// src/service/marko/complete/AttrValue.ts
+async function AttrValue({
+  document,
+  offset,
+  node,
+  parsed,
+  code
+}) {
+  const attr = node.parent;
+  if (isDocumentLinkAttr(document, attr.parent, attr)) {
+    const start = node.value.start + 1;
+    if (code[start] !== ".")
+      return;
+    const end = node.value.end - 1;
+    const relativeOffset = offset - start;
+    const rawValue = parsed.read({
+      start,
+      end
+    });
+    let segmentStart = rawValue.lastIndexOf("/", relativeOffset);
+    if (segmentStart === -1)
+      segmentStart = relativeOffset;
+    const resolveRequest = rawValue.slice(0, segmentStart) || ".";
+    const dir = resolveUrl(resolveRequest, document.uri);
+    if ((dir == null ? void 0 : dir[0]) === "/") {
+      const result = [];
+      const curDir = resolveRequest === "." ? dir : resolveUrl(".", document.uri);
+      const curFile = curDir === dir ? import_path4.default.basename(document.uri) : void 0;
+      const replaceRange = import_vscode_languageserver4.Range.create(document.positionAt(start + segmentStart + 1), document.positionAt(start + rawValue.length));
+      for (const [entry, type] of await file_system_default.readDirectory(dir)) {
+        if (entry[0] !== "." && entry !== curFile) {
+          const isDir = type === import_vscode_css_languageservice.FileType.Directory;
+          const label = isDir ? `${entry}/` : entry;
+          result.push({
+            label,
+            kind: isDir ? import_vscode_languageserver4.CompletionItemKind.Folder : import_vscode_languageserver4.CompletionItemKind.File,
+            textEdit: import_vscode_languageserver4.TextEdit.replace(replaceRange, label),
+            command: isDir ? {
+              title: "Suggest",
+              command: "editor.action.triggerSuggest"
+            } : void 0
+          });
+        }
+      }
+      return result;
+    }
+  }
+}
+
 // src/service/marko/complete/index.ts
 var handlers = {
   Tag,
   OpenTagName,
-  AttrName
+  AttrName,
+  AttrValue
 };
 var doComplete = async (doc, params) => {
   var _a;
   const parsed = parse2(doc);
   const offset = doc.offsetAt(params.position);
   const node = parsed.nodeAt(offset);
-  return import_vscode_languageserver4.CompletionList.create(await ((_a = handlers[NodeType[node.type]]) == null ? void 0 : _a.call(handlers, {
+  return import_vscode_languageserver5.CompletionList.create(await ((_a = handlers[NodeType[node.type]]) == null ? void 0 : _a.call(handlers, {
     document: doc,
     params,
     parsed,
@@ -865,15 +993,15 @@ var doComplete = async (doc, params) => {
 };
 
 // src/service/marko/validate.ts
-var import_vscode_languageserver5 = require("vscode-languageserver");
+var import_vscode_languageserver6 = require("vscode-languageserver");
 var markoErrorRegExp = /^(.+?)(?:\((\d+)(?:\s*,\s*(\d+))?\))?: (.*)$/gm;
 var doValidate = (doc) => {
   const fsPath = getDocFile(doc);
   const diagnostics = [];
-  const { compiler, translator, cache: cache2 } = getCompilerInfo(doc);
+  const { compiler, translator, cache: cache3 } = getCompilerInfo(doc);
   try {
     compiler.compileSync(doc.getText(), fsPath || "untitled.marko", {
-      cache: cache2,
+      cache: cache3,
       translator,
       code: false,
       output: "source",
@@ -885,16 +1013,16 @@ var doValidate = (doc) => {
       const [, fileName, rawLine, rawCol, msg] = match;
       const line = (parseInt(rawLine, 10) || 1) - 1;
       const col = (parseInt(rawCol, 10) || 1) - 1;
-      diagnostics.push(import_vscode_languageserver5.Diagnostic.create(import_vscode_languageserver5.Range.create(line, col, line, col), msg, import_vscode_languageserver5.DiagnosticSeverity.Error, void 0, fileName));
+      diagnostics.push(import_vscode_languageserver6.Diagnostic.create(import_vscode_languageserver6.Range.create(line, col, line, col), msg, import_vscode_languageserver6.DiagnosticSeverity.Error, void 0, fileName));
     }
   }
   return diagnostics;
 };
 
 // src/service/marko/definition/OpenTagName.ts
-var import_path3 = __toESM(require("path"));
+var import_path5 = __toESM(require("path"));
 var import_vscode_uri4 = require("vscode-uri");
-var import_vscode_languageserver7 = require("vscode-languageserver");
+var import_vscode_languageserver8 = require("vscode-languageserver");
 
 // src/utils/regexp-builder.ts
 function RegExpBuilder(strings, ...expressions) {
@@ -923,9 +1051,9 @@ function escape(val) {
 // src/utils/utils.ts
 var import_fs = __toESM(require("fs"));
 var import_vscode_uri3 = require("vscode-uri");
-var import_vscode_languageserver6 = require("vscode-languageserver");
+var import_vscode_languageserver7 = require("vscode-languageserver");
 var import_vscode_languageserver_textdocument = require("vscode-languageserver-textdocument");
-var START_OF_FILE = import_vscode_languageserver6.Range.create(import_vscode_languageserver6.Position.create(0, 0), import_vscode_languageserver6.Position.create(0, 0));
+var START_OF_FILE = import_vscode_languageserver7.Range.create(import_vscode_languageserver7.Position.create(0, 0), import_vscode_languageserver7.Position.create(0, 0));
 function createTextDocument(filename) {
   const uri = import_vscode_uri3.URI.file(filename).toString();
   const content = import_fs.default.readFileSync(filename, "utf-8");
@@ -953,24 +1081,24 @@ function OpenTagName2({
     return;
   }
   const tagEntryFile = tagDef.template || tagDef.renderer || tagDef.filePath;
-  if (!import_path3.default.isAbsolute(tagEntryFile)) {
+  if (!import_path5.default.isAbsolute(tagEntryFile)) {
     return;
   }
   if (/\/marko(?:-tag)?\.json$/.test(tagEntryFile)) {
     const tagDefDoc = createTextDocument(tagEntryFile);
     const match = RegExpBuilder`/"(?:<${tag.nameText}>|${tag.nameText})"\s*:\s*[^\r\n,]+/g`.exec(tagDefDoc.getText());
     if (match && match.index) {
-      range = import_vscode_languageserver7.Range.create(tagDefDoc.positionAt(match.index), tagDefDoc.positionAt(match.index + match[0].length));
+      range = import_vscode_languageserver8.Range.create(tagDefDoc.positionAt(match.index), tagDefDoc.positionAt(match.index + match[0].length));
     }
   }
   return [
-    import_vscode_languageserver7.LocationLink.create(import_vscode_uri4.URI.file(tagEntryFile).toString(), range, range, parsed.locationAt(node))
+    import_vscode_languageserver8.LocationLink.create(import_vscode_uri4.URI.file(tagEntryFile).toString(), range, range, parsed.locationAt(node))
   ];
 }
 
 // src/service/marko/definition/AttrName.ts
 var import_vscode_uri5 = require("vscode-uri");
-var import_vscode_languageserver8 = require("vscode-languageserver");
+var import_vscode_languageserver9 = require("vscode-languageserver");
 function AttrName2({
   lookup,
   parsed,
@@ -994,11 +1122,11 @@ function AttrName2({
     const tagDefDoc = createTextDocument(attrEntryFile);
     const match = RegExpBuilder`/"@${attrName}"\s*:\s*[^\r\n,]+/g`.exec(tagDefDoc.getText());
     if (match && match.index) {
-      range = import_vscode_languageserver8.Range.create(tagDefDoc.positionAt(match.index), tagDefDoc.positionAt(match.index + match[0].length));
+      range = import_vscode_languageserver9.Range.create(tagDefDoc.positionAt(match.index), tagDefDoc.positionAt(match.index + match[0].length));
     }
   }
   return [
-    import_vscode_languageserver8.LocationLink.create(import_vscode_uri5.URI.file(attrEntryFile).toString(), range, range, parsed.locationAt(node))
+    import_vscode_languageserver9.LocationLink.create(import_vscode_uri5.URI.file(attrEntryFile).toString(), range, range, parsed.locationAt(node))
   ];
 }
 
@@ -1023,17 +1151,83 @@ var findDefinition = async (doc, params) => {
   })) || [];
 };
 
-// src/service/marko/format.ts
-var import_vscode_languageserver9 = require("vscode-languageserver");
+// src/service/marko/document-links/extract.ts
+var import_vscode_languageserver10 = require("vscode-languageserver");
 var import_vscode_uri6 = require("vscode-uri");
+var importTagReg = /(['"])<((?:[^\1\\>]+|\\.)*)>?\1/g;
+function extractDocumentLinks(doc, parsed, lookup) {
+  if (import_vscode_uri6.URI.parse(doc.uri).scheme === "untitled") {
+    return [];
+  }
+  const links = [];
+  const { program } = parsed;
+  const code = doc.getText();
+  const read = (range) => code.slice(range.start, range.end);
+  const visit = (node) => {
+    switch (node.type) {
+      case 1 /* Tag */:
+        if (node.attrs && node.nameText) {
+          for (const attr of node.attrs) {
+            if (isDocumentLinkAttr(doc, node, attr)) {
+              links.push(import_vscode_languageserver10.DocumentLink.create({
+                start: parsed.positionAt(attr.value.value.start),
+                end: parsed.positionAt(attr.value.value.end)
+              }, resolveUrl(read(attr.value.value).slice(1, -1), doc.uri)));
+            }
+          }
+        }
+        if (node.body) {
+          for (const child of node.body) {
+            visit(child);
+          }
+        }
+        break;
+    }
+  };
+  for (const item of program.static) {
+    if (item.type === 20 /* Statement */ && code[item.start] === "i") {
+      importTagReg.lastIndex = 0;
+      const value = parsed.read(item);
+      const match = importTagReg.exec(value);
+      if (match) {
+        const [{ length }, , tagName] = match;
+        const tagDef = lookup.getTag(tagName);
+        const fileForTag = tagDef && (tagDef.template || tagDef.renderer);
+        if (fileForTag) {
+          links.push(import_vscode_languageserver10.DocumentLink.create({
+            start: parsed.positionAt(item.start + match.index),
+            end: parsed.positionAt(item.start + match.index + length)
+          }, fileForTag));
+        }
+      }
+    }
+  }
+  for (const item of program.body) {
+    visit(item);
+  }
+  return links;
+}
+
+// src/service/marko/document-links/index.ts
+var cache = /* @__PURE__ */ new WeakMap();
+var findDocumentLinks = async (doc) => {
+  const parsed = parse2(doc);
+  let result = cache.get(parsed);
+  if (!result) {
+    result = extractDocumentLinks(doc, parsed, getCompilerInfo(doc).lookup);
+    cache.set(parsed, result);
+  }
+  return result;
+};
+
+// src/service/marko/format.ts
+var import_vscode_languageserver11 = require("vscode-languageserver");
+var import_vscode_uri7 = require("vscode-uri");
 var prettier = __toESM(require("prettier"));
 var markoPrettier = __toESM(require("prettier-plugin-marko"));
-var NO_EDIT = [
-  import_vscode_languageserver9.TextEdit.replace(import_vscode_languageserver9.Range.create(import_vscode_languageserver9.Position.create(0, 0), import_vscode_languageserver9.Position.create(0, 0)), "")
-];
-var format2 = async (doc, params, token) => {
+var format2 = async (doc, params, cancel) => {
   try {
-    const { fsPath, scheme } = import_vscode_uri6.URI.parse(doc.uri);
+    const { fsPath, scheme } = import_vscode_uri7.URI.parse(doc.uri);
     const text = doc.getText();
     const options = {
       parser: "marko",
@@ -1045,15 +1239,14 @@ var format2 = async (doc, params, token) => {
         editorconfig: true
       }).catch(() => null) : null
     };
-    if (!token.isCancellationRequested) {
-      return [
-        import_vscode_languageserver9.TextEdit.replace(import_vscode_languageserver9.Range.create(doc.positionAt(0), doc.positionAt(text.length)), prettier.format(text, options))
-      ];
-    }
+    if (cancel.isCancellationRequested)
+      return;
+    return [
+      import_vscode_languageserver11.TextEdit.replace(import_vscode_languageserver11.Range.create(doc.positionAt(0), doc.positionAt(text.length)), prettier.format(text, options))
+    ];
   } catch (e) {
     displayError(e);
   }
-  return NO_EDIT;
 };
 
 // src/service/marko/index.ts
@@ -1061,12 +1254,13 @@ var marko_default = {
   doComplete,
   doValidate,
   findDefinition,
+  findDocumentLinks,
   format: format2
 };
 
 // src/service/stylesheet/index.ts
-var import_vscode_languageserver10 = require("vscode-languageserver");
-var import_vscode_css_languageservice = require("vscode-css-languageservice");
+var import_vscode_languageserver12 = require("vscode-languageserver");
+var import_vscode_css_languageservice2 = require("vscode-css-languageservice");
 var import_vscode_languageserver_textdocument2 = require("vscode-languageserver-textdocument");
 
 // src/utils/extractor.ts
@@ -1129,7 +1323,7 @@ function createExtractor(code) {
           const generatedStart = generatedMap[key];
           const sourceStart = generatedMap[key + 1];
           const sourceEnd = generatedMap[key + 2];
-          return sourceEnd - sourceStart <= generatedOffset - generatedStart ? void 0 : sourceStart + (generatedOffset - generatedStart);
+          return sourceEnd - sourceStart < generatedOffset - generatedStart ? void 0 : sourceStart + (generatedOffset - generatedStart);
         },
         generatedOffsetAt(sourceOffset) {
           let max = sourceMap.length / 3;
@@ -1169,10 +1363,20 @@ function extractStyleSheets(code, program, lookup) {
     }).replace(/^.*\./, "") : "css";
   };
   const visit = (node) => {
-    var _a, _b, _c;
+    var _a, _b;
     switch (node.type) {
       case 1 /* Tag */:
-        if ((_a = node.body) == null ? void 0 : _a.length) {
+        if (node.nameText === "style" && node.concise && node.attrs) {
+          const block = node.attrs.at(-1);
+          if (block.type === 8 /* AttrNamed */ && code[block.start] === "{") {
+            getExtractor(getFileExtFromTag(node)).write`${{
+              start: block.start + 1,
+              end: block.end - 1
+            }}`;
+            break;
+          }
+        }
+        if (node.body) {
           if (node.nameText === "style") {
             const ext = getFileExtFromTag(node);
             for (const child of node.body) {
@@ -1186,30 +1390,22 @@ function extractStyleSheets(code, program, lookup) {
               }
             }
           } else {
-            if (node.attrs) {
-              for (const attr of node.attrs) {
-                if (attr.type === 8 /* AttrNamed */ && ((_b = attr.value) == null ? void 0 : _b.type) === 11 /* AttrValue */ && /^['"]$/.test(code[attr.value.value.start])) {
-                  const name = read(attr.name);
-                  if (name === "#style" || name === "style" && lookup && node.nameText && name === "style" && ((_c = lookup.getTag(node.nameText)) == null ? void 0 : _c.html)) {
-                    getExtractor("css").write`:root{${{
-                      start: attr.value.value.start + 1,
-                      end: attr.value.value.end - 1
-                    }}}`;
-                  }
-                }
-              }
-            }
             for (const child of node.body) {
               visit(child);
             }
           }
-        } else if (node.nameText === "style" && node.concise && node.attrs) {
-          const block = node.attrs.at(-1);
-          if (block.type === 8 /* AttrNamed */ && code[block.start] === "{") {
-            getExtractor(getFileExtFromTag(node)).write`${{
-              start: block.start + 1,
-              end: block.end - 1
-            }}`;
+        }
+        if (node.attrs) {
+          for (const attr of node.attrs) {
+            if (attr.type === 8 /* AttrNamed */ && ((_a = attr.value) == null ? void 0 : _a.type) === 11 /* AttrValue */ && /^['"]$/.test(code[attr.value.value.start])) {
+              const name = read(attr.name);
+              if (name === "#style" || name === "style" && node.nameText && name === "style" && ((_b = lookup.getTag(node.nameText)) == null ? void 0 : _b.html)) {
+                getExtractor("css").write`:root{${{
+                  start: attr.value.value.start + 1,
+                  end: attr.value.value.end - 1
+                }}}`;
+              }
+            }
           }
         }
         break;
@@ -1225,13 +1421,17 @@ function extractStyleSheets(code, program, lookup) {
 }
 
 // src/service/stylesheet/index.ts
-var cache = /* @__PURE__ */ new WeakMap();
+var cache2 = /* @__PURE__ */ new WeakMap();
 var services = {
-  css: import_vscode_css_languageservice.getCSSLanguageService,
-  less: import_vscode_css_languageservice.getLESSLanguageService,
-  scss: import_vscode_css_languageservice.getSCSSLanguageService
+  css: import_vscode_css_languageservice2.getCSSLanguageService,
+  less: import_vscode_css_languageservice2.getLESSLanguageService,
+  scss: import_vscode_css_languageservice2.getSCSSLanguageService
 };
-var stylesheet_default = {
+var clientCapabilities;
+var StyleSheetService = {
+  initialize(params) {
+    clientCapabilities = params.capabilities;
+  },
   async doComplete(doc, params) {
     const infoByExt = getStyleSheetInfo(doc);
     const sourceOffset = doc.offsetAt(params.position);
@@ -1241,37 +1441,31 @@ var stylesheet_default = {
       if (generatedOffset === void 0)
         continue;
       const { service: service2, virtualDoc } = info;
-      const result = service2.doComplete(virtualDoc, virtualDoc.positionAt(generatedOffset), info.parsed);
-      for (const item of result.items) {
-        if (item.additionalTextEdits) {
-          for (const edit of item.additionalTextEdits) {
-            if (!updateRange(doc, info, edit.range)) {
-              edit.newText = "";
-              edit.range = START_OF_FILE;
-            }
+      const result = await service2.doComplete2(virtualDoc, virtualDoc.positionAt(generatedOffset), info.parsed, { resolveReference: resolveUrl });
+      if (result.itemDefaults) {
+        const { editRange } = result.itemDefaults;
+        if (editRange) {
+          if ("start" in editRange) {
+            result.itemDefaults.editRange = getSourceRange(doc, info, editRange);
+          } else {
+            editRange.insert = getSourceRange(doc, info, editRange.insert);
+            editRange.replace = getSourceRange(doc, info, editRange.replace);
           }
         }
-        const { textEdit } = item;
-        if (textEdit) {
-          if (textEdit.range) {
-            if (!updateRange(doc, info, textEdit.range)) {
-              textEdit.newText = "";
-              textEdit.range = START_OF_FILE;
-            }
-          }
-          if (textEdit.insert) {
-            if (!updateRange(doc, info, textEdit.insert)) {
-              textEdit.newText = "";
-              textEdit.insert = START_OF_FILE;
-            }
-          }
+      }
+      for (const item of result.items) {
+        if (item.textEdit) {
+          item.textEdit = getSourceInsertReplaceEdit(doc, info, item.textEdit);
+        }
+        if (item.additionalTextEdits) {
+          item.additionalTextEdits = getSourceEdits(doc, info, item.additionalTextEdits);
         }
       }
       return result;
     }
-    return import_vscode_languageserver10.CompletionList.create([], true);
+    return import_vscode_languageserver12.CompletionList.create([], true);
   },
-  async findDefinition(doc, params) {
+  findDefinition(doc, params) {
     const infoByExt = getStyleSheetInfo(doc);
     const sourceOffset = doc.offsetAt(params.position);
     for (const ext in infoByExt) {
@@ -1281,13 +1475,19 @@ var stylesheet_default = {
         continue;
       const { service: service2, virtualDoc } = info;
       const result = service2.findDefinition(virtualDoc, virtualDoc.positionAt(generatedOffset), info.parsed);
-      if (result && updateRange(doc, info, result.range)) {
-        return result;
+      if (result) {
+        const range = getSourceRange(doc, info, result.range);
+        if (range) {
+          return {
+            range,
+            uri: doc.uri
+          };
+        }
       }
       break;
     }
   },
-  async doHover(doc, params) {
+  findReferences(doc, params) {
     const infoByExt = getStyleSheetInfo(doc);
     const sourceOffset = doc.offsetAt(params.position);
     for (const ext in infoByExt) {
@@ -1296,45 +1496,269 @@ var stylesheet_default = {
       if (generatedOffset === void 0)
         continue;
       const { service: service2, virtualDoc } = info;
-      const result = service2.doHover(virtualDoc, virtualDoc.positionAt(generatedOffset), service2.parseStylesheet(virtualDoc));
-      if (result && (!result.range || updateRange(doc, info, result.range))) {
-        return result;
+      const result = [];
+      for (const location of service2.findReferences(virtualDoc, virtualDoc.positionAt(generatedOffset), info.parsed)) {
+        const range = getSourceRange(doc, info, location.range);
+        if (range) {
+          result.push({
+            range,
+            uri: location.uri
+          });
+        }
       }
+      return result.length ? result : void 0;
     }
   },
-  async doValidate(doc) {
+  findDocumentLinks(doc) {
+    const infoByExt = getStyleSheetInfo(doc);
+    const result = [];
+    for (const ext in infoByExt) {
+      const info = infoByExt[ext];
+      const { service: service2, virtualDoc } = info;
+      for (const link of service2.findDocumentLinks(virtualDoc, info.parsed, {
+        resolveReference: resolveUrl
+      })) {
+        const range = getSourceRange(doc, info, link.range);
+        if (range) {
+          result.push({
+            range,
+            target: link.target,
+            tooltip: link.tooltip,
+            data: link.data
+          });
+        }
+      }
+    }
+    return result.length ? result : void 0;
+  },
+  findDocumentHighlights(doc, params) {
+    const infoByExt = getStyleSheetInfo(doc);
+    const sourceOffset = doc.offsetAt(params.position);
+    for (const ext in infoByExt) {
+      const info = infoByExt[ext];
+      const generatedOffset = info.generatedOffsetAt(sourceOffset);
+      if (generatedOffset === void 0)
+        continue;
+      const { service: service2, virtualDoc } = info;
+      const result = [];
+      for (const highlight of service2.findDocumentHighlights(virtualDoc, virtualDoc.positionAt(generatedOffset), info.parsed)) {
+        const range = getSourceRange(doc, info, highlight.range);
+        if (range) {
+          result.push({
+            range,
+            kind: highlight.kind
+          });
+        }
+      }
+      return result.length ? result : void 0;
+    }
+  },
+  findDocumentColors(doc) {
+    const infoByExt = getStyleSheetInfo(doc);
+    const result = [];
+    for (const ext in infoByExt) {
+      const info = infoByExt[ext];
+      const { service: service2, virtualDoc } = info;
+      for (const colorInfo of service2.findDocumentColors(virtualDoc, info.parsed)) {
+        const range = getSourceRange(doc, info, colorInfo.range);
+        if (range) {
+          result.push({
+            range,
+            color: colorInfo.color
+          });
+        }
+      }
+    }
+    return result.length ? result : void 0;
+  },
+  getColorPresentations(doc, params) {
+    const infoByExt = getStyleSheetInfo(doc);
+    const sourceOffset = doc.offsetAt(params.range.start);
+    for (const ext in infoByExt) {
+      const info = infoByExt[ext];
+      const generatedOffsetStart = info.generatedOffsetAt(sourceOffset);
+      if (generatedOffsetStart === void 0)
+        continue;
+      const generatedOffsetEnd = info.generatedOffsetAt(doc.offsetAt(params.range.end));
+      if (generatedOffsetEnd === void 0)
+        continue;
+      const { service: service2, virtualDoc } = info;
+      const result = [];
+      for (const colorPresentation of service2.getColorPresentations(virtualDoc, info.parsed, params.color, import_vscode_languageserver12.Range.create(virtualDoc.positionAt(generatedOffsetStart), virtualDoc.positionAt(generatedOffsetEnd)))) {
+        const textEdit = colorPresentation.textEdit && getSourceEdit(doc, info, colorPresentation.textEdit);
+        const additionalTextEdits = colorPresentation.additionalTextEdits && getSourceEdits(doc, info, colorPresentation.additionalTextEdits);
+        if (textEdit || additionalTextEdits) {
+          result.push({
+            label: colorPresentation.label,
+            textEdit,
+            additionalTextEdits
+          });
+        }
+      }
+      return result.length ? result : void 0;
+    }
+  },
+  doHover(doc, params) {
+    const infoByExt = getStyleSheetInfo(doc);
+    const sourceOffset = doc.offsetAt(params.position);
+    for (const ext in infoByExt) {
+      const info = infoByExt[ext];
+      const generatedOffset = info.generatedOffsetAt(sourceOffset);
+      if (generatedOffset === void 0)
+        continue;
+      const { service: service2, virtualDoc } = info;
+      const result = service2.doHover(virtualDoc, virtualDoc.positionAt(generatedOffset), info.parsed);
+      if (result) {
+        if (result.range) {
+          const range = getSourceRange(doc, info, result.range);
+          if (range) {
+            return {
+              range,
+              contents: result.contents
+            };
+          }
+        } else {
+          return result;
+        }
+      }
+    }
+  },
+  async doRename(doc, params) {
+    const infoByExt = getStyleSheetInfo(doc);
+    const sourceOffset = doc.offsetAt(params.position);
+    for (const ext in infoByExt) {
+      const info = infoByExt[ext];
+      const generatedOffset = info.generatedOffsetAt(sourceOffset);
+      if (generatedOffset === void 0)
+        continue;
+      const { service: service2, virtualDoc } = info;
+      const result = service2.doRename(virtualDoc, virtualDoc.positionAt(generatedOffset), params.newName, info.parsed);
+      if (result.changes) {
+        for (const uri in result.changes) {
+          if (uri === doc.uri) {
+            result.changes[uri] = getSourceEdits(doc, info, result.changes[uri]) || [];
+          }
+        }
+      }
+      if (result.documentChanges) {
+        for (const change of result.documentChanges) {
+          if (import_vscode_languageserver12.TextDocumentEdit.is(change)) {
+            if (change.textDocument.uri === doc.uri) {
+              change.edits = getSourceEdits(doc, info, change.edits) || [];
+            }
+          }
+        }
+      }
+      return result;
+    }
+  },
+  doCodeActions(doc, params) {
+    var _a;
+    const infoByExt = getStyleSheetInfo(doc);
+    const sourceOffset = doc.offsetAt(params.range.start);
+    for (const ext in infoByExt) {
+      const info = infoByExt[ext];
+      const generatedOffsetStart = info.generatedOffsetAt(sourceOffset);
+      if (generatedOffsetStart === void 0)
+        continue;
+      const generatedOffsetEnd = info.generatedOffsetAt(doc.offsetAt(params.range.end));
+      if (generatedOffsetEnd === void 0)
+        continue;
+      const { service: service2, virtualDoc } = info;
+      const result = service2.doCodeActions(virtualDoc, import_vscode_languageserver12.Range.create(virtualDoc.positionAt(generatedOffsetStart), virtualDoc.positionAt(generatedOffsetEnd)), params.context, info.parsed);
+      for (const command of result) {
+        const edits = (_a = command.arguments) == null ? void 0 : _a[2];
+        if (edits && Array.isArray(edits) && isTextEdit(edits[0])) {
+          command.arguments[2] = getSourceEdits(doc, info, edits);
+        }
+      }
+      return result;
+    }
+  },
+  doValidate(doc) {
     const infoByExt = getStyleSheetInfo(doc);
     const result = [];
     for (const ext in infoByExt) {
       const info = infoByExt[ext];
       for (const diag of info.service.doValidation(info.virtualDoc, info.parsed)) {
-        if (updateRange(doc, info, diag.range)) {
+        const range = getSourceRange(doc, info, diag.range);
+        if (range) {
+          diag.range = range;
           result.push(diag);
         }
       }
     }
-    return result;
+    return result.length ? result : void 0;
   }
 };
-function updateRange(doc, info, range) {
+function getSourceEdits(doc, info, edits) {
+  const result = [];
+  for (const edit of edits) {
+    const sourceEdit = getSourceEdit(doc, info, edit);
+    if (sourceEdit) {
+      result.push(sourceEdit);
+    }
+  }
+  return result.length ? result : void 0;
+}
+function getSourceEdit(doc, info, textEdit) {
+  const range = getSourceRange(doc, info, textEdit.range);
+  if (range) {
+    return {
+      newText: textEdit.newText,
+      range
+    };
+  }
+}
+function getSourceInsertReplaceEdit(doc, info, textEdit) {
+  if (isTextEdit(textEdit)) {
+    return getSourceEdit(doc, info, textEdit);
+  } else if (textEdit.replace) {
+    const range = getSourceRange(doc, info, textEdit.replace);
+    if (range) {
+      return {
+        newText: textEdit.newText,
+        replace: range
+      };
+    }
+  } else {
+    const range = getSourceRange(doc, info, textEdit.insert);
+    if (range) {
+      return {
+        newText: textEdit.newText,
+        insert: range
+      };
+    }
+  }
+}
+function getSourceRange(doc, info, range) {
   const start = info.sourceOffsetAt(info.virtualDoc.offsetAt(range.start));
-  const end = info.sourceOffsetAt(info.virtualDoc.offsetAt(range.end));
-  if (start !== void 0 || end !== void 0) {
-    range.start = doc.positionAt(start ?? end);
-    range.end = doc.positionAt(end ?? start);
-    return true;
+  if (start === void 0)
+    return;
+  let end = start;
+  if (range.start.line !== range.end.line || range.start.character !== range.end.character) {
+    end = info.sourceOffsetAt(info.virtualDoc.offsetAt(range.end));
+    if (end === void 0)
+      return;
   }
-  return false;
+  const pos = doc.positionAt(start);
+  return {
+    start: pos,
+    end: start === end ? pos : doc.positionAt(end)
+  };
 }
 function getStyleSheetInfo(doc) {
   var _a;
   const parsed = parse2(doc);
-  let cached = cache.get(parsed);
+  let cached = cache2.get(parsed);
   if (!cached) {
     const results = extractStyleSheets(doc.getText(), parsed.program, getCompilerInfo(doc).lookup);
     cached = {};
     for (const ext in results) {
-      const service2 = (_a = services[ext]) == null ? void 0 : _a.call(services);
+      const service2 = (_a = services[ext]) == null ? void 0 : _a.call(services, {
+        fileSystemProvider: file_system_default,
+        clientCapabilities
+      });
       if (!service2)
         continue;
       const { generated, sourceOffsetAt, generatedOffsetAt } = results[ext];
@@ -1347,16 +1771,25 @@ function getStyleSheetInfo(doc) {
         parsed: service2.parseStylesheet(virtualDoc)
       };
     }
-    cache.set(parsed, cached);
+    cache2.set(parsed, cached);
   }
   return cached;
 }
+function isTextEdit(edit) {
+  return edit.range !== void 0;
+}
 
 // src/service/index.ts
-var plugins = [marko_default, stylesheet_default];
+var plugins = [marko_default, StyleSheetService];
 var service = {
+  async initialize(params) {
+    await Promise.all(plugins.map((plugin) => {
+      var _a;
+      return (_a = plugin.initialize) == null ? void 0 : _a.call(plugin, params);
+    }));
+  },
   async doComplete(doc, params, cancel) {
-    const result = import_vscode_languageserver11.CompletionList.create([], false);
+    const result = import_vscode_languageserver13.CompletionList.create([], false);
     try {
       const requests = plugins.map((plugin) => {
         var _a;
@@ -1365,7 +1798,7 @@ var service = {
       for (const pending of requests) {
         const cur = await pending;
         if (cancel.isCancellationRequested)
-          break;
+          return;
         if (cur) {
           let items;
           if (Array.isArray(cur)) {
@@ -1393,7 +1826,7 @@ var service = {
       for (const pending of requests) {
         const cur = await pending;
         if (cancel.isCancellationRequested)
-          break;
+          return;
         if (cur) {
           if (Array.isArray(cur)) {
             result.push(...cur);
@@ -1407,6 +1840,126 @@ var service = {
     }
     return result;
   },
+  async findReferences(doc, params, cancel) {
+    let result;
+    try {
+      const requests = plugins.map((plugin) => {
+        var _a;
+        return (_a = plugin.findReferences) == null ? void 0 : _a.call(plugin, doc, params, cancel);
+      });
+      for (const pending of requests) {
+        const cur = await pending;
+        if (cancel.isCancellationRequested)
+          return;
+        if (cur) {
+          if (result) {
+            result.push(...cur);
+          } else {
+            result = cur;
+          }
+        }
+      }
+    } catch (err) {
+      displayError(err);
+    }
+    return result;
+  },
+  async findDocumentLinks(doc, params, cancel) {
+    let result;
+    try {
+      const requests = plugins.map((plugin) => {
+        var _a;
+        return (_a = plugin.findDocumentLinks) == null ? void 0 : _a.call(plugin, doc, params, cancel);
+      });
+      for (const pending of requests) {
+        const cur = await pending;
+        if (cancel.isCancellationRequested)
+          return;
+        if (cur) {
+          if (result) {
+            result.push(...cur);
+          } else {
+            result = cur;
+          }
+        }
+      }
+    } catch (err) {
+      displayError(err);
+    }
+    return result;
+  },
+  async findDocumentHighlights(doc, params, cancel) {
+    let result;
+    try {
+      const requests = plugins.map((plugin) => {
+        var _a;
+        return (_a = plugin.findDocumentHighlights) == null ? void 0 : _a.call(plugin, doc, params, cancel);
+      });
+      for (const pending of requests) {
+        const cur = await pending;
+        if (cancel.isCancellationRequested)
+          return;
+        if (cur) {
+          if (result) {
+            result.push(...cur);
+          } else {
+            result = cur;
+          }
+        }
+      }
+    } catch (err) {
+      displayError(err);
+    }
+    return result;
+  },
+  async findDocumentColors(doc, params, cancel) {
+    let result;
+    try {
+      const requests = plugins.map((plugin) => {
+        var _a;
+        return (_a = plugin.findDocumentColors) == null ? void 0 : _a.call(plugin, doc, params, cancel);
+      });
+      for (const pending of requests) {
+        const cur = await pending;
+        if (cancel.isCancellationRequested)
+          return;
+        if (cur) {
+          if (result) {
+            result.push(...cur);
+          } else {
+            result = cur;
+          }
+        }
+      }
+    } catch (err) {
+      displayError(err);
+    }
+    return result;
+  },
+  async getColorPresentations(doc, params, cancel) {
+    let result;
+    try {
+      const requests = plugins.map((plugin) => {
+        var _a;
+        return (_a = plugin.getColorPresentations) == null ? void 0 : _a.call(plugin, doc, params, cancel);
+      });
+      for (const pending of requests) {
+        const cur = await pending;
+        if (cancel.isCancellationRequested)
+          return;
+        if (cur) {
+          if (result) {
+            result.push(...cur);
+          } else {
+            result = cur;
+          }
+        }
+      }
+    } catch (err) {
+      displayError(err);
+    }
+    return result;
+  },
   async doHover(doc, params, cancel) {
     var _a;
     try {
@@ -1421,6 +1974,80 @@ var service = {
       displayError(err);
     }
   },
+  async doRename(doc, params, cancel) {
+    let changes;
+    let changeAnnotations;
+    let documentChanges;
+    try {
+      const requests = plugins.map((plugin) => {
+        var _a;
+        return (_a = plugin.doRename) == null ? void 0 : _a.call(plugin, doc, params, cancel);
+      });
+      for (const pending of requests) {
+        const cur = await pending;
+        if (cancel.isCancellationRequested)
+          return;
+        if (cur) {
+          if (cur.changes) {
+            if (changes) {
+              for (const uri in cur.changes) {
+                if (changes[uri]) {
+                  changes[uri].push(...cur.changes[uri]);
+                } else {
+                  changes[uri] = cur.changes[uri];
+                }
+              }
+            } else {
+              changes = cur.changes;
+            }
+          }
+          if (cur.changeAnnotations) {
+            if (changeAnnotations) {
+              Object.assign(changeAnnotations, cur.changeAnnotations);
+            } else {
+              changeAnnotations = cur.changeAnnotations;
+            }
+          }
+          if (cur.documentChanges) {
+            if (documentChanges) {
+              documentChanges.push(...cur.documentChanges);
+            } else {
+              documentChanges = cur.documentChanges;
+            }
+          }
+        }
+      }
+    } catch (err) {
+      displayError(err);
+    }
+    if (changes || changeAnnotations || documentChanges) {
+      return {
+        changes,
+        changeAnnotations,
+        documentChanges
+      };
+    }
+  },
+  async doCodeActions(doc, params, cancel) {
+    const result = [];
+    try {
+      const requests = plugins.map((plugin) => {
+        var _a;
+        return (_a = plugin.doCodeActions) == null ? void 0 : _a.call(plugin, doc, params, cancel);
+      });
+      for (const pending of requests) {
+        const cur = await pending;
+        if (cancel.isCancellationRequested)
+          return;
+        if (cur) {
+          result.push(...cur);
+        }
+      }
+    } catch (err) {
+      displayError(err);
+    }
+    return result;
+  },
   async doValidate(doc) {
     const result = [];
     try {
@@ -1458,14 +2085,21 @@ console.error = (...args) => {
 };
 process.on("uncaughtException", console.error);
 process.on("unhandledRejection", console.error);
-connection2.onInitialize(() => {
+connection2.onInitialize(async (params) => {
   setup(connection2);
+  await service.initialize(params);
   return {
     capabilities: {
       textDocumentSync: import_node.TextDocumentSyncKind.Incremental,
       documentFormattingProvider: true,
       definitionProvider: true,
       hoverProvider: true,
+      renameProvider: true,
+      codeActionProvider: true,
+      referencesProvider: true,
+      documentLinkProvider: { resolveProvider: false },
+      colorProvider: true,
+      documentHighlightProvider: true,
       completionProvider: {
         triggerCharacters: [
           ".",
@@ -1505,9 +2139,30 @@ connection2.onCompletion(async (params, cancel) => {
 connection2.onDefinition(async (params, cancel) => {
   return await service.findDefinition(documents.get(params.textDocument.uri), params, cancel) || null;
 });
+connection2.onReferences(async (params, cancel) => {
+  return await service.findReferences(documents.get(params.textDocument.uri), params, cancel) || null;
+});
+connection2.onDocumentLinks(async (params, cancel) => {
+  return await service.findDocumentLinks(documents.get(params.textDocument.uri), params, cancel) || null;
+});
+connection2.onDocumentHighlight(async (params, cancel) => {
+  return await service.findDocumentHighlights(documents.get(params.textDocument.uri), params, cancel) || null;
+});
+connection2.onDocumentColor(async (params, cancel) => {
+  return await service.findDocumentColors(documents.get(params.textDocument.uri), params, cancel) || null;
+});
+connection2.onColorPresentation(async (params, cancel) => {
+  return await service.getColorPresentations(documents.get(params.textDocument.uri), params, cancel) || null;
+});
 connection2.onHover(async (params, cancel) => {
   return await service.doHover(documents.get(params.textDocument.uri), params, cancel) || null;
 });
+connection2.onRenameRequest(async (params, cancel) => {
+  return await service.doRename(documents.get(params.textDocument.uri), params, cancel) || null;
+});
+connection2.onCodeAction(async (params, cancel) => {
+  return await service.doCodeActions(documents.get(params.textDocument.uri), params, cancel) || null;
+});
 connection2.onDocumentFormatting(async (params, cancel) => {
   return await service.format(documents.get(params.textDocument.uri), params, cancel) || null;
 });