feature: vor und nachteile

praesentation/node_modules/monaco-editor/esm/vs/language/css/monaco.contribution.d.ts

@@ -0,0 +1 @@
+export {}

praesentation/node_modules/monaco-editor/esm/vs/language/css/monaco.contribution.js

@@ -0,0 +1,148 @@
+import '../../editor/editor.api.js';
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.51.0(67d664a32968e19e2eb08b696a92463804182ae4)
+ * 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 && __copyProps(secondTarget, mod, "default"));
+
+// src/fillers/monaco-editor-core.ts
+var monaco_editor_core_exports = {};
+__reExport(monaco_editor_core_exports, monaco_editor_core_star);
+import * as monaco_editor_core_star from "../../editor/editor.api.js";
+
+// src/language/css/monaco.contribution.ts
+var LanguageServiceDefaultsImpl = class {
+  constructor(languageId, options, modeConfiguration) {
+    this._onDidChange = new monaco_editor_core_exports.Emitter();
+    this._languageId = languageId;
+    this.setOptions(options);
+    this.setModeConfiguration(modeConfiguration);
+  }
+  get onDidChange() {
+    return this._onDidChange.event;
+  }
+  get languageId() {
+    return this._languageId;
+  }
+  get modeConfiguration() {
+    return this._modeConfiguration;
+  }
+  get diagnosticsOptions() {
+    return this.options;
+  }
+  get options() {
+    return this._options;
+  }
+  setOptions(options) {
+    this._options = options || /* @__PURE__ */ Object.create(null);
+    this._onDidChange.fire(this);
+  }
+  setDiagnosticsOptions(options) {
+    this.setOptions(options);
+  }
+  setModeConfiguration(modeConfiguration) {
+    this._modeConfiguration = modeConfiguration || /* @__PURE__ */ Object.create(null);
+    this._onDidChange.fire(this);
+  }
+};
+var optionsDefault = {
+  validate: true,
+  lint: {
+    compatibleVendorPrefixes: "ignore",
+    vendorPrefix: "warning",
+    duplicateProperties: "warning",
+    emptyRules: "warning",
+    importStatement: "ignore",
+    boxModel: "ignore",
+    universalSelector: "ignore",
+    zeroUnits: "ignore",
+    fontFaceProperties: "warning",
+    hexColorLength: "error",
+    argumentsInColorFunction: "error",
+    unknownProperties: "warning",
+    ieHack: "ignore",
+    unknownVendorSpecificProperties: "ignore",
+    propertyIgnoredDueToDisplay: "warning",
+    important: "ignore",
+    float: "ignore",
+    idSelector: "ignore"
+  },
+  data: { useDefaultDataProvider: true },
+  format: {
+    newlineBetweenSelectors: true,
+    newlineBetweenRules: true,
+    spaceAroundSelectorSeparator: false,
+    braceStyle: "collapse",
+    maxPreserveNewLines: void 0,
+    preserveNewLines: true
+  }
+};
+var modeConfigurationDefault = {
+  completionItems: true,
+  hovers: true,
+  documentSymbols: true,
+  definitions: true,
+  references: true,
+  documentHighlights: true,
+  rename: true,
+  colors: true,
+  foldingRanges: true,
+  diagnostics: true,
+  selectionRanges: true,
+  documentFormattingEdits: true,
+  documentRangeFormattingEdits: true
+};
+var cssDefaults = new LanguageServiceDefaultsImpl(
+  "css",
+  optionsDefault,
+  modeConfigurationDefault
+);
+var scssDefaults = new LanguageServiceDefaultsImpl(
+  "scss",
+  optionsDefault,
+  modeConfigurationDefault
+);
+var lessDefaults = new LanguageServiceDefaultsImpl(
+  "less",
+  optionsDefault,
+  modeConfigurationDefault
+);
+monaco_editor_core_exports.languages.css = { cssDefaults, lessDefaults, scssDefaults };
+function getMode() {
+  if (false) {
+    return new Promise((resolve, reject) => {
+      __require(["vs/language/css/cssMode"], resolve, reject);
+    });
+  } else {
+    return import("./cssMode.js");
+  }
+}
+monaco_editor_core_exports.languages.onLanguage("less", () => {
+  getMode().then((mode) => mode.setupMode(lessDefaults));
+});
+monaco_editor_core_exports.languages.onLanguage("scss", () => {
+  getMode().then((mode) => mode.setupMode(scssDefaults));
+});
+monaco_editor_core_exports.languages.onLanguage("css", () => {
+  getMode().then((mode) => mode.setupMode(cssDefaults));
+});
+export {
+  cssDefaults,
+  lessDefaults,
+  scssDefaults
+};

