@typespec/playground 0.14.0-dev.3 → 0.14.0-dev.5

package/dist/services-Z619RuQS.js

@@ -1,760 +0,0 @@
-import { resolvePath, getSourceFileKindFromExt, createSourceFile, TypeSpecLanguageConfiguration } from '@typespec/compiler';
-import * as monaco from 'monaco-editor';
-import * as lsp from 'vscode-languageserver';
-import { DiagnosticSeverity, Range, FormattingOptions, DocumentHighlightKind } from 'vscode-languageserver';
-import { TextDocument } from 'vscode-languageserver-textdocument';
-
-function printDebugInfo() {
-  console.info("TypeSpec Playground");
-  console.info(
-    "Some variables are bound to the `window` object in the browser console for debugging."
-  );
-  console.info(" - `program`: The current TypeSpec program.");
-  console.info(" - `host`: The current compiler host.");
-  console.info(" - `compiler`: The TypeSpec compiler API.");
-  console.info(" - `$$`: A Typekit instance bound to the current program.");
-  console.info(" - `libs`: A map of all loaded TypeSpec libraries.");
-  console.info(" - `vars`: Types bookmarked in the type graph.");
-}
-function debugGlobals() {
-  return window;
-}
-function debugLibs() {
-  return window.libs ??= {};
-}
-
-async function importTypeSpecCompiler(config) {
-  const compiler = await importLibrary("@typespec/compiler", config);
-  debugGlobals().compiler = compiler;
-  return compiler;
-}
-async function importLibrary(name, config) {
-  const lib = await (config.useShim ? importShim(name) : import(
-    /* @vite-ignore */
-    /* webpackIgnore: true */
-    name
-  ));
-  debugLibs()[name] = lib;
-  return lib;
-}
-async function importShim(name) {
-  return window.importShim(name);
-}
-
-function resolveVirtualPath(path, ...paths) {
-  return resolvePath("/test", path, ...paths);
-}
-function createBrowserHostInternal(options) {
-  const virtualFs = /* @__PURE__ */ new Map();
-  const jsImports = /* @__PURE__ */ new Map();
-  const libraries = {
-    ...options.libraries
-  };
-  function registerLibraryFiles(libName, lib) {
-    for (const [key, value] of Object.entries(lib._TypeSpecLibrary_.typespecSourceFiles)) {
-      virtualFs.set(`/test/node_modules/${libName}/${key}`, value);
-    }
-    for (const [key, value] of Object.entries(lib._TypeSpecLibrary_.jsSourceFiles)) {
-      addJsImport(`/test/node_modules/${libName}/${key}`, value);
-    }
-  }
-  function updatePackageJson() {
-    virtualFs.set(
-      `/test/package.json`,
-      JSON.stringify({
-        name: "playground-pkg",
-        dependencies: Object.fromEntries(
-          Object.values(libraries).map((x) => [x.name, x.packageJson.version])
-        )
-      })
-    );
-  }
-  for (const [libName, lib] of Object.entries(libraries)) {
-    registerLibraryFiles(libName, lib);
-  }
-  updatePackageJson();
-  function addJsImport(path, value) {
-    virtualFs.set(path, "");
-    jsImports.set(path, value);
-  }
-  return {
-    compiler: options.compiler,
-    libraries,
-    async readUrl(url) {
-      const contents = virtualFs.get(url);
-      if (contents === void 0) {
-        const e = new Error(`File ${url} not found.`);
-        e.code = "ENOENT";
-        throw e;
-      }
-      return createSourceFile(contents, url);
-    },
-    async readFile(path) {
-      path = resolveVirtualPath(path);
-      const contents = virtualFs.get(path);
-      if (contents === void 0) {
-        const e = new Error(`File ${path} not found.`);
-        e.code = "ENOENT";
-        throw e;
-      }
-      return createSourceFile(contents, path);
-    },
-    async writeFile(path, content) {
-      path = resolveVirtualPath(path);
-      virtualFs.set(path, content);
-    },
-    async readDir(path) {
-      path = resolveVirtualPath(path);
-      const fileFolder = [...virtualFs.keys()].filter((x) => x.startsWith(`${path}/`)).map((x) => x.replace(`${path}/`, "")).map((x) => {
-        const index = x.indexOf("/");
-        return index !== -1 ? x.substring(0, index) : x;
-      });
-      return [...new Set(fileFolder)];
-    },
-    async rm(path) {
-      path = resolveVirtualPath(path);
-      for (const key of virtualFs.keys()) {
-        if (key === path || key.startsWith(`${path}/`)) {
-          virtualFs.delete(key);
-        }
-      }
-    },
-    getLibDirs() {
-      if (virtualFs.has(resolveVirtualPath("/test/node_modules/@typespec/compiler/lib/std/main.tsp"))) {
-        return [resolveVirtualPath("/test/node_modules/@typespec/compiler/lib/std")];
-      } else {
-        return [resolveVirtualPath("/test/node_modules/@typespec/compiler/lib")];
-      }
-    },
-    getExecutionRoot() {
-      return resolveVirtualPath("/test/node_modules/@typespec/compiler");
-    },
-    async getJsImport(path) {
-      path = resolveVirtualPath(path);
-      const module = await jsImports.get(path);
-      if (module === void 0) {
-        const e = new Error(`Module ${path} not found`);
-        e.code = "MODULE_NOT_FOUND";
-        throw e;
-      }
-      return module;
-    },
-    async stat(path) {
-      path = resolveVirtualPath(path);
-      if (virtualFs.has(path)) {
-        return {
-          isDirectory() {
-            return false;
-          },
-          isFile() {
-            return true;
-          }
-        };
-      }
-      for (const fsPath of virtualFs.keys()) {
-        if (fsPath.startsWith(path) && fsPath !== path) {
-          return {
-            isDirectory() {
-              return true;
-            },
-            isFile() {
-              return false;
-            }
-          };
-        }
-      }
-      const e = new Error(`File ${path} not found.`);
-      e.code = "ENOENT";
-      throw e;
-    },
-    // symlinks not supported in test-host
-    async realpath(path) {
-      return path;
-    },
-    getSourceFileKind: getSourceFileKindFromExt,
-    logSink: console,
-    mkdirp: async (path) => path,
-    fileURLToPath(path) {
-      return path.replace("inmemory:/", "");
-    },
-    pathToFileURL(path) {
-      return "inmemory:/" + resolveVirtualPath(path);
-    }
-  };
-}
-async function loadLibraries(libsToLoad, importOptions = {}) {
-  const entries = await Promise.all(
-    libsToLoad.map(async (libName) => {
-      const { _TypeSpecLibrary_, $lib, $linter } = await importLibrary(
-        libName,
-        importOptions
-      );
-      const lib = {
-        name: libName,
-        isEmitter: $lib?.emitter,
-        definition: $lib,
-        packageJson: JSON.parse(_TypeSpecLibrary_.typespecSourceFiles["package.json"]),
-        linter: $linter,
-        _TypeSpecLibrary_
-      };
-      return [libName, lib];
-    })
-  );
-  return Object.fromEntries(entries);
-}
-async function createBrowserHost(libsToLoad, importOptions = {}) {
-  const [libraries, compiler] = await Promise.all([
-    loadLibraries(libsToLoad, importOptions),
-    importTypeSpecCompiler(importOptions)
-  ]);
-  return createBrowserHostInternal({
-    compiler,
-    libraries
-  });
-}
-
-function range$1(range2) {
-  return {
-    startColumn: range2.start.character + 1,
-    startLineNumber: range2.start.line + 1,
-    endColumn: range2.end.character + 1,
-    endLineNumber: range2.end.line + 1
-  };
-}
-function foldingRange(range2) {
-  return {
-    start: range2.startLine + 1,
-    end: range2.endLine + 1,
-    kind: range2.kind ? new monaco.languages.FoldingRangeKind(range2.kind) : void 0
-  };
-}
-function textEdits(edit) {
-  return edit.map(textEdit);
-}
-function textEdit(edit) {
-  return {
-    range: range$1(edit.range),
-    text: edit.newText
-  };
-}
-function signatureHelp(help) {
-  return {
-    signatures: help?.signatures.map((x) => ({
-      ...x,
-      parameters: x.parameters ?? []
-    })) ?? [],
-    activeSignature: help?.activeSignature ?? 0,
-    activeParameter: help?.activeParameter ?? 0
-  };
-}
-function command(command2) {
-  return {
-    id: command2.command,
-    title: command2.title,
-    arguments: command2.arguments
-  };
-}
-function severity$1(severity2) {
-  switch (severity2) {
-    case DiagnosticSeverity.Error:
-      return monaco.MarkerSeverity.Error;
-    case DiagnosticSeverity.Warning:
-      return monaco.MarkerSeverity.Warning;
-    case DiagnosticSeverity.Hint:
-      return monaco.MarkerSeverity.Hint;
-    case DiagnosticSeverity.Information:
-      return monaco.MarkerSeverity.Info;
-  }
-}
-function diagnostic(diagnostic2) {
-  return {
-    severity: diagnostic2.severity ? severity$1(diagnostic2.severity) : monaco.MarkerSeverity.Error,
-    message: diagnostic2.message,
-    code: diagnostic2.code?.toString(),
-    source: diagnostic2.source,
-    startLineNumber: diagnostic2.range.start.line + 1,
-    startColumn: diagnostic2.range.start.character + 1,
-    endLineNumber: diagnostic2.range.end.line + 1,
-    endColumn: diagnostic2.range.end.character + 1
-  };
-}
-function codeAction(action) {
-  return {
-    title: action.title,
-    kind: action.kind,
-    diagnostics: action.diagnostics?.map(diagnostic),
-    command: action.command && command(action.command)
-  };
-}
-const LspToMonaco = {
-  range: range$1,
-  foldingRange,
-  textEdits,
-  textEdit,
-  signatureHelp,
-  codeAction,
-  command
-};
-
-function textDocumentForModel(model) {
-  return TextDocument.create(
-    model.uri.toString(),
-    "typespec",
-    model.getVersionId(),
-    model.getValue()
-  );
-}
-function position(pos) {
-  return {
-    line: pos.lineNumber - 1,
-    character: pos.column - 1
-  };
-}
-function range(range2) {
-  return Range.create(
-    {
-      line: range2.startLineNumber - 1,
-      character: range2.startColumn - 1
-    },
-    {
-      line: range2.endLineNumber - 1,
-      character: range2.endColumn - 1
-    }
-  );
-}
-function severity(severity2) {
-  switch (severity2) {
-    case monaco.MarkerSeverity.Error:
-      return DiagnosticSeverity.Error;
-    case monaco.MarkerSeverity.Warning:
-      return DiagnosticSeverity.Warning;
-    case monaco.MarkerSeverity.Hint:
-      return DiagnosticSeverity.Hint;
-    case monaco.MarkerSeverity.Info:
-      return DiagnosticSeverity.Information;
-  }
-}
-function markerToDiagnostic(marker) {
-  return {
-    severity: marker.severity ? severity(marker.severity) : DiagnosticSeverity.Error,
-    range: range(marker),
-    message: marker.message,
-    code: typeof marker.code === "string" ? marker.code : marker.code?.value,
-    source: marker.source,
-    data: marker.relatedInformation
-  };
-}
-function codeActionContext(context) {
-  return {
-    only: context.only ? [context.only] : void 0,
-    triggerKind: context.trigger,
-    diagnostics: context.markers.map(markerToDiagnostic)
-  };
-}
-const MonacoToLsp = {
-  textDocumentForModel,
-  position,
-  range,
-  codeActionContext
-};
-
-let _currentDiagnostics = [];
-let _currentCompiler;
-function updateDiagnosticsForCodeFixes(compiler, diagnostics) {
-  _currentDiagnostics = diagnostics;
-  _currentCompiler = compiler;
-}
-function getIndentAction(value) {
-  switch (value) {
-    case "none":
-      return monaco.languages.IndentAction.None;
-    case "indent":
-      return monaco.languages.IndentAction.Indent;
-    case "indentOutdent":
-      return monaco.languages.IndentAction.IndentOutdent;
-    case "outdent":
-      return monaco.languages.IndentAction.Outdent;
-  }
-}
-function getTypeSpecLanguageConfiguration() {
-  return {
-    ...TypeSpecLanguageConfiguration,
-    onEnterRules: TypeSpecLanguageConfiguration.onEnterRules.map((rule) => {
-      return {
-        beforeText: new RegExp(rule.beforeText.pattern),
-        previousLineText: "previousLineText" in rule ? new RegExp(rule.previousLineText.pattern) : void 0,
-        action: {
-          indentAction: getIndentAction(rule.action.indent),
-          appendText: "appendText" in rule.action ? rule.action.appendText : void 0,
-          removeText: "removeText" in rule.action ? rule.action.removeText : void 0
-        }
-      };
-    })
-  };
-}
-async function registerMonacoLanguage(host) {
-  monaco.languages.register({ id: "typespec", extensions: [".tsp"] });
-  monaco.languages.setLanguageConfiguration("typespec", getTypeSpecLanguageConfiguration());
-  if (window.registeredServices) {
-    return;
-  }
-  window.registeredServices = true;
-  const serverHost = {
-    compilerHost: host,
-    getOpenDocumentByURL(url) {
-      const model = monaco.editor.getModel(monaco.Uri.parse(url));
-      return model ? MonacoToLsp.textDocumentForModel(model) : void 0;
-    },
-    sendDiagnostics() {
-    },
-    log: (log) => {
-      switch (log.level) {
-        case "error":
-          console.error(log);
-          break;
-        case "warning":
-          console.warn(log);
-          break;
-        case "info":
-          console.info(log);
-          break;
-        case "debug":
-          console.debug(log);
-          break;
-      }
-    },
-    applyEdit(param) {
-      return Promise.resolve({ applied: false });
-    }
-  };
-  const { createServer } = host.compiler;
-  const serverLib = createServer(serverHost);
-  const lsConfig = await serverLib.initialize({
-    capabilities: {},
-    processId: 1,
-    workspaceFolders: [],
-    rootUri: "inmemory://"
-  });
-  serverLib.initialized({});
-  monaco.editor.onDidCreateModel((model) => {
-    if (model.getLanguageId() !== "typespec") return;
-    model.onDidChangeContent(async (changes) => {
-      serverLib.checkChange(monacoToLspChangeEvent(model));
-    });
-  });
-  function monacoToLspChangeEvent(model) {
-    return {
-      document: MonacoToLsp.textDocumentForModel(model)
-    };
-  }
-  function lspDocumentArgs(model) {
-    return {
-      textDocument: MonacoToLsp.textDocumentForModel(model)
-    };
-  }
-  function lspArgs(model, pos) {
-    return {
-      ...lspDocumentArgs(model),
-      position: lspPosition(pos)
-    };
-  }
-  function lspPosition(pos) {
-    return {
-      line: pos.lineNumber - 1,
-      character: pos.column - 1
-    };
-  }
-  function lspFormattingOptions(options) {
-    return FormattingOptions.create(options.tabSize, options.insertSpaces);
-  }
-  function monacoLocation(loc) {
-    return {
-      uri: monaco.Uri.parse(loc.uri),
-      range: LspToMonaco.range(loc.range)
-    };
-  }
-  function monacoDocumentHighlight(highlight) {
-    return {
-      range: LspToMonaco.range(highlight.range),
-      kind: monacoDocumentHighlightKind(highlight.kind)
-    };
-  }
-  function monacoDocumentHighlightKind(kind) {
-    switch (kind) {
-      case DocumentHighlightKind.Text:
-        return monaco.languages.DocumentHighlightKind.Text;
-      case DocumentHighlightKind.Read:
-        return monaco.languages.DocumentHighlightKind.Read;
-      case DocumentHighlightKind.Write:
-        return monaco.languages.DocumentHighlightKind.Write;
-      default:
-        return void 0;
-    }
-  }
-  function monacoHoverContents(contents) {
-    return [{ value: contents.value }];
-  }
-  function monacoHover(hover) {
-    if (Array.isArray(hover.contents) || lsp.MarkedString.is(hover.contents)) {
-      throw new Error("MarkedString (deprecated) not supported.");
-    }
-    return {
-      contents: monacoHoverContents(hover.contents),
-      range: hover.range ? LspToMonaco.range(hover.range) : void 0
-    };
-  }
-  function monacoWorkspaceEdit(edit) {
-    const edits = [];
-    for (const [uri, changes] of Object.entries(edit.changes ?? {})) {
-      const resource = monaco.Uri.parse(uri);
-      for (const change of changes) {
-        edits.push({ resource, textEdit: LspToMonaco.textEdit(change), versionId: void 0 });
-      }
-    }
-    return { edits };
-  }
-  monaco.languages.registerDefinitionProvider("typespec", {
-    async provideDefinition(model, position) {
-      const results = await serverLib.gotoDefinition(lspArgs(model, position));
-      return results.map(monacoLocation);
-    }
-  });
-  monaco.languages.registerReferenceProvider("typespec", {
-    async provideReferences(model, position, context) {
-      const results = await serverLib.findReferences({ ...lspArgs(model, position), context });
-      return results.map(monacoLocation);
-    }
-  });
-  monaco.languages.registerRenameProvider("typespec", {
-    async resolveRenameLocation(model, position) {
-      const result = await serverLib.prepareRename(lspArgs(model, position));
-      if (!result) {
-        throw new Error("This element can't be renamed.");
-      }
-      const text = model.getWordAtPosition(position)?.word;
-      if (!text) {
-        throw new Error("Failed to obtain word at position.");
-      }
-      return { text, range: LspToMonaco.range(result) };
-    },
-    async provideRenameEdits(model, position, newName) {
-      const result = await serverLib.rename({ ...lspArgs(model, position), newName });
-      return monacoWorkspaceEdit(result);
-    }
-  });
-  monaco.languages.registerFoldingRangeProvider("typespec", {
-    async provideFoldingRanges(model) {
-      const ranges = await serverLib.getFoldingRanges(lspDocumentArgs(model));
-      const output = ranges.map(LspToMonaco.foldingRange);
-      return output;
-    }
-  });
-  monaco.languages.registerHoverProvider("typespec", {
-    async provideHover(model, position) {
-      const hover = await serverLib.getHover(lspArgs(model, position));
-      return monacoHover(hover);
-    }
-  });
-  monaco.languages.registerSignatureHelpProvider("typespec", {
-    signatureHelpTriggerCharacters: ["(", ",", "<"],
-    signatureHelpRetriggerCharacters: [")"],
-    async provideSignatureHelp(model, position) {
-      const help = await serverLib.getSignatureHelp(lspArgs(model, position));
-      return { value: LspToMonaco.signatureHelp(help), dispose: () => {
-      } };
-    }
-  });
-  monaco.languages.registerDocumentFormattingEditProvider("typespec", {
-    async provideDocumentFormattingEdits(model, options, token) {
-      const edits = await serverLib.formatDocument({
-        ...lspDocumentArgs(model),
-        options: lspFormattingOptions(options)
-      });
-      return LspToMonaco.textEdits(edits);
-    }
-  });
-  monaco.languages.registerDocumentHighlightProvider("typespec", {
-    async provideDocumentHighlights(model, position) {
-      const highlights = await serverLib.findDocumentHighlight(lspArgs(model, position));
-      return highlights.map(monacoDocumentHighlight);
-    }
-  });
-  monaco.languages.registerCompletionItemProvider("typespec", {
-    triggerCharacters: lsConfig.capabilities.completionProvider.triggerCharacters,
-    async provideCompletionItems(model, position) {
-      const result = await serverLib.complete(lspArgs(model, position));
-      const word = model.getWordUntilPosition(position);
-      const range = {
-        startLineNumber: position.lineNumber,
-        endLineNumber: position.lineNumber,
-        startColumn: word.startColumn,
-        endColumn: word.endColumn
-      };
-      const suggestions = [];
-      for (const item of result.items) {
-        let itemRange = range;
-        let insertText = item.insertText ?? item.label;
-        if (item.textEdit && "range" in item.textEdit) {
-          itemRange = LspToMonaco.range(item.textEdit.range);
-          insertText = item.textEdit.newText;
-        }
-        suggestions.push({
-          label: item.label,
-          kind: item.kind,
-          documentation: item.documentation,
-          insertText,
-          range: itemRange,
-          commitCharacters: item.commitCharacters ?? lsConfig.capabilities.completionProvider.allCommitCharacters,
-          tags: item.tags
-        });
-      }
-      return { suggestions };
-    }
-  });
-  monaco.languages.registerCodeActionProvider("typespec", {
-    async provideCodeActions(model, range) {
-      const compiler = _currentCompiler;
-      if (!compiler) return { actions: [], dispose: () => {
-      } };
-      const actions = [];
-      for (const diag of _currentDiagnostics) {
-        if (!diag.codefixes?.length) continue;
-        const loc = compiler.getSourceLocation(diag.target, { locateId: true });
-        if (!loc || loc.file.path !== "/test/main.tsp") continue;
-        const monacoRange = getMonacoRange(compiler, diag.target);
-        if (!monacoRangesOverlap(monacoRange, range)) continue;
-        for (const fix of diag.codefixes) {
-          const edits = await compiler.resolveCodeFix(fix);
-          const workspaceEdits = edits.filter((edit) => edit.file.path === "/test/main.tsp").map((edit) => {
-            const start = edit.file.getLineAndCharacterOfPosition(edit.pos);
-            if (edit.kind === "insert-text") {
-              return {
-                resource: model.uri,
-                textEdit: {
-                  range: {
-                    startLineNumber: start.line + 1,
-                    startColumn: start.character + 1,
-                    endLineNumber: start.line + 1,
-                    endColumn: start.character + 1
-                  },
-                  text: edit.text
-                },
-                versionId: void 0
-              };
-            } else {
-              const end = edit.file.getLineAndCharacterOfPosition(edit.end);
-              return {
-                resource: model.uri,
-                textEdit: {
-                  range: {
-                    startLineNumber: start.line + 1,
-                    startColumn: start.character + 1,
-                    endLineNumber: end.line + 1,
-                    endColumn: end.character + 1
-                  },
-                  text: edit.text
-                },
-                versionId: void 0
-              };
-            }
-          });
-          if (workspaceEdits.length > 0) {
-            actions.push({
-              title: fix.label,
-              kind: "quickfix",
-              edit: { edits: workspaceEdits }
-            });
-          }
-        }
-      }
-      return { actions, dispose: () => {
-      } };
-    }
-  });
-  monaco.editor.defineTheme("typespec", {
-    base: "vs",
-    inherit: true,
-    colors: {},
-    rules: [
-      { token: "macro", foreground: "#800000" },
-      { token: "function", foreground: "#795E26" }
-    ]
-  });
-  monaco.editor.defineTheme("typespec-dark", {
-    base: "vs-dark",
-    inherit: true,
-    colors: {},
-    rules: [
-      { token: "macro", foreground: "#E06C75" },
-      { token: "function", foreground: "#E06C75" }
-    ]
-  });
-  monaco.languages.registerDocumentSemanticTokensProvider("typespec", {
-    getLegend() {
-      const legend = lsConfig.capabilities.semanticTokensProvider.legend;
-      return {
-        tokenModifiers: legend.tokenModifiers,
-        tokenTypes: legend.tokenTypes.map((entry) => {
-          switch (entry) {
-            case "namespace":
-            case "class":
-            case "enum":
-            case "typeParameter":
-            case "struct":
-            case "interface":
-              return "type";
-            case "property":
-            case "enumMember":
-              return "variable";
-            case "docCommentTag":
-              return "keyword";
-            default:
-              return entry;
-          }
-        })
-      };
-    },
-    async provideDocumentSemanticTokens(model) {
-      const result = await serverLib.buildSemanticTokens(lspDocumentArgs(model));
-      return {
-        resultId: result.resultId,
-        data: new Uint32Array(result.data)
-      };
-    },
-    releaseDocumentSemanticTokens() {
-    }
-  });
-}
-function getMonacoRange(typespecCompiler, target) {
-  const loc = typespecCompiler.getSourceLocation(target, { locateId: true });
-  if (loc === void 0 || loc.file.path !== "/test/main.tsp") {
-    return {
-      startLineNumber: 1,
-      startColumn: 1,
-      endLineNumber: 1,
-      endColumn: 1
-    };
-  }
-  const start = loc.file.getLineAndCharacterOfPosition(loc.pos);
-  const end = loc.file.getLineAndCharacterOfPosition(loc.end);
-  return {
-    startLineNumber: start.line + 1,
-    startColumn: start.character + 1,
-    endLineNumber: end.line + 1,
-    endColumn: end.character + 1
-  };
-}
-function monacoRangesOverlap(a, b) {
-  if (a.endLineNumber < b.startLineNumber || b.endLineNumber < a.startLineNumber) {
-    return false;
-  }
-  if (a.endLineNumber === b.startLineNumber && a.endColumn < b.startColumn) {
-    return false;
-  }
-  if (b.endLineNumber === a.startLineNumber && b.endColumn < a.startColumn) {
-    return false;
-  }
-  return true;
-}
-
-export { resolveVirtualPath as a, createBrowserHost as c, debugGlobals as d, getMonacoRange as g, printDebugInfo as p, registerMonacoLanguage as r, updateDiagnosticsForCodeFixes as u };