modern-monaco 0.2.1 → 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
+};

package/dist/lsp/json/setup.mjs

@@ -111,7 +111,8 @@ var schemas = [
 ];
 
 // src/lsp/json/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 createData = {
@@ -132,11 +133,11 @@ async function setup(monaco, languageId, languageSettings, formattingOptions, wo
       trimFinalNewlines: true,
       ...formattingOptions
     },
-    workspace: !!workspace
+    fs: workspace ? await walk(workspace.fs, "/") : void 0
   };
   const worker = editor.createWebWorker({
     worker: getWorker(createData),
-    host: ls.createHost(workspace)
+    host: client.createHost(workspace)
   });
   const resetSchema = async (uri) => {
     (await worker.getProxy()).resetSchema(uri.toString());
@@ -151,9 +152,9 @@ async function setup(monaco, languageId, languageSettings, formattingOptions, wo
       resetSchema(event.model.uri);
     }
   });
-  ls.registerBasicFeatures(languageId, worker, [" ", ":", '"'], workspace);
-  ls.registerColorPresentation(languageId, worker);
-  ls.registerDocumentLinks(languageId, worker);
+  client.registerBasicFeatures(languageId, worker, [" ", ":", '"'], workspace);
+  client.registerColorPresentation(languageId, worker);
+  client.registerDocumentLinks(languageId, worker);
   languages.registerCodeLensProvider(languageId, {
     provideCodeLenses: function(model, _token) {
       const isImportMap = model.uri.scheme == "file" && ["importmap.json", "import_map.json", "import-map.json", "importMap.json"].some((name) => model.uri.path === "/" + name);
@@ -249,10 +250,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: "json-worker" }
     );
   }
-  return new Worker(new URL("./worker.mjs", import.meta.url), { type: "module" });
+  return new Worker(workerUrl, { type: "module", name: "json-worker" });
 }
 function getWorker(createData) {
   const worker = createWebWorker();

package/dist/lsp/json/worker.mjs

@@ -7682,21 +7682,36 @@ function getLanguageService(params) {
 
 // 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();
@@ -7737,10 +7752,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;
   }
@@ -7751,10 +7766,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]);
             }
           }
         }
@@ -7763,8 +7780,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));
@@ -7781,29 +7798,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/typescript/setup.mjs

@@ -95,8 +95,8 @@ function isSameImports(a, b) {
 
 // src/lsp/typescript/setup.ts
 import { cache } from "../../cache.mjs";
-import { ErrorNotFound } from "../../workspace.mjs";
-import * as ls from "../language-service.mjs";
+import { ErrorNotFound, walk } from "../../workspace.mjs";
+import * as client from "../client.mjs";
 var worker = null;
 async function setup(monaco, languageId, languageSettings, formattingOptions, workspace) {
   if (!worker) {
@@ -105,10 +105,10 @@ async function setup(monaco, languageId, languageSettings, formattingOptions, wo
   if (worker instanceof Promise) {
     worker = await worker;
   }
-  ls.registerBasicFeatures(languageId, worker, [".", "/", '"', "'", "<"], workspace);
-  ls.registerAutoComplete(languageId, worker, [">", "/"]);
-  ls.registerSignatureHelp(languageId, worker, ["(", ","]);
-  ls.registerCodeAction(languageId, worker);
+  client.registerBasicFeatures(languageId, worker, [".", "/", '"', "'", "<"], workspace);
+  client.registerAutoComplete(languageId, worker, [">", "/"]);
+  client.registerSignatureHelp(languageId, worker, ["(", ","]);
+  client.registerCodeAction(languageId, worker);
 }
 async function createWorker(monaco, workspace, languageSettings, formattingOptions) {
   const fs = workspace?.fs;
@@ -168,7 +168,7 @@ async function createWorker(monaco, workspace, languageSettings, formattingOptio
     },
     importMap,
     types: typesStore.types,
-    workspace: !!workspace
+    fs: workspace ? await walk(workspace.fs, "/") : void 0
   };
   const worker2 = monaco.editor.createWebWorker({
     worker: getWorker(createData),
@@ -282,10 +282,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: "typescript-worker" }
     );
   }
-  return new Worker(new URL("./worker.mjs", import.meta.url), { type: "module" });
+  return new Worker(workerUrl, { type: "module", name: "typescript-worker" });
 }
 function getWorker(createData) {
   const worker2 = createWebWorker();

package/dist/lsp/typescript/worker.mjs

@@ -1466,21 +1466,36 @@ function getWellformedEdit(textEdit) {
 
 // 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();
@@ -1521,10 +1536,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(document2);
+    const languageDocument = this.#createLanguageDocument(document2);
     this.#documentCache.set(uri, [version, document2, languageDocument]);
     return languageDocument;
   }
@@ -1535,10 +1550,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]);
             }
           }
         }
