modern-monaco 0.1.9 → 0.2.0

package/dist/{index.js → index.mjs}

@@ -697,21 +697,21 @@ var vitesse_dark_default = {
 var builtinLSPProviders = {
   html: {
     // @ts-expect-error 'setup.js' is generated at build time
-    import: () => import("./lsp/html/setup.js")
+    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.js")
+    import: () => import("./lsp/css/setup.mjs")
   },
   json: {
     // @ts-expect-error 'setup.js' is generated at build time
-    import: () => import("./lsp/json/setup.js")
+    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.js")
+    import: () => import("./lsp/typescript/setup.mjs")
   }
 };
 
@@ -29343,8 +29343,8 @@ var syntaxes = [
 ];
 
 // src/index.ts
-import { registerLSPProvider, registerSyntax, registerTheme } from "./core.js";
-import { errors, hydrate, init, lazy, Workspace } from "./core.js";
+import { registerLSPProvider, 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);
 }

package/dist/lsp/css/{setup.js → setup.mjs}

@@ -1,6 +1,6 @@
 // src/lsp/css/setup.ts
-import * as ls from "../language-service.js";
-async function setup(monaco, languageId, workspace, languageSettings, formattingOptions) {
+import * as ls from "../language-service.mjs";
+async function setup(monaco, languageId, languageSettings, formattingOptions, workspace) {
   const { tabSize, insertSpaces, insertFinalNewline, trimFinalNewlines } = formattingOptions ?? {};
   const createData = {
     language: languageId,
@@ -17,12 +17,11 @@ async function setup(monaco, languageId, workspace, languageSettings, formatting
       newlineBetweenRules: true,
       spaceAroundSelectorSeparator: false,
       braceStyle: "collapse"
-    }
+    },
+    workspace: !!workspace
   };
   const worker = monaco.editor.createWebWorker({
-    moduleId: "lsp/css/worker",
-    label: languageId,
-    createData,
+    worker: getWorker(createData),
     host: ls.createHost(workspace)
   });
   ls.registerBasicFeatures(languageId, worker, ["/", "-", ":", "("], workspace);
@@ -30,13 +29,21 @@ async function setup(monaco, languageId, workspace, languageSettings, formatting
   ls.registerColorPresentation(languageId, worker);
   ls.registerDocumentLinks(languageId, worker);
 }
-function getWorkerUrl() {
-  const i = () => import("./worker.js");
-  const m = getWorkerUrl.toString().match(/import\(['"](.+?)['"]\)/);
-  if (!m) throw new Error("worker url not found", { cause: i });
-  return new URL(m[1], import.meta.url);
+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" }
+    );
+  }
+  return new Worker(new URL("./worker.mjs", import.meta.url), { type: "module" });
+}
+function getWorker(createData) {
+  const worker = createWebWorker();
+  worker.postMessage(createData);
+  return worker;
 }
 export {
-  getWorkerUrl,
   setup
 };

package/dist/lsp/css/{worker.js → worker.mjs}

@@ -48125,14 +48125,15 @@ function getLESSLanguageService(options = defaultLanguageServiceOptions) {
 
 // src/lsp/worker-base.ts
 var WorkerBase = class {
-  constructor(_ctx, _createLanguageDocument) {
+  constructor(_ctx, _createData, _createLanguageDocument) {
     this._ctx = _ctx;
+    this._createData = _createData;
     this._createLanguageDocument = _createLanguageDocument;
   }
-  _documentCache = /* @__PURE__ */ new Map();
-  _fsEntries;
+  #documentCache = /* @__PURE__ */ new Map();
+  #fs;
   get hasFileSystemProvider() {
-    return !!this._fsEntries;
+    return !!this._createData.workspace;
   }
   get host() {
     return this._ctx.host;
@@ -48165,17 +48166,17 @@ var WorkerBase = class {
     if (!model) {
       return null;
     }
-    const cached = this._documentCache.get(uri);
+    const cached = this.#documentCache.get(uri);
     if (cached && cached[0] === model.version) {
       return cached[1];
     }
     const document = TextDocument2.create(uri, "-", model.version, model.getValue());
-    this._documentCache.set(uri, [model.version, document, void 0]);
+    this.#documentCache.set(uri, [model.version, document, void 0]);
     return document;
   }
   getLanguageDocument(document) {
     const { uri, version } = document;
-    const cached = this._documentCache.get(uri);
+    const cached = this.#documentCache.get(uri);
     if (cached && cached[0] === version && cached[2]) {
       return cached[2];
     }
@@ -48183,14 +48184,13 @@ var WorkerBase = class {
       throw new Error("createLanguageDocument is not provided");
     }
     const languageDocument = this._createLanguageDocument(document);
-    this._documentCache.set(uri, [version, document, languageDocument]);
+    this.#documentCache.set(uri, [version, document, languageDocument]);
     return languageDocument;
   }
   readDir(uri, extensions) {
     const entries = [];
-    const fsTree = this._fsEntries;
-    if (fsTree) {
-      for (const [path, type] of fsTree) {
+    if (this.#fs) {
+      for (const [path, type] of this.#fs) {
         if (path.startsWith(uri)) {
           const name = path.slice(uri.length);
           if (!name.includes("/")) {
@@ -48226,30 +48226,25 @@ var WorkerBase = class {
   resolveReference(ref, baseUrl) {
     const url = new URL(ref, baseUrl);
     const href = url.href;
-    if (url.protocol === "file:" && this._fsEntries) {
-      if (!this._fsEntries.has(href)) {
-        return void 0;
-      }
+    if (url.protocol === "file:" && url.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) {
-    this._documentCache.delete(uri);
-  }
-  async syncFSEntries(entries) {
-    this._fsEntries = new Map(entries);
+    this.#documentCache.delete(uri);
   }
   async fsNotify(kind, path, type) {
     const url = "file://" + path;
-    const entries = this._fsEntries ?? (this._fsEntries = /* @__PURE__ */ new Map());
+    const entries = this.#fs ?? (this.#fs = /* @__PURE__ */ new Map());
     if (kind === "create") {
       if (type) {
         entries.set(url, type);
       }
     } else if (kind === "remove") {
       if (entries.get(url) === 1 /* File */) {
-        this._documentCache.delete(url);
+        this.#documentCache.delete(url);
       }
       entries.delete(url);
     }
@@ -48258,12 +48253,12 @@ var WorkerBase = class {
 };
 
 // src/lsp/css/worker.ts
-import { initializeWorker } from "../../editor-worker.js";
+import { initializeWorker } from "../../editor-worker.mjs";
 var CSSWorker = class extends WorkerBase {
   _formatSettings;
   _languageService;
   constructor(ctx, createData) {
-    super(ctx, (document) => this._languageService.parseStylesheet(document));
+    super(ctx, createData, (document) => this._languageService.parseStylesheet(document));
     const data = createData.data;
     const customDataProviders = [];
     if (data?.dataProviders) {

package/dist/lsp/html/{setup.js → setup.mjs}

@@ -1,6 +1,6 @@
 // src/lsp/html/setup.ts
-import * as ls from "../language-service.js";
-async function setup(monaco, languageId, workspace, languageSettings, formattingOptions) {
+import * as ls from "../language-service.mjs";
+async function setup(monaco, languageId, languageSettings, formattingOptions, workspace) {
   const { editor, languages } = monaco;
   const { tabSize, insertSpaces, insertFinalNewline, trimFinalNewlines } = formattingOptions ?? {};
   const createData = {
@@ -25,12 +25,11 @@ async function setup(monaco, languageId, workspace, languageSettings, formatting
     data: {
       useDefaultDataProvider: true,
       dataProviders: Array.isArray(languageSettings?.customTags) ? { custom: { version: 1.1, tags: languageSettings.customTags } } : void 0
-    }
+    },
+    workspace: !!workspace
   };
   const htmlWorker = editor.createWebWorker({
-    moduleId: "lsp/html/worker",
-    label: languageId,
-    createData,
+    worker: getWorker(createData),
     host: ls.createHost(workspace)
   });
   const workerWithEmbeddedLanguages = ls.createWorkerWithEmbeddedLanguages(htmlWorker);
@@ -77,13 +76,21 @@ async function setup(monaco, languageId, workspace, languageSettings, formatting
     }
   });
 }
-function getWorkerUrl() {
-  const i = () => import("./worker.js");
-  const m = getWorkerUrl.toString().match(/import\(['"](.+?)['"]\)/);
-  if (!m) throw new Error("worker url not found", { cause: i });
-  return new URL(m[1], import.meta.url);
+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" }
+    );
+  }
+  return new Worker(new URL("./worker.mjs", import.meta.url), { type: "module" });
+}
+function getWorker(createData) {
+  const worker = createWebWorker();
+  worker.postMessage(createData);
+  return worker;
 }
 export {
-  getWorkerUrl,
   setup
 };

package/dist/lsp/html/{worker.js → worker.mjs}

@@ -22052,14 +22052,15 @@ function getAttributeLanguage(attributeName) {
 
 // src/lsp/worker-base.ts
 var WorkerBase = class {
-  constructor(_ctx, _createLanguageDocument) {
+  constructor(_ctx, _createData, _createLanguageDocument) {
     this._ctx = _ctx;
+    this._createData = _createData;
     this._createLanguageDocument = _createLanguageDocument;
   }
-  _documentCache = /* @__PURE__ */ new Map();
-  _fsEntries;
+  #documentCache = /* @__PURE__ */ new Map();
+  #fs;
   get hasFileSystemProvider() {
-    return !!this._fsEntries;
+    return !!this._createData.workspace;
   }
   get host() {
     return this._ctx.host;
@@ -22092,17 +22093,17 @@ var WorkerBase = class {
     if (!model) {
       return null;
     }
-    const cached = this._documentCache.get(uri);
+    const cached = this.#documentCache.get(uri);
     if (cached && cached[0] === model.version) {
       return cached[1];
     }
     const document = TextDocument2.create(uri, "-", model.version, model.getValue());
-    this._documentCache.set(uri, [model.version, document, void 0]);
+    this.#documentCache.set(uri, [model.version, document, void 0]);
     return document;
   }
   getLanguageDocument(document) {
     const { uri, version } = document;
-    const cached = this._documentCache.get(uri);
+    const cached = this.#documentCache.get(uri);
     if (cached && cached[0] === version && cached[2]) {
       return cached[2];
     }
@@ -22110,14 +22111,13 @@ var WorkerBase = class {
       throw new Error("createLanguageDocument is not provided");
     }
     const languageDocument = this._createLanguageDocument(document);
-    this._documentCache.set(uri, [version, document, languageDocument]);
+    this.#documentCache.set(uri, [version, document, languageDocument]);
     return languageDocument;
   }
   readDir(uri, extensions) {
     const entries = [];
-    const fsTree = this._fsEntries;
-    if (fsTree) {
-      for (const [path, type] of fsTree) {
+    if (this.#fs) {
+      for (const [path, type] of this.#fs) {
         if (path.startsWith(uri)) {
           const name = path.slice(uri.length);
           if (!name.includes("/")) {
@@ -22153,30 +22153,25 @@ var WorkerBase = class {
   resolveReference(ref, baseUrl) {
     const url = new URL(ref, baseUrl);
     const href = url.href;
-    if (url.protocol === "file:" && this._fsEntries) {
-      if (!this._fsEntries.has(href)) {
-        return void 0;
-      }
+    if (url.protocol === "file:" && url.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) {
-    this._documentCache.delete(uri);
-  }
-  async syncFSEntries(entries) {
-    this._fsEntries = new Map(entries);
+    this.#documentCache.delete(uri);
   }
   async fsNotify(kind, path, type) {
     const url = "file://" + path;
-    const entries = this._fsEntries ?? (this._fsEntries = /* @__PURE__ */ new Map());
+    const entries = this.#fs ?? (this.#fs = /* @__PURE__ */ new Map());
     if (kind === "create") {
       if (type) {
         entries.set(url, type);
       }
     } else if (kind === "remove") {
       if (entries.get(url) === 1 /* File */) {
-        this._documentCache.delete(url);
+        this.#documentCache.delete(url);
       }
       entries.delete(url);
     }
@@ -22185,13 +22180,13 @@ var WorkerBase = class {
 };
 
 // src/lsp/html/worker.ts
-import { initializeWorker } from "../../editor-worker.js";
+import { initializeWorker } from "../../editor-worker.mjs";
 var HTMLWorker = class extends WorkerBase {
   _formatSettings;
   _suggestSettings;
   _languageService;
   constructor(ctx, createData) {
-    super(ctx, (document) => this._languageService.parseHTMLDocument(document));
+    super(ctx, createData, (document) => this._languageService.parseHTMLDocument(document));
     const data = createData.data;
     const useDefaultDataProvider = data?.useDefaultDataProvider;
     const fileSystemProvider = this.getFileSystemProvider();

package/dist/lsp/json/{setup.js → setup.mjs}

@@ -111,8 +111,8 @@ var schemas = [
 ];
 
 // src/lsp/json/setup.ts
-import * as ls from "../language-service.js";
-async function setup(monaco, languageId, workspace, languageSettings, formattingOptions) {
+import * as ls from "../language-service.mjs";
+async function setup(monaco, languageId, languageSettings, formattingOptions, workspace) {
   const { editor, languages } = monaco;
   const createData = {
     settings: {
@@ -131,12 +131,11 @@ async function setup(monaco, languageId, workspace, languageSettings, formatting
       insertFinalNewline: true,
       trimFinalNewlines: true,
       ...formattingOptions
-    }
+    },
+    workspace: !!workspace
   };
   const worker = editor.createWebWorker({
-    moduleId: "lsp/json/worker",
-    label: languageId,
-    createData,
+    worker: getWorker(createData),
     host: ls.createHost(workspace)
   });
   const resetSchema = async (uri) => {
@@ -245,13 +244,21 @@ async function searchPackagesFromNpm(keyword, size = 20) {
   }
   return items.slice(0, len);
 }
-function getWorkerUrl() {
-  const i = () => import("./worker.js");
-  const m = getWorkerUrl.toString().match(/import\(['"](.+?)['"]\)/);
-  if (!m) throw new Error("worker url not found", { cause: i });
-  return new URL(m[1], import.meta.url);
+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" }
+    );
+  }
+  return new Worker(new URL("./worker.mjs", import.meta.url), { type: "module" });
+}
+function getWorker(createData) {
+  const worker = createWebWorker();
+  worker.postMessage(createData);
+  return worker;
 }
 export {
-  getWorkerUrl,
   setup
 };

package/dist/lsp/json/{worker.js → worker.mjs}

@@ -7682,14 +7682,15 @@ function getLanguageService(params) {
 
 // src/lsp/worker-base.ts
 var WorkerBase = class {
-  constructor(_ctx, _createLanguageDocument) {
+  constructor(_ctx, _createData, _createLanguageDocument) {
     this._ctx = _ctx;
+    this._createData = _createData;
     this._createLanguageDocument = _createLanguageDocument;
   }
-  _documentCache = /* @__PURE__ */ new Map();
-  _fsEntries;
+  #documentCache = /* @__PURE__ */ new Map();
+  #fs;
   get hasFileSystemProvider() {
-    return !!this._fsEntries;
+    return !!this._createData.workspace;
   }
   get host() {
     return this._ctx.host;
@@ -7722,17 +7723,17 @@ var WorkerBase = class {
     if (!model) {
       return null;
     }
-    const cached = this._documentCache.get(uri);
+    const cached = this.#documentCache.get(uri);
     if (cached && cached[0] === model.version) {
       return cached[1];
     }
     const document = TextDocument2.create(uri, "-", model.version, model.getValue());
-    this._documentCache.set(uri, [model.version, document, void 0]);
+    this.#documentCache.set(uri, [model.version, document, void 0]);
     return document;
   }
   getLanguageDocument(document) {
     const { uri, version } = document;
-    const cached = this._documentCache.get(uri);
+    const cached = this.#documentCache.get(uri);
     if (cached && cached[0] === version && cached[2]) {
       return cached[2];
     }
@@ -7740,14 +7741,13 @@ var WorkerBase = class {
       throw new Error("createLanguageDocument is not provided");
     }
     const languageDocument = this._createLanguageDocument(document);
-    this._documentCache.set(uri, [version, document, languageDocument]);
+    this.#documentCache.set(uri, [version, document, languageDocument]);
     return languageDocument;
   }
   readDir(uri, extensions) {
     const entries = [];
-    const fsTree = this._fsEntries;
-    if (fsTree) {
-      for (const [path, type] of fsTree) {
+    if (this.#fs) {
+      for (const [path, type] of this.#fs) {
         if (path.startsWith(uri)) {
           const name = path.slice(uri.length);
           if (!name.includes("/")) {
@@ -7783,30 +7783,25 @@ var WorkerBase = class {
   resolveReference(ref, baseUrl) {
     const url = new URL(ref, baseUrl);
     const href = url.href;
-    if (url.protocol === "file:" && this._fsEntries) {
-      if (!this._fsEntries.has(href)) {
-        return void 0;
-      }
+    if (url.protocol === "file:" && url.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) {
-    this._documentCache.delete(uri);
-  }
-  async syncFSEntries(entries) {
-    this._fsEntries = new Map(entries);
+    this.#documentCache.delete(uri);
   }
   async fsNotify(kind, path, type) {
     const url = "file://" + path;
-    const entries = this._fsEntries ?? (this._fsEntries = /* @__PURE__ */ new Map());
+    const entries = this.#fs ?? (this.#fs = /* @__PURE__ */ new Map());
     if (kind === "create") {
       if (type) {
         entries.set(url, type);
       }
     } else if (kind === "remove") {
       if (entries.get(url) === 1 /* File */) {
-        this._documentCache.delete(url);
+        this.#documentCache.delete(url);
       }
       entries.delete(url);
     }
@@ -7815,13 +7810,13 @@ var WorkerBase = class {
 };
 
 // src/lsp/json/worker.ts
-import { cache } from "../../cache.js";
-import { initializeWorker } from "../../editor-worker.js";
+import { cache } from "../../cache.mjs";
+import { initializeWorker } from "../../editor-worker.mjs";
 var JSONWorker = class extends WorkerBase {
   _formatSettings;
   _languageService;
   constructor(ctx, createData) {
-    super(ctx, (document) => this._languageService.parseJSONDocument(document));
+    super(ctx, createData, (document) => this._languageService.parseJSONDocument(document));
     this._formatSettings = createData.format;
     this._languageService = getLanguageService({
       workspaceContext: {

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

@@ -1182,7 +1182,7 @@ var Is;
 })(Is || (Is = {}));
 
 // src/lsp/language-service.ts
-import { cache } from "../cache.js";
+import { cache } from "../cache.mjs";
 var monaco;
 function init(monacoNS) {
   monaco = monacoNS;
@@ -1201,9 +1201,6 @@ function createHost(workspace) {
   } : /* @__PURE__ */ Object.create(null);
 }
 function lspRequest(req, token) {
-  if (!token) {
-    return req();
-  }
   return new Promise((resolve, reject) => {
     if (token.isCancellationRequested) {
       resolve(void 0);
@@ -1266,9 +1263,12 @@ function registerBasicFeatures(languageId, worker, completionTriggerCharacters,
         worker.getProxy().then((proxy) => proxy.fsNotify(kind, path, type));
       }
     });
-    workspace.fs.entries().then((entries) => {
-      worker.getProxy().then((proxy) => proxy.syncFSEntries(entries));
-    });
+    (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/typescript/{setup.js → setup.mjs}

@@ -94,11 +94,11 @@ function isSameImports(a, b) {
 }
 
 // src/lsp/typescript/setup.ts
-import { cache } from "../../cache.js";
-import { ErrorNotFound } from "../../workspace.js";
-import * as ls from "../language-service.js";
+import { cache } from "../../cache.mjs";
+import { ErrorNotFound } from "../../workspace.mjs";
+import * as ls from "../language-service.mjs";
 var worker = null;
-async function setup(monaco, languageId, workspace, languageSettings, formattingOptions) {
+async function setup(monaco, languageId, languageSettings, formattingOptions, workspace) {
   if (!worker) {
     worker = createWorker(monaco, workspace, languageSettings, formattingOptions);
   }
@@ -110,12 +110,6 @@ async function setup(monaco, languageId, workspace, languageSettings, formatting
   ls.registerSignatureHelp(languageId, worker, ["(", ","]);
   ls.registerCodeAction(languageId, worker);
 }
-function getWorkerUrl() {
-  const i = () => import("./worker.js");
-  const m = getWorkerUrl.toString().match(/import\(['"](.+?)['"]\)/);
-  if (!m) throw new Error("worker url not found", { cause: i });
-  return new URL(m[1], import.meta.url);
-}
 async function createWorker(monaco, workspace, languageSettings, formattingOptions) {
   const fs = workspace?.fs;
   const defaultCompilerOptions = {
@@ -173,13 +167,12 @@ async function createWorker(monaco, workspace, languageSettings, formattingOptio
       insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: insertSpaces
     },
     importMap,
-    types: typesStore.types
+    types: typesStore.types,
+    workspace: !!workspace
   };
   const worker2 = monaco.editor.createWebWorker({
-    moduleId: "lsp/typescript/worker",
-    label: "typescript",
+    worker: getWorker(createData),
     keepIdleModels: true,
-    createData,
     host: {
       openModel: async (uri) => {
         if (!workspace) {
@@ -284,6 +277,21 @@ async function createWorker(monaco, workspace, languageSettings, formattingOptio
   });
   return worker2;
 }
+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" }
+    );
+  }
+  return new Worker(new URL("./worker.mjs", import.meta.url), { type: "module" });
+}
+function getWorker(createData) {
+  const worker2 = createWebWorker();
+  worker2.postMessage(createData);
+  return worker2;
+}
 var TypesSet = class {
   _types = {};
   _removedtypes = {};
@@ -418,7 +426,6 @@ function parseJsonc(text) {
   }
 }
 export {
-  getWorkerUrl,
   loadImportMap,
   setup
 };