modern-monaco 0.2.0 → 0.2.2

package/dist/cache.mjs

@@ -1,5 +1,5 @@
 // src/cache.ts
-import { defineProperty, openIDB, promisifyIDBRequest, toURL } from "./util.mjs";
+import { defineProperty, normalizeURL, openIDB, promisifyIDBRequest } from "./util.mjs";
 var IndexedDB = class {
   #db;
   constructor(name) {
@@ -43,7 +43,7 @@ var Cache = class {
     }
   }
   async fetch(url) {
-    url = toURL(url);
+    url = normalizeURL(url);
     const storedRes = await this.query(url);
     if (storedRes) {
       return storedRes;
@@ -75,7 +75,7 @@ var Cache = class {
     return res;
   }
   async query(key) {
-    const url = toURL(key).href;
+    const url = normalizeURL(key).href;
     const file = await this._db.get(url);
     if (file && file.headers) {
       const headers = new Headers(file.headers);

package/dist/core.mjs

@@ -1,42 +1,55 @@
-// src/core.ts
-import { getExtnameFromLanguageId, getLanguageIdFromPath, grammars, initShiki, setDefaultWasmLoader, themes } from "./shiki.mjs";
-import { initShikiMonacoTokenizer, registerShikiMonacoTokenizer } from "./shiki.mjs";
-import { render } from "./shiki.mjs";
-import { getWasmInstance } from "./shiki-wasm.mjs";
-import { ErrorNotFound, Workspace } from "./workspace.mjs";
-
-// src/util.ts
-var dec = /* @__PURE__ */ new TextDecoder();
-function decode(data) {
-  return data instanceof Uint8Array ? dec.decode(data) : data;
+// node_modules/.pnpm/@esm.sh+import-map@0.1.1/node_modules/@esm.sh/import-map/dist/import-map.mjs
+function parseImportMapFromJson(json, baseURL) {
+  const importMap = {
+    $baseURL: new URL(baseURL ?? ".", "file:///").href,
+    imports: {},
+    scopes: {}
+  };
+  const v = JSON.parse(json);
+  if (isObject(v)) {
+    const { imports, scopes } = v;
+    if (isObject(imports)) {
+      validateImports(imports);
+      importMap.imports = imports;
+    }
+    if (isObject(scopes)) {
+      validateScopes(scopes);
+      importMap.scopes = scopes;
+    }
+  }
+  return importMap;
 }
-function isDigital(v) {
-  return typeof v === "number" || typeof v === "string" && /^\d+$/.test(v);
+function validateImports(imports) {
+  for (const [k, v] of Object.entries(imports)) {
+    if (!v || typeof v !== "string") {
+      delete imports[k];
+    }
+  }
 }
-function debunce(fn, delay) {
-  let timer = null;
-  return () => {
-    if (timer !== null) {
-      clearTimeout(timer);
+function validateScopes(imports) {
+  for (const [k, v] of Object.entries(imports)) {
+    if (isObject(v)) {
+      validateImports(v);
+    } else {
+      delete imports[k];
     }
-    timer = setTimeout(() => {
-      timer = null;
-      fn();
-    }, delay);
-  };
+  }
 }
-function promiseWithResolvers() {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve, reject };
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 
+// package.json
+var version = "0.2.2";
+
 // src/core.ts
-import { init as initLS } from "./lsp/language-service.mjs";
+import { getExtnameFromLanguageId, getLanguageIdFromPath, grammars, initShiki, setDefaultWasmLoader, themes } from "./shiki.mjs";
+import { initShikiMonacoTokenizer, registerShikiMonacoTokenizer } from "./shiki.mjs";
+import { render } from "./shiki.mjs";
+import { getWasmInstance } from "./shiki-wasm.mjs";
+import { ErrorNotFound, Workspace } from "./workspace.mjs";
+import { debunce, decode, isDigital } from "./util.mjs";
+import { init as initLspClient } from "./lsp/client.mjs";
 var editorProps = [
   "autoDetectHighContrast",
   "automaticLayout",
@@ -71,9 +84,9 @@ var editorProps = [
 var errors = {
   NotFound: ErrorNotFound
 };
+var cdnUrl = `https://esm.sh/modern-monaco@${version}`;
 var syntaxes = [];
 var lspProviders = {};
-var { promise: editorWorkerPromise, resolve: onDidEditorWorkerResolve } = promiseWithResolvers();
 var attr = (el, name) => el.getAttribute(name);
 var style = (el, style2) => Object.assign(el.style, style2);
 async function init(options) {
@@ -243,7 +256,7 @@ async function lazy(options) {
               }
             }
           }
-          async function createEditor() {
+          {
             const monaco = await (monacoPromise ?? (monacoPromise = loadMonaco(highlighter, workspace, options?.lsp)));
             const editor = monaco.editor.create(containerEl, renderOptions);
             if (workspace) {
@@ -300,34 +313,49 @@ async function lazy(options) {
               editor.setModel(monaco.editor.createModel(""));
             }
             if (prerenderEl) {
-              editorWorkerPromise.then(() => {
-                setTimeout(() => {
-                  const animate = prerenderEl.animate?.([{ opacity: 1 }, { opacity: 0 }], { duration: 150 });
-                  if (animate) {
-                    animate.finished.then(() => prerenderEl.remove());
-                  } else {
-                    setTimeout(() => prerenderEl.remove(), 150);
-                  }
-                }, 100);
-              });
+              setTimeout(() => {
+                const animate = prerenderEl.animate?.([{ opacity: 1 }, { opacity: 0 }], { duration: 200 });
+                if (animate) {
+                  animate.finished.then(() => prerenderEl.remove());
+                } else {
+                  setTimeout(() => prerenderEl.remove(), 200);
+                }
+              }, 200);
             }
           }
-          await createEditor();
         }
       }
     );
   }
-  await editorWorkerPromise;
 }
 function hydrate(options) {
   return lazy(options);
 }
 async function loadMonaco(highlighter, workspace, lsp) {
-  const monaco = await import("./editor-core.mjs");
-  const lspProviderMap = { ...lspProviders, ...lsp?.providers };
+  let importmap = null;
+  let editorCoreModuleUrl = `${cdnUrl}/es2022/editor-core.mjs`;
+  let lspModuleUrl = `${cdnUrl}/es2022/lsp.mjs`;
+  if (importmap = document.querySelector("script[type='importmap']")) {
+    try {
+      const { imports = {} } = parseImportMapFromJson(importmap.textContent);
+      if (imports["modern-monaco/editor-core"]) {
+        editorCoreModuleUrl = imports["modern-monaco/editor-core"];
+      }
+      if (imports["modern-monaco/lsp"]) {
+        lspModuleUrl = imports["modern-monaco/lsp"];
+      }
+    } catch (error) {
+    }
+  }
+  const builtinLSP = globalThis.MonacoEnvironment?.builtinLSP;
+  const [monaco, { builtinLSPProviders }] = await Promise.all([
+    import(editorCoreModuleUrl),
+    builtinLSP ? import(lspModuleUrl) : Promise.resolve({ builtinLSPProviders: {} })
+  ]);
+  const lspProviderMap = { ...builtinLSPProviders, ...lspProviders, ...lsp?.providers };
   workspace?.setupMonaco(monaco);
   if (Object.keys(lspProviderMap).length > 0) {
-    initLS(monaco);
+    initLspClient(monaco);
   }
   if (!document.getElementById("monaco-editor-core-css")) {
     const styleEl = document.createElement("style");
@@ -339,13 +367,7 @@ async function loadMonaco(highlighter, workspace, lsp) {
   Reflect.set(globalThis, "MonacoEnvironment", {
     getWorker: async (_workerId, label) => {
       if (label === "editorWorkerService") {
-        const worker = monaco.createEditorWorkerMain();
-        const onMessage = (e) => {
-          worker.removeEventListener("message", onMessage);
-          onDidEditorWorkerResolve();
-        };
-        worker.addEventListener("message", onMessage);
-        return worker;
+        return monaco.createEditorWorkerMain();
       }
     },
     getLanguageIdFromUri: (uri) => getLanguageIdFromPath(uri.path),

package/dist/editor-core.mjs

@@ -198377,10 +198377,10 @@ function createEditorWorkerMain() {
   if (workerUrl.origin !== location.origin) {
     return new Worker(
       URL.createObjectURL(new Blob([`import "${workerUrl.href}"`], { type: "application/javascript" })),
-      { type: "module" }
+      { type: "module", name: "editor-worker-main" }
     );
   }
-  return new Worker(new URL("./editor-worker-main.mjs", import.meta.url), { type: "module" });
+  return new Worker(workerUrl, { type: "module", name: "editor-worker-main" });
 }
 export {
   CancellationTokenSource2 as CancellationTokenSource,

package/dist/index.mjs

@@ -693,28 +693,6 @@ var vitesse_dark_default = {
   type: "dark"
 };
 
-// src/lsp/index.ts
-var builtinLSPProviders = {
-  html: {
-    // @ts-expect-error 'setup.js' is generated at build time
-    import: () => import("./lsp/html/setup.mjs")
-  },
-  css: {
-    aliases: ["less", "sass"],
-    // @ts-expect-error 'setup.js' is generated at build time
-    import: () => import("./lsp/css/setup.mjs")
-  },
-  json: {
-    // @ts-expect-error 'setup.js' is generated at build time
-    import: () => import("./lsp/json/setup.mjs")
-  },
-  typescript: {
-    aliases: ["javascript", "jsx", "tsx"],
-    // @ts-expect-error 'setup.js' is generated at build time
-    import: () => import("./lsp/typescript/setup.mjs")
-  }
-};
-
 // node_modules/.pnpm/tm-grammars@1.24.10/node_modules/tm-grammars/grammars/html.json
 var html_default = {
   displayName: "HTML",
@@ -29343,15 +29321,13 @@ var syntaxes = [
 ];
 
 // src/index.ts
-import { registerLSPProvider, registerSyntax, registerTheme } from "./core.mjs";
+import { registerSyntax, registerTheme } from "./core.mjs";
 import { errors, hydrate, init, lazy, Workspace } from "./core.mjs";
-for (const [lang, provider] of Object.entries(builtinLSPProviders)) {
-  registerLSPProvider(lang, provider);
-}
 for (const syntax of syntaxes) {
   registerSyntax(syntax);
 }
 registerTheme(vitesse_dark_default);
+Reflect.set(globalThis, "MonacoEnvironment", { builtinLSP: true });
 export {
   Workspace,
   errors,

package/dist/lsp/{language-service.mjs → client.mjs}

@@ -1181,7 +1181,7 @@ var Is;
   Is2.typedArray = typedArray;
 })(Is || (Is = {}));
 
-// src/lsp/language-service.ts
+// src/lsp/client.ts
 import { cache } from "../cache.mjs";
 var monaco;
 function init(monacoNS) {
@@ -1222,7 +1222,7 @@ function registerBasicFeatures(languageId, worker, completionTriggerCharacters,
   const { editor, languages } = monaco;
   const onDispose = async (model) => {
     const workerProxy = await worker.withSyncedResources([]);
-    workerProxy.removeDocumentCache(model.uri.toString());
+    workerProxy.releaseDocument(model.uri.toString());
   };
   editor.onDidChangeModelLanguage(({ model, oldLanguage }) => {
     if (oldLanguage === languageId) {
@@ -1263,12 +1263,6 @@ function registerBasicFeatures(languageId, worker, completionTriggerCharacters,
         worker.getProxy().then((proxy) => proxy.fsNotify(kind, path, type));
       }
     });
-    (async () => {
-      const workerProxy = await worker.getProxy();
-      for await (const [path, type] of workspace.fs.walk()) {
-        workerProxy.fsNotify("create", path, type);
-      }
-    })();
   }
 }
 function registerDiagnostics(languageId, worker) {

package/dist/lsp/css/setup.mjs

@@ -1,5 +1,6 @@
 // src/lsp/css/setup.ts
-import * as ls from "../language-service.mjs";
+import { walk } from "../../workspace.mjs";
+import * as client from "../client.mjs";
 async function setup(monaco, languageId, languageSettings, formattingOptions, workspace) {
   const { tabSize, insertSpaces, insertFinalNewline, trimFinalNewlines } = formattingOptions ?? {};
   const createData = {
@@ -18,26 +19,26 @@ async function setup(monaco, languageId, languageSettings, formattingOptions, wo
       spaceAroundSelectorSeparator: false,
       braceStyle: "collapse"
     },
-    workspace: !!workspace
+    fs: workspace ? await walk(workspace.fs, "/") : void 0
   };
   const worker = monaco.editor.createWebWorker({
     worker: getWorker(createData),
-    host: ls.createHost(workspace)
+    host: client.createHost(workspace)
   });
-  ls.registerBasicFeatures(languageId, worker, ["/", "-", ":", "("], workspace);
-  ls.registerCodeAction(languageId, worker);
-  ls.registerColorPresentation(languageId, worker);
-  ls.registerDocumentLinks(languageId, worker);
+  client.registerBasicFeatures(languageId, worker, ["/", "-", ":", "("], workspace);
+  client.registerCodeAction(languageId, worker);
+  client.registerColorPresentation(languageId, worker);
+  client.registerDocumentLinks(languageId, worker);
 }
 function createWebWorker() {
   const workerUrl = new URL("./worker.mjs", import.meta.url);
   if (workerUrl.origin !== location.origin) {
     return new Worker(
       URL.createObjectURL(new Blob([`import "${workerUrl.href}"`], { type: "application/javascript" })),
-      { type: "module" }
+      { type: "module", name: "css-worker" }
     );
   }
-  return new Worker(new URL("./worker.mjs", import.meta.url), { type: "module" });
+  return new Worker(workerUrl, { type: "module", name: "css-worker" });
 }
 function getWorker(createData) {
   const worker = createWebWorker();

package/dist/lsp/css/worker.mjs

@@ -48125,21 +48125,36 @@ function getLESSLanguageService(options = defaultLanguageServiceOptions) {
 
 // src/lsp/worker-base.ts
 var WorkerBase = class {
-  constructor(_ctx, _createData, _createLanguageDocument) {
-    this._ctx = _ctx;
-    this._createData = _createData;
-    this._createLanguageDocument = _createLanguageDocument;
-  }
-  #documentCache = /* @__PURE__ */ new Map();
+  #ctx;
   #fs;
+  #documentCache = /* @__PURE__ */ new Map();
+  #createLanguageDocument;
+  constructor(ctx, createData, createLanguageDocument) {
+    this.#ctx = ctx;
+    if (createData.fs) {
+      const dirs = /* @__PURE__ */ new Set(["/"]);
+      this.#fs = new Map(createData.fs.map((path) => {
+        const dir = path.slice(0, path.lastIndexOf("/"));
+        if (dir) {
+          dirs.add(dir);
+        }
+        return ["file://" + path, 1];
+      }));
+      for (const dir of dirs) {
+        this.#fs.set("file://" + dir, 2);
+      }
+      createData.fs.length = 0;
+    }
+    this.#createLanguageDocument = createLanguageDocument;
+  }
   get hasFileSystemProvider() {
-    return !!this._createData.workspace;
+    return !!this.#fs;
   }
   get host() {
-    return this._ctx.host;
+    return this.#ctx.host;
   }
   getMirrorModels() {
-    return this._ctx.getMirrorModels();
+    return this.#ctx.getMirrorModels();
   }
   hasModel(fileName) {
     const models = this.getMirrorModels();
@@ -48180,10 +48195,10 @@ var WorkerBase = class {
     if (cached && cached[0] === version && cached[2]) {
       return cached[2];
     }
-    if (!this._createLanguageDocument) {
+    if (!this.#createLanguageDocument) {
       throw new Error("createLanguageDocument is not provided");
     }
-    const languageDocument = this._createLanguageDocument(document);
+    const languageDocument = this.#createLanguageDocument(document);
     this.#documentCache.set(uri, [version, document, languageDocument]);
     return languageDocument;
   }
@@ -48194,10 +48209,12 @@ var WorkerBase = class {
         if (path.startsWith(uri)) {
           const name = path.slice(uri.length);
           if (!name.includes("/")) {
-            if (type === 2) {
-              entries.push([name, 2 /* Directory */]);
-            } else if (!extensions || extensions.some((ext) => name.endsWith(ext))) {
-              entries.push([name, 1 /* File */]);
+            if (type === 1) {
+              if (!extensions || extensions.some((ext) => name.endsWith(ext))) {
+                entries.push([name, 1]);
+              }
+            } else if (type === 2) {
+              entries.push([name, 2]);
             }
           }
         }
@@ -48206,8 +48223,8 @@ var WorkerBase = class {
     return entries;
   }
   getFileSystemProvider() {
-    if (this.hasFileSystemProvider) {
-      const host = this._ctx.host;
+    if (this.#fs) {
+      const host = this.#ctx.host;
       return {
         readDirectory: (uri) => {
           return Promise.resolve(this.readDir(uri));
@@ -48224,29 +48241,27 @@ var WorkerBase = class {
   }
   // resolveReference implementes the `DocumentContext` interface
   resolveReference(ref, baseUrl) {
-    const url = new URL(ref, baseUrl);
-    const href = url.href;
-    if (url.protocol === "file:" && url.pathname !== "/" && this.#fs && !this.#fs.has(href.endsWith("/") ? href.slice(0, -1) : href)) {
+    const { protocol, pathname, href } = new URL(ref, baseUrl);
+    if (protocol === "file:" && pathname !== "/" && this.#fs && !this.#fs.has(href.endsWith("/") ? href.slice(0, -1) : href)) {
       return void 0;
     }
     return href;
   }
   // #region methods used by the host
-  async removeDocumentCache(uri) {
+  async releaseDocument(uri) {
     this.#documentCache.delete(uri);
   }
   async fsNotify(kind, path, type) {
-    const url = "file://" + path;
-    const entries = this.#fs ?? (this.#fs = /* @__PURE__ */ new Map());
+    const fs = this.#fs ?? (this.#fs = /* @__PURE__ */ new Map());
     if (kind === "create") {
       if (type) {
-        entries.set(url, type);
+        fs.set(path, type);
       }
     } else if (kind === "remove") {
-      if (entries.get(url) === 1 /* File */) {
-        this.#documentCache.delete(url);
+      if (fs.get(path) === 1) {
+        this.#documentCache.delete(path);
       }
-      entries.delete(url);
+      fs.delete(path);
     }
   }
   // #endregion

package/dist/lsp/html/setup.mjs

@@ -1,5 +1,6 @@
 // src/lsp/html/setup.ts
-import * as ls from "../language-service.mjs";
+import { walk } from "../../workspace.mjs";
+import * as client from "../client.mjs";
 async function setup(monaco, languageId, languageSettings, formattingOptions, workspace) {
   const { editor, languages } = monaco;
   const { tabSize, insertSpaces, insertFinalNewline, trimFinalNewlines } = formattingOptions ?? {};
@@ -26,18 +27,18 @@ async function setup(monaco, languageId, languageSettings, formattingOptions, wo
       useDefaultDataProvider: true,
       dataProviders: Array.isArray(languageSettings?.customTags) ? { custom: { version: 1.1, tags: languageSettings.customTags } } : void 0
     },
-    workspace: !!workspace
+    fs: workspace ? await walk(workspace.fs, "/") : void 0
   };
   const htmlWorker = editor.createWebWorker({
     worker: getWorker(createData),
-    host: ls.createHost(workspace)
+    host: client.createHost(workspace)
   });
-  const workerWithEmbeddedLanguages = ls.createWorkerWithEmbeddedLanguages(htmlWorker);
-  ls.registerEmbedded(languageId, workerWithEmbeddedLanguages, ["css", "javascript", "importmap"]);
-  ls.registerBasicFeatures(languageId, workerWithEmbeddedLanguages, ["<", "/", "=", '"'], workspace);
-  ls.registerAutoComplete(languageId, workerWithEmbeddedLanguages, [">", "/", "="]);
-  ls.registerColorPresentation(languageId, workerWithEmbeddedLanguages);
-  ls.registerDocumentLinks(languageId, workerWithEmbeddedLanguages);
+  const workerWithEmbeddedLanguages = client.createWorkerWithEmbeddedLanguages(htmlWorker);
+  client.registerEmbedded(languageId, workerWithEmbeddedLanguages, ["css", "javascript", "importmap"]);
+  client.registerBasicFeatures(languageId, workerWithEmbeddedLanguages, ["<", "/", "=", '"'], workspace);
+  client.registerAutoComplete(languageId, workerWithEmbeddedLanguages, [">", "/", "="]);
+  client.registerColorPresentation(languageId, workerWithEmbeddedLanguages);
+  client.registerDocumentLinks(languageId, workerWithEmbeddedLanguages);
   languages.registerCodeLensProvider(languageId, {
     provideCodeLenses: (model, _token) => {
       const m = model.findNextMatch(
@@ -81,10 +82,10 @@ function createWebWorker() {
   if (workerUrl.origin !== location.origin) {
     return new Worker(
       URL.createObjectURL(new Blob([`import "${workerUrl.href}"`], { type: "application/javascript" })),
-      { type: "module" }
+      { type: "module", name: "html-worker" }
     );
   }
-  return new Worker(new URL("./worker.mjs", import.meta.url), { type: "module" });
+  return new Worker(workerUrl, { type: "module", name: "html-worker" });
 }
 function getWorker(createData) {
   const worker = createWebWorker();

package/dist/lsp/html/worker.mjs

@@ -22052,21 +22052,36 @@ function getAttributeLanguage(attributeName) {
 
 // src/lsp/worker-base.ts
 var WorkerBase = class {
-  constructor(_ctx, _createData, _createLanguageDocument) {
-    this._ctx = _ctx;
-    this._createData = _createData;
-    this._createLanguageDocument = _createLanguageDocument;
-  }
-  #documentCache = /* @__PURE__ */ new Map();
+  #ctx;
   #fs;
+  #documentCache = /* @__PURE__ */ new Map();
+  #createLanguageDocument;
+  constructor(ctx, createData, createLanguageDocument) {
+    this.#ctx = ctx;
+    if (createData.fs) {
+      const dirs = /* @__PURE__ */ new Set(["/"]);
+      this.#fs = new Map(createData.fs.map((path) => {
+        const dir = path.slice(0, path.lastIndexOf("/"));
+        if (dir) {
+          dirs.add(dir);
+        }
+        return ["file://" + path, 1];
+      }));
+      for (const dir of dirs) {
+        this.#fs.set("file://" + dir, 2);
+      }
+      createData.fs.length = 0;
+    }
+    this.#createLanguageDocument = createLanguageDocument;
+  }
   get hasFileSystemProvider() {
-    return !!this._createData.workspace;
+    return !!this.#fs;
   }
   get host() {
-    return this._ctx.host;
+    return this.#ctx.host;
   }
   getMirrorModels() {
-    return this._ctx.getMirrorModels();
+    return this.#ctx.getMirrorModels();
   }
   hasModel(fileName) {
     const models = this.getMirrorModels();
@@ -22107,10 +22122,10 @@ var WorkerBase = class {
     if (cached && cached[0] === version && cached[2]) {
       return cached[2];
     }
-    if (!this._createLanguageDocument) {
+    if (!this.#createLanguageDocument) {
       throw new Error("createLanguageDocument is not provided");
     }
-    const languageDocument = this._createLanguageDocument(document);
+    const languageDocument = this.#createLanguageDocument(document);
     this.#documentCache.set(uri, [version, document, languageDocument]);
     return languageDocument;
   }
@@ -22121,10 +22136,12 @@ var WorkerBase = class {
         if (path.startsWith(uri)) {
           const name = path.slice(uri.length);
           if (!name.includes("/")) {
-            if (type === 2) {
-              entries.push([name, 2 /* Directory */]);
-            } else if (!extensions || extensions.some((ext) => name.endsWith(ext))) {
-              entries.push([name, 1 /* File */]);
+            if (type === 1) {
+              if (!extensions || extensions.some((ext) => name.endsWith(ext))) {
+                entries.push([name, 1]);
+              }
+            } else if (type === 2) {
+              entries.push([name, 2]);
             }
           }
         }
@@ -22133,8 +22150,8 @@ var WorkerBase = class {
     return entries;
   }
   getFileSystemProvider() {
-    if (this.hasFileSystemProvider) {
-      const host = this._ctx.host;
+    if (this.#fs) {
+      const host = this.#ctx.host;
       return {
         readDirectory: (uri) => {
           return Promise.resolve(this.readDir(uri));
@@ -22151,29 +22168,27 @@ var WorkerBase = class {
   }
   // resolveReference implementes the `DocumentContext` interface
   resolveReference(ref, baseUrl) {
-    const url = new URL(ref, baseUrl);
-    const href = url.href;
-    if (url.protocol === "file:" && url.pathname !== "/" && this.#fs && !this.#fs.has(href.endsWith("/") ? href.slice(0, -1) : href)) {
+    const { protocol, pathname, href } = new URL(ref, baseUrl);
+    if (protocol === "file:" && pathname !== "/" && this.#fs && !this.#fs.has(href.endsWith("/") ? href.slice(0, -1) : href)) {
       return void 0;
     }
     return href;
   }
   // #region methods used by the host
-  async removeDocumentCache(uri) {
+  async releaseDocument(uri) {
     this.#documentCache.delete(uri);
   }
   async fsNotify(kind, path, type) {
-    const url = "file://" + path;
-    const entries = this.#fs ?? (this.#fs = /* @__PURE__ */ new Map());
+    const fs = this.#fs ?? (this.#fs = /* @__PURE__ */ new Map());
     if (kind === "create") {
       if (type) {
-        entries.set(url, type);
+        fs.set(path, type);
       }
     } else if (kind === "remove") {
-      if (entries.get(url) === 1 /* File */) {
-        this.#documentCache.delete(url);
+      if (fs.get(path) === 1) {
+        this.#documentCache.delete(path);
       }
-      entries.delete(url);
+      fs.delete(path);
     }
   }
   // #endregion

package/dist/lsp/index.mjs

@@ -0,0 +1,20 @@
+// src/lsp/index.ts
+var builtinLSPProviders = {
+  html: {
+    import: () => import("./html/setup.mjs")
+  },
+  css: {
+    aliases: ["less", "sass"],
+    import: () => import("./css/setup.mjs")
+  },
+  json: {
+    import: () => import("./json/setup.mjs")
+  },
+  typescript: {
+    aliases: ["javascript", "jsx", "tsx"],
+    import: () => import("./typescript/setup.mjs")
+  }
+};
+export {
+  builtinLSPProviders
+};