modern-monaco 0.1.4 → 0.1.6

package/dist/lsp/typescript/worker.js

@@ -1603,33 +1603,33 @@ import libs from "./libs.js";
 import { cache } from "../../cache.js";
 import { initializeWorker } from "../../editor-worker.js";
 var TypeScriptWorker = class extends WorkerBase {
-  _compilerOptions;
-  _importMap;
-  _importMapVersion;
-  _isBlankImportMap;
-  _types;
-  _formatOptions;
-  _languageService = ts.createLanguageService(this);
-  _urlMappings = /* @__PURE__ */ new Map();
-  _typesMappings = /* @__PURE__ */ new Map();
-  _httpLibs = /* @__PURE__ */ new Map();
-  _httpModules = /* @__PURE__ */ new Map();
-  _httpTsModules = /* @__PURE__ */ new Map();
-  _redirectedImports = [];
-  _unknownImports = /* @__PURE__ */ new Set();
-  _badImports = /* @__PURE__ */ new Set();
-  _openPromises = /* @__PURE__ */ new Map();
-  _fetchPromises = /* @__PURE__ */ new Map();
-  _httpDocumentCache = /* @__PURE__ */ new Map();
+  #compilerOptions;
+  #formatOptions;
+  #importMap;
+  #importMapVersion;
+  #isBlankImportMap;
+  #types;
+  #languageService = ts.createLanguageService(this);
+  #urlMappings = /* @__PURE__ */ new Map();
+  #typesMappings = /* @__PURE__ */ new Map();
+  #httpLibs = /* @__PURE__ */ new Map();
+  #httpModules = /* @__PURE__ */ new Map();
+  #httpTsModules = /* @__PURE__ */ new Map();
+  #redirectedImports = [];
+  #unknownImports = /* @__PURE__ */ new Set();
+  #badImports = /* @__PURE__ */ new Set();
+  #openPromises = /* @__PURE__ */ new Map();
+  #fetchPromises = /* @__PURE__ */ new Map();
+  #httpDocumentCache = /* @__PURE__ */ new Map();
   constructor(ctx, createData) {
     super(ctx);
-    this._compilerOptions = ts.convertCompilerOptionsFromJson(createData.compilerOptions, ".").options;
-    this._importMap = createData.importMap;
-    this._importMapVersion = 0;
-    this._isBlankImportMap = isBlankImportMap(createData.importMap);
-    this._types = createData.types;
-    this._formatOptions = createData.formatOptions;
-    this._updateJsxImportSource();
+    this.#compilerOptions = ts.convertCompilerOptionsFromJson(createData.compilerOptions, ".").options;
+    this.#importMap = createData.importMap;
+    this.#importMapVersion = 0;
+    this.#isBlankImportMap = isBlankImportMap(createData.importMap);
+    this.#types = createData.types;
+    this.#formatOptions = createData.formatOptions;
+    this.#updateJsxImportSource();
   }
   // #region language service host
   getCurrentDirectory() {
@@ -1641,30 +1641,30 @@ var TypeScriptWorker = class extends WorkerBase {
     }
     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 !== "/" && key.includes("/")).map((key) => key.split("/")[0]);
+      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);
   }
   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 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);
   }
   fileExists(filename) {
     if (filename.startsWith("/node_modules/")) return false;
-    return filename in libs || `lib.${filename}.d.ts` in libs || filename in this._types || this._httpLibs.has(filename) || this._httpModules.has(filename) || this._httpTsModules.has(filename) || this.hasModel(filename);
+    return filename in libs || `lib.${filename}.d.ts` in libs || filename in this.#types || this.#httpLibs.has(filename) || this.#httpModules.has(filename) || this.#httpTsModules.has(filename) || this.hasModel(filename);
   }
   readFile(filename) {
-    return this._getScriptText(filename);
+    return this.#getScriptText(filename);
   }
   getScriptFileNames() {
     const models = this.getMirrorModels();
-    const types = Object.keys(this._types);
+    const types = Object.keys(this.#types);
     const libNames = Object.keys(libs);
     const filenames = new Array(
-      models.length + types.length + libNames.length + this._httpLibs.size + this._httpModules.size + this._httpTsModules.size
+      models.length + types.length + libNames.length + this.#httpLibs.size + this.#httpModules.size + this.#httpTsModules.size
     );
     let i = 0;
     for (const model of models) {
@@ -1676,39 +1676,39 @@ var TypeScriptWorker = class extends WorkerBase {
     for (const filename of libNames) {
       filenames[i++] = filename;
     }
-    for (const filename of this._httpLibs.keys()) {
+    for (const filename of this.#httpLibs.keys()) {
       filenames[i++] = filename;
     }
-    for (const filename of this._httpModules.keys()) {
+    for (const filename of this.#httpModules.keys()) {
       filenames[i++] = filename;
     }
-    for (const filename of this._httpTsModules.keys()) {
+    for (const filename of this.#httpTsModules.keys()) {
       filenames[i++] = filename;
     }
     return filenames;
   }
   getScriptVersion(fileName) {
-    if (fileName in this._types) {
-      return String(this._types[fileName].version);
+    if (fileName in this.#types) {
+      return String(this.#types[fileName].version);
     }
-    if (fileName in libs || fileName in this._types || this._httpLibs.has(fileName) || this._httpModules.has(fileName) || this._httpTsModules.has(fileName)) {
+    if (fileName in libs || fileName in this.#types || this.#httpLibs.has(fileName) || this.#httpModules.has(fileName) || this.#httpTsModules.has(fileName)) {
       return "1";
     }
     const model = this.getModel(fileName);
     if (model) {
-      return this._importMapVersion + "." + model.version;
+      return this.#importMapVersion + "." + model.version;
     }
     return "0";
   }
   getScriptSnapshot(fileName) {
-    const text = this._getScriptText(fileName);
+    const text = this.#getScriptText(fileName);
     if (text === void 0) {
       return void 0;
     }
     return ts.ScriptSnapshot.fromString(text);
   }
   getCompilationSettings() {
-    return this._compilerOptions;
+    return this.#compilerOptions;
   }
   getDefaultLibFileName(options) {
     switch (options.target) {
@@ -1725,6 +1725,7 @@ var TypeScriptWorker = class extends WorkerBase {
       case 8:
       case 9:
       case 10:
+      case 11:
         return `lib.es${2013 + options.target}.full.d.ts`;
       case 99:
         return "lib.esnext.full.d.ts";
@@ -1733,12 +1734,12 @@ var TypeScriptWorker = class extends WorkerBase {
     }
   }
   resolveModuleNameLiterals(moduleLiterals, containingFile, _redirectedReference, _options, _containingSourceFile, _reusedNames) {
-    this._redirectedImports = this._redirectedImports.filter(([modelUrl]) => modelUrl !== containingFile);
+    this.#redirectedImports = this.#redirectedImports.filter(([modelUrl]) => modelUrl !== containingFile);
     return moduleLiterals.map((literal) => {
       let specifier = literal.text;
       let importMapResolved = false;
-      if (!this._isBlankImportMap) {
-        const [url, resolved] = resolve(this._importMap, specifier, containingFile);
+      if (!this.#isBlankImportMap) {
+        const [url, resolved] = resolve(this.#importMap, specifier, containingFile);
         importMapResolved = resolved;
         if (importMapResolved) {
           specifier = url;
@@ -1759,7 +1760,7 @@ var TypeScriptWorker = class extends WorkerBase {
           moduleUrl.pathname += ext;
         }
       }
-      if (this._httpModules.has(containingFile)) {
+      if (this.#httpModules.has(containingFile)) {
         return {
           resolvedFileName: moduleUrl.href,
           extension: ".js"
@@ -1767,7 +1768,7 @@ var TypeScriptWorker = class extends WorkerBase {
       }
       if (moduleUrl.protocol === "file:") {
         const moduleHref = moduleUrl.href;
-        if (this._badImports.has(moduleHref)) {
+        if (this.#badImports.has(moduleHref)) {
           return void 0;
         }
         for (const model of this.getMirrorModels()) {
@@ -1781,96 +1782,96 @@ var TypeScriptWorker = class extends WorkerBase {
         if (!this.hasFileSystemProvider) {
           return void 0;
         }
-        if (!this._openPromises.has(moduleHref)) {
-          this._openPromises.set(
+        if (!this.#openPromises.has(moduleHref)) {
+          this.#openPromises.set(
             moduleHref,
             this.host.openModel(moduleHref).then((ok) => {
               if (!ok) {
-                this._badImports.add(moduleHref);
-                this._rollbackVersion(containingFile);
+                this.#badImports.add(moduleHref);
+                this.#rollbackVersion(containingFile);
               }
             }).finally(() => {
-              this._openPromises.delete(moduleHref);
+              this.#openPromises.delete(moduleHref);
               this.host.refreshDiagnostics(containingFile);
             })
           );
         }
       } else {
         const moduleHref = moduleUrl.href;
-        if (this._badImports.has(moduleHref) || this._unknownImports.has(moduleHref)) {
+        if (this.#badImports.has(moduleHref) || this.#unknownImports.has(moduleHref)) {
           return void 0;
         }
-        if (!importMapResolved && this._urlMappings.has(moduleHref)) {
-          const redirectUrl = this._urlMappings.get(moduleHref);
-          this._redirectedImports.push([containingFile, literal, redirectUrl]);
+        if (!importMapResolved && this.#urlMappings.has(moduleHref)) {
+          const redirectUrl = this.#urlMappings.get(moduleHref);
+          this.#redirectedImports.push([containingFile, literal, redirectUrl]);
         }
-        if (this._httpModules.has(moduleHref)) {
+        if (this.#httpModules.has(moduleHref)) {
           return {
             resolvedFileName: moduleHref,
             extension: getScriptExtension(moduleUrl.pathname) ?? ".js"
           };
         }
-        if (this._httpTsModules.has(moduleHref)) {
+        if (this.#httpTsModules.has(moduleHref)) {
           return {
             resolvedFileName: moduleHref,
             extension: getScriptExtension(moduleUrl.pathname) ?? ".ts"
           };
         }
-        if (this._typesMappings.has(moduleHref)) {
+        if (this.#typesMappings.has(moduleHref)) {
           return {
-            resolvedFileName: this._typesMappings.get(moduleHref),
+            resolvedFileName: this.#typesMappings.get(moduleHref),
             extension: ".d.ts"
           };
         }
-        if (this._httpLibs.has(moduleHref)) {
+        if (this.#httpLibs.has(moduleHref)) {
           return {
             resolvedFileName: moduleHref,
             extension: ".d.ts"
           };
         }
-        if (!this._fetchPromises.has(moduleHref)) {
-          const autoFetch = importMapResolved || this._isJsxImportUrl(specifier) || isHttpUrl(containingFile) || isWellKnownCDNURL(moduleUrl);
+        if (!this.#fetchPromises.has(moduleHref)) {
+          const autoFetch = importMapResolved || this.#isJsxImportUrl(specifier) || isHttpUrl(containingFile) || isWellKnownCDNURL(moduleUrl);
           const promise = autoFetch ? cache.fetch(moduleUrl) : cache.query(moduleUrl);
-          this._fetchPromises.set(
+          this.#fetchPromises.set(
             moduleHref,
             promise.then(async (res) => {
               if (!res) {
-                this._unknownImports.add(moduleHref);
+                this.#unknownImports.add(moduleHref);
                 return;
               }
               if (res.ok) {
                 const contentType = res.headers.get("content-type");
                 const dts = res.headers.get("x-typescript-types");
                 if (res.redirected) {
-                  this._urlMappings.set(moduleHref, res.url);
+                  this.#urlMappings.set(moduleHref, res.url);
                 } else if (dts) {
                   res.body?.cancel();
                   const dtsRes = await cache.fetch(new URL(dts, res.url));
                   if (dtsRes.ok) {
-                    this._typesMappings.set(moduleHref, dtsRes.url);
-                    this._markHttpLib(dtsRes.url, await dtsRes.text());
+                    this.#typesMappings.set(moduleHref, dtsRes.url);
+                    this.#markHttpLib(dtsRes.url, await dtsRes.text());
                   }
                 } else if (/\.(c|m)?jsx?$/.test(moduleUrl.pathname) || contentType && /^(application|text)\/(javascript|jsx)/.test(contentType)) {
-                  this._httpModules.set(moduleHref, await res.text());
+                  this.#httpModules.set(moduleHref, await res.text());
                 } else if (/\.(c|m)?tsx?$/.test(moduleUrl.pathname) || contentType && /^(application|text)\/(typescript|tsx)/.test(contentType)) {
                   if (/\.d\.(c|m)?ts$/.test(moduleUrl.pathname)) {
-                    this._markHttpLib(moduleHref, await res.text());
+                    this.#markHttpLib(moduleHref, await res.text());
                   } else {
-                    this._httpTsModules.set(moduleHref, await res.text());
+                    this.#httpTsModules.set(moduleHref, await res.text());
                   }
                 } else {
                   res.body?.cancel();
-                  this._badImports.add(moduleHref);
+                  this.#badImports.add(moduleHref);
                 }
               } else {
                 res.body?.cancel();
-                this._badImports.add(moduleHref);
+                this.#badImports.add(moduleHref);
               }
             }).catch((err) => {
               console.error(`Failed to fetch module: ${moduleHref}`, err);
             }).finally(() => {
-              this._rollbackVersion(containingFile);
-              this._fetchPromises.delete(moduleHref);
+              this.#rollbackVersion(containingFile);
+              this.#fetchPromises.delete(moduleHref);
               this.host.refreshDiagnostics(containingFile);
             })
           );
@@ -1884,27 +1885,27 @@ var TypeScriptWorker = class extends WorkerBase {
   // #endregion
   // #region language features
   async doValidation(uri) {
-    const document2 = this._getTextDocument(uri);
+    const document2 = this.#getTextDocument(uri);
     if (!document2) {
       return null;
     }
     const ext = getScriptExtension(uri);
     const diagnostics = [];
-    for (const diagnostic of this._languageService.getSyntacticDiagnostics(uri)) {
-      diagnostics.push(this._convertDiagnostic(document2, diagnostic));
+    for (const diagnostic of this.#languageService.getSyntacticDiagnostics(uri)) {
+      diagnostics.push(this.#convertDiagnostic(document2, diagnostic));
     }
-    for (const diagnostic of this._languageService.getSuggestionDiagnostics(uri)) {
-      diagnostics.push(this._convertDiagnostic(document2, diagnostic));
+    for (const diagnostic of this.#languageService.getSuggestionDiagnostics(uri)) {
+      diagnostics.push(this.#convertDiagnostic(document2, diagnostic));
     }
     if (ext === ".tsx" || ext?.endsWith("ts")) {
-      for (const diagnostic of this._languageService.getSemanticDiagnostics(uri)) {
-        diagnostics.push(this._convertDiagnostic(document2, diagnostic));
+      for (const diagnostic of this.#languageService.getSemanticDiagnostics(uri)) {
+        diagnostics.push(this.#convertDiagnostic(document2, diagnostic));
       }
     }
-    if (this._redirectedImports.length > 0) {
-      this._redirectedImports.forEach(([modelUrl, node, url]) => {
+    if (this.#redirectedImports.length > 0) {
+      this.#redirectedImports.forEach(([modelUrl, node, url]) => {
         if (modelUrl === uri) {
-          diagnostics.push(this._convertDiagnostic(document2, {
+          diagnostics.push(this.#convertDiagnostic(document2, {
             file: void 0,
             start: node.getStart(),
             length: node.getWidth(),
@@ -1918,23 +1919,23 @@ var TypeScriptWorker = class extends WorkerBase {
     return diagnostics;
   }
   async doAutoComplete(uri, position, ch) {
-    const document2 = this._getTextDocument(uri);
+    const document2 = this.#getTextDocument(uri);
     if (!document2) {
       return null;
     }
-    const info = this._languageService.getJsxClosingTagAtPosition(uri, document2.offsetAt(position));
+    const info = this.#languageService.getJsxClosingTagAtPosition(uri, document2.offsetAt(position));
     if (info) {
       return "$0" + info.newText;
     }
     return null;
   }
   async doComplete(uri, position) {
-    const document2 = this._getTextDocument(uri);
+    const document2 = this.#getTextDocument(uri);
     if (!document2) {
       return null;
     }
     const offset = document2.offsetAt(position);
-    const completions = this._getCompletionsAtPosition(uri, offset);
+    const completions = this.#getCompletionsAtPosition(uri, offset);
     if (!completions) {
       return { isIncomplete: false, items: [] };
     }
@@ -1943,7 +1944,7 @@ var TypeScriptWorker = class extends WorkerBase {
       if (entry.name === "") {
         continue;
       }
-      if (entry.kind === "script" && entry.name in this._importMap.imports || entry.name + "/" in this._importMap.imports) {
+      if (entry.kind === "script" && entry.name in this.#importMap.imports || entry.name + "/" in this.#importMap.imports) {
         const { replacementSpan } = entry;
         if (replacementSpan?.length) {
           const replacementText = document2.getText({
@@ -1980,11 +1981,11 @@ var TypeScriptWorker = class extends WorkerBase {
       return null;
     }
     const { uri, offset } = item.data.context;
-    const document2 = this._getTextDocument(uri);
+    const document2 = this.#getTextDocument(uri);
     if (!document2) {
       return null;
     }
-    const details = this._getCompletionEntryDetails(uri, offset, item.label, item.data.entryData);
+    const details = this.#getCompletionEntryDetails(uri, offset, item.label, item.data.entryData);
     if (!details) {
       return null;
     }
@@ -2006,11 +2007,11 @@ var TypeScriptWorker = class extends WorkerBase {
     return { label: item.label, detail, documentation, additionalTextEdits };
   }
   async doHover(uri, position) {
-    const document2 = this._getTextDocument(uri);
+    const document2 = this.#getTextDocument(uri);
     if (!document2) {
       return null;
     }
-    const info = this._getQuickInfoAtPosition(uri, document2.offsetAt(position));
+    const info = this.#getQuickInfoAtPosition(uri, document2.offsetAt(position));
     if (info) {
       const contents = ts.displayPartsToString(info.displayParts);
       const documentation = ts.displayPartsToString(info.documentation);
@@ -2027,7 +2028,7 @@ var TypeScriptWorker = class extends WorkerBase {
   }
   async doSignatureHelp(uri, position, context) {
     const triggerReason = toTsSignatureHelpTriggerReason(context);
-    const items = this._languageService.getSignatureHelpItems(uri, position, { triggerReason });
+    const items = this.#languageService.getSignatureHelpItems(uri, position, { triggerReason });
     if (!items) {
       return null;
     }
@@ -2059,14 +2060,14 @@ var TypeScriptWorker = class extends WorkerBase {
     return { signatures, activeSignature, activeParameter };
   }
   async doCodeAction(uri, range, context, formatOptions) {
-    const document2 = this._getTextDocument(uri);
+    const document2 = this.#getTextDocument(uri);
     if (!document2) {
       return null;
     }
     const start = document2.offsetAt(range.start);
     const end = document2.offsetAt(range.end);
     const errorCodes = context.diagnostics.map((diagnostic) => diagnostic.code).filter(Boolean).map(Number);
-    const codeFixes = await this._getCodeFixesAtPosition(uri, start, end, errorCodes, toTsFormatOptions(formatOptions));
+    const codeFixes = await this.#getCodeFixesAtPosition(uri, start, end, errorCodes, toTsFormatOptions(formatOptions));
     return codeFixes.map((codeFix) => {
       const action = {
         title: codeFix.description,
@@ -2093,16 +2094,16 @@ var TypeScriptWorker = class extends WorkerBase {
     });
   }
   async doRename(uri, position, newName) {
-    const document2 = this._getTextDocument(uri);
+    const document2 = this.#getTextDocument(uri);
     if (!document2) {
       return null;
     }
     const documentPosition = document2.offsetAt(position);
-    const renameInfo = this._languageService.getRenameInfo(uri, documentPosition, { allowRenameOfImportPath: true });
+    const renameInfo = this.#languageService.getRenameInfo(uri, documentPosition, { allowRenameOfImportPath: true });
     if (!renameInfo.canRename) {
       return null;
     }
-    const locations = this._languageService.findRenameLocations(uri, documentPosition, false, false, {
+    const locations = this.#languageService.findRenameLocations(uri, documentPosition, false, false, {
       providePrefixAndSuffixTextForRename: false
     });
     if (!locations) {
@@ -2111,7 +2112,7 @@ var TypeScriptWorker = class extends WorkerBase {
     const changes = {};
     locations.map((loc) => {
       const edits = changes[loc.fileName] || (changes[loc.fileName] = []);
-      const locDocument = this._getTextDocument(loc.fileName);
+      const locDocument = this.#getTextDocument(loc.fileName);
       if (locDocument) {
         edits.push({
           range: createRangeFromDocumentSpan(locDocument, loc.textSpan),
@@ -2122,18 +2123,18 @@ var TypeScriptWorker = class extends WorkerBase {
     return { changes };
   }
   async doFormat(uri, range, formatOptions, docText) {
-    const document2 = docText ? TextDocument2.create(uri, "typescript", 0, docText) : this._getTextDocument(uri);
+    const document2 = docText ? TextDocument2.create(uri, "typescript", 0, docText) : this.#getTextDocument(uri);
     if (!document2) {
       return null;
     }
-    const formattingOptions = this._mergeFormatOptions(toTsFormatOptions(formatOptions));
+    const formattingOptions = this.#mergeFormatOptions(toTsFormatOptions(formatOptions));
     let edits;
     if (range) {
       const start = document2.offsetAt(range.start);
       const end = document2.offsetAt(range.end);
-      edits = this._languageService.getFormattingEditsForRange(uri, start, end, formattingOptions);
+      edits = this.#languageService.getFormattingEditsForRange(uri, start, end, formattingOptions);
     } else {
-      edits = this._languageService.getFormattingEditsForDocument(uri, formattingOptions);
+      edits = this.#languageService.getFormattingEditsForDocument(uri, formattingOptions);
     }
     return edits.map(({ span, newText }) => ({
       range: createRangeFromDocumentSpan(document2, span),
@@ -2141,7 +2142,7 @@ var TypeScriptWorker = class extends WorkerBase {
     }));
   }
   async findDocumentSymbols(uri) {
-    const document2 = this._getTextDocument(uri);
+    const document2 = this.#getTextDocument(uri);
     if (!document2) {
       return null;
     }
@@ -2158,20 +2159,20 @@ var TypeScriptWorker = class extends WorkerBase {
       }
       return result;
     };
-    const root = this._languageService.getNavigationTree(uri);
+    const root = this.#languageService.getNavigationTree(uri);
     return root.childItems?.map((item) => toSymbol(item)) ?? null;
   }
   async findDefinition(uri, position) {
-    const document2 = this._getTextDocument(uri);
+    const document2 = this.#getTextDocument(uri);
     if (!document2) {
       return null;
     }
-    const res = this._languageService.getDefinitionAndBoundSpan(uri, document2.offsetAt(position));
+    const res = this.#languageService.getDefinitionAndBoundSpan(uri, document2.offsetAt(position));
     if (res) {
       const { definitions, textSpan } = res;
       if (definitions) {
         return definitions.map((d) => {
-          const targetDocument = d.fileName === uri ? document2 : this._getTextDocument(d.fileName);
+          const targetDocument = d.fileName === uri ? document2 : this.#getTextDocument(d.fileName);
           if (targetDocument) {
             const range = createRangeFromDocumentSpan(targetDocument, d.textSpan);
             const link = {
@@ -2200,15 +2201,15 @@ var TypeScriptWorker = class extends WorkerBase {
     return null;
   }
   async findReferences(uri, position) {
-    const document2 = this._getTextDocument(uri);
+    const document2 = this.#getTextDocument(uri);
     if (!document2) {
       return null;
     }
-    const references = this._languageService.getReferencesAtPosition(uri, document2.offsetAt(position));
+    const references = this.#languageService.getReferencesAtPosition(uri, document2.offsetAt(position));
     const result = [];
     if (references) {
       for (let entry of references) {
-        const entryDocument = this._getTextDocument(entry.fileName);
+        const entryDocument = this.#getTextDocument(entry.fileName);
         if (entryDocument) {
           result.push({
             uri: entryDocument.uri,
@@ -2220,11 +2221,11 @@ var TypeScriptWorker = class extends WorkerBase {
     return result;
   }
   async findDocumentHighlights(uri, position) {
-    const document2 = this._getTextDocument(uri);
+    const document2 = this.#getTextDocument(uri);
     if (!document2) {
       return null;
     }
-    const highlights = this._languageService.getDocumentHighlights(uri, document2.offsetAt(position), [uri]);
+    const highlights = this.#languageService.getDocumentHighlights(uri, document2.offsetAt(position), [uri]);
     const out = [];
     for (const entry of highlights || []) {
       for (const highlight of entry.highlightSpans) {
@@ -2237,11 +2238,11 @@ var TypeScriptWorker = class extends WorkerBase {
     return out;
   }
   async getFoldingRanges(uri) {
-    const document2 = this._getTextDocument(uri);
+    const document2 = this.#getTextDocument(uri);
     if (!document2) {
       return null;
     }
-    const spans = this._languageService.getOutliningSpans(uri);
+    const spans = this.#languageService.getOutliningSpans(uri);
     const ranges = [];
     for (const span of spans) {
       const curr = createRangeFromDocumentSpan(document2, span.textSpan);
@@ -2259,7 +2260,7 @@ var TypeScriptWorker = class extends WorkerBase {
     return ranges;
   }
   async getSelectionRanges(uri, positions) {
-    const document2 = this._getTextDocument(uri);
+    const document2 = this.#getTextDocument(uri);
     if (!document2) {
       return null;
     }
@@ -2268,53 +2269,53 @@ var TypeScriptWorker = class extends WorkerBase {
       return SelectionRange.create(createRangeFromDocumentSpan(document2, selectionRange.textSpan), parent);
     }
     return positions.map((position) => {
-      const range = this._languageService.getSmartSelectionRange(uri, document2.offsetAt(position));
+      const range = this.#languageService.getSmartSelectionRange(uri, document2.offsetAt(position));
       return convertSelectionRange(range);
     });
   }
   // #endregion
   // #region public methods used by the host
   async fetchHttpModule(specifier, containingFile) {
-    if (this._unknownImports.has(specifier)) {
+    if (this.#unknownImports.has(specifier)) {
       const res = await cache.fetch(specifier);
       res.body?.cancel();
-      this._unknownImports.delete(specifier);
+      this.#unknownImports.delete(specifier);
       if (!res.ok) {
-        this._badImports.add(specifier);
+        this.#badImports.add(specifier);
       }
-      this._rollbackVersion(containingFile);
+      this.#rollbackVersion(containingFile);
       this.host.refreshDiagnostics(containingFile);
     }
   }
   async updateCompilerOptions(options) {
     const { compilerOptions, importMap, types } = options;
     if (compilerOptions) {
-      this._compilerOptions = ts.convertCompilerOptionsFromJson(compilerOptions, ".").options;
-      this._updateJsxImportSource();
+      this.#compilerOptions = ts.convertCompilerOptionsFromJson(compilerOptions, ".").options;
+      this.#updateJsxImportSource();
     }
     if (importMap) {
-      this._importMap = importMap;
-      this._importMapVersion++;
-      this._isBlankImportMap = isBlankImportMap(importMap);
-      this._updateJsxImportSource();
+      this.#importMap = importMap;
+      this.#importMapVersion++;
+      this.#isBlankImportMap = isBlankImportMap(importMap);
+      this.#updateJsxImportSource();
     }
     if (types) {
-      for (const uri of Object.keys(this._types)) {
+      for (const uri of Object.keys(this.#types)) {
         if (!(uri in types)) {
           this.removeDocumentCache(uri);
         }
       }
-      this._types = types;
+      this.#types = types;
     }
   }
   // #endregion
   // #region private methods
-  _getCompletionsAtPosition(fileName, position) {
-    const completions = this._languageService.getCompletionsAtPosition(
+  #getCompletionsAtPosition(fileName, position) {
+    const completions = this.#languageService.getCompletionsAtPosition(
       fileName,
       position,
       {
-        quotePreference: this._formatOptions?.quotePreference,
+        quotePreference: this.#formatOptions?.quotePreference,
         allowRenameOfImportPath: true,
         importModuleSpecifierEnding: "js",
         importModuleSpecifierPreference: "shortest",
@@ -2332,11 +2333,11 @@ var TypeScriptWorker = class extends WorkerBase {
           return true;
         }
         const { moduleSpecifier, exportName } = data;
-        if (moduleSpecifier && (moduleSpecifier in this._importMap.imports || this._typesMappings.has(moduleSpecifier))) {
+        if (moduleSpecifier && (moduleSpecifier in this.#importMap.imports || this.#typesMappings.has(moduleSpecifier))) {
           autoImports.add(exportName + " " + moduleSpecifier);
           return true;
         }
-        const specifier = this._getSpecifierFromDts(data.fileName);
+        const specifier = this.#getSpecifierFromDts(data.fileName);
         if (specifier && !autoImports.has(exportName + " " + specifier)) {
           autoImports.add(exportName + " " + specifier);
           return true;
@@ -2347,9 +2348,9 @@ var TypeScriptWorker = class extends WorkerBase {
     }
     return void 0;
   }
-  _getCompletionEntryDetails(fileName, position, entryName, data) {
+  #getCompletionEntryDetails(fileName, position, entryName, data) {
     try {
-      const detail = this._languageService.getCompletionEntryDetails(
+      const detail = this.#languageService.getCompletionEntryDetails(
         fileName,
         position,
         entryName,
@@ -2364,7 +2365,7 @@ var TypeScriptWorker = class extends WorkerBase {
       detail?.codeActions?.forEach((action) => {
         if (action.description.startsWith("Add import from ")) {
           const specifier = action.description.slice(17, -1);
-          const newSpecifier = this._getSpecifierFromDts(isDts(specifier) ? specifier : specifier + ".d.ts");
+          const newSpecifier = this.#getSpecifierFromDts(isDts(specifier) ? specifier : specifier + ".d.ts");
           if (newSpecifier) {
             action.description = `Add type import from "${newSpecifier}"`;
             action.changes.forEach((change) => {
@@ -2383,8 +2384,8 @@ var TypeScriptWorker = class extends WorkerBase {
       return;
     }
   }
-  _getQuickInfoAtPosition(fileName, position) {
-    const info = this._languageService.getQuickInfoAtPosition(fileName, position);
+  #getQuickInfoAtPosition(fileName, position) {
+    const info = this.#languageService.getQuickInfoAtPosition(fileName, position);
     if (!info) {
       return;
     }
@@ -2408,7 +2409,7 @@ var TypeScriptWorker = class extends WorkerBase {
         kindModifiers === "declare" && moduleName.startsWith('"http')
       ) {
         const specifier = JSON.parse(moduleName);
-        for (const [url, dts] of this._typesMappings) {
+        for (const [url, dts] of this.#typesMappings) {
           if (specifier + ".d.ts" === dts) {
             displayParts[2].text = '"' + url + '"';
             info.tags = [{
@@ -2444,22 +2445,22 @@ var TypeScriptWorker = class extends WorkerBase {
     }
     return info;
   }
-  async _getCodeFixesAtPosition(fileName, start, end, errorCodes, formatOptions) {
+  async #getCodeFixesAtPosition(fileName, start, end, errorCodes, formatOptions) {
     let span = [start + 1, end - 1];
-    if (start === end && (this._redirectedImports.length > 0 || errorCodes.includes(2307))) {
-      const a = this._languageService.getReferencesAtPosition(fileName, start);
+    if (start === end && (this.#redirectedImports.length > 0 || errorCodes.includes(2307))) {
+      const a = this.#languageService.getReferencesAtPosition(fileName, start);
       if (a && a.length > 0) {
         const b = a[0];
         span = [b.textSpan.start, b.textSpan.start + b.textSpan.length];
       }
     }
     const fixes = [];
-    if (this._redirectedImports.length > 0) {
-      const i = this._redirectedImports.findIndex(([modelUrl, node]) => {
+    if (this.#redirectedImports.length > 0) {
+      const i = this.#redirectedImports.findIndex(([modelUrl, node]) => {
         return fileName === modelUrl && node.getStart() === span[0] - 1 && node.getEnd() === span[1] + 1;
       });
       if (i >= 0) {
-        const [_, node, url] = this._redirectedImports[i];
+        const [_, node, url] = this.#redirectedImports[i];
         const fixName = `Update module specifier to ${url}`;
         fixes.push({
           fixName,
@@ -2477,7 +2478,7 @@ var TypeScriptWorker = class extends WorkerBase {
     if (errorCodes.includes(2307)) {
       const specifier = this.getModel(fileName)?.getValue().slice(...span);
       if (specifier) {
-        if (this._unknownImports.has(specifier)) {
+        if (this.#unknownImports.has(specifier)) {
           const fixName = `Fetch module from '${specifier}'`;
           fixes.push({
             fixName,
@@ -2493,12 +2494,12 @@ var TypeScriptWorker = class extends WorkerBase {
       }
     }
     try {
-      const tsFixes = this._languageService.getCodeFixesAtPosition(
+      const tsFixes = this.#languageService.getCodeFixesAtPosition(
         fileName,
         start,
         end,
         errorCodes,
-        this._mergeFormatOptions(formatOptions),
+        this.#mergeFormatOptions(formatOptions),
         {}
       );
       return fixes.concat(tsFixes);
@@ -2507,26 +2508,26 @@ var TypeScriptWorker = class extends WorkerBase {
     }
   }
   /** rollback the version to force reinvoke `resolveModuleNameLiterals` method. */
-  _rollbackVersion(fileName) {
+  #rollbackVersion(fileName) {
     const model = this.getModel(fileName);
     if (model) {
       model._versionId--;
     }
   }
-  _getScriptText(fileName) {
-    return libs[fileName] ?? libs[`lib.${fileName}.d.ts`] ?? this._types[fileName]?.content ?? this._httpLibs.get(fileName) ?? this._httpModules.get(fileName) ?? this._httpTsModules.get(fileName) ?? this.getModel(fileName)?.getValue();
+  #getScriptText(fileName) {
+    return libs[fileName] ?? libs[`lib.${fileName}.d.ts`] ?? this.#types[fileName]?.content ?? this.#httpLibs.get(fileName) ?? this.#httpModules.get(fileName) ?? this.#httpTsModules.get(fileName) ?? this.getModel(fileName)?.getValue();
   }
-  _getTextDocument(uri) {
+  #getTextDocument(uri) {
     const doc = this.getTextDocument(uri);
     if (doc) {
       return doc;
     }
     if (uri.startsWith("http://") || uri.startsWith("https://")) {
-      const docCache = this._httpDocumentCache;
+      const docCache = this.#httpDocumentCache;
       if (docCache.has(uri)) {
         return docCache.get(uri);
       }
-      const scriptText = this._getScriptText(uri);
+      const scriptText = this.#getScriptText(uri);
       if (scriptText) {
         const doc2 = TextDocument2.create(uri, "typescript", 1, scriptText);
         docCache.set(uri, doc2);
@@ -2535,36 +2536,36 @@ var TypeScriptWorker = class extends WorkerBase {
     }
     return null;
   }
-  _markHttpLib(url, dtsContent) {
-    this._httpLibs.set(url, dtsContent);
+  #markHttpLib(url, dtsContent) {
+    this.#httpLibs.set(url, dtsContent);
     setTimeout(() => {
-      const referencedFiles = this._languageService.getProgram()?.getSourceFile(url)?.referencedFiles ?? [];
+      const referencedFiles = this.#languageService.getProgram()?.getSourceFile(url)?.referencedFiles ?? [];
       referencedFiles.forEach((ref) => {
         const refUrl = new URL(ref.fileName, url).href;
-        if (isDts(refUrl) && !this._fetchPromises.has(refUrl) && !this._httpLibs.has(refUrl) && !this._badImports.has(refUrl)) {
-          this._fetchPromises.set(
+        if (isDts(refUrl) && !this.#fetchPromises.has(refUrl) && !this.#httpLibs.has(refUrl) && !this.#badImports.has(refUrl)) {
+          this.#fetchPromises.set(
             refUrl,
             cache.fetch(refUrl).then(async (res) => {
               if (res.ok) {
-                this._httpLibs.set(refUrl, await res.text());
+                this.#httpLibs.set(refUrl, await res.text());
               } else {
-                this._badImports.add(refUrl);
+                this.#badImports.add(refUrl);
               }
             }).catch((err) => {
               console.error(`Failed to fetch types: ${refUrl}`, err);
             }).finally(() => {
-              this._fetchPromises.delete(refUrl);
+              this.#fetchPromises.delete(refUrl);
             })
           );
         }
       });
     });
   }
-  _getSpecifierFromDts(filename) {
-    for (const [specifier, dts] of this._typesMappings) {
+  #getSpecifierFromDts(filename) {
+    for (const [specifier, dts] of this.#typesMappings) {
       if (filename === dts) {
-        if (!this._isBlankImportMap) {
-          for (const [key, value] of Object.entries(this._importMap.imports)) {
+        if (!this.#isBlankImportMap) {
+          for (const [key, value] of Object.entries(this.#importMap.imports)) {
             if (value === specifier && key !== "@jsxRuntime") {
               return key;
             }
@@ -2574,7 +2575,7 @@ var TypeScriptWorker = class extends WorkerBase {
       }
     }
   }
-  _convertDiagnostic(document2, diagnostic) {
+  #convertDiagnostic(document2, diagnostic) {
     const tags = [];
     if (diagnostic.reportsUnnecessary) {
       tags.push(DiagnosticTag.Unnecessary);
@@ -2589,16 +2590,16 @@ var TypeScriptWorker = class extends WorkerBase {
       message: ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
       source: diagnostic.source,
       tags,
-      relatedInformation: this._convertRelatedInformation(document2, diagnostic.relatedInformation)
+      relatedInformation: this.#convertRelatedInformation(document2, diagnostic.relatedInformation)
     };
   }
-  _convertRelatedInformation(document2, relatedInformation) {
+  #convertRelatedInformation(document2, relatedInformation) {
     if (!relatedInformation) {
       return [];
     }
     const result = [];
     relatedInformation.forEach((info) => {
-      const doc = info.file ? this._getTextDocument(info.file.fileName) : document2;
+      const doc = info.file ? this.#getTextDocument(info.file.fileName) : document2;
       if (!doc) {
         return;
       }
@@ -2614,8 +2615,8 @@ var TypeScriptWorker = class extends WorkerBase {
     });
     return result;
   }
-  _getJsxImportSource() {
-    const { imports } = this._importMap;
+  #getJsxImportSource() {
+    const { imports } = this.#importMap;
     for (const specifier of ["@jsxRuntime", "@jsxImportSource", "preact", "react"]) {
       if (specifier in imports) {
         return imports[specifier];
@@ -2623,20 +2624,20 @@ var TypeScriptWorker = class extends WorkerBase {
     }
     return void 0;
   }
-  _updateJsxImportSource() {
-    if (!this._compilerOptions.jsxImportSource) {
-      const jsxImportSource = this._getJsxImportSource();
+  #updateJsxImportSource() {
+    if (!this.#compilerOptions.jsxImportSource) {
+      const jsxImportSource = this.#getJsxImportSource();
       if (jsxImportSource) {
-        this._compilerOptions.jsx = ts.JsxEmit.React;
-        this._compilerOptions.jsxImportSource = jsxImportSource;
+        this.#compilerOptions.jsx = ts.JsxEmit.React;
+        this.#compilerOptions.jsxImportSource = jsxImportSource;
       }
     }
   }
-  _mergeFormatOptions(formatOptions) {
-    return { ...this._formatOptions, ...formatOptions };
+  #mergeFormatOptions(formatOptions) {
+    return { ...this.#formatOptions, ...formatOptions };
   }
-  _isJsxImportUrl(url) {
-    const jsxImportUrl = this._getJsxImportSource();
+  #isJsxImportUrl(url) {
+    const jsxImportUrl = this.#getJsxImportSource();
     if (jsxImportUrl) {
       return url === jsxImportUrl + "/jsx-runtime" || url === jsxImportUrl + "/jsx-dev-runtime";
     }