praesentation/node_modules/monaco-editor/esm/vs/language/html/monaco.contribution.d.ts

@@ -0,0 +1 @@
+export {}

praesentation/node_modules/monaco-editor/esm/vs/language/html/monaco.contribution.js

@@ -0,0 +1,157 @@
+import '../../editor/editor.api.js';
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.51.0(67d664a32968e19e2eb08b696a92463804182ae4)
+ * 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 && __copyProps(secondTarget, mod, "default"));
+
+// src/fillers/monaco-editor-core.ts
+var monaco_editor_core_exports = {};
+__reExport(monaco_editor_core_exports, monaco_editor_core_star);
+import * as monaco_editor_core_star from "../../editor/editor.api.js";
+
+// src/language/html/monaco.contribution.ts
+var LanguageServiceDefaultsImpl = class {
+  constructor(languageId, options, modeConfiguration) {
+    this._onDidChange = new monaco_editor_core_exports.Emitter();
+    this._languageId = languageId;
+    this.setOptions(options);
+    this.setModeConfiguration(modeConfiguration);
+  }
+  get onDidChange() {
+    return this._onDidChange.event;
+  }
+  get languageId() {
+    return this._languageId;
+  }
+  get options() {
+    return this._options;
+  }
+  get modeConfiguration() {
+    return this._modeConfiguration;
+  }
+  setOptions(options) {
+    this._options = options || /* @__PURE__ */ Object.create(null);
+    this._onDidChange.fire(this);
+  }
+  setModeConfiguration(modeConfiguration) {
+    this._modeConfiguration = modeConfiguration || /* @__PURE__ */ Object.create(null);
+    this._onDidChange.fire(this);
+  }
+};
+var formatDefaults = {
+  tabSize: 4,
+  insertSpaces: false,
+  wrapLineLength: 120,
+  unformatted: 'default": "a, abbr, acronym, b, bdo, big, br, button, cite, code, dfn, em, i, img, input, kbd, label, map, object, q, samp, select, small, span, strong, sub, sup, textarea, tt, var',
+  contentUnformatted: "pre",
+  indentInnerHtml: false,
+  preserveNewLines: true,
+  maxPreserveNewLines: void 0,
+  indentHandlebars: false,
+  endWithNewline: false,
+  extraLiners: "head, body, /html",
+  wrapAttributes: "auto"
+};
+var optionsDefault = {
+  format: formatDefaults,
+  suggest: {},
+  data: { useDefaultDataProvider: true }
+};
+function getConfigurationDefault(languageId) {
+  return {
+    completionItems: true,
+    hovers: true,
+    documentSymbols: true,
+    links: true,
+    documentHighlights: true,
+    rename: true,
+    colors: true,
+    foldingRanges: true,
+    selectionRanges: true,
+    diagnostics: languageId === htmlLanguageId,
+    // turned off for Razor and Handlebar
+    documentFormattingEdits: languageId === htmlLanguageId,
+    // turned off for Razor and Handlebar
+    documentRangeFormattingEdits: languageId === htmlLanguageId
+    // turned off for Razor and Handlebar
+  };
+}
+var htmlLanguageId = "html";
+var handlebarsLanguageId = "handlebars";
+var razorLanguageId = "razor";
+var htmlLanguageService = registerHTMLLanguageService(
+  htmlLanguageId,
+  optionsDefault,
+  getConfigurationDefault(htmlLanguageId)
+);
+var htmlDefaults = htmlLanguageService.defaults;
+var handlebarLanguageService = registerHTMLLanguageService(
+  handlebarsLanguageId,
+  optionsDefault,
+  getConfigurationDefault(handlebarsLanguageId)
+);
+var handlebarDefaults = handlebarLanguageService.defaults;
+var razorLanguageService = registerHTMLLanguageService(
+  razorLanguageId,
+  optionsDefault,
+  getConfigurationDefault(razorLanguageId)
+);
+var razorDefaults = razorLanguageService.defaults;
+monaco_editor_core_exports.languages.html = {
+  htmlDefaults,
+  razorDefaults,
+  handlebarDefaults,
+  htmlLanguageService,
+  handlebarLanguageService,
+  razorLanguageService,
+  registerHTMLLanguageService
+};
+function getMode() {
+  if (false) {
+    return new Promise((resolve, reject) => {
+      __require(["vs/language/html/htmlMode"], resolve, reject);
+    });
+  } else {
+    return import("./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);
+  });
+  return {
+    defaults,
+    dispose() {
+      onLanguageListener.dispose();
+      mode?.dispose();
+      mode = void 0;
+    }
+  };
+}
+export {
+  handlebarDefaults,
+  handlebarLanguageService,
+  htmlDefaults,
+  htmlLanguageService,
+  razorDefaults,
+  razorLanguageService,
+  registerHTMLLanguageService
+};