@@ -1547,8 +1564,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));
@@ -1565,29 +1582,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
@@ -1639,14 +1654,14 @@ var TypeScriptWorker = class extends WorkerBase {
       const dirname = path.slice("file:///node_modules/".length);
       return Object.keys(this.#importMap.imports).filter((key) => key !== "@jsxRuntime" && (dirname.length === 0 || key.startsWith(dirname))).map((key) => dirname.length > 0 ? key.slice(dirname.length) : key).filter((key) => key !== "/" && key.includes("/")).map((key) => key.split("/")[0]);
     }
-    return this.readDir(path).filter(([_, type]) => type === 2 /* Directory */).map(([name, _]) => name);
+    return this.readDir(path).filter(([_, type]) => type === 2).map(([name, _]) => name);
   }
   readDirectory(path, extensions, exclude, include, depth) {
     if (path.startsWith("file:///node_modules/")) {
       const dirname = path.slice("file:///node_modules/".length);
       return Object.keys(this.#importMap.imports).filter((key) => key !== "@jsxRuntime" && (dirname.length === 0 || key.startsWith(dirname))).map((key) => dirname.length > 0 ? key.slice(dirname.length) : key).filter((key) => !key.includes("/"));
     }
-    return this.readDir(path, extensions).filter(([_, type]) => type === 1 /* File */).map(([name, _]) => name);
+    return this.readDir(path, extensions).filter(([_, type]) => type === 1).map(([name, _]) => name);
   }
   fileExists(filename) {
     if (filename.startsWith("/node_modules/")) return false;
@@ -2298,7 +2313,7 @@ var TypeScriptWorker = class extends WorkerBase {
     if (types) {
       for (const uri of Object.keys(this.#types)) {
         if (!(uri in types)) {
-          this.removeDocumentCache(uri);
+          this.releaseDocument(uri);
         }
       }
       this.#types = types;

package/dist/shiki.mjs

@@ -7917,7 +7917,7 @@ function hashCode(s) {
   return [...s].reduce((hash, c) => Math.imul(31, hash) + c.charCodeAt(0) | 0, 0);
 }
 function normalizeFontFamily(fontFamily) {
-  return fontFamily.split(",").map((f) => f.replace(/['"]+/g, "").trim()).filter(Boolean).map((f) => f.includes(" ") ? `'${f}'` : f).join(", ");
+  return fontFamily.split(",").map((f) => f.trim().replace(/['"]+/g, "")).filter(Boolean).map((f) => f.includes(" ") ? `'${f}'` : f).join(", ");
 }
 
 // src/shiki-monaco.ts
@@ -8117,7 +8117,7 @@ function loadTMTheme(src, cdn = "https://esm.sh") {
     return cache.fetch(url2).then((res) => res.json());
   }
   const url = typeof src === "string" ? new URL(src, globalThis.location?.href) : src;
-  if (url.protocol === "http" || url.protocol === "https") {
+  if (url.protocol === "http:" || url.protocol === "https:") {
     return cache.fetch(url).then((res) => res.json());
   }
   throw new Error(`Unsupported theme source: ${src}`);
@@ -8131,7 +8131,7 @@ function loadTMGrammar(src, cdn = "https://esm.sh") {
     }
   }
   const url = typeof src === "string" ? new URL(src, globalThis.location?.href) : src;
-  if (url.protocol === "http" || url.protocol === "https") {
+  if (url.protocol === "http:" || url.protocol === "https:") {
     return cache.fetch(url).then((res) => res.json());
   }
   throw new Error(`Unsupported grammar source: ${src}`);

package/dist/util.mjs

@@ -10,7 +10,7 @@ function decode(data) {
 function defineProperty(obj, prop, value) {
   Object.defineProperty(obj, prop, { value });
 }
-function toURL(uri) {
+function normalizeURL(uri) {
   return uri instanceof URL ? uri : new URL(uri, "file:///");
 }
 function filenameToURL(filename) {
@@ -131,10 +131,10 @@ function promisifyIDBRequest(req) {
   });
 }
 async function openIDB(name, version = 1, ...stores) {
-  const req = indexedDB.open(name, version);
+  const openRequest = indexedDB.open(name, version);
   const promises = [];
-  req.onupgradeneeded = () => {
-    const db2 = req.result;
+  openRequest.onupgradeneeded = () => {
+    const db2 = openRequest.result;
     for (const { name: name2, keyPath, onCreate } of stores) {
       if (!db2.objectStoreNames.contains(name2)) {
         const store = db2.createObjectStore(name2, { keyPath });
@@ -144,15 +144,15 @@ async function openIDB(name, version = 1, ...stores) {
       }
     }
   };
-  const db = await promisifyIDBRequest(req);
+  const db = await promisifyIDBRequest(openRequest);
   await Promise.all(promises);
   return db;
 }
 function openIDBCursor(store, range, callback, direction) {
   return new Promise((resolve, reject) => {
-    const ocr = store.openCursor(range, direction);
-    ocr.onsuccess = () => {
-      const cursor = ocr.result;
+    const corsor = store.openCursor(range, direction);
+    corsor.onsuccess = () => {
+      const cursor = corsor.result;
       if (cursor) {
         if (callback(cursor) !== false) {
           cursor.continue();
@@ -161,12 +161,15 @@ function openIDBCursor(store, range, callback, direction) {
       }
       resolve();
     };
-    ocr.onerror = () => {
-      reject(ocr.error);
+    corsor.onerror = () => {
+      reject(corsor.error);
     };
   });
 }
 function promiseWithResolvers() {
+  if (Promise.withResolvers) {
+    return Promise.withResolvers();
+  }
   let resolve;
   let reject;
   const promise = new Promise((res, rej) => {
@@ -187,10 +190,10 @@ export {
   filenameToURL,
   isDigital,
   isPlainObject,
+  normalizeURL,
   openIDB,
   openIDBCursor,
   promiseWithResolvers,
   promisifyIDBRequest,
-  supportLocalStorage,
-  toURL
+  supportLocalStorage
 };

package/dist/workspace.mjs

@@ -5,12 +5,12 @@ import {
   decode,
   encode,
   filenameToURL,
+  normalizeURL,
   openIDB,
   openIDBCursor,
   promiseWithResolvers,
   promisifyIDBRequest,
-  supportLocalStorage,
-  toURL
+  supportLocalStorage
 } from "./util.mjs";
 var Workspace = class {
   _monaco;
@@ -21,14 +21,14 @@ var Workspace = class {
   constructor(options = {}) {
     const { name = "default", browserHistory, initialFiles, entryFile, customFS } = options;
     this._monaco = promiseWithResolvers();
-    this._fs = customFS ?? new FS("modern-monaco-workspace(" + name + ")");
+    this._fs = customFS ?? new IndexedDBFileSystem("modern-monaco-workspace(" + name + ")");
     this._viewState = new WorkspaceStateStorage("modern-monaco-state(" + name + ")");
     this._entryFile = entryFile;
     if (initialFiles) {
       for (const [name2, data] of Object.entries(initialFiles)) {
         void this._fs.stat(name2).catch(async (err) => {
           if (err instanceof ErrorNotFound) {
-            const { pathname, href: url } = filenameToURL(name2);
+            const { pathname } = filenameToURL(name2);
             const dir = pathname.slice(0, pathname.lastIndexOf("/"));
             if (dir) {
               await this._fs.createDirectory(dir);
@@ -68,11 +68,10 @@ var Workspace = class {
     const monaco = await this._monaco.promise;
     return this._openTextDocument(uri, monaco.editor.getEditors()[0], void 0, content);
   }
-  // @internal
   async _openTextDocument(uri, editor, selectionOrPosition, readonlyContent) {
     const monaco = await this._monaco.promise;
     const fs = this._fs;
-    const href = toURL(uri).href;
+    const href = normalizeURL(uri).href;
     const content = readonlyContent ?? await fs.readTextFile(href);
     const viewState = await this.viewState.get(href);
     const modelUri = monaco.Uri.parse(href);
@@ -137,7 +136,7 @@ var Workspace = class {
     return monaco.showQuickPick(items, options, token);
   }
 };
-var FS = class {
+var IndexedDBFileSystem = class {
   _watchers = /* @__PURE__ */ new Set();
   _db;
   constructor(scope) {
@@ -155,13 +154,6 @@ var FS = class {
     const transaction = (await this._db.open()).transaction(["fs-meta", "fs-blob"], readwrite ? "readwrite" : "readonly");
     return [transaction.objectStore("fs-meta"), transaction.objectStore("fs-blob")];
   }
-  async *walk() {
-    const metaStore = await this._getIdbObjectStore("fs-meta");
-    const entries = await promisifyIDBRequest(metaStore.getAll());
-    for (const entry of entries) {
-      yield [new URL(entry.url).pathname, entry.type];
-    }
-  }
   async stat(name) {
     const url = filenameToURL(name).href;
     if (url === "file:///") {
@@ -428,6 +420,18 @@ var ErrorNotFound = class extends Error {
     super("No such file or directory: " + name);
   }
 };
+async function walk(fs, dir = "/") {
+  const entries = [];
+  for (const [name, type] of await fs.readDirectory(dir || "/")) {
+    const path = (dir.endsWith("/") ? dir.slice(0, -1) : dir) + "/" + name;
+    if (type === 2) {
+      entries.push(...await walk(fs, path));
+    } else {
+      entries.push(path);
+    }
+  }
+  return entries;
+}
 var WorkspaceDatabase = class {
   _db;
   constructor(name, ...stores) {
@@ -455,12 +459,12 @@ var WorkspaceStateStorage = class {
     );
   }
   async get(uri) {
-    const url = toURL(uri).href;
+    const url = normalizeURL(uri).href;
     const store = (await this.#db.open()).transaction("store", "readonly").objectStore("store");
     return promisifyIDBRequest(store.get(url)).then((result) => result?.state);
   }
   async save(uri, state) {
-    const url = toURL(uri).href;
+    const url = normalizeURL(uri).href;
     const store = (await this.#db.open()).transaction("store", "readwrite").objectStore("store");
     await promisifyIDBRequest(store.put({ url, state }));
   }
@@ -584,5 +588,6 @@ var BrowserHistory = class {
 };
 export {
   ErrorNotFound,
-  Workspace
+  Workspace,
+  walk
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modern-monaco",
   "description": "A modern version of Monaco Editor",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
@@ -43,6 +43,9 @@
     "./util": {
       "import": "./dist/util.mjs"
     },
+    "./lsp": {
+      "import": "./dist/lsp/index.mjs"
+    },
     "./lsp/*": {
       "import": "./dist/lsp/*.mjs"
     }

package/types/workspace.d.ts

@@ -43,9 +43,23 @@ export interface WorkspaceHistory {
   onChange(callback: (state: WorkspaceHistoryState) => void): () => void;
 }
 
-/** 0: unknown, 1: file, 2: directory, 64: symlink */
+/**
+ * The type of a file system entry.
+ * - `0`: unknown
+ * - `1`: file
+ * - `2`: directory
+ * - `64`: symlink
+ */
 export type FileSystemEntryType = 0 | 1 | 2 | 64;
 
+export interface FileSystemWatchContext {
+  isModelContentChange?: boolean;
+}
+
+export interface FileSystemWatchHandle {
+  (kind: "create" | "modify" | "remove", filename: string, type?: number, context?: FileSystemWatchContext): void;
+}
+
 export interface FileStat {
   readonly type: FileSystemEntryType;
   readonly ctime: number;
@@ -63,14 +77,9 @@ export interface FileSystem {
   readTextFile(filename: string): Promise<string>;
   rename(oldName: string, newName: string, options?: { overwrite: boolean }): Promise<void>;
   stat(filename: string): Promise<FileStat>;
-  writeFile(filename: string, content: string | Uint8Array, context?: { isModelContentChange: boolean }): Promise<void>;
+  writeFile(filename: string, content: string | Uint8Array, context?: FileSystemWatchContext): Promise<void>;
   watch(filename: string, options: { recursive: boolean }, handle: FileSystemWatchHandle): () => void;
   watch(filename: string, handle: FileSystemWatchHandle): () => void;
-  walk(): AsyncIterable<[string, FileSystemEntryType]>;
-}
-
-export interface FileSystemWatchHandle {
-  (kind: "create" | "modify" | "remove", filename: string, type?: number, context?: { isModelContentChange: boolean }): void;
 }
 
 export class ErrorNotFound extends Error {}