modern-monaco 0.0.0-beta.0 → 0.0.0-beta.2

package/dist/core.js

@@ -0,0 +1,479 @@
+// src/lsp/index.ts
+function createWebWorker(url, name) {
+  let workerUrl = url;
+  if (url.origin !== location.origin) {
+    workerUrl = URL.createObjectURL(new Blob([`import "${url.href}"`], { type: "application/javascript" }));
+  }
+  return new Worker(workerUrl, {
+    type: "module",
+    name: name ?? url.pathname.slice(1).split("/").slice(-2).join("/")
+  });
+}
+
+// src/core.ts
+import { getLanguageIdFromPath, initShiki, setDefaultWasmLoader, tmGrammars, tmThemes } from "./shiki.js";
+import { initShikiMonacoTokenizer, registerShikiMonacoTokenizer } from "./shiki.js";
+import { render } from "./shiki.js";
+import { getWasmInstance } from "./shiki-wasm.js";
+import { ErrorNotFound, Workspace } from "./workspace.js";
+
+// src/util.ts
+var dec = /* @__PURE__ */ new TextDecoder();
+function decode(data) {
+  return data instanceof Uint8Array ? dec.decode(data) : data;
+}
+function isDigital(v) {
+  return typeof v === "number" || typeof v === "string" && /^\d+$/.test(v);
+}
+function debunce(fn, delay) {
+  let timer = null;
+  return () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+    }
+    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 };
+}
+
+// src/core.ts
+import { init as initLS } from "./lsp/language-service.js";
+var editorProps = [
+  "autoDetectHighContrast",
+  "automaticLayout",
+  "contextmenu",
+  "cursorBlinking",
+  "cursorSmoothCaretAnimation",
+  "cursorStyle",
+  "cursorWidth",
+  "fontFamily",
+  "fontLigatures",
+  "fontSize",
+  "fontVariations",
+  "fontWeight",
+  "letterSpacing",
+  "lineHeight",
+  "lineNumbers",
+  "lineNumbersMinChars",
+  "matchBrackets",
+  "minimap",
+  "mouseStyle",
+  "multiCursorModifier",
+  "padding",
+  "readOnly",
+  "readOnlyMessage",
+  "rulers",
+  "scrollbar",
+  "stickyScroll",
+  "tabSize",
+  "theme",
+  "wordWrap"
+];
+var errors = {
+  NotFound: ErrorNotFound
+};
+var builtinLSPProviders = {};
+var builtinSyntaxes = [];
+async function init(options) {
+  const langs = (options?.langs ?? []).concat(builtinSyntaxes);
+  const hightlighter = await initShiki({ ...options, langs });
+  return loadMonaco(hightlighter, options?.workspace, options?.lsp);
+}
+async function lazy(options, hydrate2) {
+  const workspace = options?.workspace;
+  const { promise: editorWorkerPromise, resolve: onDidEditorWorkerResolve } = promiseWithResolvers();
+  let monacoCore = null;
+  function load(highlighter) {
+    if (monacoCore) {
+      return monacoCore;
+    }
+    return monacoCore = loadMonaco(highlighter, workspace, options?.lsp, onDidEditorWorkerResolve).then((m) => monacoCore = m);
+  }
+  function setStyle(el, style) {
+    Object.assign(el.style, style);
+  }
+  function getAttr(el, name) {
+    return el.getAttribute(name);
+  }
+  customElements.define(
+    "monaco-editor",
+    class extends HTMLElement {
+      async connectedCallback() {
+        const renderOptions = {};
+        for (const attrName of this.getAttributeNames()) {
+          const key = editorProps.find((k) => k.toLowerCase() === attrName);
+          if (key) {
+            let value = getAttr(this, attrName);
+            if (value === "") {
+              value = key === "minimap" || key === "stickyScroll" ? { enabled: true } : true;
+            } else {
+              value = value.trim();
+              if (value === "true") {
+                value = true;
+              } else if (value === "false") {
+                value = false;
+              } else if (value === "null") {
+                value = null;
+              } else if (/^\d+$/.test(value)) {
+                value = Number(value);
+              } else if (/^\{.+\}$/.test(value)) {
+                try {
+                  value = JSON.parse(value);
+                } catch (error) {
+                  value = void 0;
+                }
+              }
+            }
+            if (key === "padding") {
+              if (typeof value === "number") {
+                value = { top: value, bottom: value };
+              } else if (/^\d+\s+\d+$/.test(value)) {
+                const [top, bottom] = value.split(/\s+/);
+                if (top && bottom) {
+                  value = { top: Number(top), bottom: Number(bottom) };
+                }
+              } else {
+                value = void 0;
+              }
+            }
+            if (key === "wordWrap" && (value === "on" || value === true)) {
+              value = "on";
+            }
+            if (value !== void 0) {
+              renderOptions[key] = value;
+            }
+          }
+        }
+        let filename;
+        let code;
+        if (hydrate2) {
+          const optionsEl = this.children[0];
+          if (optionsEl && optionsEl.tagName === "SCRIPT" && optionsEl.className === "monaco-editor-options") {
+            try {
+              const v = JSON.parse(optionsEl.textContent);
+              if (Array.isArray(v) && v.length === 2) {
+                const [input, opts] = v;
+                Object.assign(renderOptions, opts);
+                if (opts.fontDigitWidth) {
+                  Reflect.set(globalThis, "__monaco_maxDigitWidth", opts.fontDigitWidth);
+                }
+                if (typeof input === "string") {
+                  code = input;
+                } else {
+                  filename = input.filename;
+                  code = input.code;
+                }
+              }
+            } catch {
+            }
+            optionsEl.remove();
+          }
+        }
+        setStyle(this, { display: "block", position: "relative" });
+        let widthAttr = getAttr(this, "width");
+        let heightAttr = getAttr(this, "height");
+        if (isDigital(widthAttr) && isDigital(heightAttr)) {
+          const width = Number(widthAttr);
+          const height = Number(heightAttr);
+          setStyle(this, { width: width + "px", height: height + "px" });
+          renderOptions.dimension = { width, height };
+        } else {
+          if (isDigital(widthAttr)) {
+            widthAttr += "px";
+          }
+          if (isDigital(heightAttr)) {
+            heightAttr += "px";
+          }
+          this.style.width ||= widthAttr ?? "100%";
+          this.style.height ||= heightAttr ?? "100%";
+        }
+        const containerEl = document.createElement("div");
+        containerEl.className = "monaco-editor-container";
+        setStyle(containerEl, { width: "100%", height: "100%" });
+        this.appendChild(containerEl);
+        if (!filename && workspace) {
+          if (workspace.history.state.current) {
+            filename = workspace.history.state.current;
+          } else if (workspace.entryFile) {
+            filename = workspace.entryFile;
+            workspace.history.replace(filename);
+          } else {
+            const rootFiles = (await workspace.fs.readDirectory("/")).filter(([name, type]) => type === 1).map(([name]) => name);
+            filename = rootFiles.includes("index.html") ? "index.html" : rootFiles[0];
+            if (filename) {
+              workspace.history.replace(filename);
+            }
+          }
+        }
+        const langs = (options?.langs ?? []).concat(builtinSyntaxes);
+        if (renderOptions.language || filename) {
+          const lang = renderOptions.language ?? getLanguageIdFromPath(filename) ?? "plaintext";
+          if (!builtinSyntaxes.find((s) => s.name === lang)) {
+            langs.push(lang);
+          }
+        }
+        if (renderOptions.theme) {
+          renderOptions.theme = renderOptions.theme.toLowerCase().replace(/ +/g, "-");
+        }
+        const highlighter = await initShiki({
+          ...options,
+          theme: renderOptions.theme ?? options?.theme,
+          langs
+        });
+        let prerenderEl = hydrate2 ? this.querySelector(".monaco-editor-prerender") : void 0;
+        if (!prerenderEl && filename && workspace) {
+          try {
+            const code2 = await workspace.fs.readFile(filename);
+            const language = getLanguageIdFromPath(filename);
+            prerenderEl = containerEl.cloneNode(true);
+            prerenderEl.className = "monaco-editor-prerender";
+            prerenderEl.innerHTML = render(highlighter, decode(code2), { ...renderOptions, language });
+          } catch (error) {
+            if (error instanceof ErrorNotFound) {
+            } else {
+              throw error;
+            }
+          }
+        }
+        if (prerenderEl) {
+          setStyle(prerenderEl, { position: "absolute", top: "0", left: "0" });
+          this.appendChild(prerenderEl);
+          if (filename && workspace) {
+            const viewState = await workspace.viewState.get(filename);
+            const scrollTop = viewState?.viewState.scrollTop ?? 0;
+            if (scrollTop) {
+              const mockEl = prerenderEl.querySelector(".mock-monaco-editor");
+              if (mockEl) {
+                mockEl.scrollTop = scrollTop;
+              }
+            }
+          }
+        }
+        async function createEditor() {
+          const monaco = await load(highlighter);
+          const editor = monaco.editor.create(containerEl, renderOptions);
+          if (workspace) {
+            const storeViewState = () => {
+              const currentModel = editor.getModel();
+              if (currentModel?.uri.scheme === "file") {
+                const state = editor.saveViewState();
+                if (state) {
+                  state.viewState.scrollTop ??= editor.getScrollTop();
+                  workspace.viewState.save(currentModel.uri.toString(), Object.freeze(state));
+                }
+              }
+            };
+            editor.onDidChangeCursorSelection(debunce(storeViewState, 500));
+            editor.onDidScrollChange(debunce(storeViewState, 500));
+            workspace.history.onChange((state) => {
+              if (editor.getModel()?.uri.toString() !== state.current) {
+                workspace._openTextDocument(state.current, editor);
+              }
+            });
+          }
+          if (filename && workspace) {
+            try {
+              const model = await workspace._openTextDocument(filename, editor);
+              if (code && code !== model.getValue()) {
+                model.setValue(code);
+              }
+            } catch (error) {
+              if (error instanceof ErrorNotFound) {
+                if (code) {
+                  await workspace.fs.writeFile(filename, code);
+                  workspace._openTextDocument(filename, editor);
+                } else {
+                  editor.setModel(monaco.editor.createModel(""));
+                }
+              } else {
+                throw error;
+              }
+            }
+          } else if (code && (renderOptions.language || filename)) {
+            const model = monaco.editor.createModel(code, renderOptions.language, filename);
+            editor.setModel(model);
+          } else {
+            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);
+            });
+          }
+        }
+        await createEditor();
+      }
+    }
+  );
+  await editorWorkerPromise;
+  return {
+    workspace
+  };
+}
+function hydrate(options) {
+  return lazy(options, true);
+}
+async function loadMonaco(highlighter, workspace, lsp, onDidEditorWorkerResolve) {
+  const monaco = await import("./editor-core.js");
+  const lspProviders = { ...builtinLSPProviders, ...lsp?.providers };
+  workspace?.setupMonaco(monaco);
+  if (Object.keys(lspProviders).length > 0) {
+    initLS(monaco);
+  }
+  if (!document.getElementById("monaco-editor-core-css")) {
+    const styleEl = document.createElement("style");
+    styleEl.id = "monaco-editor-core-css";
+    styleEl.media = "screen";
+    styleEl.textContent = monaco.CSS;
+    document.head.appendChild(styleEl);
+  }
+  Reflect.set(globalThis, "MonacoEnvironment", {
+    getWorker: async (_workerId, label) => {
+      let provider = lspProviders[label];
+      if (!provider) {
+        provider = Object.values(lspProviders).find((p) => p.aliases?.includes(label));
+      }
+      const url = provider ? (await provider.import()).getWorkerUrl() : monaco.getWorkerUrl();
+      if (label === "typescript") {
+        const tsVersion = lsp?.typescript?.tsVersion;
+        if (tsVersion && (url.hostname === "esm.sh" || url.hostname.endsWith(".esm.sh"))) {
+          url.searchParams.set("deps", `typescript@${tsVersion}`);
+        }
+      }
+      const worker = createWebWorker(url, void 0);
+      if (!provider) {
+        const onMessage = (e) => {
+          onDidEditorWorkerResolve?.();
+          worker.removeEventListener("message", onMessage);
+        };
+        worker.addEventListener("message", onMessage);
+      }
+      return worker;
+    },
+    getLanguageIdFromUri: (uri) => getLanguageIdFromPath(uri.path)
+  });
+  monaco.editor.registerLinkOpener({
+    async open(link) {
+      if ((link.scheme === "https" || link.scheme === "http") && monaco.editor.getModel(link)) {
+        return true;
+      }
+      return false;
+    }
+  });
+  monaco.editor.registerEditorOpener({
+    openCodeEditor: async (editor, resource, selectionOrPosition) => {
+      if (workspace && resource.scheme === "file") {
+        try {
+          await workspace._openTextDocument(resource.toString(), editor, selectionOrPosition);
+          return true;
+        } catch (err) {
+          if (err instanceof ErrorNotFound) {
+            return false;
+          }
+          throw err;
+        }
+      }
+      try {
+        const model = monaco.editor.getModel(resource);
+        if (model) {
+          editor.setModel(model);
+          if (selectionOrPosition) {
+            if ("startLineNumber" in selectionOrPosition) {
+              editor.setSelection(selectionOrPosition);
+            } else {
+              editor.setPosition(selectionOrPosition);
+            }
+            const pos = editor.getPosition();
+            if (pos) {
+              const svp = editor.getScrolledVisiblePosition(new monaco.Position(pos.lineNumber - 7, pos.column));
+              if (svp) {
+                editor.setScrollTop(svp.top);
+              }
+            }
+          }
+          const isHttpUrl = resource.scheme === "https" || resource.scheme === "http";
+          editor.updateOptions({ readOnly: isHttpUrl });
+          return true;
+        }
+      } catch (error) {
+      }
+      return false;
+    }
+  });
+  if (globalThis.navigator?.userAgent?.includes("Macintosh")) {
+    monaco.editor.addKeybindingRule({
+      keybinding: monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyK,
+      command: "editor.action.quickCommand"
+    });
+  }
+  const allLanguages = new Set(tmGrammars.filter((g) => !g.injectTo).map((g) => g.name));
+  allLanguages.forEach((id) => {
+    const languages = monaco.languages;
+    languages.register({ id, aliases: tmGrammars.find((g) => g.name === id)?.aliases });
+    languages.onLanguage(id, async () => {
+      const config = monaco.languageConfigurations[monaco.languageConfigurationAliases[id] ?? id];
+      const loadedGrammars = new Set(highlighter.getLoadedLanguages());
+      const reqiredGrammars = [id].concat(tmGrammars.find((g) => g.name === id)?.embedded ?? []).filter((id2) => !loadedGrammars.has(id2));
+      if (config) {
+        languages.setLanguageConfiguration(id, monaco.convertVscodeLanguageConfiguration(config));
+      }
+      if (reqiredGrammars.length > 0) {
+        await highlighter.loadGrammarFromCDN(...reqiredGrammars);
+      }
+      registerShikiMonacoTokenizer(monaco, highlighter, id);
+      let lspLabel = id;
+      let lspProvider = lspProviders[lspLabel];
+      if (!lspProvider) {
+        const alias = Object.entries(lspProviders).find(([, lsp2]) => lsp2.aliases?.includes(id));
+        if (alias) {
+          [lspLabel, lspProvider] = alias;
+        }
+      }
+      if (lspProvider) {
+        lspProvider.import().then(({ setup }) => setup(monaco, id, workspace, lsp?.[lspLabel], lsp?.formatting));
+      }
+    });
+  });
+  initShikiMonacoTokenizer(monaco, highlighter);
+  return monaco;
+}
+function registerLSPProvider(lang, provider) {
+  builtinLSPProviders[lang] = provider;
+}
+function registerSyntax(...syntaxes) {
+  builtinSyntaxes.push(...syntaxes);
+}
+function registerTheme(theme) {
+  if (theme.name) {
+    tmThemes.set(theme.name, theme);
+  }
+}
+setDefaultWasmLoader(getWasmInstance);
+export {
+  Workspace,
+  errors,
+  hydrate,
+  init,
+  lazy,
+  registerLSPProvider,
+  registerSyntax,
+  registerTheme
+};

