@codingame/monaco-vscode-standalone-html-language-features 23.1.1 → 23.2.0

package/common/initialize.js

@@ -0,0 +1,11 @@
+import { start } from 'monaco-editor/esm/vs/editor/editor.worker.start.js';
+
+function initialize(callback) {
+  self.onmessage = (m) => {
+    start((ctx) => {
+      return callback(ctx, m.data);
+    });
+  };
+}
+
+export { initialize };

package/common/workers.js

@@ -0,0 +1,69 @@
+import { editor } from 'monaco-editor';
+
+function createTrustedTypesPolicy(policyName, policyOptions) {
+  const monacoEnvironment = globalThis.MonacoEnvironment;
+  if (monacoEnvironment?.createTrustedTypesPolicy) {
+    try {
+      return monacoEnvironment.createTrustedTypesPolicy(policyName, policyOptions);
+    } catch (err) {
+      console.error(err);
+      return void 0;
+    }
+  }
+  try {
+    return globalThis.trustedTypes?.createPolicy(policyName, policyOptions);
+  } catch (err) {
+    console.error(err);
+    return void 0;
+  }
+}
+let ttPolicy;
+if (typeof self === "object" && self.constructor && self.constructor.name === "DedicatedWorkerGlobalScope" && globalThis.workerttPolicy !== void 0) {
+  ttPolicy = globalThis.workerttPolicy;
+} else {
+  ttPolicy = createTrustedTypesPolicy("defaultWorkerFactory", {
+    createScriptURL: (value) => value
+  });
+}
+function getWorker(descriptor) {
+  const label = descriptor.label;
+  const monacoEnvironment = globalThis.MonacoEnvironment;
+  if (monacoEnvironment) {
+    if (typeof monacoEnvironment.getWorker === "function") {
+      return monacoEnvironment.getWorker("workerMain.js", label);
+    }
+    if (typeof monacoEnvironment.getWorkerUrl === "function") {
+      const workerUrl = monacoEnvironment.getWorkerUrl("workerMain.js", label);
+      return new Worker(
+        ttPolicy ? ttPolicy.createScriptURL(workerUrl) : workerUrl,
+        { name: label, type: "module" }
+      );
+    }
+  }
+  if (descriptor.createWorker) {
+    return descriptor.createWorker();
+  }
+  throw new Error(
+    `You must define a function MonacoEnvironment.getWorkerUrl or MonacoEnvironment.getWorker`
+  );
+}
+function createWebWorker(opts) {
+  const worker = Promise.resolve(
+    getWorker({
+      label: opts.label ?? "monaco-editor-worker",
+      moduleId: opts.moduleId,
+      createWorker: opts.createWorker
+    })
+  ).then((w) => {
+    w.postMessage("ignore");
+    w.postMessage(opts.createData);
+    return w;
+  });
+  return editor.createWebWorker({
+    worker,
+    host: opts.host,
+    keepIdleModels: opts.keepIdleModels
+  });
+}
+
+export { createWebWorker };

package/html.worker.js

@@ -0,0 +1,8 @@
+import { initialize } from '../../common/initialize.js';
+import { HTMLWorker } from './htmlWorker.js';
+
+self.onmessage = () => {
+  initialize((ctx, createData) => {
+    return new HTMLWorker(ctx, createData);
+  });
+};

package/index.js

@@ -1,34 +1,8 @@
-import * as monaco_editor_core_star from 'monaco-editor';
+import { languages, Emitter } from 'monaco-editor';
 
-/*!-----------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Version: 0.54.0(undefined)
- * Released under the MIT license
- * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
- *-----------------------------------------------------------------------------*/
-
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget);
-
-// src/fillers/monaco-editor-core.ts
-var monaco_editor_core_exports = {};
-__reExport(monaco_editor_core_exports, monaco_editor_core_star);
-
-// src/language/html/monaco.contribution.ts
-var LanguageServiceDefaultsImpl = class {
+class LanguageServiceDefaultsImpl {
   constructor(languageId, options, modeConfiguration) {
-    this._onDidChange = new monaco_editor_core_exports.Emitter();
+    this._onDidChange = new Emitter();
     this._languageId = languageId;
     this.setOptions(options);
     this.setModeConfiguration(modeConfiguration);
@@ -53,8 +27,8 @@ var LanguageServiceDefaultsImpl = class {
     this._modeConfiguration = modeConfiguration || /* @__PURE__ */ Object.create(null);
     this._onDidChange.fire(this);
   }
-};
-var formatDefaults = {
+}
+const formatDefaults = {
   tabSize: 4,
   insertSpaces: false,
   wrapLineLength: 120,
@@ -68,7 +42,7 @@ var formatDefaults = {
   extraLiners: "head, body, /html",
   wrapAttributes: "auto"
 };
-var optionsDefault = {
+const optionsDefault = {
   format: formatDefaults,
   suggest: {},
   data: { useDefaultDataProvider: true }
@@ -92,53 +66,42 @@ function getConfigurationDefault(languageId) {
     // turned off for Razor and Handlebar
   };
 }
-var htmlLanguageId = "html";
-var handlebarsLanguageId = "handlebars";
-var razorLanguageId = "razor";
-var htmlLanguageService = registerHTMLLanguageService(
+const htmlLanguageId = "html";
+const handlebarsLanguageId = "handlebars";
+const razorLanguageId = "razor";
+const htmlLanguageService = registerHTMLLanguageService(
   htmlLanguageId,
   optionsDefault,
   getConfigurationDefault(htmlLanguageId)
 );
-var htmlDefaults = htmlLanguageService.defaults;
-var handlebarLanguageService = registerHTMLLanguageService(
+const htmlDefaults = htmlLanguageService.defaults;
+const handlebarLanguageService = registerHTMLLanguageService(
   handlebarsLanguageId,
   optionsDefault,
   getConfigurationDefault(handlebarsLanguageId)
 );
-var handlebarDefaults = handlebarLanguageService.defaults;
-var razorLanguageService = registerHTMLLanguageService(
+const handlebarDefaults = handlebarLanguageService.defaults;
+const razorLanguageService = registerHTMLLanguageService(
   razorLanguageId,
   optionsDefault,
   getConfigurationDefault(razorLanguageId)
 );
-var razorDefaults = razorLanguageService.defaults;
-monaco_editor_core_exports.languages.html = {
-  htmlDefaults,
-  razorDefaults,
-  handlebarDefaults,
-  htmlLanguageService,
-  handlebarLanguageService,
-  razorLanguageService,
-  registerHTMLLanguageService
-};
+const razorDefaults = razorLanguageService.defaults;
 function getMode() {
-  {
-    return import('./htmlMode.js');
-  }
+  return import('./language/html/htmlMode.js');
 }
 function registerHTMLLanguageService(languageId, options = optionsDefault, modeConfiguration = getConfigurationDefault(languageId)) {
   const defaults = new LanguageServiceDefaultsImpl(languageId, options, modeConfiguration);
-  let mode;
-  const onLanguageListener = monaco_editor_core_exports.languages.onLanguage(languageId, async () => {
-    mode = (await getMode()).setupMode(defaults);
+  let mode2;
+  const onLanguageListener = languages.onLanguage(languageId, async () => {
+    mode2 = (await getMode()).setupMode(defaults);
   });
   return {
     defaults,
     dispose() {
       onLanguageListener.dispose();
-      mode?.dispose();
-      mode = void 0;
+      mode2?.dispose();
+      mode2 = void 0;
     }
   };
 }