praesentation/node_modules/monaco-editor/esm/vs/language/json/monaco.contribution.d.ts

@@ -0,0 +1 @@
+export {}

praesentation/node_modules/monaco-editor/esm/vs/language/json/monaco.contribution.js

@@ -0,0 +1,107 @@
+import '../../editor/editor.api.js';
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.51.0(67d664a32968e19e2eb08b696a92463804182ae4)
+ * 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 && __copyProps(secondTarget, mod, "default"));
+
+// src/fillers/monaco-editor-core.ts
+var monaco_editor_core_exports = {};
+__reExport(monaco_editor_core_exports, monaco_editor_core_star);
+import * as monaco_editor_core_star from "../../editor/editor.api.js";
+
+// src/language/json/monaco.contribution.ts
+var LanguageServiceDefaultsImpl = class {
+  constructor(languageId, diagnosticsOptions, modeConfiguration) {
+    this._onDidChange = new monaco_editor_core_exports.Emitter();
+    this._languageId = languageId;
+    this.setDiagnosticsOptions(diagnosticsOptions);
+    this.setModeConfiguration(modeConfiguration);
+  }
+  get onDidChange() {
+    return this._onDidChange.event;
+  }
+  get languageId() {
+    return this._languageId;
+  }
+  get modeConfiguration() {
+    return this._modeConfiguration;
+  }
+  get diagnosticsOptions() {
+    return this._diagnosticsOptions;
+  }
+  setDiagnosticsOptions(options) {
+    this._diagnosticsOptions = options || /* @__PURE__ */ Object.create(null);
+    this._onDidChange.fire(this);
+  }
+  setModeConfiguration(modeConfiguration) {
+    this._modeConfiguration = modeConfiguration || /* @__PURE__ */ Object.create(null);
+    this._onDidChange.fire(this);
+  }
+};
+var diagnosticDefault = {
+  validate: true,
+  allowComments: true,
+  schemas: [],
+  enableSchemaRequest: false,
+  schemaRequest: "warning",
+  schemaValidation: "warning",
+  comments: "error",
+  trailingCommas: "error"
+};
+var modeConfigurationDefault = {
+  documentFormattingEdits: true,
+  documentRangeFormattingEdits: true,
+  completionItems: true,
+  hovers: true,
+  documentSymbols: true,
+  tokens: true,
+  colors: true,
+  foldingRanges: true,
+  diagnostics: true,
+  selectionRanges: true
+};
+var jsonDefaults = new LanguageServiceDefaultsImpl(
+  "json",
+  diagnosticDefault,
+  modeConfigurationDefault
+);
+var getWorker = () => getMode().then((mode) => mode.getWorker());
+monaco_editor_core_exports.languages.json = { jsonDefaults, getWorker };
+function getMode() {
+  if (false) {
+    return new Promise((resolve, reject) => {
+      __require(["vs/language/json/jsonMode"], resolve, reject);
+    });
+  } else {
+    return import("./jsonMode.js");
+  }
+}
+monaco_editor_core_exports.languages.register({
+  id: "json",
+  extensions: [".json", ".bowerrc", ".jshintrc", ".jscsrc", ".eslintrc", ".babelrc", ".har"],
+  aliases: ["JSON", "json"],
+  mimetypes: ["application/json"]
+});
+monaco_editor_core_exports.languages.onLanguage("json", () => {
+  getMode().then((mode) => mode.setupMode(jsonDefaults));
+});
+export {
+  getWorker,
+  jsonDefaults
+};