package/dist/editor-core.js

@@ -166674,10 +166674,6 @@ if (isMacintosh) {
   registerQuickPickCommandAndKeybindingRule({ id: "quickInput.Next", primary: 256 + 44, handler: focusHandler(QuickPickFocus.Next) });
   registerQuickPickCommandAndKeybindingRule({ id: "quickInput.Previous", primary: 256 + 46, handler: focusHandler(QuickPickFocus.Previous) });
 }
-if (isMacintosh) {
-  registerQuickPickCommandAndKeybindingRule({ id: "quickInput.Next", primary: 256 + 44, handler: focusHandler(QuickPickFocus.Next) });
-  registerQuickPickCommandAndKeybindingRule({ id: "quickInput.Previous", primary: 256 + 46, handler: focusHandler(QuickPickFocus.Previous) });
-}
 
 // node_modules/.pnpm/monaco-editor-core@0.52.2/node_modules/monaco-editor-core/esm/vs/platform/quickinput/browser/quickInputController.js
 var __decorate152 = function(decorators, target, key, desc) {
@@ -173132,6 +173128,107 @@ if (typeof globalThis.require !== "undefined" && typeof globalThis.require.confi
 
 // language-configurations.json
 var language_configurations_default = {
+  prompt: {
+    comments: {
+      blockComment: [
+        "<!--",
+        "-->"
+      ]
+    },
+    brackets: [
+      [
+        "{",
+        "}"
+      ],
+      [
+        "[",
+        "]"
+      ],
+      [
+        "(",
+        ")"
+      ]
+    ],
+    colorizedBracketPairs: [],
+    autoClosingPairs: [
+      {
+        open: "{",
+        close: "}"
+      },
+      {
+        open: "[",
+        close: "]"
+      },
+      {
+        open: "(",
+        close: ")"
+      },
+      {
+        open: "<",
+        close: ">",
+        notIn: [
+          "string"
+        ]
+      }
+    ],
+    surroundingPairs: [
+      [
+        "(",
+        ")"
+      ],
+      [
+        "[",
+        "]"
+      ],
+      [
+        "`",
+        "`"
+      ],
+      [
+        "_",
+        "_"
+      ],
+      [
+        "*",
+        "*"
+      ],
+      [
+        "{",
+        "}"
+      ],
+      [
+        "'",
+        "'"
+      ],
+      [
+        '"',
+        '"'
+      ],
+      [
+        "<",
+        ">"
+      ],
+      [
+        "~",
+        "~"
+      ],
+      [
+        "$",
+        "$"
+      ]
+    ],
+    folding: {
+      offSide: true,
+      markers: {
+        start: "^\\s*<!--\\s*#?region\\b.*-->",
+        end: "^\\s*<!--\\s*#?endregion\\b.*-->"
+      }
+    },
+    wordPattern: {
+      pattern: "(\\p{Alphabetic}|\\p{Number}|\\p{Nonspacing_Mark})(((\\p{Alphabetic}|\\p{Number}|\\p{Nonspacing_Mark})|[_])?(\\p{Alphabetic}|\\p{Number}|\\p{Nonspacing_Mark}))*",
+      flags: "ug"
+    }
+  },
   razor: {
     comments: {
       blockComment: [
@@ -175252,7 +175349,13 @@ var language_configurations_default = {
     ],
     indentationRules: {
       increaseIndentPattern: "({(?!.*}).*|\\(|\\[|((else(\\s)?)?if|else|for(each)?|while|switch|case).*:)\\s*((/[/*].*|)?$|\\?>)",
-      decreaseIndentPattern: "^(.*\\*\\/)?\\s*((\\})|(\\)+[;,])|(\\]\\)*[;,])|\\b(else:)|\\b((end(if|for(each)?|while|switch));))"
+      decreaseIndentPattern: "^(.*\\*\\/)?\\s*((\\})|(\\)+[;,])|(\\]\\)*[;,])|\\b(else:)|\\b((end(if|for(each)?|while|switch));))",
+      unIndentedLinePattern: {
+        pattern: "^(\\t|[ ])*[ ]\\*[^/]*\\*/\\s*$|^(\\t|[ ])*[ ]\\*/\\s*$|^(\\t|[ ])*\\*([ ]([^\\*]|\\*(?!/))*)?$"
+      },
+      indentNextLinePattern: {
+        pattern: "^\\s*(((if|else ?if|while|for|foreach)\\s*\\(.*\\)\\s*)|else\\s*)$"
+      }
     },
     folding: {
       markers: {
@@ -175703,7 +175806,7 @@ var language_configurations_default = {
         pattern: "^(\\t|[ ])*[ ]\\*[^/]*\\*/\\s*$|^(\\t|[ ])*[ ]\\*/\\s*$|^(\\t|[ ])*\\*([ ]([^\\*]|\\*(?!/))*)?$"
       },
       indentNextLinePattern: {
-        pattern: "^((.*=>\\s*)|((.*[^\\w]+|\\s*)(if|while|for)\\s*\\(.*\\)\\s*))$"
+        pattern: "^((.*=>\\s*)|((.*[^\\w]+|\\s*)((if|while|for)\\s*\\(.*\\)\\s*|else\\s*)))$"
       }
     },
     onEnterRules: [
@@ -175801,12 +175904,8 @@ var language_configurations_default = {
         }
       },
       {
-        beforeText: {
-          pattern: "//.*"
-        },
-        afterText: {
-          pattern: "^(?!\\s*$).+"
-        },
+        beforeText: "(?<!\\\\|\\w:)//\\s*\\S",
+        afterText: "^(?!\\s*$).+",
         action: {
           indent: "none",
           appendText: "// "
@@ -176225,7 +176324,10 @@ var language_configurations_default = {
   },
   make: {
     comments: {
-      lineComment: "#"
+      lineComment: {
+        comment: "#",
+        noIndent: true
+      }
     },
     brackets: [
       [
@@ -176620,7 +176722,7 @@ var language_configurations_default = {
     onEnterRules: [
       {
         beforeText: {
-          pattern: "//.*"
+          pattern: "[^/]//[^/].*"
         },
         afterText: {
           pattern: "^(?!\\s*$).+"
@@ -176629,6 +176731,15 @@ var language_configurations_default = {
           indent: "none",
           appendText: "// "
         }
+      },
+      {
+        beforeText: {
+          pattern: "^\\s*///"
+        },
+        action: {
+          indent: "none",
+          appendText: "/// "
+        }
       }
     ]
   },
@@ -177073,7 +177184,7 @@ var language_configurations_default = {
         pattern: "^(\\t|[ ])*[ ]\\*[^/]*\\*/\\s*$|^(\\t|[ ])*[ ]\\*/\\s*$|^(\\t|[ ])*[ ]\\*([ ]([^\\*]|\\*(?!/))*)?$"
       },
       indentNextLinePattern: {
-        pattern: "^((.*=>\\s*)|((.*[^\\w]+|\\s*)(if|while|for)\\s*\\(.*\\)\\s*))$"
+        pattern: "^((.*=>\\s*)|((.*[^\\w]+|\\s*)((if|while|for)\\s*\\(.*\\)\\s*|else\\s*)))$"
       }
     },
     onEnterRules: [
@@ -177171,12 +177282,8 @@ var language_configurations_default = {
         }
       },
       {
-        beforeText: {
-          pattern: "//.*"
-        },
-        afterText: {
-          pattern: "^(?!\\s*$).+"
-        },
+        beforeText: "(?<!\\\\|\\w:)//\\s*\\S",
+        afterText: "^(?!\\s*$).+",
         action: {
           indent: "none",
           appendText: "// "