praesentation/node_modules/monaco-editor/esm/vs/language/typescript/monaco.contribution.d.ts

@@ -0,0 +1 @@
+export {}

praesentation/node_modules/monaco-editor/esm/vs/language/typescript/monaco.contribution.js

@@ -0,0 +1,286 @@
+import '../../editor/editor.api.js';
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.51.0(67d664a32968e19e2eb08b696a92463804182ae4)
+ * 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 && __copyProps(secondTarget, mod, "default"));
+
+// src/language/typescript/lib/typescriptServicesMetadata.ts
+var typescriptVersion = "5.4.5";
+
+// src/fillers/monaco-editor-core.ts
+var monaco_editor_core_exports = {};
+__reExport(monaco_editor_core_exports, monaco_editor_core_star);
+import * as monaco_editor_core_star from "../../editor/editor.api.js";
+
+// src/language/typescript/monaco.contribution.ts
+var ModuleKind = /* @__PURE__ */ ((ModuleKind2) => {
+  ModuleKind2[ModuleKind2["None"] = 0] = "None";
+  ModuleKind2[ModuleKind2["CommonJS"] = 1] = "CommonJS";
+  ModuleKind2[ModuleKind2["AMD"] = 2] = "AMD";
+  ModuleKind2[ModuleKind2["UMD"] = 3] = "UMD";
+  ModuleKind2[ModuleKind2["System"] = 4] = "System";
+  ModuleKind2[ModuleKind2["ES2015"] = 5] = "ES2015";
+  ModuleKind2[ModuleKind2["ESNext"] = 99] = "ESNext";
+  return ModuleKind2;
+})(ModuleKind || {});
+var JsxEmit = /* @__PURE__ */ ((JsxEmit2) => {
+  JsxEmit2[JsxEmit2["None"] = 0] = "None";
+  JsxEmit2[JsxEmit2["Preserve"] = 1] = "Preserve";
+  JsxEmit2[JsxEmit2["React"] = 2] = "React";
+  JsxEmit2[JsxEmit2["ReactNative"] = 3] = "ReactNative";
+  JsxEmit2[JsxEmit2["ReactJSX"] = 4] = "ReactJSX";
+  JsxEmit2[JsxEmit2["ReactJSXDev"] = 5] = "ReactJSXDev";
+  return JsxEmit2;
+})(JsxEmit || {});
+var NewLineKind = /* @__PURE__ */ ((NewLineKind2) => {
+  NewLineKind2[NewLineKind2["CarriageReturnLineFeed"] = 0] = "CarriageReturnLineFeed";
+  NewLineKind2[NewLineKind2["LineFeed"] = 1] = "LineFeed";
+  return NewLineKind2;
+})(NewLineKind || {});
+var ScriptTarget = /* @__PURE__ */ ((ScriptTarget2) => {
+  ScriptTarget2[ScriptTarget2["ES3"] = 0] = "ES3";
+  ScriptTarget2[ScriptTarget2["ES5"] = 1] = "ES5";
+  ScriptTarget2[ScriptTarget2["ES2015"] = 2] = "ES2015";
+  ScriptTarget2[ScriptTarget2["ES2016"] = 3] = "ES2016";
+  ScriptTarget2[ScriptTarget2["ES2017"] = 4] = "ES2017";
+  ScriptTarget2[ScriptTarget2["ES2018"] = 5] = "ES2018";
+  ScriptTarget2[ScriptTarget2["ES2019"] = 6] = "ES2019";
+  ScriptTarget2[ScriptTarget2["ES2020"] = 7] = "ES2020";
+  ScriptTarget2[ScriptTarget2["ESNext"] = 99] = "ESNext";
+  ScriptTarget2[ScriptTarget2["JSON"] = 100] = "JSON";
+  ScriptTarget2[ScriptTarget2["Latest"] = 99 /* ESNext */] = "Latest";
+  return ScriptTarget2;
+})(ScriptTarget || {});
+var ModuleResolutionKind = /* @__PURE__ */ ((ModuleResolutionKind2) => {
+  ModuleResolutionKind2[ModuleResolutionKind2["Classic"] = 1] = "Classic";
+  ModuleResolutionKind2[ModuleResolutionKind2["NodeJs"] = 2] = "NodeJs";
+  return ModuleResolutionKind2;
+})(ModuleResolutionKind || {});
+var LanguageServiceDefaultsImpl = class {
+  constructor(compilerOptions, diagnosticsOptions, workerOptions, inlayHintsOptions, modeConfiguration) {
+    this._onDidChange = new monaco_editor_core_exports.Emitter();
+    this._onDidExtraLibsChange = new monaco_editor_core_exports.Emitter();
+    this._extraLibs = /* @__PURE__ */ Object.create(null);
+    this._removedExtraLibs = /* @__PURE__ */ Object.create(null);
+    this._eagerModelSync = false;
+    this.setCompilerOptions(compilerOptions);
+    this.setDiagnosticsOptions(diagnosticsOptions);
+    this.setWorkerOptions(workerOptions);
+    this.setInlayHintsOptions(inlayHintsOptions);
+    this.setModeConfiguration(modeConfiguration);
+    this._onDidExtraLibsChangeTimeout = -1;
+  }
+  get onDidChange() {
+    return this._onDidChange.event;
+  }
+  get onDidExtraLibsChange() {
+    return this._onDidExtraLibsChange.event;
+  }
+  get modeConfiguration() {
+    return this._modeConfiguration;
+  }
+  get workerOptions() {
+    return this._workerOptions;
+  }
+  get inlayHintsOptions() {
+    return this._inlayHintsOptions;
+  }
+  getExtraLibs() {
+    return this._extraLibs;
+  }
+  addExtraLib(content, _filePath) {
+    let filePath;
+    if (typeof _filePath === "undefined") {
+      filePath = `ts:extralib-${Math.random().toString(36).substring(2, 15)}`;
+    } else {
+      filePath = _filePath;
+    }
+    if (this._extraLibs[filePath] && this._extraLibs[filePath].content === content) {
+      return {
+        dispose: () => {
+        }
+      };
+    }
+    let myVersion = 1;
+    if (this._removedExtraLibs[filePath]) {
+      myVersion = this._removedExtraLibs[filePath] + 1;
+    }
+    if (this._extraLibs[filePath]) {
+      myVersion = this._extraLibs[filePath].version + 1;
+    }
+    this._extraLibs[filePath] = {
+      content,
+      version: myVersion
+    };
+    this._fireOnDidExtraLibsChangeSoon();
+    return {
+      dispose: () => {
+        let extraLib = this._extraLibs[filePath];
+        if (!extraLib) {
+          return;
+        }
+        if (extraLib.version !== myVersion) {
+          return;
+        }
+        delete this._extraLibs[filePath];
+        this._removedExtraLibs[filePath] = myVersion;
+        this._fireOnDidExtraLibsChangeSoon();
+      }
+    };
+  }
+  setExtraLibs(libs) {
+    for (const filePath in this._extraLibs) {
+      this._removedExtraLibs[filePath] = this._extraLibs[filePath].version;
+    }
+    this._extraLibs = /* @__PURE__ */ Object.create(null);
+    if (libs && libs.length > 0) {
+      for (const lib of libs) {
+        const filePath = lib.filePath || `ts:extralib-${Math.random().toString(36).substring(2, 15)}`;
+        const content = lib.content;
+        let myVersion = 1;
+        if (this._removedExtraLibs[filePath]) {
+          myVersion = this._removedExtraLibs[filePath] + 1;
+        }
+        this._extraLibs[filePath] = {
+          content,
+          version: myVersion
+        };
+      }
+    }
+    this._fireOnDidExtraLibsChangeSoon();
+  }
+  _fireOnDidExtraLibsChangeSoon() {
+    if (this._onDidExtraLibsChangeTimeout !== -1) {
+      return;
+    }
+    this._onDidExtraLibsChangeTimeout = window.setTimeout(() => {
+      this._onDidExtraLibsChangeTimeout = -1;
+      this._onDidExtraLibsChange.fire(void 0);
+    }, 0);
+  }
+  getCompilerOptions() {
+    return this._compilerOptions;
+  }
+  setCompilerOptions(options) {
+    this._compilerOptions = options || /* @__PURE__ */ Object.create(null);
+    this._onDidChange.fire(void 0);
+  }
+  getDiagnosticsOptions() {
+    return this._diagnosticsOptions;
+  }
+  setDiagnosticsOptions(options) {
+    this._diagnosticsOptions = options || /* @__PURE__ */ Object.create(null);
+    this._onDidChange.fire(void 0);
+  }
+  setWorkerOptions(options) {
+    this._workerOptions = options || /* @__PURE__ */ Object.create(null);
+    this._onDidChange.fire(void 0);
+  }
+  setInlayHintsOptions(options) {
+    this._inlayHintsOptions = options || /* @__PURE__ */ Object.create(null);
+    this._onDidChange.fire(void 0);
+  }
+  setMaximumWorkerIdleTime(value) {
+  }
+  setEagerModelSync(value) {
+    this._eagerModelSync = value;
+  }
+  getEagerModelSync() {
+    return this._eagerModelSync;
+  }
+  setModeConfiguration(modeConfiguration) {
+    this._modeConfiguration = modeConfiguration || /* @__PURE__ */ Object.create(null);
+    this._onDidChange.fire(void 0);
+  }
+};
+var typescriptVersion2 = typescriptVersion;
+var modeConfigurationDefault = {
+  completionItems: true,
+  hovers: true,
+  documentSymbols: true,
+  definitions: true,
+  references: true,
+  documentHighlights: true,
+  rename: true,
+  diagnostics: true,
+  documentRangeFormattingEdits: true,
+  signatureHelp: true,
+  onTypeFormattingEdits: true,
+  codeActions: true,
+  inlayHints: true
+};
+var typescriptDefaults = new LanguageServiceDefaultsImpl(
+  { allowNonTsExtensions: true, target: 99 /* Latest */ },
+  { noSemanticValidation: false, noSyntaxValidation: false, onlyVisible: false },
+  {},
+  {},
+  modeConfigurationDefault
+);
+var javascriptDefaults = new LanguageServiceDefaultsImpl(
+  { allowNonTsExtensions: true, allowJs: true, target: 99 /* Latest */ },
+  { noSemanticValidation: true, noSyntaxValidation: false, onlyVisible: false },
+  {},
+  {},
+  modeConfigurationDefault
+);
+var getTypeScriptWorker = () => {
+  return getMode().then((mode) => mode.getTypeScriptWorker());
+};
+var getJavaScriptWorker = () => {
+  return getMode().then((mode) => mode.getJavaScriptWorker());
+};
+monaco_editor_core_exports.languages.typescript = {
+  ModuleKind,
+  JsxEmit,
+  NewLineKind,
+  ScriptTarget,
+  ModuleResolutionKind,
+  typescriptVersion: typescriptVersion2,
+  typescriptDefaults,
+  javascriptDefaults,
+  getTypeScriptWorker,
+  getJavaScriptWorker
+};
+function getMode() {
+  if (false) {
+    return new Promise((resolve, reject) => {
+      __require(["vs/language/typescript/tsMode"], resolve, reject);
+    });
+  } else {
+    return import("./tsMode.js");
+  }
+}
+monaco_editor_core_exports.languages.onLanguage("typescript", () => {
+  return getMode().then((mode) => mode.setupTypeScript(typescriptDefaults));
+});
+monaco_editor_core_exports.languages.onLanguage("javascript", () => {
+  return getMode().then((mode) => mode.setupJavaScript(javascriptDefaults));
+});
+export {
+  JsxEmit,
+  ModuleKind,
+  ModuleResolutionKind,
+  NewLineKind,
+  ScriptTarget,
+  getJavaScriptWorker,
+  getTypeScriptWorker,
+  javascriptDefaults,
+  typescriptDefaults,
+  typescriptVersion2 as typescriptVersion
+};