Add files using upload-large-folder tool

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/python/python.js

@@ -0,0 +1,362 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/python/python", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __commonJS = (cb, mod) => function __require2() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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"));
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/fillers/monaco-editor-core-amd.ts
+  var require_monaco_editor_core_amd = __commonJS({
+    "src/fillers/monaco-editor-core-amd.ts"(exports, module) {
+      var api = __toESM(__require("vs/editor/editor.api"));
+      module.exports = api;
+    }
+  });
+
+  // src/basic-languages/python/python.ts
+  var python_exports = {};
+  __export(python_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+
+  // src/fillers/monaco-editor-core.ts
+  var monaco_editor_core_exports = {};
+  __reExport(monaco_editor_core_exports, __toESM(require_monaco_editor_core_amd()));
+
+  // src/basic-languages/python/python.ts
+  var conf = {
+    comments: {
+      lineComment: "#",
+      blockComment: ["'''", "'''"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"', notIn: ["string"] },
+      { open: "'", close: "'", notIn: ["string", "comment"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    onEnterRules: [
+      {
+        beforeText: new RegExp(
+          "^\\s*(?:def|class|for|if|elif|else|while|try|with|finally|except|async|match|case).*?:\\s*$"
+        ),
+        action: { indentAction: monaco_editor_core_exports.languages.IndentAction.Indent }
+      }
+    ],
+    folding: {
+      offSide: true,
+      markers: {
+        start: new RegExp("^\\s*#region\\b"),
+        end: new RegExp("^\\s*#endregion\\b")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".python",
+    keywords: [
+      // This section is the result of running
+      // `import keyword; for k in sorted(keyword.kwlist + keyword.softkwlist): print("  '" + k + "',")`
+      // in a Python REPL,
+      // though note that the output from Python 3 is not a strict superset of the
+      // output from Python 2.
+      "False",
+      // promoted to keyword.kwlist in Python 3
+      "None",
+      // promoted to keyword.kwlist in Python 3
+      "True",
+      // promoted to keyword.kwlist in Python 3
+      "_",
+      // new in Python 3.10
+      "and",
+      "as",
+      "assert",
+      "async",
+      // new in Python 3
+      "await",
+      // new in Python 3
+      "break",
+      "case",
+      // new in Python 3.10
+      "class",
+      "continue",
+      "def",
+      "del",
+      "elif",
+      "else",
+      "except",
+      "exec",
+      // Python 2, but not 3.
+      "finally",
+      "for",
+      "from",
+      "global",
+      "if",
+      "import",
+      "in",
+      "is",
+      "lambda",
+      "match",
+      // new in Python 3.10
+      "nonlocal",
+      // new in Python 3
+      "not",
+      "or",
+      "pass",
+      "print",
+      // Python 2, but not 3.
+      "raise",
+      "return",
+      "try",
+      "type",
+      // new in Python 3.12
+      "while",
+      "with",
+      "yield",
+      "int",
+      "float",
+      "long",
+      "complex",
+      "hex",
+      "abs",
+      "all",
+      "any",
+      "apply",
+      "basestring",
+      "bin",
+      "bool",
+      "buffer",
+      "bytearray",
+      "callable",
+      "chr",
+      "classmethod",
+      "cmp",
+      "coerce",
+      "compile",
+      "complex",
+      "delattr",
+      "dict",
+      "dir",
+      "divmod",
+      "enumerate",
+      "eval",
+      "execfile",
+      "file",
+      "filter",
+      "format",
+      "frozenset",
+      "getattr",
+      "globals",
+      "hasattr",
+      "hash",
+      "help",
+      "id",
+      "input",
+      "intern",
+      "isinstance",
+      "issubclass",
+      "iter",
+      "len",
+      "locals",
+      "list",
+      "map",
+      "max",
+      "memoryview",
+      "min",
+      "next",
+      "object",
+      "oct",
+      "open",
+      "ord",
+      "pow",
+      "print",
+      "property",
+      "reversed",
+      "range",
+      "raw_input",
+      "reduce",
+      "reload",
+      "repr",
+      "reversed",
+      "round",
+      "self",
+      "set",
+      "setattr",
+      "slice",
+      "sorted",
+      "staticmethod",
+      "str",
+      "sum",
+      "super",
+      "tuple",
+      "type",
+      "unichr",
+      "unicode",
+      "vars",
+      "xrange",
+      "zip",
+      "__dict__",
+      "__methods__",
+      "__members__",
+      "__class__",
+      "__bases__",
+      "__name__",
+      "__mro__",
+      "__subclasses__",
+      "__init__",
+      "__import__"
+    ],
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.bracket" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" }
+    ],
+    tokenizer: {
+      root: [
+        { include: "@whitespace" },
+        { include: "@numbers" },
+        { include: "@strings" },
+        [/[,:;]/, "delimiter"],
+        [/[{}\[\]()]/, "@brackets"],
+        [/@[a-zA-Z_]\w*/, "tag"],
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@keywords": "keyword",
+              "@default": "identifier"
+            }
+          }
+        ]
+      ],
+      // Deal with white space, including single and multi-line comments
+      whitespace: [
+        [/\s+/, "white"],
+        [/(^#.*$)/, "comment"],
+        [/'''/, "string", "@endDocString"],
+        [/"""/, "string", "@endDblDocString"]
+      ],
+      endDocString: [
+        [/[^']+/, "string"],
+        [/\\'/, "string"],
+        [/'''/, "string", "@popall"],
+        [/'/, "string"]
+      ],
+      endDblDocString: [
+        [/[^"]+/, "string"],
+        [/\\"/, "string"],
+        [/"""/, "string", "@popall"],
+        [/"/, "string"]
+      ],
+      // Recognize hex, negatives, decimals, imaginaries, longs, and scientific notation
+      numbers: [
+        [/-?0x([abcdef]|[ABCDEF]|\d)+[lL]?/, "number.hex"],
+        [/-?(\d*\.)?\d+([eE][+\-]?\d+)?[jJ]?[lL]?/, "number"]
+      ],
+      // Recognize strings, including those broken across lines with \ (but not without)
+      strings: [
+        [/'$/, "string.escape", "@popall"],
+        [/f'{1,3}/, "string.escape", "@fStringBody"],
+        [/'/, "string.escape", "@stringBody"],
+        [/"$/, "string.escape", "@popall"],
+        [/f"{1,3}/, "string.escape", "@fDblStringBody"],
+        [/"/, "string.escape", "@dblStringBody"]
+      ],
+      fStringBody: [
+        [/[^\\'\{\}]+$/, "string", "@popall"],
+        [/[^\\'\{\}]+/, "string"],
+        [/\{[^\}':!=]+/, "identifier", "@fStringDetail"],
+        [/\\./, "string"],
+        [/'/, "string.escape", "@popall"],
+        [/\\$/, "string"]
+      ],
+      stringBody: [
+        [/[^\\']+$/, "string", "@popall"],
+        [/[^\\']+/, "string"],
+        [/\\./, "string"],
+        [/'/, "string.escape", "@popall"],
+        [/\\$/, "string"]
+      ],
+      fDblStringBody: [
+        [/[^\\"\{\}]+$/, "string", "@popall"],
+        [/[^\\"\{\}]+/, "string"],
+        [/\{[^\}':!=]+/, "identifier", "@fStringDetail"],
+        [/\\./, "string"],
+        [/"/, "string.escape", "@popall"],
+        [/\\$/, "string"]
+      ],
+      dblStringBody: [
+        [/[^\\"]+$/, "string", "@popall"],
+        [/[^\\"]+/, "string"],
+        [/\\./, "string"],
+        [/"/, "string.escape", "@popall"],
+        [/\\$/, "string"]
+      ],
+      fStringDetail: [
+        [/[:][^}]+/, "string"],
+        [/[!][ars]/, "string"],
+        // only !a, !r, !s are supported by f-strings: https://docs.python.org/3/tutorial/inputoutput.html#formatted-string-literals
+        [/=/, "string"],
+        [/\}/, "identifier", "@pop"]
+      ]
+    }
+  };
+  return __toCommonJS(python_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/sb/sb.js

@@ -0,0 +1,149 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/sb/sb", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/sb/sb.ts
+  var sb_exports = {};
+  __export(sb_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "'"
+    },
+    brackets: [
+      ["(", ")"],
+      ["[", "]"],
+      ["If", "EndIf"],
+      ["While", "EndWhile"],
+      ["For", "EndFor"],
+      ["Sub", "EndSub"]
+    ],
+    autoClosingPairs: [
+      { open: '"', close: '"', notIn: ["string", "comment"] },
+      { open: "(", close: ")", notIn: ["string", "comment"] },
+      { open: "[", close: "]", notIn: ["string", "comment"] }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".sb",
+    ignoreCase: true,
+    brackets: [
+      { token: "delimiter.array", open: "[", close: "]" },
+      { token: "delimiter.parenthesis", open: "(", close: ")" },
+      // Special bracket statement pairs
+      { token: "keyword.tag-if", open: "If", close: "EndIf" },
+      { token: "keyword.tag-while", open: "While", close: "EndWhile" },
+      { token: "keyword.tag-for", open: "For", close: "EndFor" },
+      { token: "keyword.tag-sub", open: "Sub", close: "EndSub" }
+    ],
+    keywords: [
+      "Else",
+      "ElseIf",
+      "EndFor",
+      "EndIf",
+      "EndSub",
+      "EndWhile",
+      "For",
+      "Goto",
+      "If",
+      "Step",
+      "Sub",
+      "Then",
+      "To",
+      "While"
+    ],
+    tagwords: ["If", "Sub", "While", "For"],
+    operators: [">", "<", "<>", "<=", ">=", "And", "Or", "+", "-", "*", "/", "="],
+    // we include these common regular expressions
+    identifier: /[a-zA-Z_][\w]*/,
+    symbols: /[=><:+\-*\/%\.,]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // whitespace
+        { include: "@whitespace" },
+        // classes
+        [/(@identifier)(?=[.])/, "type"],
+        // identifiers, tagwords, and keywords
+        [
+          /@identifier/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@operators": "operator",
+              "@default": "variable.name"
+            }
+          }
+        ],
+        // methods, properties, and events
+        [
+          /([.])(@identifier)/,
+          {
+            cases: {
+              $2: ["delimiter", "type.member"],
+              "@default": ""
+            }
+          }
+        ],
+        // numbers
+        [/\d*\.\d+/, "number.float"],
+        [/\d+/, "number"],
+        // delimiters and operators
+        [/[()\[\]]/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "operator",
+              "@default": "delimiter"
+            }
+          }
+        ],
+        // strings
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/"/, "string", "@string"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/(\').*$/, "comment"]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"C?/, "string", "@pop"]
+      ]
+    }
+  };
+  return __toCommonJS(sb_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/scala/scala.js

@@ -0,0 +1,404 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/scala/scala", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/scala/scala.ts
+  var scala_exports = {};
+  __export(scala_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    /*
+     * `...` is allowed as an identifier.
+     * $ is allowed in identifiers.
+     * unary_<op> is allowed as an identifier.
+     * <name>_= is allowed as an identifier.
+     */
+    wordPattern: /(unary_[@~!#%^&*()\-=+\\|:<>\/?]+)|([a-zA-Z_$][\w$]*?_=)|(`[^`]+`)|([a-zA-Z_$][\w$]*)/g,
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),
+        end: new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")
+      }
+    }
+  };
+  var language = {
+    tokenPostfix: ".scala",
+    // We can't easily add everything from Dotty, but we can at least add some of its keywords
+    keywords: [
+      "asInstanceOf",
+      "catch",
+      "class",
+      "classOf",
+      "def",
+      "do",
+      "else",
+      "extends",
+      "finally",
+      "for",
+      "foreach",
+      "forSome",
+      "if",
+      "import",
+      "isInstanceOf",
+      "macro",
+      "match",
+      "new",
+      "object",
+      "package",
+      "return",
+      "throw",
+      "trait",
+      "try",
+      "type",
+      "until",
+      "val",
+      "var",
+      "while",
+      "with",
+      "yield",
+      // Dotty-specific:
+      "given",
+      "enum",
+      "then"
+    ],
+    // Dotty-specific:
+    softKeywords: ["as", "export", "extension", "end", "derives", "on"],
+    constants: ["true", "false", "null", "this", "super"],
+    modifiers: [
+      "abstract",
+      "final",
+      "implicit",
+      "lazy",
+      "override",
+      "private",
+      "protected",
+      "sealed"
+    ],
+    // Dotty-specific:
+    softModifiers: ["inline", "opaque", "open", "transparent", "using"],
+    name: /(?:[a-z_$][\w$]*|`[^`]+`)/,
+    type: /(?:[A-Z][\w$]*)/,
+    // we include these common regular expressions
+    symbols: /[=><!~?:&|+\-*\/^\\%@#]+/,
+    digits: /\d+(_+\d+)*/,
+    hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+    // C# style strings
+    escapes: /\\(?:[btnfr\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    fstring_conv: /[bBhHsScCdoxXeEfgGaAt]|[Tn](?:[HIklMSLNpzZsQ]|[BbhAaCYyjmde]|[RTrDFC])/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // strings
+        [/\braw"""/, { token: "string.quote", bracket: "@open", next: "@rawstringt" }],
+        [/\braw"/, { token: "string.quote", bracket: "@open", next: "@rawstring" }],
+        [/\bs"""/, { token: "string.quote", bracket: "@open", next: "@sstringt" }],
+        [/\bs"/, { token: "string.quote", bracket: "@open", next: "@sstring" }],
+        [/\bf""""/, { token: "string.quote", bracket: "@open", next: "@fstringt" }],
+        [/\bf"/, { token: "string.quote", bracket: "@open", next: "@fstring" }],
+        [/"""/, { token: "string.quote", bracket: "@open", next: "@stringt" }],
+        [/"/, { token: "string.quote", bracket: "@open", next: "@string" }],
+        // numbers
+        [/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/, "number.float", "@allowMethod"],
+        [/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/, "number.float", "@allowMethod"],
+        [/0[xX](@hexdigits)[Ll]?/, "number.hex", "@allowMethod"],
+        [/(@digits)[fFdD]/, "number.float", "@allowMethod"],
+        [/(@digits)[lL]?/, "number", "@allowMethod"],
+        [/\b_\*/, "key"],
+        [/\b(_)\b/, "keyword", "@allowMethod"],
+        // identifiers and keywords
+        [/\bimport\b/, "keyword", "@import"],
+        [/\b(case)([ \t]+)(class)\b/, ["keyword.modifier", "white", "keyword"]],
+        [/\bcase\b/, "keyword", "@case"],
+        [/\bva[lr]\b/, "keyword", "@vardef"],
+        [
+          /\b(def)([ \t]+)((?:unary_)?@symbols|@name(?:_=)|@name)/,
+          ["keyword", "white", "identifier"]
+        ],
+        [/@name(?=[ \t]*:(?!:))/, "variable"],
+        [/(\.)(@name|@symbols)/, ["operator", { token: "@rematch", next: "@allowMethod" }]],
+        [/([{(])(\s*)(@name(?=\s*=>))/, ["@brackets", "white", "variable"]],
+        [
+          /@name/,
+          {
+            cases: {
+              "@keywords": "keyword",
+              "@softKeywords": "keyword",
+              "@modifiers": "keyword.modifier",
+              "@softModifiers": "keyword.modifier",
+              "@constants": {
+                token: "constant",
+                next: "@allowMethod"
+              },
+              "@default": {
+                token: "identifier",
+                next: "@allowMethod"
+              }
+            }
+          }
+        ],
+        [/@type/, "type", "@allowMethod"],
+        // whitespace
+        { include: "@whitespace" },
+        // @ annotations.
+        [/@[a-zA-Z_$][\w$]*(?:\.[a-zA-Z_$][\w$]*)*/, "annotation"],
+        // delimiters and operators
+        [/[{(]/, "@brackets"],
+        [/[})]/, "@brackets", "@allowMethod"],
+        [/\[/, "operator.square"],
+        [/](?!\s*(?:va[rl]|def|type)\b)/, "operator.square", "@allowMethod"],
+        [/]/, "operator.square"],
+        [/([=-]>|<-|>:|<:|:>|<%)(?=[\s\w()[\]{},\."'`])/, "keyword"],
+        [/@symbols/, "operator"],
+        // delimiter: after number because of .\d floats
+        [/[;,\.]/, "delimiter"],
+        // symbols
+        [/'[a-zA-Z$][\w$]*(?!')/, "attribute.name"],
+        // characters
+        [/'[^\\']'/, "string", "@allowMethod"],
+        [/(')(@escapes)(')/, ["string", "string.escape", { token: "string", next: "@allowMethod" }]],
+        [/'/, "string.invalid"]
+      ],
+      import: [
+        [/;/, "delimiter", "@pop"],
+        [/^|$/, "", "@pop"],
+        [/[ \t]+/, "white"],
+        [/[\n\r]+/, "white", "@pop"],
+        [/\/\*/, "comment", "@comment"],
+        [/@name|@type/, "type"],
+        [/[(){}]/, "@brackets"],
+        [/[[\]]/, "operator.square"],
+        [/[\.,]/, "delimiter"]
+      ],
+      allowMethod: [
+        [/^|$/, "", "@pop"],
+        [/[ \t]+/, "white"],
+        [/[\n\r]+/, "white", "@pop"],
+        [/\/\*/, "comment", "@comment"],
+        [/(?==>[\s\w([{])/, "keyword", "@pop"],
+        [
+          /(@name|@symbols)(?=[ \t]*[[({"'`]|[ \t]+(?:[+-]?\.?\d|\w))/,
+          {
+            cases: {
+              "@keywords": { token: "keyword", next: "@pop" },
+              "->|<-|>:|<:|<%": { token: "keyword", next: "@pop" },
+              "@default": { token: "@rematch", next: "@pop" }
+            }
+          }
+        ],
+        ["", "", "@pop"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\/\*/, "comment", "@push"],
+        // nested comment
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      case: [
+        [/\b_\*/, "key"],
+        [/\b(_|true|false|null|this|super)\b/, "keyword", "@allowMethod"],
+        [/\bif\b|=>/, "keyword", "@pop"],
+        [/`[^`]+`/, "identifier", "@allowMethod"],
+        [/@name/, "variable", "@allowMethod"],
+        [/:::?|\||@(?![a-z_$])/, "keyword"],
+        { include: "@root" }
+      ],
+      vardef: [
+        [/\b_\*/, "key"],
+        [/\b(_|true|false|null|this|super)\b/, "keyword"],
+        [/@name/, "variable"],
+        [/:::?|\||@(?![a-z_$])/, "keyword"],
+        [/=|:(?!:)/, "operator", "@pop"],
+        [/$/, "white", "@pop"],
+        { include: "@root" }
+      ],
+      string: [
+        [/[^\\"\n\r]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [
+          /"/,
+          {
+            token: "string.quote",
+            bracket: "@close",
+            switchTo: "@allowMethod"
+          }
+        ]
+      ],
+      stringt: [
+        [/[^\\"\n\r]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"(?=""")/, "string"],
+        [
+          /"""/,
+          {
+            token: "string.quote",
+            bracket: "@close",
+            switchTo: "@allowMethod"
+          }
+        ],
+        [/"/, "string"]
+      ],
+      fstring: [
+        [/@escapes/, "string.escape"],
+        [
+          /"/,
+          {
+            token: "string.quote",
+            bracket: "@close",
+            switchTo: "@allowMethod"
+          }
+        ],
+        [/\$\$/, "string"],
+        [/(\$)([a-z_]\w*)/, ["operator", "identifier"]],
+        [/\$\{/, "operator", "@interp"],
+        [/%%/, "string"],
+        [
+          /(%)([\-#+ 0,(])(\d+|\.\d+|\d+\.\d+)(@fstring_conv)/,
+          ["metatag", "keyword.modifier", "number", "metatag"]
+        ],
+        [/(%)(\d+|\.\d+|\d+\.\d+)(@fstring_conv)/, ["metatag", "number", "metatag"]],
+        [/(%)([\-#+ 0,(])(@fstring_conv)/, ["metatag", "keyword.modifier", "metatag"]],
+        [/(%)(@fstring_conv)/, ["metatag", "metatag"]],
+        [/./, "string"]
+      ],
+      fstringt: [
+        [/@escapes/, "string.escape"],
+        [/"(?=""")/, "string"],
+        [
+          /"""/,
+          {
+            token: "string.quote",
+            bracket: "@close",
+            switchTo: "@allowMethod"
+          }
+        ],
+        [/\$\$/, "string"],
+        [/(\$)([a-z_]\w*)/, ["operator", "identifier"]],
+        [/\$\{/, "operator", "@interp"],
+        [/%%/, "string"],
+        [
+          /(%)([\-#+ 0,(])(\d+|\.\d+|\d+\.\d+)(@fstring_conv)/,
+          ["metatag", "keyword.modifier", "number", "metatag"]
+        ],
+        [/(%)(\d+|\.\d+|\d+\.\d+)(@fstring_conv)/, ["metatag", "number", "metatag"]],
+        [/(%)([\-#+ 0,(])(@fstring_conv)/, ["metatag", "keyword.modifier", "metatag"]],
+        [/(%)(@fstring_conv)/, ["metatag", "metatag"]],
+        [/./, "string"]
+      ],
+      sstring: [
+        [/@escapes/, "string.escape"],
+        [
+          /"/,
+          {
+            token: "string.quote",
+            bracket: "@close",
+            switchTo: "@allowMethod"
+          }
+        ],
+        [/\$\$/, "string"],
+        [/(\$)([a-z_]\w*)/, ["operator", "identifier"]],
+        [/\$\{/, "operator", "@interp"],
+        [/./, "string"]
+      ],
+      sstringt: [
+        [/@escapes/, "string.escape"],
+        [/"(?=""")/, "string"],
+        [
+          /"""/,
+          {
+            token: "string.quote",
+            bracket: "@close",
+            switchTo: "@allowMethod"
+          }
+        ],
+        [/\$\$/, "string"],
+        [/(\$)([a-z_]\w*)/, ["operator", "identifier"]],
+        [/\$\{/, "operator", "@interp"],
+        [/./, "string"]
+      ],
+      interp: [[/{/, "operator", "@push"], [/}/, "operator", "@pop"], { include: "@root" }],
+      rawstring: [
+        [/[^"]/, "string"],
+        [
+          /"/,
+          {
+            token: "string.quote",
+            bracket: "@close",
+            switchTo: "@allowMethod"
+          }
+        ]
+      ],
+      rawstringt: [
+        [/[^"]/, "string"],
+        [/"(?=""")/, "string"],
+        [
+          /"""/,
+          {
+            token: "string.quote",
+            bracket: "@close",
+            switchTo: "@allowMethod"
+          }
+        ],
+        [/"/, "string"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, "white"],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ]
+    }
+  };
+  return __toCommonJS(scala_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/scheme/scheme.js

@@ -0,0 +1,142 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/scheme/scheme", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/scheme/scheme.ts
+  var scheme_exports = {};
+  __export(scheme_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: ";",
+      blockComment: ["#|", "|#"]
+    },
+    brackets: [
+      ["(", ")"],
+      ["{", "}"],
+      ["[", "]"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    ignoreCase: true,
+    tokenPostfix: ".scheme",
+    brackets: [
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.square" }
+    ],
+    keywords: [
+      "case",
+      "do",
+      "let",
+      "loop",
+      "if",
+      "else",
+      "when",
+      "cons",
+      "car",
+      "cdr",
+      "cond",
+      "lambda",
+      "lambda*",
+      "syntax-rules",
+      "format",
+      "set!",
+      "quote",
+      "eval",
+      "append",
+      "list",
+      "list?",
+      "member?",
+      "load"
+    ],
+    constants: ["#t", "#f"],
+    operators: ["eq?", "eqv?", "equal?", "and", "or", "not", "null?"],
+    tokenizer: {
+      root: [
+        [/#[xXoObB][0-9a-fA-F]+/, "number.hex"],
+        [/[+-]?\d+(?:(?:\.\d*)?(?:[eE][+-]?\d+)?)?/, "number.float"],
+        [
+          /(?:\b(?:(define|define-syntax|define-macro))\b)(\s+)((?:\w|\-|\!|\?)*)/,
+          ["keyword", "white", "variable"]
+        ],
+        { include: "@whitespace" },
+        { include: "@strings" },
+        [
+          /[a-zA-Z_#][a-zA-Z0-9_\-\?\!\*]*/,
+          {
+            cases: {
+              "@keywords": "keyword",
+              "@constants": "constant",
+              "@operators": "operators",
+              "@default": "identifier"
+            }
+          }
+        ]
+      ],
+      comment: [
+        [/[^\|#]+/, "comment"],
+        [/#\|/, "comment", "@push"],
+        [/\|#/, "comment", "@pop"],
+        [/[\|#]/, "comment"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, "white"],
+        [/#\|/, "comment", "@comment"],
+        [/;.*$/, "comment"]
+      ],
+      strings: [
+        [/"$/, "string", "@popall"],
+        [/"(?=.)/, "string", "@multiLineString"]
+      ],
+      multiLineString: [
+        [/[^\\"]+$/, "string", "@popall"],
+        [/[^\\"]+/, "string"],
+        [/\\./, "string.escape"],
+        [/"/, "string", "@popall"],
+        [/\\$/, "string"]
+      ]
+    }
+  };
+  return __toCommonJS(scheme_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/scss/scss.js

@@ -0,0 +1,294 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/scss/scss", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/scss/scss.ts
+  var scss_exports = {};
+  __export(scss_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    wordPattern: /(#?-?\d*\.\d\w*%?)|([@$#!.:]?[\w-?]+%?)|[@#!.]/g,
+    comments: {
+      blockComment: ["/*", "*/"],
+      lineComment: "//"
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}", notIn: ["string", "comment"] },
+      { open: "[", close: "]", notIn: ["string", "comment"] },
+      { open: "(", close: ")", notIn: ["string", "comment"] },
+      { open: '"', close: '"', notIn: ["string", "comment"] },
+      { open: "'", close: "'", notIn: ["string", "comment"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*\\/\\*\\s*#region\\b\\s*(.*?)\\s*\\*\\/"),
+        end: new RegExp("^\\s*\\/\\*\\s*#endregion\\b.*\\*\\/")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".scss",
+    ws: "[ 	\n\r\f]*",
+    // whitespaces (referenced in several rules)
+    identifier: "-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*",
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.bracket" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "<", close: ">", token: "delimiter.angle" }
+    ],
+    tokenizer: {
+      root: [{ include: "@selector" }],
+      selector: [
+        { include: "@comments" },
+        { include: "@import" },
+        { include: "@variabledeclaration" },
+        { include: "@warndebug" },
+        // sass: log statements
+        ["[@](include)", { token: "keyword", next: "@includedeclaration" }],
+        // sass: include statement
+        [
+          "[@](keyframes|-webkit-keyframes|-moz-keyframes|-o-keyframes)",
+          { token: "keyword", next: "@keyframedeclaration" }
+        ],
+        ["[@](page|content|font-face|-moz-document)", { token: "keyword" }],
+        // sass: placeholder for includes
+        ["[@](charset|namespace)", { token: "keyword", next: "@declarationbody" }],
+        ["[@](function)", { token: "keyword", next: "@functiondeclaration" }],
+        ["[@](mixin)", { token: "keyword", next: "@mixindeclaration" }],
+        ["url(\\-prefix)?\\(", { token: "meta", next: "@urldeclaration" }],
+        { include: "@controlstatement" },
+        // sass control statements
+        { include: "@selectorname" },
+        ["[&\\*]", "tag"],
+        // selector symbols
+        ["[>\\+,]", "delimiter"],
+        // selector operators
+        ["\\[", { token: "delimiter.bracket", next: "@selectorattribute" }],
+        ["{", { token: "delimiter.curly", next: "@selectorbody" }]
+      ],
+      selectorbody: [
+        ["[*_]?@identifier@ws:(?=(\\s|\\d|[^{;}]*[;}]))", "attribute.name", "@rulevalue"],
+        // rule definition: to distinguish from a nested selector check for whitespace, number or a semicolon
+        { include: "@selector" },
+        // sass: nested selectors
+        ["[@](extend)", { token: "keyword", next: "@extendbody" }],
+        // sass: extend other selectors
+        ["[@](return)", { token: "keyword", next: "@declarationbody" }],
+        ["}", { token: "delimiter.curly", next: "@pop" }]
+      ],
+      selectorname: [
+        ["#{", { token: "meta", next: "@variableinterpolation" }],
+        // sass: interpolation
+        ["(\\.|#(?=[^{])|%|(@identifier)|:)+", "tag"]
+        // selector (.foo, div, ...)
+      ],
+      selectorattribute: [{ include: "@term" }, ["]", { token: "delimiter.bracket", next: "@pop" }]],
+      term: [
+        { include: "@comments" },
+        ["url(\\-prefix)?\\(", { token: "meta", next: "@urldeclaration" }],
+        { include: "@functioninvocation" },
+        { include: "@numbers" },
+        { include: "@strings" },
+        { include: "@variablereference" },
+        ["(and\\b|or\\b|not\\b)", "operator"],
+        { include: "@name" },
+        ["([<>=\\+\\-\\*\\/\\^\\|\\~,])", "operator"],
+        [",", "delimiter"],
+        ["!default", "literal"],
+        ["\\(", { token: "delimiter.parenthesis", next: "@parenthizedterm" }]
+      ],
+      rulevalue: [
+        { include: "@term" },
+        ["!important", "literal"],
+        [";", "delimiter", "@pop"],
+        ["{", { token: "delimiter.curly", switchTo: "@nestedproperty" }],
+        // sass: nested properties
+        ["(?=})", { token: "", next: "@pop" }]
+        // missing semicolon
+      ],
+      nestedproperty: [
+        ["[*_]?@identifier@ws:", "attribute.name", "@rulevalue"],
+        { include: "@comments" },
+        ["}", { token: "delimiter.curly", next: "@pop" }]
+      ],
+      warndebug: [["[@](warn|debug)", { token: "keyword", next: "@declarationbody" }]],
+      import: [["[@](import)", { token: "keyword", next: "@declarationbody" }]],
+      variabledeclaration: [
+        // sass variables
+        ["\\$@identifier@ws:", "variable.decl", "@declarationbody"]
+      ],
+      urldeclaration: [
+        { include: "@strings" },
+        ["[^)\r\n]+", "string"],
+        ["\\)", { token: "meta", next: "@pop" }]
+      ],
+      parenthizedterm: [
+        { include: "@term" },
+        ["\\)", { token: "delimiter.parenthesis", next: "@pop" }]
+      ],
+      declarationbody: [
+        { include: "@term" },
+        [";", "delimiter", "@pop"],
+        ["(?=})", { token: "", next: "@pop" }]
+        // missing semicolon
+      ],
+      extendbody: [
+        { include: "@selectorname" },
+        ["!optional", "literal"],
+        [";", "delimiter", "@pop"],
+        ["(?=})", { token: "", next: "@pop" }]
+        // missing semicolon
+      ],
+      variablereference: [
+        // sass variable reference
+        ["\\$@identifier", "variable.ref"],
+        ["\\.\\.\\.", "operator"],
+        // var args in reference
+        ["#{", { token: "meta", next: "@variableinterpolation" }]
+        // sass var resolve
+      ],
+      variableinterpolation: [
+        { include: "@variablereference" },
+        ["}", { token: "meta", next: "@pop" }]
+      ],
+      comments: [
+        ["\\/\\*", "comment", "@comment"],
+        ["\\/\\/+.*", "comment"]
+      ],
+      comment: [
+        ["\\*\\/", "comment", "@pop"],
+        [".", "comment"]
+      ],
+      name: [["@identifier", "attribute.value"]],
+      numbers: [
+        ["(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?", { token: "number", next: "@units" }],
+        ["#[0-9a-fA-F_]+(?!\\w)", "number.hex"]
+      ],
+      units: [
+        [
+          "(em|ex|ch|rem|fr|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?",
+          "number",
+          "@pop"
+        ]
+      ],
+      functiondeclaration: [
+        ["@identifier@ws\\(", { token: "meta", next: "@parameterdeclaration" }],
+        ["{", { token: "delimiter.curly", switchTo: "@functionbody" }]
+      ],
+      mixindeclaration: [
+        // mixin with parameters
+        ["@identifier@ws\\(", { token: "meta", next: "@parameterdeclaration" }],
+        // mixin without parameters
+        ["@identifier", "meta"],
+        ["{", { token: "delimiter.curly", switchTo: "@selectorbody" }]
+      ],
+      parameterdeclaration: [
+        ["\\$@identifier@ws:", "variable.decl"],
+        ["\\.\\.\\.", "operator"],
+        // var args in declaration
+        [",", "delimiter"],
+        { include: "@term" },
+        ["\\)", { token: "meta", next: "@pop" }]
+      ],
+      includedeclaration: [
+        { include: "@functioninvocation" },
+        ["@identifier", "meta"],
+        [";", "delimiter", "@pop"],
+        ["(?=})", { token: "", next: "@pop" }],
+        // missing semicolon
+        ["{", { token: "delimiter.curly", switchTo: "@selectorbody" }]
+      ],
+      keyframedeclaration: [
+        ["@identifier", "meta"],
+        ["{", { token: "delimiter.curly", switchTo: "@keyframebody" }]
+      ],
+      keyframebody: [
+        { include: "@term" },
+        ["{", { token: "delimiter.curly", next: "@selectorbody" }],
+        ["}", { token: "delimiter.curly", next: "@pop" }]
+      ],
+      controlstatement: [
+        [
+          "[@](if|else|for|while|each|media)",
+          { token: "keyword.flow", next: "@controlstatementdeclaration" }
+        ]
+      ],
+      controlstatementdeclaration: [
+        ["(in|from|through|if|to)\\b", { token: "keyword.flow" }],
+        { include: "@term" },
+        ["{", { token: "delimiter.curly", switchTo: "@selectorbody" }]
+      ],
+      functionbody: [
+        ["[@](return)", { token: "keyword" }],
+        { include: "@variabledeclaration" },
+        { include: "@term" },
+        { include: "@controlstatement" },
+        [";", "delimiter"],
+        ["}", { token: "delimiter.curly", next: "@pop" }]
+      ],
+      functioninvocation: [["@identifier\\(", { token: "meta", next: "@functionarguments" }]],
+      functionarguments: [
+        ["\\$@identifier@ws:", "attribute.name"],
+        ["[,]", "delimiter"],
+        { include: "@term" },
+        ["\\)", { token: "meta", next: "@pop" }]
+      ],
+      strings: [
+        ['~?"', { token: "string.delimiter", next: "@stringenddoublequote" }],
+        ["~?'", { token: "string.delimiter", next: "@stringendquote" }]
+      ],
+      stringenddoublequote: [
+        ["\\\\.", "string"],
+        ['"', { token: "string.delimiter", next: "@pop" }],
+        [".", "string"]
+      ],
+      stringendquote: [
+        ["\\\\.", "string"],
+        ["'", { token: "string.delimiter", next: "@pop" }],
+        [".", "string"]
+      ]
+    }
+  };
+  return __toCommonJS(scss_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/shell/shell.js

@@ -0,0 +1,255 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/shell/shell", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/shell/shell.ts
+  var shell_exports = {};
+  __export(shell_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "#"
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "`", close: "`" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "`", close: "`" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    ignoreCase: true,
+    tokenPostfix: ".shell",
+    brackets: [
+      { token: "delimiter.bracket", open: "{", close: "}" },
+      { token: "delimiter.parenthesis", open: "(", close: ")" },
+      { token: "delimiter.square", open: "[", close: "]" }
+    ],
+    keywords: [
+      "if",
+      "then",
+      "do",
+      "else",
+      "elif",
+      "while",
+      "until",
+      "for",
+      "in",
+      "esac",
+      "fi",
+      "fin",
+      "fil",
+      "done",
+      "exit",
+      "set",
+      "unset",
+      "export",
+      "function"
+    ],
+    builtins: [
+      "ab",
+      "awk",
+      "bash",
+      "beep",
+      "cat",
+      "cc",
+      "cd",
+      "chown",
+      "chmod",
+      "chroot",
+      "clear",
+      "cp",
+      "curl",
+      "cut",
+      "diff",
+      "echo",
+      "find",
+      "gawk",
+      "gcc",
+      "get",
+      "git",
+      "grep",
+      "hg",
+      "kill",
+      "killall",
+      "ln",
+      "ls",
+      "make",
+      "mkdir",
+      "openssl",
+      "mv",
+      "nc",
+      "node",
+      "npm",
+      "ping",
+      "ps",
+      "restart",
+      "rm",
+      "rmdir",
+      "sed",
+      "service",
+      "sh",
+      "shopt",
+      "shred",
+      "source",
+      "sort",
+      "sleep",
+      "ssh",
+      "start",
+      "stop",
+      "su",
+      "sudo",
+      "svn",
+      "tee",
+      "telnet",
+      "top",
+      "touch",
+      "vi",
+      "vim",
+      "wall",
+      "wc",
+      "wget",
+      "who",
+      "write",
+      "yes",
+      "zsh"
+    ],
+    startingWithDash: /\-+\w+/,
+    identifiersWithDashes: /[a-zA-Z]\w+(?:@startingWithDash)+/,
+    // we include these common regular expressions
+    symbols: /[=><!~?&|+\-*\/\^;\.,]+/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        [/@identifiersWithDashes/, ""],
+        [/(\s)((?:@startingWithDash)+)/, ["white", "attribute.name"]],
+        [
+          /[a-zA-Z]\w*/,
+          {
+            cases: {
+              "@keywords": "keyword",
+              "@builtins": "type.identifier",
+              "@default": ""
+            }
+          }
+        ],
+        { include: "@whitespace" },
+        { include: "@strings" },
+        { include: "@parameters" },
+        { include: "@heredoc" },
+        [/[{}\[\]()]/, "@brackets"],
+        [/@symbols/, "delimiter"],
+        { include: "@numbers" },
+        [/[,;]/, "delimiter"]
+      ],
+      whitespace: [
+        [/\s+/, "white"],
+        [/(^#!.*$)/, "metatag"],
+        [/(^#.*$)/, "comment"]
+      ],
+      numbers: [
+        [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+        [/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, "number.hex"],
+        [/\d+/, "number"]
+      ],
+      // Recognize strings, including those broken across lines
+      strings: [
+        [/'/, "string", "@stringBody"],
+        [/"/, "string", "@dblStringBody"]
+      ],
+      stringBody: [
+        [/'/, "string", "@popall"],
+        [/./, "string"]
+      ],
+      dblStringBody: [
+        [/"/, "string", "@popall"],
+        [/./, "string"]
+      ],
+      heredoc: [
+        [
+          /(<<[-<]?)(\s*)(['"`]?)([\w\-]+)(['"`]?)/,
+          [
+            "constants",
+            "white",
+            "string.heredoc.delimiter",
+            "string.heredoc",
+            "string.heredoc.delimiter"
+          ]
+        ]
+      ],
+      parameters: [
+        [/\$\d+/, "variable.predefined"],
+        [/\$\w+/, "variable"],
+        [/\$[*@#?\-$!0_]/, "variable"],
+        [/\$'/, "variable", "@parameterBodyQuote"],
+        [/\$"/, "variable", "@parameterBodyDoubleQuote"],
+        [/\$\(/, "variable", "@parameterBodyParen"],
+        [/\$\{/, "variable", "@parameterBodyCurlyBrace"]
+      ],
+      parameterBodyQuote: [
+        [/[^#:%*@\-!_']+/, "variable"],
+        [/[#:%*@\-!_]/, "delimiter"],
+        [/[']/, "variable", "@pop"]
+      ],
+      parameterBodyDoubleQuote: [
+        [/[^#:%*@\-!_"]+/, "variable"],
+        [/[#:%*@\-!_]/, "delimiter"],
+        [/["]/, "variable", "@pop"]
+      ],
+      parameterBodyParen: [
+        [/[^#:%*@\-!_)]+/, "variable"],
+        [/[#:%*@\-!_]/, "delimiter"],
+        [/[)]/, "variable", "@pop"]
+      ],
+      parameterBodyCurlyBrace: [
+        [/[^#:%*@\-!_}]+/, "variable"],
+        [/[#:%*@\-!_]/, "delimiter"],
+        [/[}]/, "variable", "@pop"]
+      ]
+    }
+  };
+  return __toCommonJS(shell_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/solidity/solidity.js

@@ -0,0 +1,1401 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/solidity/solidity", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/solidity/solidity.ts
+  var solidity_exports = {};
+  __export(solidity_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"],
+      ["<", ">"]
+    ],
+    autoClosingPairs: [
+      { open: '"', close: '"', notIn: ["string", "comment"] },
+      { open: "{", close: "}", notIn: ["string", "comment"] },
+      { open: "[", close: "]", notIn: ["string", "comment"] },
+      { open: "(", close: ")", notIn: ["string", "comment"] }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".sol",
+    brackets: [
+      { token: "delimiter.curly", open: "{", close: "}" },
+      { token: "delimiter.parenthesis", open: "(", close: ")" },
+      { token: "delimiter.square", open: "[", close: "]" },
+      { token: "delimiter.angle", open: "<", close: ">" }
+    ],
+    keywords: [
+      // Main keywords
+      "pragma",
+      "solidity",
+      "contract",
+      "library",
+      "using",
+      "struct",
+      "function",
+      "modifier",
+      "constructor",
+      //Built-in types
+      "address",
+      "string",
+      "bool",
+      //Other types
+      "Int",
+      "Uint",
+      "Byte",
+      "Fixed",
+      "Ufixed",
+      //All int
+      "int",
+      "int8",
+      "int16",
+      "int24",
+      "int32",
+      "int40",
+      "int48",
+      "int56",
+      "int64",
+      "int72",
+      "int80",
+      "int88",
+      "int96",
+      "int104",
+      "int112",
+      "int120",
+      "int128",
+      "int136",
+      "int144",
+      "int152",
+      "int160",
+      "int168",
+      "int176",
+      "int184",
+      "int192",
+      "int200",
+      "int208",
+      "int216",
+      "int224",
+      "int232",
+      "int240",
+      "int248",
+      "int256",
+      //All uint
+      "uint",
+      "uint8",
+      "uint16",
+      "uint24",
+      "uint32",
+      "uint40",
+      "uint48",
+      "uint56",
+      "uint64",
+      "uint72",
+      "uint80",
+      "uint88",
+      "uint96",
+      "uint104",
+      "uint112",
+      "uint120",
+      "uint128",
+      "uint136",
+      "uint144",
+      "uint152",
+      "uint160",
+      "uint168",
+      "uint176",
+      "uint184",
+      "uint192",
+      "uint200",
+      "uint208",
+      "uint216",
+      "uint224",
+      "uint232",
+      "uint240",
+      "uint248",
+      "uint256",
+      //All Byte
+      "byte",
+      "bytes",
+      "bytes1",
+      "bytes2",
+      "bytes3",
+      "bytes4",
+      "bytes5",
+      "bytes6",
+      "bytes7",
+      "bytes8",
+      "bytes9",
+      "bytes10",
+      "bytes11",
+      "bytes12",
+      "bytes13",
+      "bytes14",
+      "bytes15",
+      "bytes16",
+      "bytes17",
+      "bytes18",
+      "bytes19",
+      "bytes20",
+      "bytes21",
+      "bytes22",
+      "bytes23",
+      "bytes24",
+      "bytes25",
+      "bytes26",
+      "bytes27",
+      "bytes28",
+      "bytes29",
+      "bytes30",
+      "bytes31",
+      "bytes32",
+      //All fixed
+      "fixed",
+      "fixed0x8",
+      "fixed0x16",
+      "fixed0x24",
+      "fixed0x32",
+      "fixed0x40",
+      "fixed0x48",
+      "fixed0x56",
+      "fixed0x64",
+      "fixed0x72",
+      "fixed0x80",
+      "fixed0x88",
+      "fixed0x96",
+      "fixed0x104",
+      "fixed0x112",
+      "fixed0x120",
+      "fixed0x128",
+      "fixed0x136",
+      "fixed0x144",
+      "fixed0x152",
+      "fixed0x160",
+      "fixed0x168",
+      "fixed0x176",
+      "fixed0x184",
+      "fixed0x192",
+      "fixed0x200",
+      "fixed0x208",
+      "fixed0x216",
+      "fixed0x224",
+      "fixed0x232",
+      "fixed0x240",
+      "fixed0x248",
+      "fixed0x256",
+      "fixed8x8",
+      "fixed8x16",
+      "fixed8x24",
+      "fixed8x32",
+      "fixed8x40",
+      "fixed8x48",
+      "fixed8x56",
+      "fixed8x64",
+      "fixed8x72",
+      "fixed8x80",
+      "fixed8x88",
+      "fixed8x96",
+      "fixed8x104",
+      "fixed8x112",
+      "fixed8x120",
+      "fixed8x128",
+      "fixed8x136",
+      "fixed8x144",
+      "fixed8x152",
+      "fixed8x160",
+      "fixed8x168",
+      "fixed8x176",
+      "fixed8x184",
+      "fixed8x192",
+      "fixed8x200",
+      "fixed8x208",
+      "fixed8x216",
+      "fixed8x224",
+      "fixed8x232",
+      "fixed8x240",
+      "fixed8x248",
+      "fixed16x8",
+      "fixed16x16",
+      "fixed16x24",
+      "fixed16x32",
+      "fixed16x40",
+      "fixed16x48",
+      "fixed16x56",
+      "fixed16x64",
+      "fixed16x72",
+      "fixed16x80",
+      "fixed16x88",
+      "fixed16x96",
+      "fixed16x104",
+      "fixed16x112",
+      "fixed16x120",
+      "fixed16x128",
+      "fixed16x136",
+      "fixed16x144",
+      "fixed16x152",
+      "fixed16x160",
+      "fixed16x168",
+      "fixed16x176",
+      "fixed16x184",
+      "fixed16x192",
+      "fixed16x200",
+      "fixed16x208",
+      "fixed16x216",
+      "fixed16x224",
+      "fixed16x232",
+      "fixed16x240",
+      "fixed24x8",
+      "fixed24x16",
+      "fixed24x24",
+      "fixed24x32",
+      "fixed24x40",
+      "fixed24x48",
+      "fixed24x56",
+      "fixed24x64",
+      "fixed24x72",
+      "fixed24x80",
+      "fixed24x88",
+      "fixed24x96",
+      "fixed24x104",
+      "fixed24x112",
+      "fixed24x120",
+      "fixed24x128",
+      "fixed24x136",
+      "fixed24x144",
+      "fixed24x152",
+      "fixed24x160",
+      "fixed24x168",
+      "fixed24x176",
+      "fixed24x184",
+      "fixed24x192",
+      "fixed24x200",
+      "fixed24x208",
+      "fixed24x216",
+      "fixed24x224",
+      "fixed24x232",
+      "fixed32x8",
+      "fixed32x16",
+      "fixed32x24",
+      "fixed32x32",
+      "fixed32x40",
+      "fixed32x48",
+      "fixed32x56",
+      "fixed32x64",
+      "fixed32x72",
+      "fixed32x80",
+      "fixed32x88",
+      "fixed32x96",
+      "fixed32x104",
+      "fixed32x112",
+      "fixed32x120",
+      "fixed32x128",
+      "fixed32x136",
+      "fixed32x144",
+      "fixed32x152",
+      "fixed32x160",
+      "fixed32x168",
+      "fixed32x176",
+      "fixed32x184",
+      "fixed32x192",
+      "fixed32x200",
+      "fixed32x208",
+      "fixed32x216",
+      "fixed32x224",
+      "fixed40x8",
+      "fixed40x16",
+      "fixed40x24",
+      "fixed40x32",
+      "fixed40x40",
+      "fixed40x48",
+      "fixed40x56",
+      "fixed40x64",
+      "fixed40x72",
+      "fixed40x80",
+      "fixed40x88",
+      "fixed40x96",
+      "fixed40x104",
+      "fixed40x112",
+      "fixed40x120",
+      "fixed40x128",
+      "fixed40x136",
+      "fixed40x144",
+      "fixed40x152",
+      "fixed40x160",
+      "fixed40x168",
+      "fixed40x176",
+      "fixed40x184",
+      "fixed40x192",
+      "fixed40x200",
+      "fixed40x208",
+      "fixed40x216",
+      "fixed48x8",
+      "fixed48x16",
+      "fixed48x24",
+      "fixed48x32",
+      "fixed48x40",
+      "fixed48x48",
+      "fixed48x56",
+      "fixed48x64",
+      "fixed48x72",
+      "fixed48x80",
+      "fixed48x88",
+      "fixed48x96",
+      "fixed48x104",
+      "fixed48x112",
+      "fixed48x120",
+      "fixed48x128",
+      "fixed48x136",
+      "fixed48x144",
+      "fixed48x152",
+      "fixed48x160",
+      "fixed48x168",
+      "fixed48x176",
+      "fixed48x184",
+      "fixed48x192",
+      "fixed48x200",
+      "fixed48x208",
+      "fixed56x8",
+      "fixed56x16",
+      "fixed56x24",
+      "fixed56x32",
+      "fixed56x40",
+      "fixed56x48",
+      "fixed56x56",
+      "fixed56x64",
+      "fixed56x72",
+      "fixed56x80",
+      "fixed56x88",
+      "fixed56x96",
+      "fixed56x104",
+      "fixed56x112",
+      "fixed56x120",
+      "fixed56x128",
+      "fixed56x136",
+      "fixed56x144",
+      "fixed56x152",
+      "fixed56x160",
+      "fixed56x168",
+      "fixed56x176",
+      "fixed56x184",
+      "fixed56x192",
+      "fixed56x200",
+      "fixed64x8",
+      "fixed64x16",
+      "fixed64x24",
+      "fixed64x32",
+      "fixed64x40",
+      "fixed64x48",
+      "fixed64x56",
+      "fixed64x64",
+      "fixed64x72",
+      "fixed64x80",
+      "fixed64x88",
+      "fixed64x96",
+      "fixed64x104",
+      "fixed64x112",
+      "fixed64x120",
+      "fixed64x128",
+      "fixed64x136",
+      "fixed64x144",
+      "fixed64x152",
+      "fixed64x160",
+      "fixed64x168",
+      "fixed64x176",
+      "fixed64x184",
+      "fixed64x192",
+      "fixed72x8",
+      "fixed72x16",
+      "fixed72x24",
+      "fixed72x32",
+      "fixed72x40",
+      "fixed72x48",
+      "fixed72x56",
+      "fixed72x64",
+      "fixed72x72",
+      "fixed72x80",
+      "fixed72x88",
+      "fixed72x96",
+      "fixed72x104",
+      "fixed72x112",
+      "fixed72x120",
+      "fixed72x128",
+      "fixed72x136",
+      "fixed72x144",
+      "fixed72x152",
+      "fixed72x160",
+      "fixed72x168",
+      "fixed72x176",
+      "fixed72x184",
+      "fixed80x8",
+      "fixed80x16",
+      "fixed80x24",
+      "fixed80x32",
+      "fixed80x40",
+      "fixed80x48",
+      "fixed80x56",
+      "fixed80x64",
+      "fixed80x72",
+      "fixed80x80",
+      "fixed80x88",
+      "fixed80x96",
+      "fixed80x104",
+      "fixed80x112",
+      "fixed80x120",
+      "fixed80x128",
+      "fixed80x136",
+      "fixed80x144",
+      "fixed80x152",
+      "fixed80x160",
+      "fixed80x168",
+      "fixed80x176",
+      "fixed88x8",
+      "fixed88x16",
+      "fixed88x24",
+      "fixed88x32",
+      "fixed88x40",
+      "fixed88x48",
+      "fixed88x56",
+      "fixed88x64",
+      "fixed88x72",
+      "fixed88x80",
+      "fixed88x88",
+      "fixed88x96",
+      "fixed88x104",
+      "fixed88x112",
+      "fixed88x120",
+      "fixed88x128",
+      "fixed88x136",
+      "fixed88x144",
+      "fixed88x152",
+      "fixed88x160",
+      "fixed88x168",
+      "fixed96x8",
+      "fixed96x16",
+      "fixed96x24",
+      "fixed96x32",
+      "fixed96x40",
+      "fixed96x48",
+      "fixed96x56",
+      "fixed96x64",
+      "fixed96x72",
+      "fixed96x80",
+      "fixed96x88",
+      "fixed96x96",
+      "fixed96x104",
+      "fixed96x112",
+      "fixed96x120",
+      "fixed96x128",
+      "fixed96x136",
+      "fixed96x144",
+      "fixed96x152",
+      "fixed96x160",
+      "fixed104x8",
+      "fixed104x16",
+      "fixed104x24",
+      "fixed104x32",
+      "fixed104x40",
+      "fixed104x48",
+      "fixed104x56",
+      "fixed104x64",
+      "fixed104x72",
+      "fixed104x80",
+      "fixed104x88",
+      "fixed104x96",
+      "fixed104x104",
+      "fixed104x112",
+      "fixed104x120",
+      "fixed104x128",
+      "fixed104x136",
+      "fixed104x144",
+      "fixed104x152",
+      "fixed112x8",
+      "fixed112x16",
+      "fixed112x24",
+      "fixed112x32",
+      "fixed112x40",
+      "fixed112x48",
+      "fixed112x56",
+      "fixed112x64",
+      "fixed112x72",
+      "fixed112x80",
+      "fixed112x88",
+      "fixed112x96",
+      "fixed112x104",
+      "fixed112x112",
+      "fixed112x120",
+      "fixed112x128",
+      "fixed112x136",
+      "fixed112x144",
+      "fixed120x8",
+      "fixed120x16",
+      "fixed120x24",
+      "fixed120x32",
+      "fixed120x40",
+      "fixed120x48",
+      "fixed120x56",
+      "fixed120x64",
+      "fixed120x72",
+      "fixed120x80",
+      "fixed120x88",
+      "fixed120x96",
+      "fixed120x104",
+      "fixed120x112",
+      "fixed120x120",
+      "fixed120x128",
+      "fixed120x136",
+      "fixed128x8",
+      "fixed128x16",
+      "fixed128x24",
+      "fixed128x32",
+      "fixed128x40",
+      "fixed128x48",
+      "fixed128x56",
+      "fixed128x64",
+      "fixed128x72",
+      "fixed128x80",
+      "fixed128x88",
+      "fixed128x96",
+      "fixed128x104",
+      "fixed128x112",
+      "fixed128x120",
+      "fixed128x128",
+      "fixed136x8",
+      "fixed136x16",
+      "fixed136x24",
+      "fixed136x32",
+      "fixed136x40",
+      "fixed136x48",
+      "fixed136x56",
+      "fixed136x64",
+      "fixed136x72",
+      "fixed136x80",
+      "fixed136x88",
+      "fixed136x96",
+      "fixed136x104",
+      "fixed136x112",
+      "fixed136x120",
+      "fixed144x8",
+      "fixed144x16",
+      "fixed144x24",
+      "fixed144x32",
+      "fixed144x40",
+      "fixed144x48",
+      "fixed144x56",
+      "fixed144x64",
+      "fixed144x72",
+      "fixed144x80",
+      "fixed144x88",
+      "fixed144x96",
+      "fixed144x104",
+      "fixed144x112",
+      "fixed152x8",
+      "fixed152x16",
+      "fixed152x24",
+      "fixed152x32",
+      "fixed152x40",
+      "fixed152x48",
+      "fixed152x56",
+      "fixed152x64",
+      "fixed152x72",
+      "fixed152x80",
+      "fixed152x88",
+      "fixed152x96",
+      "fixed152x104",
+      "fixed160x8",
+      "fixed160x16",
+      "fixed160x24",
+      "fixed160x32",
+      "fixed160x40",
+      "fixed160x48",
+      "fixed160x56",
+      "fixed160x64",
+      "fixed160x72",
+      "fixed160x80",
+      "fixed160x88",
+      "fixed160x96",
+      "fixed168x8",
+      "fixed168x16",
+      "fixed168x24",
+      "fixed168x32",
+      "fixed168x40",
+      "fixed168x48",
+      "fixed168x56",
+      "fixed168x64",
+      "fixed168x72",
+      "fixed168x80",
+      "fixed168x88",
+      "fixed176x8",
+      "fixed176x16",
+      "fixed176x24",
+      "fixed176x32",
+      "fixed176x40",
+      "fixed176x48",
+      "fixed176x56",
+      "fixed176x64",
+      "fixed176x72",
+      "fixed176x80",
+      "fixed184x8",
+      "fixed184x16",
+      "fixed184x24",
+      "fixed184x32",
+      "fixed184x40",
+      "fixed184x48",
+      "fixed184x56",
+      "fixed184x64",
+      "fixed184x72",
+      "fixed192x8",
+      "fixed192x16",
+      "fixed192x24",
+      "fixed192x32",
+      "fixed192x40",
+      "fixed192x48",
+      "fixed192x56",
+      "fixed192x64",
+      "fixed200x8",
+      "fixed200x16",
+      "fixed200x24",
+      "fixed200x32",
+      "fixed200x40",
+      "fixed200x48",
+      "fixed200x56",
+      "fixed208x8",
+      "fixed208x16",
+      "fixed208x24",
+      "fixed208x32",
+      "fixed208x40",
+      "fixed208x48",
+      "fixed216x8",
+      "fixed216x16",
+      "fixed216x24",
+      "fixed216x32",
+      "fixed216x40",
+      "fixed224x8",
+      "fixed224x16",
+      "fixed224x24",
+      "fixed224x32",
+      "fixed232x8",
+      "fixed232x16",
+      "fixed232x24",
+      "fixed240x8",
+      "fixed240x16",
+      "fixed248x8",
+      //All ufixed
+      "ufixed",
+      "ufixed0x8",
+      "ufixed0x16",
+      "ufixed0x24",
+      "ufixed0x32",
+      "ufixed0x40",
+      "ufixed0x48",
+      "ufixed0x56",
+      "ufixed0x64",
+      "ufixed0x72",
+      "ufixed0x80",
+      "ufixed0x88",
+      "ufixed0x96",
+      "ufixed0x104",
+      "ufixed0x112",
+      "ufixed0x120",
+      "ufixed0x128",
+      "ufixed0x136",
+      "ufixed0x144",
+      "ufixed0x152",
+      "ufixed0x160",
+      "ufixed0x168",
+      "ufixed0x176",
+      "ufixed0x184",
+      "ufixed0x192",
+      "ufixed0x200",
+      "ufixed0x208",
+      "ufixed0x216",
+      "ufixed0x224",
+      "ufixed0x232",
+      "ufixed0x240",
+      "ufixed0x248",
+      "ufixed0x256",
+      "ufixed8x8",
+      "ufixed8x16",
+      "ufixed8x24",
+      "ufixed8x32",
+      "ufixed8x40",
+      "ufixed8x48",
+      "ufixed8x56",
+      "ufixed8x64",
+      "ufixed8x72",
+      "ufixed8x80",
+      "ufixed8x88",
+      "ufixed8x96",
+      "ufixed8x104",
+      "ufixed8x112",
+      "ufixed8x120",
+      "ufixed8x128",
+      "ufixed8x136",
+      "ufixed8x144",
+      "ufixed8x152",
+      "ufixed8x160",
+      "ufixed8x168",
+      "ufixed8x176",
+      "ufixed8x184",
+      "ufixed8x192",
+      "ufixed8x200",
+      "ufixed8x208",
+      "ufixed8x216",
+      "ufixed8x224",
+      "ufixed8x232",
+      "ufixed8x240",
+      "ufixed8x248",
+      "ufixed16x8",
+      "ufixed16x16",
+      "ufixed16x24",
+      "ufixed16x32",
+      "ufixed16x40",
+      "ufixed16x48",
+      "ufixed16x56",
+      "ufixed16x64",
+      "ufixed16x72",
+      "ufixed16x80",
+      "ufixed16x88",
+      "ufixed16x96",
+      "ufixed16x104",
+      "ufixed16x112",
+      "ufixed16x120",
+      "ufixed16x128",
+      "ufixed16x136",
+      "ufixed16x144",
+      "ufixed16x152",
+      "ufixed16x160",
+      "ufixed16x168",
+      "ufixed16x176",
+      "ufixed16x184",
+      "ufixed16x192",
+      "ufixed16x200",
+      "ufixed16x208",
+      "ufixed16x216",
+      "ufixed16x224",
+      "ufixed16x232",
+      "ufixed16x240",
+      "ufixed24x8",
+      "ufixed24x16",
+      "ufixed24x24",
+      "ufixed24x32",
+      "ufixed24x40",
+      "ufixed24x48",
+      "ufixed24x56",
+      "ufixed24x64",
+      "ufixed24x72",
+      "ufixed24x80",
+      "ufixed24x88",
+      "ufixed24x96",
+      "ufixed24x104",
+      "ufixed24x112",
+      "ufixed24x120",
+      "ufixed24x128",
+      "ufixed24x136",
+      "ufixed24x144",
+      "ufixed24x152",
+      "ufixed24x160",
+      "ufixed24x168",
+      "ufixed24x176",
+      "ufixed24x184",
+      "ufixed24x192",
+      "ufixed24x200",
+      "ufixed24x208",
+      "ufixed24x216",
+      "ufixed24x224",
+      "ufixed24x232",
+      "ufixed32x8",
+      "ufixed32x16",
+      "ufixed32x24",
+      "ufixed32x32",
+      "ufixed32x40",
+      "ufixed32x48",
+      "ufixed32x56",
+      "ufixed32x64",
+      "ufixed32x72",
+      "ufixed32x80",
+      "ufixed32x88",
+      "ufixed32x96",
+      "ufixed32x104",
+      "ufixed32x112",
+      "ufixed32x120",
+      "ufixed32x128",
+      "ufixed32x136",
+      "ufixed32x144",
+      "ufixed32x152",
+      "ufixed32x160",
+      "ufixed32x168",
+      "ufixed32x176",
+      "ufixed32x184",
+      "ufixed32x192",
+      "ufixed32x200",
+      "ufixed32x208",
+      "ufixed32x216",
+      "ufixed32x224",
+      "ufixed40x8",
+      "ufixed40x16",
+      "ufixed40x24",
+      "ufixed40x32",
+      "ufixed40x40",
+      "ufixed40x48",
+      "ufixed40x56",
+      "ufixed40x64",
+      "ufixed40x72",
+      "ufixed40x80",
+      "ufixed40x88",
+      "ufixed40x96",
+      "ufixed40x104",
+      "ufixed40x112",
+      "ufixed40x120",
+      "ufixed40x128",
+      "ufixed40x136",
+      "ufixed40x144",
+      "ufixed40x152",
+      "ufixed40x160",
+      "ufixed40x168",
+      "ufixed40x176",
+      "ufixed40x184",
+      "ufixed40x192",
+      "ufixed40x200",
+      "ufixed40x208",
+      "ufixed40x216",
+      "ufixed48x8",
+      "ufixed48x16",
+      "ufixed48x24",
+      "ufixed48x32",
+      "ufixed48x40",
+      "ufixed48x48",
+      "ufixed48x56",
+      "ufixed48x64",
+      "ufixed48x72",
+      "ufixed48x80",
+      "ufixed48x88",
+      "ufixed48x96",
+      "ufixed48x104",
+      "ufixed48x112",
+      "ufixed48x120",
+      "ufixed48x128",
+      "ufixed48x136",
+      "ufixed48x144",
+      "ufixed48x152",
+      "ufixed48x160",
+      "ufixed48x168",
+      "ufixed48x176",
+      "ufixed48x184",
+      "ufixed48x192",
+      "ufixed48x200",
+      "ufixed48x208",
+      "ufixed56x8",
+      "ufixed56x16",
+      "ufixed56x24",
+      "ufixed56x32",
+      "ufixed56x40",
+      "ufixed56x48",
+      "ufixed56x56",
+      "ufixed56x64",
+      "ufixed56x72",
+      "ufixed56x80",
+      "ufixed56x88",
+      "ufixed56x96",
+      "ufixed56x104",
+      "ufixed56x112",
+      "ufixed56x120",
+      "ufixed56x128",
+      "ufixed56x136",
+      "ufixed56x144",
+      "ufixed56x152",
+      "ufixed56x160",
+      "ufixed56x168",
+      "ufixed56x176",
+      "ufixed56x184",
+      "ufixed56x192",
+      "ufixed56x200",
+      "ufixed64x8",
+      "ufixed64x16",
+      "ufixed64x24",
+      "ufixed64x32",
+      "ufixed64x40",
+      "ufixed64x48",
+      "ufixed64x56",
+      "ufixed64x64",
+      "ufixed64x72",
+      "ufixed64x80",
+      "ufixed64x88",
+      "ufixed64x96",
+      "ufixed64x104",
+      "ufixed64x112",
+      "ufixed64x120",
+      "ufixed64x128",
+      "ufixed64x136",
+      "ufixed64x144",
+      "ufixed64x152",
+      "ufixed64x160",
+      "ufixed64x168",
+      "ufixed64x176",
+      "ufixed64x184",
+      "ufixed64x192",
+      "ufixed72x8",
+      "ufixed72x16",
+      "ufixed72x24",
+      "ufixed72x32",
+      "ufixed72x40",
+      "ufixed72x48",
+      "ufixed72x56",
+      "ufixed72x64",
+      "ufixed72x72",
+      "ufixed72x80",
+      "ufixed72x88",
+      "ufixed72x96",
+      "ufixed72x104",
+      "ufixed72x112",
+      "ufixed72x120",
+      "ufixed72x128",
+      "ufixed72x136",
+      "ufixed72x144",
+      "ufixed72x152",
+      "ufixed72x160",
+      "ufixed72x168",
+      "ufixed72x176",
+      "ufixed72x184",
+      "ufixed80x8",
+      "ufixed80x16",
+      "ufixed80x24",
+      "ufixed80x32",
+      "ufixed80x40",
+      "ufixed80x48",
+      "ufixed80x56",
+      "ufixed80x64",
+      "ufixed80x72",
+      "ufixed80x80",
+      "ufixed80x88",
+      "ufixed80x96",
+      "ufixed80x104",
+      "ufixed80x112",
+      "ufixed80x120",
+      "ufixed80x128",
+      "ufixed80x136",
+      "ufixed80x144",
+      "ufixed80x152",
+      "ufixed80x160",
+      "ufixed80x168",
+      "ufixed80x176",
+      "ufixed88x8",
+      "ufixed88x16",
+      "ufixed88x24",
+      "ufixed88x32",
+      "ufixed88x40",
+      "ufixed88x48",
+      "ufixed88x56",
+      "ufixed88x64",
+      "ufixed88x72",
+      "ufixed88x80",
+      "ufixed88x88",
+      "ufixed88x96",
+      "ufixed88x104",
+      "ufixed88x112",
+      "ufixed88x120",
+      "ufixed88x128",
+      "ufixed88x136",
+      "ufixed88x144",
+      "ufixed88x152",
+      "ufixed88x160",
+      "ufixed88x168",
+      "ufixed96x8",
+      "ufixed96x16",
+      "ufixed96x24",
+      "ufixed96x32",
+      "ufixed96x40",
+      "ufixed96x48",
+      "ufixed96x56",
+      "ufixed96x64",
+      "ufixed96x72",
+      "ufixed96x80",
+      "ufixed96x88",
+      "ufixed96x96",
+      "ufixed96x104",
+      "ufixed96x112",
+      "ufixed96x120",
+      "ufixed96x128",
+      "ufixed96x136",
+      "ufixed96x144",
+      "ufixed96x152",
+      "ufixed96x160",
+      "ufixed104x8",
+      "ufixed104x16",
+      "ufixed104x24",
+      "ufixed104x32",
+      "ufixed104x40",
+      "ufixed104x48",
+      "ufixed104x56",
+      "ufixed104x64",
+      "ufixed104x72",
+      "ufixed104x80",
+      "ufixed104x88",
+      "ufixed104x96",
+      "ufixed104x104",
+      "ufixed104x112",
+      "ufixed104x120",
+      "ufixed104x128",
+      "ufixed104x136",
+      "ufixed104x144",
+      "ufixed104x152",
+      "ufixed112x8",
+      "ufixed112x16",
+      "ufixed112x24",
+      "ufixed112x32",
+      "ufixed112x40",
+      "ufixed112x48",
+      "ufixed112x56",
+      "ufixed112x64",
+      "ufixed112x72",
+      "ufixed112x80",
+      "ufixed112x88",
+      "ufixed112x96",
+      "ufixed112x104",
+      "ufixed112x112",
+      "ufixed112x120",
+      "ufixed112x128",
+      "ufixed112x136",
+      "ufixed112x144",
+      "ufixed120x8",
+      "ufixed120x16",
+      "ufixed120x24",
+      "ufixed120x32",
+      "ufixed120x40",
+      "ufixed120x48",
+      "ufixed120x56",
+      "ufixed120x64",
+      "ufixed120x72",
+      "ufixed120x80",
+      "ufixed120x88",
+      "ufixed120x96",
+      "ufixed120x104",
+      "ufixed120x112",
+      "ufixed120x120",
+      "ufixed120x128",
+      "ufixed120x136",
+      "ufixed128x8",
+      "ufixed128x16",
+      "ufixed128x24",
+      "ufixed128x32",
+      "ufixed128x40",
+      "ufixed128x48",
+      "ufixed128x56",
+      "ufixed128x64",
+      "ufixed128x72",
+      "ufixed128x80",
+      "ufixed128x88",
+      "ufixed128x96",
+      "ufixed128x104",
+      "ufixed128x112",
+      "ufixed128x120",
+      "ufixed128x128",
+      "ufixed136x8",
+      "ufixed136x16",
+      "ufixed136x24",
+      "ufixed136x32",
+      "ufixed136x40",
+      "ufixed136x48",
+      "ufixed136x56",
+      "ufixed136x64",
+      "ufixed136x72",
+      "ufixed136x80",
+      "ufixed136x88",
+      "ufixed136x96",
+      "ufixed136x104",
+      "ufixed136x112",
+      "ufixed136x120",
+      "ufixed144x8",
+      "ufixed144x16",
+      "ufixed144x24",
+      "ufixed144x32",
+      "ufixed144x40",
+      "ufixed144x48",
+      "ufixed144x56",
+      "ufixed144x64",
+      "ufixed144x72",
+      "ufixed144x80",
+      "ufixed144x88",
+      "ufixed144x96",
+      "ufixed144x104",
+      "ufixed144x112",
+      "ufixed152x8",
+      "ufixed152x16",
+      "ufixed152x24",
+      "ufixed152x32",
+      "ufixed152x40",
+      "ufixed152x48",
+      "ufixed152x56",
+      "ufixed152x64",
+      "ufixed152x72",
+      "ufixed152x80",
+      "ufixed152x88",
+      "ufixed152x96",
+      "ufixed152x104",
+      "ufixed160x8",
+      "ufixed160x16",
+      "ufixed160x24",
+      "ufixed160x32",
+      "ufixed160x40",
+      "ufixed160x48",
+      "ufixed160x56",
+      "ufixed160x64",
+      "ufixed160x72",
+      "ufixed160x80",
+      "ufixed160x88",
+      "ufixed160x96",
+      "ufixed168x8",
+      "ufixed168x16",
+      "ufixed168x24",
+      "ufixed168x32",
+      "ufixed168x40",
+      "ufixed168x48",
+      "ufixed168x56",
+      "ufixed168x64",
+      "ufixed168x72",
+      "ufixed168x80",
+      "ufixed168x88",
+      "ufixed176x8",
+      "ufixed176x16",
+      "ufixed176x24",
+      "ufixed176x32",
+      "ufixed176x40",
+      "ufixed176x48",
+      "ufixed176x56",
+      "ufixed176x64",
+      "ufixed176x72",
+      "ufixed176x80",
+      "ufixed184x8",
+      "ufixed184x16",
+      "ufixed184x24",
+      "ufixed184x32",
+      "ufixed184x40",
+      "ufixed184x48",
+      "ufixed184x56",
+      "ufixed184x64",
+      "ufixed184x72",
+      "ufixed192x8",
+      "ufixed192x16",
+      "ufixed192x24",
+      "ufixed192x32",
+      "ufixed192x40",
+      "ufixed192x48",
+      "ufixed192x56",
+      "ufixed192x64",
+      "ufixed200x8",
+      "ufixed200x16",
+      "ufixed200x24",
+      "ufixed200x32",
+      "ufixed200x40",
+      "ufixed200x48",
+      "ufixed200x56",
+      "ufixed208x8",
+      "ufixed208x16",
+      "ufixed208x24",
+      "ufixed208x32",
+      "ufixed208x40",
+      "ufixed208x48",
+      "ufixed216x8",
+      "ufixed216x16",
+      "ufixed216x24",
+      "ufixed216x32",
+      "ufixed216x40",
+      "ufixed224x8",
+      "ufixed224x16",
+      "ufixed224x24",
+      "ufixed224x32",
+      "ufixed232x8",
+      "ufixed232x16",
+      "ufixed232x24",
+      "ufixed240x8",
+      "ufixed240x16",
+      "ufixed248x8",
+      "event",
+      "enum",
+      "let",
+      "mapping",
+      "private",
+      "public",
+      "external",
+      "inherited",
+      "payable",
+      "true",
+      "false",
+      "var",
+      "import",
+      "constant",
+      "if",
+      "else",
+      "for",
+      "else",
+      "for",
+      "while",
+      "do",
+      "break",
+      "continue",
+      "throw",
+      "returns",
+      "return",
+      "suicide",
+      "new",
+      "is",
+      "this",
+      "super"
+    ],
+    operators: [
+      "=",
+      ">",
+      "<",
+      "!",
+      "~",
+      "?",
+      ":",
+      "==",
+      "<=",
+      ">=",
+      "!=",
+      "&&",
+      "||",
+      "++",
+      "--",
+      "+",
+      "-",
+      "*",
+      "/",
+      "&",
+      "|",
+      "^",
+      "%",
+      "<<",
+      ">>",
+      ">>>",
+      "+=",
+      "-=",
+      "*=",
+      "/=",
+      "&=",
+      "|=",
+      "^=",
+      "%=",
+      "<<=",
+      ">>=",
+      ">>>="
+    ],
+    // we include these common regular expressions
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    integersuffix: /(ll|LL|u|U|l|L)?(ll|LL|u|U|l|L)?/,
+    floatsuffix: /[fFlL]?/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // identifiers and keywords
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        // whitespace
+        { include: "@whitespace" },
+        // [[ attributes ]].
+        [/\[\[.*\]\]/, "annotation"],
+        // Preprocessor directive
+        [/^\s*#\w+/, "keyword"],
+        //DataTypes
+        [/int\d*/, "keyword"],
+        // delimiters and operators
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        // numbers
+        [/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/, "number.float"],
+        [/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/, "number.float"],
+        [/0[xX][0-9a-fA-F']*[0-9a-fA-F](@integersuffix)/, "number.hex"],
+        [/0[0-7']*[0-7](@integersuffix)/, "number.octal"],
+        [/0[bB][0-1']*[0-1](@integersuffix)/, "number.binary"],
+        [/\d[\d']*\d(@integersuffix)/, "number"],
+        [/\d(@integersuffix)/, "number"],
+        // delimiter: after number because of .\d floats
+        [/[;,.]/, "delimiter"],
+        // strings
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/"/, "string", "@string"],
+        // characters
+        [/'[^\\']'/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*\*(?!\/)/, "comment.doc", "@doccomment"],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      //Identical copy of comment above, except for the addition of .doc
+      doccomment: [
+        [/[^\/*]+/, "comment.doc"],
+        [/\*\//, "comment.doc", "@pop"],
+        [/[\/*]/, "comment.doc"]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"]
+      ]
+    }
+  };
+  return __toCommonJS(solidity_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/sophia/sophia.js

@@ -0,0 +1,233 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/sophia/sophia", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/sophia/sophia.ts
+  var sophia_exports = {};
+  __export(sophia_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"],
+      ["<", ">"]
+    ],
+    autoClosingPairs: [
+      { open: '"', close: '"', notIn: ["string", "comment"] },
+      { open: "{", close: "}", notIn: ["string", "comment"] },
+      { open: "[", close: "]", notIn: ["string", "comment"] },
+      { open: "(", close: ")", notIn: ["string", "comment"] }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".aes",
+    brackets: [
+      { token: "delimiter.curly", open: "{", close: "}" },
+      { token: "delimiter.parenthesis", open: "(", close: ")" },
+      { token: "delimiter.square", open: "[", close: "]" },
+      { token: "delimiter.angle", open: "<", close: ">" }
+    ],
+    keywords: [
+      // Main keywords
+      "contract",
+      "library",
+      "entrypoint",
+      "function",
+      "stateful",
+      "state",
+      "hash",
+      "signature",
+      "tuple",
+      "list",
+      "address",
+      "string",
+      "bool",
+      "int",
+      "record",
+      "datatype",
+      "type",
+      "option",
+      "oracle",
+      "oracle_query",
+      "Call",
+      "Bits",
+      "Bytes",
+      "Oracle",
+      "String",
+      "Crypto",
+      "Address",
+      "Auth",
+      "Chain",
+      "None",
+      "Some",
+      "bits",
+      "bytes",
+      "event",
+      "let",
+      "map",
+      "private",
+      "public",
+      "true",
+      "false",
+      "var",
+      "if",
+      "else",
+      "throw"
+    ],
+    operators: [
+      "=",
+      ">",
+      "<",
+      "!",
+      "~",
+      "?",
+      "::",
+      ":",
+      "==",
+      "<=",
+      ">=",
+      "!=",
+      "&&",
+      "||",
+      "++",
+      "--",
+      "+",
+      "-",
+      "*",
+      "/",
+      "&",
+      "|",
+      "^",
+      "%",
+      "<<",
+      ">>",
+      ">>>",
+      "+=",
+      "-=",
+      "*=",
+      "/=",
+      "&=",
+      "|=",
+      "^=",
+      "%=",
+      "<<=",
+      ">>=",
+      ">>>="
+    ],
+    // we include these common regular expressions
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    integersuffix: /(ll|LL|u|U|l|L)?(ll|LL|u|U|l|L)?/,
+    floatsuffix: /[fFlL]?/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // identifiers and keywords
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        // whitespace
+        { include: "@whitespace" },
+        // [[ attributes ]].
+        [/\[\[.*\]\]/, "annotation"],
+        // Preprocessor directive
+        [/^\s*#\w+/, "keyword"],
+        //DataTypes
+        [/int\d*/, "keyword"],
+        // delimiters and operators
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        // numbers
+        [/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/, "number.float"],
+        [/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/, "number.float"],
+        [/0[xX][0-9a-fA-F']*[0-9a-fA-F](@integersuffix)/, "number.hex"],
+        [/0[0-7']*[0-7](@integersuffix)/, "number.octal"],
+        [/0[bB][0-1']*[0-1](@integersuffix)/, "number.binary"],
+        [/\d[\d']*\d(@integersuffix)/, "number"],
+        [/\d(@integersuffix)/, "number"],
+        // delimiter: after number because of .\d floats
+        [/[;,.]/, "delimiter"],
+        // strings
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/"/, "string", "@string"],
+        // characters
+        [/'[^\\']'/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*\*(?!\/)/, "comment.doc", "@doccomment"],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      //Identical copy of comment above, except for the addition of .doc
+      doccomment: [
+        [/[^\/*]+/, "comment.doc"],
+        [/\*\//, "comment.doc", "@pop"],
+        [/[\/*]/, "comment.doc"]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"]
+      ]
+    }
+  };
+  return __toCommonJS(sophia_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/sparql/sparql.js

@@ -0,0 +1,235 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/sparql/sparql", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/sparql/sparql.ts
+  var sparql_exports = {};
+  __export(sparql_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "#"
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "'", close: "'", notIn: ["string"] },
+      { open: '"', close: '"', notIn: ["string"] },
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".rq",
+    brackets: [
+      { token: "delimiter.curly", open: "{", close: "}" },
+      { token: "delimiter.parenthesis", open: "(", close: ")" },
+      { token: "delimiter.square", open: "[", close: "]" },
+      { token: "delimiter.angle", open: "<", close: ">" }
+    ],
+    keywords: [
+      "add",
+      "as",
+      "asc",
+      "ask",
+      "base",
+      "by",
+      "clear",
+      "construct",
+      "copy",
+      "create",
+      "data",
+      "delete",
+      "desc",
+      "describe",
+      "distinct",
+      "drop",
+      "false",
+      "filter",
+      "from",
+      "graph",
+      "group",
+      "having",
+      "in",
+      "insert",
+      "limit",
+      "load",
+      "minus",
+      "move",
+      "named",
+      "not",
+      "offset",
+      "optional",
+      "order",
+      "prefix",
+      "reduced",
+      "select",
+      "service",
+      "silent",
+      "to",
+      "true",
+      "undef",
+      "union",
+      "using",
+      "values",
+      "where",
+      "with"
+    ],
+    builtinFunctions: [
+      "a",
+      "abs",
+      "avg",
+      "bind",
+      "bnode",
+      "bound",
+      "ceil",
+      "coalesce",
+      "concat",
+      "contains",
+      "count",
+      "datatype",
+      "day",
+      "encode_for_uri",
+      "exists",
+      "floor",
+      "group_concat",
+      "hours",
+      "if",
+      "iri",
+      "isblank",
+      "isiri",
+      "isliteral",
+      "isnumeric",
+      "isuri",
+      "lang",
+      "langmatches",
+      "lcase",
+      "max",
+      "md5",
+      "min",
+      "minutes",
+      "month",
+      "now",
+      "rand",
+      "regex",
+      "replace",
+      "round",
+      "sameterm",
+      "sample",
+      "seconds",
+      "sha1",
+      "sha256",
+      "sha384",
+      "sha512",
+      "str",
+      "strafter",
+      "strbefore",
+      "strdt",
+      "strends",
+      "strlang",
+      "strlen",
+      "strstarts",
+      "struuid",
+      "substr",
+      "sum",
+      "timezone",
+      "tz",
+      "ucase",
+      "uri",
+      "uuid",
+      "year"
+    ],
+    // describe tokens
+    ignoreCase: true,
+    tokenizer: {
+      root: [
+        // resource indicators
+        [/<[^\s\u00a0>]*>?/, "tag"],
+        // strings
+        { include: "@strings" },
+        // line comment
+        [/#.*/, "comment"],
+        // special chars with special meaning
+        [/[{}()\[\]]/, "@brackets"],
+        [/[;,.]/, "delimiter"],
+        // (prefixed) name
+        [/[_\w\d]+:(\.(?=[\w_\-\\%])|[:\w_-]|\\[-\\_~.!$&'()*+,;=/?#@%]|%[a-f\d][a-f\d])*/, "tag"],
+        [/:(\.(?=[\w_\-\\%])|[:\w_-]|\\[-\\_~.!$&'()*+,;=/?#@%]|%[a-f\d][a-f\d])+/, "tag"],
+        // identifiers, builtinFunctions and keywords
+        [
+          /[$?]?[_\w\d]+/,
+          {
+            cases: {
+              "@keywords": { token: "keyword" },
+              "@builtinFunctions": { token: "predefined.sql" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        // operators
+        [/\^\^/, "operator.sql"],
+        [/\^[*+\-<>=&|^\/!?]*/, "operator.sql"],
+        [/[*+\-<>=&|\/!?]/, "operator.sql"],
+        // symbol
+        [/@[a-z\d\-]*/, "metatag.html"],
+        // whitespaces
+        [/\s+/, "white"]
+      ],
+      strings: [
+        [/'([^'\\]|\\.)*$/, "string.invalid"],
+        // non-terminated single-quoted string
+        [/'$/, "string.sql", "@pop"],
+        [/'/, "string.sql", "@stringBody"],
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        // non-terminated single-quoted string
+        [/"$/, "string.sql", "@pop"],
+        [/"/, "string.sql", "@dblStringBody"]
+      ],
+      // single-quoted strings
+      stringBody: [
+        [/[^\\']+/, "string.sql"],
+        [/\\./, "string.escape"],
+        [/'/, "string.sql", "@pop"]
+      ],
+      // double-quoted strings
+      dblStringBody: [
+        [/[^\\"]+/, "string.sql"],
+        [/\\./, "string.escape"],
+        [/"/, "string.sql", "@pop"]
+      ]
+    }
+  };
+  return __toCommonJS(sparql_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/sql/sql.js

@@ -0,0 +1,887 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/sql/sql", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/sql/sql.ts
+  var sql_exports = {};
+  __export(sql_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "--",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".sql",
+    ignoreCase: true,
+    brackets: [
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" }
+    ],
+    keywords: [
+      // This list is generated using `keywords.js`
+      "ABORT",
+      "ABSOLUTE",
+      "ACTION",
+      "ADA",
+      "ADD",
+      "AFTER",
+      "ALL",
+      "ALLOCATE",
+      "ALTER",
+      "ALWAYS",
+      "ANALYZE",
+      "AND",
+      "ANY",
+      "ARE",
+      "AS",
+      "ASC",
+      "ASSERTION",
+      "AT",
+      "ATTACH",
+      "AUTHORIZATION",
+      "AUTOINCREMENT",
+      "AVG",
+      "BACKUP",
+      "BEFORE",
+      "BEGIN",
+      "BETWEEN",
+      "BIT",
+      "BIT_LENGTH",
+      "BOTH",
+      "BREAK",
+      "BROWSE",
+      "BULK",
+      "BY",
+      "CASCADE",
+      "CASCADED",
+      "CASE",
+      "CAST",
+      "CATALOG",
+      "CHAR",
+      "CHARACTER",
+      "CHARACTER_LENGTH",
+      "CHAR_LENGTH",
+      "CHECK",
+      "CHECKPOINT",
+      "CLOSE",
+      "CLUSTERED",
+      "COALESCE",
+      "COLLATE",
+      "COLLATION",
+      "COLUMN",
+      "COMMIT",
+      "COMPUTE",
+      "CONFLICT",
+      "CONNECT",
+      "CONNECTION",
+      "CONSTRAINT",
+      "CONSTRAINTS",
+      "CONTAINS",
+      "CONTAINSTABLE",
+      "CONTINUE",
+      "CONVERT",
+      "CORRESPONDING",
+      "COUNT",
+      "CREATE",
+      "CROSS",
+      "CURRENT",
+      "CURRENT_DATE",
+      "CURRENT_TIME",
+      "CURRENT_TIMESTAMP",
+      "CURRENT_USER",
+      "CURSOR",
+      "DATABASE",
+      "DATE",
+      "DAY",
+      "DBCC",
+      "DEALLOCATE",
+      "DEC",
+      "DECIMAL",
+      "DECLARE",
+      "DEFAULT",
+      "DEFERRABLE",
+      "DEFERRED",
+      "DELETE",
+      "DENY",
+      "DESC",
+      "DESCRIBE",
+      "DESCRIPTOR",
+      "DETACH",
+      "DIAGNOSTICS",
+      "DISCONNECT",
+      "DISK",
+      "DISTINCT",
+      "DISTRIBUTED",
+      "DO",
+      "DOMAIN",
+      "DOUBLE",
+      "DROP",
+      "DUMP",
+      "EACH",
+      "ELSE",
+      "END",
+      "END-EXEC",
+      "ERRLVL",
+      "ESCAPE",
+      "EXCEPT",
+      "EXCEPTION",
+      "EXCLUDE",
+      "EXCLUSIVE",
+      "EXEC",
+      "EXECUTE",
+      "EXISTS",
+      "EXIT",
+      "EXPLAIN",
+      "EXTERNAL",
+      "EXTRACT",
+      "FAIL",
+      "FALSE",
+      "FETCH",
+      "FILE",
+      "FILLFACTOR",
+      "FILTER",
+      "FIRST",
+      "FLOAT",
+      "FOLLOWING",
+      "FOR",
+      "FOREIGN",
+      "FORTRAN",
+      "FOUND",
+      "FREETEXT",
+      "FREETEXTTABLE",
+      "FROM",
+      "FULL",
+      "FUNCTION",
+      "GENERATED",
+      "GET",
+      "GLOB",
+      "GLOBAL",
+      "GO",
+      "GOTO",
+      "GRANT",
+      "GROUP",
+      "GROUPS",
+      "HAVING",
+      "HOLDLOCK",
+      "HOUR",
+      "IDENTITY",
+      "IDENTITYCOL",
+      "IDENTITY_INSERT",
+      "IF",
+      "IGNORE",
+      "IMMEDIATE",
+      "IN",
+      "INCLUDE",
+      "INDEX",
+      "INDEXED",
+      "INDICATOR",
+      "INITIALLY",
+      "INNER",
+      "INPUT",
+      "INSENSITIVE",
+      "INSERT",
+      "INSTEAD",
+      "INT",
+      "INTEGER",
+      "INTERSECT",
+      "INTERVAL",
+      "INTO",
+      "IS",
+      "ISNULL",
+      "ISOLATION",
+      "JOIN",
+      "KEY",
+      "KILL",
+      "LANGUAGE",
+      "LAST",
+      "LEADING",
+      "LEFT",
+      "LEVEL",
+      "LIKE",
+      "LIMIT",
+      "LINENO",
+      "LOAD",
+      "LOCAL",
+      "LOWER",
+      "MATCH",
+      "MATERIALIZED",
+      "MAX",
+      "MERGE",
+      "MIN",
+      "MINUTE",
+      "MODULE",
+      "MONTH",
+      "NAMES",
+      "NATIONAL",
+      "NATURAL",
+      "NCHAR",
+      "NEXT",
+      "NO",
+      "NOCHECK",
+      "NONCLUSTERED",
+      "NONE",
+      "NOT",
+      "NOTHING",
+      "NOTNULL",
+      "NULL",
+      "NULLIF",
+      "NULLS",
+      "NUMERIC",
+      "OCTET_LENGTH",
+      "OF",
+      "OFF",
+      "OFFSET",
+      "OFFSETS",
+      "ON",
+      "ONLY",
+      "OPEN",
+      "OPENDATASOURCE",
+      "OPENQUERY",
+      "OPENROWSET",
+      "OPENXML",
+      "OPTION",
+      "OR",
+      "ORDER",
+      "OTHERS",
+      "OUTER",
+      "OUTPUT",
+      "OVER",
+      "OVERLAPS",
+      "PAD",
+      "PARTIAL",
+      "PARTITION",
+      "PASCAL",
+      "PERCENT",
+      "PIVOT",
+      "PLAN",
+      "POSITION",
+      "PRAGMA",
+      "PRECEDING",
+      "PRECISION",
+      "PREPARE",
+      "PRESERVE",
+      "PRIMARY",
+      "PRINT",
+      "PRIOR",
+      "PRIVILEGES",
+      "PROC",
+      "PROCEDURE",
+      "PUBLIC",
+      "QUERY",
+      "RAISE",
+      "RAISERROR",
+      "RANGE",
+      "READ",
+      "READTEXT",
+      "REAL",
+      "RECONFIGURE",
+      "RECURSIVE",
+      "REFERENCES",
+      "REGEXP",
+      "REINDEX",
+      "RELATIVE",
+      "RELEASE",
+      "RENAME",
+      "REPLACE",
+      "REPLICATION",
+      "RESTORE",
+      "RESTRICT",
+      "RETURN",
+      "RETURNING",
+      "REVERT",
+      "REVOKE",
+      "RIGHT",
+      "ROLLBACK",
+      "ROW",
+      "ROWCOUNT",
+      "ROWGUIDCOL",
+      "ROWS",
+      "RULE",
+      "SAVE",
+      "SAVEPOINT",
+      "SCHEMA",
+      "SCROLL",
+      "SECOND",
+      "SECTION",
+      "SECURITYAUDIT",
+      "SELECT",
+      "SEMANTICKEYPHRASETABLE",
+      "SEMANTICSIMILARITYDETAILSTABLE",
+      "SEMANTICSIMILARITYTABLE",
+      "SESSION",
+      "SESSION_USER",
+      "SET",
+      "SETUSER",
+      "SHUTDOWN",
+      "SIZE",
+      "SMALLINT",
+      "SOME",
+      "SPACE",
+      "SQL",
+      "SQLCA",
+      "SQLCODE",
+      "SQLERROR",
+      "SQLSTATE",
+      "SQLWARNING",
+      "STATISTICS",
+      "SUBSTRING",
+      "SUM",
+      "SYSTEM_USER",
+      "TABLE",
+      "TABLESAMPLE",
+      "TEMP",
+      "TEMPORARY",
+      "TEXTSIZE",
+      "THEN",
+      "TIES",
+      "TIME",
+      "TIMESTAMP",
+      "TIMEZONE_HOUR",
+      "TIMEZONE_MINUTE",
+      "TO",
+      "TOP",
+      "TRAILING",
+      "TRAN",
+      "TRANSACTION",
+      "TRANSLATE",
+      "TRANSLATION",
+      "TRIGGER",
+      "TRIM",
+      "TRUE",
+      "TRUNCATE",
+      "TRY_CONVERT",
+      "TSEQUAL",
+      "UNBOUNDED",
+      "UNION",
+      "UNIQUE",
+      "UNKNOWN",
+      "UNPIVOT",
+      "UPDATE",
+      "UPDATETEXT",
+      "UPPER",
+      "USAGE",
+      "USE",
+      "USER",
+      "USING",
+      "VACUUM",
+      "VALUE",
+      "VALUES",
+      "VARCHAR",
+      "VARYING",
+      "VIEW",
+      "VIRTUAL",
+      "WAITFOR",
+      "WHEN",
+      "WHENEVER",
+      "WHERE",
+      "WHILE",
+      "WINDOW",
+      "WITH",
+      "WITHIN GROUP",
+      "WITHOUT",
+      "WORK",
+      "WRITE",
+      "WRITETEXT",
+      "YEAR",
+      "ZONE"
+    ],
+    operators: [
+      // Logical
+      "ALL",
+      "AND",
+      "ANY",
+      "BETWEEN",
+      "EXISTS",
+      "IN",
+      "LIKE",
+      "NOT",
+      "OR",
+      "SOME",
+      // Set
+      "EXCEPT",
+      "INTERSECT",
+      "UNION",
+      // Join
+      "APPLY",
+      "CROSS",
+      "FULL",
+      "INNER",
+      "JOIN",
+      "LEFT",
+      "OUTER",
+      "RIGHT",
+      // Predicates
+      "CONTAINS",
+      "FREETEXT",
+      "IS",
+      "NULL",
+      // Pivoting
+      "PIVOT",
+      "UNPIVOT",
+      // Merging
+      "MATCHED"
+    ],
+    builtinFunctions: [
+      // Aggregate
+      "AVG",
+      "CHECKSUM_AGG",
+      "COUNT",
+      "COUNT_BIG",
+      "GROUPING",
+      "GROUPING_ID",
+      "MAX",
+      "MIN",
+      "SUM",
+      "STDEV",
+      "STDEVP",
+      "VAR",
+      "VARP",
+      // Analytic
+      "CUME_DIST",
+      "FIRST_VALUE",
+      "LAG",
+      "LAST_VALUE",
+      "LEAD",
+      "PERCENTILE_CONT",
+      "PERCENTILE_DISC",
+      "PERCENT_RANK",
+      // Collation
+      "COLLATE",
+      "COLLATIONPROPERTY",
+      "TERTIARY_WEIGHTS",
+      // Azure
+      "FEDERATION_FILTERING_VALUE",
+      // Conversion
+      "CAST",
+      "CONVERT",
+      "PARSE",
+      "TRY_CAST",
+      "TRY_CONVERT",
+      "TRY_PARSE",
+      // Cryptographic
+      "ASYMKEY_ID",
+      "ASYMKEYPROPERTY",
+      "CERTPROPERTY",
+      "CERT_ID",
+      "CRYPT_GEN_RANDOM",
+      "DECRYPTBYASYMKEY",
+      "DECRYPTBYCERT",
+      "DECRYPTBYKEY",
+      "DECRYPTBYKEYAUTOASYMKEY",
+      "DECRYPTBYKEYAUTOCERT",
+      "DECRYPTBYPASSPHRASE",
+      "ENCRYPTBYASYMKEY",
+      "ENCRYPTBYCERT",
+      "ENCRYPTBYKEY",
+      "ENCRYPTBYPASSPHRASE",
+      "HASHBYTES",
+      "IS_OBJECTSIGNED",
+      "KEY_GUID",
+      "KEY_ID",
+      "KEY_NAME",
+      "SIGNBYASYMKEY",
+      "SIGNBYCERT",
+      "SYMKEYPROPERTY",
+      "VERIFYSIGNEDBYCERT",
+      "VERIFYSIGNEDBYASYMKEY",
+      // Cursor
+      "CURSOR_STATUS",
+      // Datatype
+      "DATALENGTH",
+      "IDENT_CURRENT",
+      "IDENT_INCR",
+      "IDENT_SEED",
+      "IDENTITY",
+      "SQL_VARIANT_PROPERTY",
+      // Datetime
+      "CURRENT_TIMESTAMP",
+      "DATEADD",
+      "DATEDIFF",
+      "DATEFROMPARTS",
+      "DATENAME",
+      "DATEPART",
+      "DATETIME2FROMPARTS",
+      "DATETIMEFROMPARTS",
+      "DATETIMEOFFSETFROMPARTS",
+      "DAY",
+      "EOMONTH",
+      "GETDATE",
+      "GETUTCDATE",
+      "ISDATE",
+      "MONTH",
+      "SMALLDATETIMEFROMPARTS",
+      "SWITCHOFFSET",
+      "SYSDATETIME",
+      "SYSDATETIMEOFFSET",
+      "SYSUTCDATETIME",
+      "TIMEFROMPARTS",
+      "TODATETIMEOFFSET",
+      "YEAR",
+      // Logical
+      "CHOOSE",
+      "COALESCE",
+      "IIF",
+      "NULLIF",
+      // Mathematical
+      "ABS",
+      "ACOS",
+      "ASIN",
+      "ATAN",
+      "ATN2",
+      "CEILING",
+      "COS",
+      "COT",
+      "DEGREES",
+      "EXP",
+      "FLOOR",
+      "LOG",
+      "LOG10",
+      "PI",
+      "POWER",
+      "RADIANS",
+      "RAND",
+      "ROUND",
+      "SIGN",
+      "SIN",
+      "SQRT",
+      "SQUARE",
+      "TAN",
+      // Metadata
+      "APP_NAME",
+      "APPLOCK_MODE",
+      "APPLOCK_TEST",
+      "ASSEMBLYPROPERTY",
+      "COL_LENGTH",
+      "COL_NAME",
+      "COLUMNPROPERTY",
+      "DATABASE_PRINCIPAL_ID",
+      "DATABASEPROPERTYEX",
+      "DB_ID",
+      "DB_NAME",
+      "FILE_ID",
+      "FILE_IDEX",
+      "FILE_NAME",
+      "FILEGROUP_ID",
+      "FILEGROUP_NAME",
+      "FILEGROUPPROPERTY",
+      "FILEPROPERTY",
+      "FULLTEXTCATALOGPROPERTY",
+      "FULLTEXTSERVICEPROPERTY",
+      "INDEX_COL",
+      "INDEXKEY_PROPERTY",
+      "INDEXPROPERTY",
+      "OBJECT_DEFINITION",
+      "OBJECT_ID",
+      "OBJECT_NAME",
+      "OBJECT_SCHEMA_NAME",
+      "OBJECTPROPERTY",
+      "OBJECTPROPERTYEX",
+      "ORIGINAL_DB_NAME",
+      "PARSENAME",
+      "SCHEMA_ID",
+      "SCHEMA_NAME",
+      "SCOPE_IDENTITY",
+      "SERVERPROPERTY",
+      "STATS_DATE",
+      "TYPE_ID",
+      "TYPE_NAME",
+      "TYPEPROPERTY",
+      // Ranking
+      "DENSE_RANK",
+      "NTILE",
+      "RANK",
+      "ROW_NUMBER",
+      // Replication
+      "PUBLISHINGSERVERNAME",
+      // Rowset
+      "OPENDATASOURCE",
+      "OPENQUERY",
+      "OPENROWSET",
+      "OPENXML",
+      // Security
+      "CERTENCODED",
+      "CERTPRIVATEKEY",
+      "CURRENT_USER",
+      "HAS_DBACCESS",
+      "HAS_PERMS_BY_NAME",
+      "IS_MEMBER",
+      "IS_ROLEMEMBER",
+      "IS_SRVROLEMEMBER",
+      "LOGINPROPERTY",
+      "ORIGINAL_LOGIN",
+      "PERMISSIONS",
+      "PWDENCRYPT",
+      "PWDCOMPARE",
+      "SESSION_USER",
+      "SESSIONPROPERTY",
+      "SUSER_ID",
+      "SUSER_NAME",
+      "SUSER_SID",
+      "SUSER_SNAME",
+      "SYSTEM_USER",
+      "USER",
+      "USER_ID",
+      "USER_NAME",
+      // String
+      "ASCII",
+      "CHAR",
+      "CHARINDEX",
+      "CONCAT",
+      "DIFFERENCE",
+      "FORMAT",
+      "LEFT",
+      "LEN",
+      "LOWER",
+      "LTRIM",
+      "NCHAR",
+      "PATINDEX",
+      "QUOTENAME",
+      "REPLACE",
+      "REPLICATE",
+      "REVERSE",
+      "RIGHT",
+      "RTRIM",
+      "SOUNDEX",
+      "SPACE",
+      "STR",
+      "STUFF",
+      "SUBSTRING",
+      "UNICODE",
+      "UPPER",
+      // System
+      "BINARY_CHECKSUM",
+      "CHECKSUM",
+      "CONNECTIONPROPERTY",
+      "CONTEXT_INFO",
+      "CURRENT_REQUEST_ID",
+      "ERROR_LINE",
+      "ERROR_NUMBER",
+      "ERROR_MESSAGE",
+      "ERROR_PROCEDURE",
+      "ERROR_SEVERITY",
+      "ERROR_STATE",
+      "FORMATMESSAGE",
+      "GETANSINULL",
+      "GET_FILESTREAM_TRANSACTION_CONTEXT",
+      "HOST_ID",
+      "HOST_NAME",
+      "ISNULL",
+      "ISNUMERIC",
+      "MIN_ACTIVE_ROWVERSION",
+      "NEWID",
+      "NEWSEQUENTIALID",
+      "ROWCOUNT_BIG",
+      "XACT_STATE",
+      // TextImage
+      "TEXTPTR",
+      "TEXTVALID",
+      // Trigger
+      "COLUMNS_UPDATED",
+      "EVENTDATA",
+      "TRIGGER_NESTLEVEL",
+      "UPDATE",
+      // ChangeTracking
+      "CHANGETABLE",
+      "CHANGE_TRACKING_CONTEXT",
+      "CHANGE_TRACKING_CURRENT_VERSION",
+      "CHANGE_TRACKING_IS_COLUMN_IN_MASK",
+      "CHANGE_TRACKING_MIN_VALID_VERSION",
+      // FullTextSearch
+      "CONTAINSTABLE",
+      "FREETEXTTABLE",
+      // SemanticTextSearch
+      "SEMANTICKEYPHRASETABLE",
+      "SEMANTICSIMILARITYDETAILSTABLE",
+      "SEMANTICSIMILARITYTABLE",
+      // FileStream
+      "FILETABLEROOTPATH",
+      "GETFILENAMESPACEPATH",
+      "GETPATHLOCATOR",
+      "PATHNAME",
+      // ServiceBroker
+      "GET_TRANSMISSION_STATUS"
+    ],
+    builtinVariables: [
+      // Configuration
+      "@@DATEFIRST",
+      "@@DBTS",
+      "@@LANGID",
+      "@@LANGUAGE",
+      "@@LOCK_TIMEOUT",
+      "@@MAX_CONNECTIONS",
+      "@@MAX_PRECISION",
+      "@@NESTLEVEL",
+      "@@OPTIONS",
+      "@@REMSERVER",
+      "@@SERVERNAME",
+      "@@SERVICENAME",
+      "@@SPID",
+      "@@TEXTSIZE",
+      "@@VERSION",
+      // Cursor
+      "@@CURSOR_ROWS",
+      "@@FETCH_STATUS",
+      // Datetime
+      "@@DATEFIRST",
+      // Metadata
+      "@@PROCID",
+      // System
+      "@@ERROR",
+      "@@IDENTITY",
+      "@@ROWCOUNT",
+      "@@TRANCOUNT",
+      // Stats
+      "@@CONNECTIONS",
+      "@@CPU_BUSY",
+      "@@IDLE",
+      "@@IO_BUSY",
+      "@@PACKET_ERRORS",
+      "@@PACK_RECEIVED",
+      "@@PACK_SENT",
+      "@@TIMETICKS",
+      "@@TOTAL_ERRORS",
+      "@@TOTAL_READ",
+      "@@TOTAL_WRITE"
+    ],
+    pseudoColumns: ["$ACTION", "$IDENTITY", "$ROWGUID", "$PARTITION"],
+    tokenizer: {
+      root: [
+        { include: "@comments" },
+        { include: "@whitespace" },
+        { include: "@pseudoColumns" },
+        { include: "@numbers" },
+        { include: "@strings" },
+        { include: "@complexIdentifiers" },
+        { include: "@scopes" },
+        [/[;,.]/, "delimiter"],
+        [/[()]/, "@brackets"],
+        [
+          /[\w@#$]+/,
+          {
+            cases: {
+              "@operators": "operator",
+              "@builtinVariables": "predefined",
+              "@builtinFunctions": "predefined",
+              "@keywords": "keyword",
+              "@default": "identifier"
+            }
+          }
+        ],
+        [/[<>=!%&+\-*/|~^]/, "operator"]
+      ],
+      whitespace: [[/\s+/, "white"]],
+      comments: [
+        [/--+.*/, "comment"],
+        [/\/\*/, { token: "comment.quote", next: "@comment" }]
+      ],
+      comment: [
+        [/[^*/]+/, "comment"],
+        // Not supporting nested comments, as nested comments seem to not be standard?
+        // i.e. http://stackoverflow.com/questions/728172/are-there-multiline-comment-delimiters-in-sql-that-are-vendor-agnostic
+        // [/\/\*/, { token: 'comment.quote', next: '@push' }],    // nested comment not allowed :-(
+        [/\*\//, { token: "comment.quote", next: "@pop" }],
+        [/./, "comment"]
+      ],
+      pseudoColumns: [
+        [
+          /[$][A-Za-z_][\w@#$]*/,
+          {
+            cases: {
+              "@pseudoColumns": "predefined",
+              "@default": "identifier"
+            }
+          }
+        ]
+      ],
+      numbers: [
+        [/0[xX][0-9a-fA-F]*/, "number"],
+        [/[$][+-]*\d*(\.\d*)?/, "number"],
+        [/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, "number"]
+      ],
+      strings: [
+        [/N'/, { token: "string", next: "@string" }],
+        [/'/, { token: "string", next: "@string" }]
+      ],
+      string: [
+        [/[^']+/, "string"],
+        [/''/, "string"],
+        [/'/, { token: "string", next: "@pop" }]
+      ],
+      complexIdentifiers: [
+        [/\[/, { token: "identifier.quote", next: "@bracketedIdentifier" }],
+        [/"/, { token: "identifier.quote", next: "@quotedIdentifier" }]
+      ],
+      bracketedIdentifier: [
+        [/[^\]]+/, "identifier"],
+        [/]]/, "identifier"],
+        [/]/, { token: "identifier.quote", next: "@pop" }]
+      ],
+      quotedIdentifier: [
+        [/[^"]+/, "identifier"],
+        [/""/, "identifier"],
+        [/"/, { token: "identifier.quote", next: "@pop" }]
+      ],
+      scopes: [
+        [/BEGIN\s+(DISTRIBUTED\s+)?TRAN(SACTION)?\b/i, "keyword"],
+        [/BEGIN\s+TRY\b/i, { token: "keyword.try" }],
+        [/END\s+TRY\b/i, { token: "keyword.try" }],
+        [/BEGIN\s+CATCH\b/i, { token: "keyword.catch" }],
+        [/END\s+CATCH\b/i, { token: "keyword.catch" }],
+        [/(BEGIN|CASE)\b/i, { token: "keyword.block" }],
+        [/END\b/i, { token: "keyword.block" }],
+        [/WHEN\b/i, { token: "keyword.choice" }],
+        [/THEN\b/i, { token: "keyword.choice" }]
+      ]
+    }
+  };
+  return __toCommonJS(sql_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/st/st.js

@@ -0,0 +1,450 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/st/st", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/st/st.ts
+  var st_exports = {};
+  __export(st_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["(*", "*)"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"],
+      ["var", "end_var"],
+      ["var_input", "end_var"],
+      ["var_output", "end_var"],
+      ["var_in_out", "end_var"],
+      ["var_temp", "end_var"],
+      ["var_global", "end_var"],
+      ["var_access", "end_var"],
+      ["var_external", "end_var"],
+      ["type", "end_type"],
+      ["struct", "end_struct"],
+      ["program", "end_program"],
+      ["function", "end_function"],
+      ["function_block", "end_function_block"],
+      ["action", "end_action"],
+      ["step", "end_step"],
+      ["initial_step", "end_step"],
+      ["transaction", "end_transaction"],
+      ["configuration", "end_configuration"],
+      ["tcp", "end_tcp"],
+      ["recource", "end_recource"],
+      ["channel", "end_channel"],
+      ["library", "end_library"],
+      ["folder", "end_folder"],
+      ["binaries", "end_binaries"],
+      ["includes", "end_includes"],
+      ["sources", "end_sources"]
+    ],
+    autoClosingPairs: [
+      { open: "[", close: "]" },
+      { open: "{", close: "}" },
+      { open: "(", close: ")" },
+      { open: "/*", close: "*/" },
+      { open: "'", close: "'", notIn: ["string_sq"] },
+      { open: '"', close: '"', notIn: ["string_dq"] },
+      { open: "var_input", close: "end_var" },
+      { open: "var_output", close: "end_var" },
+      { open: "var_in_out", close: "end_var" },
+      { open: "var_temp", close: "end_var" },
+      { open: "var_global", close: "end_var" },
+      { open: "var_access", close: "end_var" },
+      { open: "var_external", close: "end_var" },
+      { open: "type", close: "end_type" },
+      { open: "struct", close: "end_struct" },
+      { open: "program", close: "end_program" },
+      { open: "function", close: "end_function" },
+      { open: "function_block", close: "end_function_block" },
+      { open: "action", close: "end_action" },
+      { open: "step", close: "end_step" },
+      { open: "initial_step", close: "end_step" },
+      { open: "transaction", close: "end_transaction" },
+      { open: "configuration", close: "end_configuration" },
+      { open: "tcp", close: "end_tcp" },
+      { open: "recource", close: "end_recource" },
+      { open: "channel", close: "end_channel" },
+      { open: "library", close: "end_library" },
+      { open: "folder", close: "end_folder" },
+      { open: "binaries", close: "end_binaries" },
+      { open: "includes", close: "end_includes" },
+      { open: "sources", close: "end_sources" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "var", close: "end_var" },
+      { open: "var_input", close: "end_var" },
+      { open: "var_output", close: "end_var" },
+      { open: "var_in_out", close: "end_var" },
+      { open: "var_temp", close: "end_var" },
+      { open: "var_global", close: "end_var" },
+      { open: "var_access", close: "end_var" },
+      { open: "var_external", close: "end_var" },
+      { open: "type", close: "end_type" },
+      { open: "struct", close: "end_struct" },
+      { open: "program", close: "end_program" },
+      { open: "function", close: "end_function" },
+      { open: "function_block", close: "end_function_block" },
+      { open: "action", close: "end_action" },
+      { open: "step", close: "end_step" },
+      { open: "initial_step", close: "end_step" },
+      { open: "transaction", close: "end_transaction" },
+      { open: "configuration", close: "end_configuration" },
+      { open: "tcp", close: "end_tcp" },
+      { open: "recource", close: "end_recource" },
+      { open: "channel", close: "end_channel" },
+      { open: "library", close: "end_library" },
+      { open: "folder", close: "end_folder" },
+      { open: "binaries", close: "end_binaries" },
+      { open: "includes", close: "end_includes" },
+      { open: "sources", close: "end_sources" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*#pragma\\s+region\\b"),
+        end: new RegExp("^\\s*#pragma\\s+endregion\\b")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".st",
+    ignoreCase: true,
+    brackets: [
+      { token: "delimiter.curly", open: "{", close: "}" },
+      { token: "delimiter.parenthesis", open: "(", close: ")" },
+      { token: "delimiter.square", open: "[", close: "]" }
+    ],
+    keywords: [
+      "if",
+      "end_if",
+      "elsif",
+      "else",
+      "case",
+      "of",
+      "to",
+      "__try",
+      "__catch",
+      "__finally",
+      "do",
+      "with",
+      "by",
+      "while",
+      "repeat",
+      "end_while",
+      "end_repeat",
+      "end_case",
+      "for",
+      "end_for",
+      "task",
+      "retain",
+      "non_retain",
+      "constant",
+      "with",
+      "at",
+      "exit",
+      "return",
+      "interval",
+      "priority",
+      "address",
+      "port",
+      "on_channel",
+      "then",
+      "iec",
+      "file",
+      "uses",
+      "version",
+      "packagetype",
+      "displayname",
+      "copyright",
+      "summary",
+      "vendor",
+      "common_source",
+      "from",
+      "extends",
+      "implements"
+    ],
+    constant: ["false", "true", "null"],
+    defineKeywords: [
+      "var",
+      "var_input",
+      "var_output",
+      "var_in_out",
+      "var_temp",
+      "var_global",
+      "var_access",
+      "var_external",
+      "end_var",
+      "type",
+      "end_type",
+      "struct",
+      "end_struct",
+      "program",
+      "end_program",
+      "function",
+      "end_function",
+      "function_block",
+      "end_function_block",
+      "interface",
+      "end_interface",
+      "method",
+      "end_method",
+      "property",
+      "end_property",
+      "namespace",
+      "end_namespace",
+      "configuration",
+      "end_configuration",
+      "tcp",
+      "end_tcp",
+      "resource",
+      "end_resource",
+      "channel",
+      "end_channel",
+      "library",
+      "end_library",
+      "folder",
+      "end_folder",
+      "binaries",
+      "end_binaries",
+      "includes",
+      "end_includes",
+      "sources",
+      "end_sources",
+      "action",
+      "end_action",
+      "step",
+      "initial_step",
+      "end_step",
+      "transaction",
+      "end_transaction"
+    ],
+    typeKeywords: [
+      "int",
+      "sint",
+      "dint",
+      "lint",
+      "usint",
+      "uint",
+      "udint",
+      "ulint",
+      "real",
+      "lreal",
+      "time",
+      "date",
+      "time_of_day",
+      "date_and_time",
+      "string",
+      "bool",
+      "byte",
+      "word",
+      "dword",
+      "array",
+      "pointer",
+      "lword"
+    ],
+    operators: [
+      "=",
+      ">",
+      "<",
+      ":",
+      ":=",
+      "<=",
+      ">=",
+      "<>",
+      "&",
+      "+",
+      "-",
+      "*",
+      "**",
+      "MOD",
+      "^",
+      "or",
+      "and",
+      "not",
+      "xor",
+      "abs",
+      "acos",
+      "asin",
+      "atan",
+      "cos",
+      "exp",
+      "expt",
+      "ln",
+      "log",
+      "sin",
+      "sqrt",
+      "tan",
+      "sel",
+      "max",
+      "min",
+      "limit",
+      "mux",
+      "shl",
+      "shr",
+      "rol",
+      "ror",
+      "indexof",
+      "sizeof",
+      "adr",
+      "adrinst",
+      "bitadr",
+      "is_valid",
+      "ref",
+      "ref_to"
+    ],
+    builtinVariables: [],
+    builtinFunctions: [
+      "sr",
+      "rs",
+      "tp",
+      "ton",
+      "tof",
+      "eq",
+      "ge",
+      "le",
+      "lt",
+      "ne",
+      "round",
+      "trunc",
+      "ctd",
+      "\u0441tu",
+      "ctud",
+      "r_trig",
+      "f_trig",
+      "move",
+      "concat",
+      "delete",
+      "find",
+      "insert",
+      "left",
+      "len",
+      "replace",
+      "right",
+      "rtc"
+    ],
+    // we include these common regular expressions
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    // C# style strings
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        [/(\.\.)/, "delimiter"],
+        [/\b(16#[0-9A-Fa-f\_]*)+\b/, "number.hex"],
+        [/\b(2#[01\_]+)+\b/, "number.binary"],
+        [/\b(8#[0-9\_]*)+\b/, "number.octal"],
+        [/\b\d*\.\d+([eE][\-+]?\d+)?\b/, "number.float"],
+        [/\b(L?REAL)#[0-9\_\.e]+\b/, "number.float"],
+        [/\b(BYTE|(?:D|L)?WORD|U?(?:S|D|L)?INT)#[0-9\_]+\b/, "number"],
+        [/\d+/, "number"],
+        [/\b(T|DT|TOD)#[0-9:-_shmyd]+\b/, "tag"],
+        [/\%(I|Q|M)(X|B|W|D|L)[0-9\.]+/, "tag"],
+        [/\%(I|Q|M)[0-9\.]*/, "tag"],
+        [/\b[A-Za-z]{1,6}#[0-9]+\b/, "tag"],
+        [/\b(TO_|CTU_|CTD_|CTUD_|MUX_|SEL_)[A_Za-z]+\b/, "predefined"],
+        [/\b[A_Za-z]+(_TO_)[A_Za-z]+\b/, "predefined"],
+        [/[;]/, "delimiter"],
+        [/[.]/, { token: "delimiter", next: "@params" }],
+        // identifiers and keywords
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@operators": "operators",
+              "@keywords": "keyword",
+              "@typeKeywords": "type",
+              "@defineKeywords": "variable",
+              "@constant": "constant",
+              "@builtinVariables": "predefined",
+              "@builtinFunctions": "predefined",
+              "@default": "identifier"
+            }
+          }
+        ],
+        { include: "@whitespace" },
+        [/[{}()\[\]]/, "@brackets"],
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/"/, { token: "string.quote", bracket: "@open", next: "@string_dq" }],
+        [/'/, { token: "string.quote", bracket: "@open", next: "@string_sq" }],
+        [/'[^\\']'/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      params: [
+        [/\b[A-Za-z0-9_]+\b(?=\()/, { token: "identifier", next: "@pop" }],
+        [/\b[A-Za-z0-9_]+\b/, "variable.name", "@pop"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\/\*/, "comment", "@push"],
+        // nested comment
+        ["\\*/", "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      comment2: [
+        [/[^\(*]+/, "comment"],
+        [/\(\*/, "comment", "@push"],
+        // nested comment
+        ["\\*\\)", "comment", "@pop"],
+        [/[\(*]/, "comment"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, "white"],
+        [/\/\/.*$/, "comment"],
+        [/\/\*/, "comment", "@comment"],
+        [/\(\*/, "comment", "@comment2"]
+      ],
+      string_dq: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, { token: "string.quote", bracket: "@close", next: "@pop" }]
+      ],
+      string_sq: [
+        [/[^\\']+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/'/, { token: "string.quote", bracket: "@close", next: "@pop" }]
+      ]
+    }
+  };
+  return __toCommonJS(st_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/swift/swift.js

@@ -0,0 +1,346 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/swift/swift", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/swift/swift.ts
+  var swift_exports = {};
+  __export(swift_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "`", close: "`" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "`", close: "`" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".swift",
+    // TODO(owensd): Support the full range of unicode valid identifiers.
+    identifier: /[a-zA-Z_][\w$]*/,
+    attributes: [
+      "@GKInspectable",
+      "@IBAction",
+      "@IBDesignable",
+      "@IBInspectable",
+      "@IBOutlet",
+      "@IBSegueAction",
+      "@NSApplicationMain",
+      "@NSCopying",
+      "@NSManaged",
+      "@Sendable",
+      "@UIApplicationMain",
+      "@autoclosure",
+      "@actorIndependent",
+      "@asyncHandler",
+      "@available",
+      "@convention",
+      "@derivative",
+      "@differentiable",
+      "@discardableResult",
+      "@dynamicCallable",
+      "@dynamicMemberLookup",
+      "@escaping",
+      "@frozen",
+      "@globalActor",
+      "@inlinable",
+      "@inline",
+      "@main",
+      "@noDerivative",
+      "@nonobjc",
+      "@noreturn",
+      "@objc",
+      "@objcMembers",
+      "@preconcurrency",
+      "@propertyWrapper",
+      "@requires_stored_property_inits",
+      "@resultBuilder",
+      "@testable",
+      "@unchecked",
+      "@unknown",
+      "@usableFromInline",
+      "@warn_unqualified_access"
+    ],
+    accessmodifiers: ["open", "public", "internal", "fileprivate", "private"],
+    keywords: [
+      "#available",
+      "#colorLiteral",
+      "#column",
+      "#dsohandle",
+      "#else",
+      "#elseif",
+      "#endif",
+      "#error",
+      "#file",
+      "#fileID",
+      "#fileLiteral",
+      "#filePath",
+      "#function",
+      "#if",
+      "#imageLiteral",
+      "#keyPath",
+      "#line",
+      "#selector",
+      "#sourceLocation",
+      "#warning",
+      "Any",
+      "Protocol",
+      "Self",
+      "Type",
+      "actor",
+      "as",
+      "assignment",
+      "associatedtype",
+      "associativity",
+      "async",
+      "await",
+      "break",
+      "case",
+      "catch",
+      "class",
+      "continue",
+      "convenience",
+      "default",
+      "defer",
+      "deinit",
+      "didSet",
+      "do",
+      "dynamic",
+      "dynamicType",
+      "else",
+      "enum",
+      "extension",
+      "fallthrough",
+      "false",
+      "fileprivate",
+      "final",
+      "for",
+      "func",
+      "get",
+      "guard",
+      "higherThan",
+      "if",
+      "import",
+      "in",
+      "indirect",
+      "infix",
+      "init",
+      "inout",
+      "internal",
+      "is",
+      "isolated",
+      "lazy",
+      "left",
+      "let",
+      "lowerThan",
+      "mutating",
+      "nil",
+      "none",
+      "nonisolated",
+      "nonmutating",
+      "open",
+      "operator",
+      "optional",
+      "override",
+      "postfix",
+      "precedence",
+      "precedencegroup",
+      "prefix",
+      "private",
+      "protocol",
+      "public",
+      "repeat",
+      "required",
+      "rethrows",
+      "return",
+      "right",
+      "safe",
+      "self",
+      "set",
+      "some",
+      "static",
+      "struct",
+      "subscript",
+      "super",
+      "switch",
+      "throw",
+      "throws",
+      "true",
+      "try",
+      "typealias",
+      "unowned",
+      "unsafe",
+      "var",
+      "weak",
+      "where",
+      "while",
+      "willSet",
+      "__consuming",
+      "__owned"
+    ],
+    symbols: /[=(){}\[\].,:;@#\_&\-<>`?!+*\\\/]/,
+    // Moved . to operatorstart so it can be a delimiter
+    operatorstart: /[\/=\-+!*%<>&|^~?\u00A1-\u00A7\u00A9\u00AB\u00AC\u00AE\u00B0-\u00B1\u00B6\u00BB\u00BF\u00D7\u00F7\u2016-\u2017\u2020-\u2027\u2030-\u203E\u2041-\u2053\u2055-\u205E\u2190-\u23FF\u2500-\u2775\u2794-\u2BFF\u2E00-\u2E7F\u3001-\u3003\u3008-\u3030]/,
+    operatorend: /[\u0300-\u036F\u1DC0-\u1DFF\u20D0-\u20FF\uFE00-\uFE0F\uFE20-\uFE2F\uE0100-\uE01EF]/,
+    operators: /(@operatorstart)((@operatorstart)|(@operatorend))*/,
+    // TODO(owensd): These are borrowed from C#; need to validate correctness for Swift.
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    tokenizer: {
+      root: [
+        { include: "@whitespace" },
+        { include: "@comment" },
+        { include: "@attribute" },
+        { include: "@literal" },
+        { include: "@keyword" },
+        { include: "@invokedmethod" },
+        { include: "@symbol" }
+      ],
+      whitespace: [
+        [/\s+/, "white"],
+        [/"""/, "string.quote", "@endDblDocString"]
+      ],
+      endDblDocString: [
+        [/[^"]+/, "string"],
+        [/\\"/, "string"],
+        [/"""/, "string.quote", "@popall"],
+        [/"/, "string"]
+      ],
+      symbol: [
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [/[.]/, "delimiter"],
+        [/@operators/, "operator"],
+        [/@symbols/, "operator"]
+      ],
+      comment: [
+        [/\/\/\/.*$/, "comment.doc"],
+        [/\/\*\*/, "comment.doc", "@commentdocbody"],
+        [/\/\/.*$/, "comment"],
+        [/\/\*/, "comment", "@commentbody"]
+      ],
+      commentdocbody: [
+        [/\/\*/, "comment", "@commentbody"],
+        [/\*\//, "comment.doc", "@pop"],
+        [/\:[a-zA-Z]+\:/, "comment.doc.param"],
+        [/./, "comment.doc"]
+      ],
+      commentbody: [
+        [/\/\*/, "comment", "@commentbody"],
+        [/\*\//, "comment", "@pop"],
+        [/./, "comment"]
+      ],
+      attribute: [
+        [
+          /@@@identifier/,
+          {
+            cases: {
+              "@attributes": "keyword.control",
+              "@default": ""
+            }
+          }
+        ]
+      ],
+      literal: [
+        [/"/, { token: "string.quote", next: "@stringlit" }],
+        [/0[b]([01]_?)+/, "number.binary"],
+        [/0[o]([0-7]_?)+/, "number.octal"],
+        [/0[x]([0-9a-fA-F]_?)+([pP][\-+](\d_?)+)?/, "number.hex"],
+        [/(\d_?)*\.(\d_?)+([eE][\-+]?(\d_?)+)?/, "number.float"],
+        [/(\d_?)+/, "number"]
+      ],
+      stringlit: [
+        [/\\\(/, { token: "operator", next: "@interpolatedexpression" }],
+        [/@escapes/, "string"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, { token: "string.quote", next: "@pop" }],
+        [/./, "string"]
+      ],
+      interpolatedexpression: [
+        [/\(/, { token: "operator", next: "@interpolatedexpression" }],
+        [/\)/, { token: "operator", next: "@pop" }],
+        { include: "@literal" },
+        { include: "@keyword" },
+        { include: "@symbol" }
+      ],
+      keyword: [
+        [/`/, { token: "operator", next: "@escapedkeyword" }],
+        [
+          /@identifier/,
+          {
+            cases: {
+              "@keywords": "keyword",
+              "[A-Z][a-zA-Z0-9$]*": "type.identifier",
+              "@default": "identifier"
+            }
+          }
+        ]
+      ],
+      escapedkeyword: [
+        [/`/, { token: "operator", next: "@pop" }],
+        [/./, "identifier"]
+      ],
+      invokedmethod: [
+        [
+          /([.])(@identifier)/,
+          {
+            cases: {
+              $2: ["delimeter", "type.identifier"],
+              "@default": ""
+            }
+          }
+        ]
+      ]
+    }
+  };
+  return __toCommonJS(swift_exports);
+})();
+/*!---------------------------------------------------------------------------------------------
+ *  Copyright (C) David Owens II, owensd.io. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/systemverilog/systemverilog.js

@@ -0,0 +1,610 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/systemverilog/systemverilog", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/systemverilog/systemverilog.ts
+  var systemverilog_exports = {};
+  __export(systemverilog_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"],
+      ["begin", "end"],
+      ["case", "endcase"],
+      ["casex", "endcase"],
+      ["casez", "endcase"],
+      ["checker", "endchecker"],
+      ["class", "endclass"],
+      ["clocking", "endclocking"],
+      ["config", "endconfig"],
+      ["function", "endfunction"],
+      ["generate", "endgenerate"],
+      ["group", "endgroup"],
+      ["interface", "endinterface"],
+      ["module", "endmodule"],
+      ["package", "endpackage"],
+      ["primitive", "endprimitive"],
+      ["program", "endprogram"],
+      ["property", "endproperty"],
+      ["specify", "endspecify"],
+      ["sequence", "endsequence"],
+      ["table", "endtable"],
+      ["task", "endtask"]
+    ],
+    autoClosingPairs: [
+      { open: "[", close: "]" },
+      { open: "{", close: "}" },
+      { open: "(", close: ")" },
+      { open: "'", close: "'", notIn: ["string", "comment"] },
+      { open: '"', close: '"', notIn: ["string"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    folding: {
+      offSide: false,
+      markers: {
+        start: new RegExp(
+          "^(?:\\s*|.*(?!\\/[\\/\\*])[^\\w])(?:begin|case(x|z)?|class|clocking|config|covergroup|function|generate|interface|module|package|primitive|property|program|sequence|specify|table|task)\\b"
+        ),
+        end: new RegExp(
+          "^(?:\\s*|.*(?!\\/[\\/\\*])[^\\w])(?:end|endcase|endclass|endclocking|endconfig|endgroup|endfunction|endgenerate|endinterface|endmodule|endpackage|endprimitive|endproperty|endprogram|endsequence|endspecify|endtable|endtask)\\b"
+        )
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".sv",
+    brackets: [
+      { token: "delimiter.curly", open: "{", close: "}" },
+      { token: "delimiter.parenthesis", open: "(", close: ")" },
+      { token: "delimiter.square", open: "[", close: "]" },
+      { token: "delimiter.angle", open: "<", close: ">" }
+    ],
+    keywords: [
+      "accept_on",
+      "alias",
+      "always",
+      "always_comb",
+      "always_ff",
+      "always_latch",
+      "and",
+      "assert",
+      "assign",
+      "assume",
+      "automatic",
+      "before",
+      "begin",
+      "bind",
+      "bins",
+      "binsof",
+      "bit",
+      "break",
+      "buf",
+      "bufif0",
+      "bufif1",
+      "byte",
+      "case",
+      "casex",
+      "casez",
+      "cell",
+      "chandle",
+      "checker",
+      "class",
+      "clocking",
+      "cmos",
+      "config",
+      "const",
+      "constraint",
+      "context",
+      "continue",
+      "cover",
+      "covergroup",
+      "coverpoint",
+      "cross",
+      "deassign",
+      "default",
+      "defparam",
+      "design",
+      "disable",
+      "dist",
+      "do",
+      "edge",
+      "else",
+      "end",
+      "endcase",
+      "endchecker",
+      "endclass",
+      "endclocking",
+      "endconfig",
+      "endfunction",
+      "endgenerate",
+      "endgroup",
+      "endinterface",
+      "endmodule",
+      "endpackage",
+      "endprimitive",
+      "endprogram",
+      "endproperty",
+      "endspecify",
+      "endsequence",
+      "endtable",
+      "endtask",
+      "enum",
+      "event",
+      "eventually",
+      "expect",
+      "export",
+      "extends",
+      "extern",
+      "final",
+      "first_match",
+      "for",
+      "force",
+      "foreach",
+      "forever",
+      "fork",
+      "forkjoin",
+      "function",
+      "generate",
+      "genvar",
+      "global",
+      "highz0",
+      "highz1",
+      "if",
+      "iff",
+      "ifnone",
+      "ignore_bins",
+      "illegal_bins",
+      "implements",
+      "implies",
+      "import",
+      "incdir",
+      "include",
+      "initial",
+      "inout",
+      "input",
+      "inside",
+      "instance",
+      "int",
+      "integer",
+      "interconnect",
+      "interface",
+      "intersect",
+      "join",
+      "join_any",
+      "join_none",
+      "large",
+      "let",
+      "liblist",
+      "library",
+      "local",
+      "localparam",
+      "logic",
+      "longint",
+      "macromodule",
+      "matches",
+      "medium",
+      "modport",
+      "module",
+      "nand",
+      "negedge",
+      "nettype",
+      "new",
+      "nexttime",
+      "nmos",
+      "nor",
+      "noshowcancelled",
+      "not",
+      "notif0",
+      "notif1",
+      "null",
+      "or",
+      "output",
+      "package",
+      "packed",
+      "parameter",
+      "pmos",
+      "posedge",
+      "primitive",
+      "priority",
+      "program",
+      "property",
+      "protected",
+      "pull0",
+      "pull1",
+      "pulldown",
+      "pullup",
+      "pulsestyle_ondetect",
+      "pulsestyle_onevent",
+      "pure",
+      "rand",
+      "randc",
+      "randcase",
+      "randsequence",
+      "rcmos",
+      "real",
+      "realtime",
+      "ref",
+      "reg",
+      "reject_on",
+      "release",
+      "repeat",
+      "restrict",
+      "return",
+      "rnmos",
+      "rpmos",
+      "rtran",
+      "rtranif0",
+      "rtranif1",
+      "s_always",
+      "s_eventually",
+      "s_nexttime",
+      "s_until",
+      "s_until_with",
+      "scalared",
+      "sequence",
+      "shortint",
+      "shortreal",
+      "showcancelled",
+      "signed",
+      "small",
+      "soft",
+      "solve",
+      "specify",
+      "specparam",
+      "static",
+      "string",
+      "strong",
+      "strong0",
+      "strong1",
+      "struct",
+      "super",
+      "supply0",
+      "supply1",
+      "sync_accept_on",
+      "sync_reject_on",
+      "table",
+      "tagged",
+      "task",
+      "this",
+      "throughout",
+      "time",
+      "timeprecision",
+      "timeunit",
+      "tran",
+      "tranif0",
+      "tranif1",
+      "tri",
+      "tri0",
+      "tri1",
+      "triand",
+      "trior",
+      "trireg",
+      "type",
+      "typedef",
+      "union",
+      "unique",
+      "unique0",
+      "unsigned",
+      "until",
+      "until_with",
+      "untyped",
+      "use",
+      "uwire",
+      "var",
+      "vectored",
+      "virtual",
+      "void",
+      "wait",
+      "wait_order",
+      "wand",
+      "weak",
+      "weak0",
+      "weak1",
+      "while",
+      "wildcard",
+      "wire",
+      "with",
+      "within",
+      "wor",
+      "xnor",
+      "xor"
+    ],
+    builtin_gates: [
+      "and",
+      "nand",
+      "nor",
+      "or",
+      "xor",
+      "xnor",
+      "buf",
+      "not",
+      "bufif0",
+      "bufif1",
+      "notif1",
+      "notif0",
+      "cmos",
+      "nmos",
+      "pmos",
+      "rcmos",
+      "rnmos",
+      "rpmos",
+      "tran",
+      "tranif1",
+      "tranif0",
+      "rtran",
+      "rtranif1",
+      "rtranif0"
+    ],
+    operators: [
+      // assignment operators
+      "=",
+      "+=",
+      "-=",
+      "*=",
+      "/=",
+      "%=",
+      "&=",
+      "|=",
+      "^=",
+      "<<=",
+      ">>+",
+      "<<<=",
+      ">>>=",
+      // conditional expression
+      "?",
+      ":",
+      // Unary operators
+      "+",
+      "-",
+      "!",
+      "~",
+      "&",
+      "~&",
+      "|",
+      "~|",
+      "^",
+      "~^",
+      "^~",
+      //binary operators
+      "+",
+      "-",
+      "*",
+      "/",
+      "%",
+      "==",
+      "!=",
+      "===",
+      "!==",
+      "==?",
+      "!=?",
+      "&&",
+      "||",
+      "**",
+      "<",
+      "<=",
+      ">",
+      ">=",
+      "&",
+      "|",
+      "^",
+      ">>",
+      "<<",
+      ">>>",
+      "<<<",
+      // increment or decrement operator
+      "++",
+      "--",
+      //binary logical operator
+      "->",
+      "<->",
+      // binary set membership operator
+      "inside",
+      // binary distrubution operator
+      "dist",
+      "::",
+      "+:",
+      "-:",
+      "*>",
+      "&&&",
+      "|->",
+      "|=>",
+      "#=#"
+    ],
+    // we include these common regular expressions
+    symbols: /[=><!~?:&|+\-*\/\^%#]+/,
+    escapes: /%%|\\(?:[antvf\\"']|x[0-9A-Fa-f]{1,2}|[0-7]{1,3})/,
+    identifier: /(?:[a-zA-Z_][a-zA-Z0-9_$\.]*|\\\S+ )/,
+    systemcall: /[$][a-zA-Z0-9_]+/,
+    timeunits: /s|ms|us|ns|ps|fs/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // module instances
+        [
+          /^(\s*)(@identifier)/,
+          [
+            "",
+            {
+              cases: {
+                "@builtin_gates": {
+                  token: "keyword.$2",
+                  next: "@module_instance"
+                },
+                table: {
+                  token: "keyword.$2",
+                  next: "@table"
+                },
+                "@keywords": { token: "keyword.$2" },
+                "@default": {
+                  token: "identifier",
+                  next: "@module_instance"
+                }
+              }
+            }
+          ]
+        ],
+        // include statements
+        [/^\s*`include/, { token: "keyword.directive.include", next: "@include" }],
+        // Preprocessor directives
+        [/^\s*`\s*\w+/, "keyword"],
+        // identifiers and keywords
+        { include: "@identifier_or_keyword" },
+        // whitespace and comments
+        { include: "@whitespace" },
+        // (* attributes *).
+        [/\(\*.*\*\)/, "annotation"],
+        // Systemcall
+        [/@systemcall/, "variable.predefined"],
+        // delimiters and operators
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        // numbers
+        { include: "@numbers" },
+        // delimiter: after number because of .\d floats
+        [/[;,.]/, "delimiter"],
+        // strings
+        { include: "@strings" }
+      ],
+      identifier_or_keyword: [
+        [
+          /@identifier/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ]
+      ],
+      numbers: [
+        [/\d+?[\d_]*(?:\.[\d_]+)?[eE][\-+]?\d+/, "number.float"],
+        [/\d+?[\d_]*\.[\d_]+(?:\s*@timeunits)?/, "number.float"],
+        [/(?:\d+?[\d_]*\s*)?'[sS]?[dD]\s*[0-9xXzZ?]+?[0-9xXzZ?_]*/, "number"],
+        [/(?:\d+?[\d_]*\s*)?'[sS]?[bB]\s*[0-1xXzZ?]+?[0-1xXzZ?_]*/, "number.binary"],
+        [/(?:\d+?[\d_]*\s*)?'[sS]?[oO]\s*[0-7xXzZ?]+?[0-7xXzZ?_]*/, "number.octal"],
+        [/(?:\d+?[\d_]*\s*)?'[sS]?[hH]\s*[0-9a-fA-FxXzZ?]+?[0-9a-fA-FxXzZ?_]*/, "number.hex"],
+        [/1step/, "number"],
+        [/[\dxXzZ]+?[\dxXzZ_]*(?:\s*@timeunits)?/, "number"],
+        [/'[01xXzZ]+/, "number"]
+      ],
+      module_instance: [
+        { include: "@whitespace" },
+        [/(#?)(\()/, ["", { token: "@brackets", next: "@port_connection" }]],
+        [/@identifier\s*[;={}\[\],]/, { token: "@rematch", next: "@pop" }],
+        [/@symbols|[;={}\[\],]/, { token: "@rematch", next: "@pop" }],
+        [/@identifier/, "type"],
+        [/;/, "delimiter", "@pop"]
+      ],
+      port_connection: [
+        { include: "@identifier_or_keyword" },
+        { include: "@whitespace" },
+        [/@systemcall/, "variable.predefined"],
+        { include: "@numbers" },
+        { include: "@strings" },
+        [/[,]/, "delimiter"],
+        [/\(/, "@brackets", "@port_connection"],
+        [/\)/, "@brackets", "@pop"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      strings: [
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/"/, "string", "@string"]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"]
+      ],
+      include: [
+        [
+          /(\s*)(")([\w*\/*]*)(.\w*)(")/,
+          [
+            "",
+            "string.include.identifier",
+            "string.include.identifier",
+            "string.include.identifier",
+            { token: "string.include.identifier", next: "@pop" }
+          ]
+        ],
+        [
+          /(\s*)(<)([\w*\/*]*)(.\w*)(>)/,
+          [
+            "",
+            "string.include.identifier",
+            "string.include.identifier",
+            "string.include.identifier",
+            { token: "string.include.identifier", next: "@pop" }
+          ]
+        ]
+      ],
+      table: [
+        { include: "@whitespace" },
+        [/[()]/, "@brackets"],
+        [/[:;]/, "delimiter"],
+        [/[01\-*?xXbBrRfFpPnN]/, "variable.predefined"],
+        ["endtable", "keyword.endtable", "@pop"]
+      ]
+    }
+  };
+  return __toCommonJS(systemverilog_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/tcl/tcl.js

@@ -0,0 +1,266 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/tcl/tcl", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/tcl/tcl.ts
+  var tcl_exports = {};
+  __export(tcl_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ]
+  };
+  var language = {
+    tokenPostfix: ".tcl",
+    specialFunctions: [
+      "set",
+      "unset",
+      "rename",
+      "variable",
+      "proc",
+      "coroutine",
+      "foreach",
+      "incr",
+      "append",
+      "lappend",
+      "linsert",
+      "lreplace"
+    ],
+    mainFunctions: [
+      "if",
+      "then",
+      "elseif",
+      "else",
+      "case",
+      "switch",
+      "while",
+      "for",
+      "break",
+      "continue",
+      "return",
+      "package",
+      "namespace",
+      "catch",
+      "exit",
+      "eval",
+      "expr",
+      "uplevel",
+      "upvar"
+    ],
+    builtinFunctions: [
+      "file",
+      "info",
+      "concat",
+      "join",
+      "lindex",
+      "list",
+      "llength",
+      "lrange",
+      "lsearch",
+      "lsort",
+      "split",
+      "array",
+      "parray",
+      "binary",
+      "format",
+      "regexp",
+      "regsub",
+      "scan",
+      "string",
+      "subst",
+      "dict",
+      "cd",
+      "clock",
+      "exec",
+      "glob",
+      "pid",
+      "pwd",
+      "close",
+      "eof",
+      "fblocked",
+      "fconfigure",
+      "fcopy",
+      "fileevent",
+      "flush",
+      "gets",
+      "open",
+      "puts",
+      "read",
+      "seek",
+      "socket",
+      "tell",
+      "interp",
+      "after",
+      "auto_execok",
+      "auto_load",
+      "auto_mkindex",
+      "auto_reset",
+      "bgerror",
+      "error",
+      "global",
+      "history",
+      "load",
+      "source",
+      "time",
+      "trace",
+      "unknown",
+      "unset",
+      "update",
+      "vwait",
+      "winfo",
+      "wm",
+      "bind",
+      "event",
+      "pack",
+      "place",
+      "grid",
+      "font",
+      "bell",
+      "clipboard",
+      "destroy",
+      "focus",
+      "grab",
+      "lower",
+      "option",
+      "raise",
+      "selection",
+      "send",
+      "tk",
+      "tkwait",
+      "tk_bisque",
+      "tk_focusNext",
+      "tk_focusPrev",
+      "tk_focusFollowsMouse",
+      "tk_popup",
+      "tk_setPalette"
+    ],
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    brackets: [
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.square" }
+    ],
+    escapes: /\\(?:[abfnrtv\\"'\[\]\{\};\$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    variables: /(?:\$+(?:(?:\:\:?)?[a-zA-Z_]\w*)+)/,
+    tokenizer: {
+      root: [
+        // identifiers and keywords
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@specialFunctions": {
+                token: "keyword.flow",
+                next: "@specialFunc"
+              },
+              "@mainFunctions": "keyword",
+              "@builtinFunctions": "variable",
+              "@default": "operator.scss"
+            }
+          }
+        ],
+        [/\s+\-+(?!\d|\.)\w*|{\*}/, "metatag"],
+        // whitespace
+        { include: "@whitespace" },
+        // delimiters and operators
+        [/[{}()\[\]]/, "@brackets"],
+        [/@symbols/, "operator"],
+        [/\$+(?:\:\:)?\{/, { token: "identifier", next: "@nestedVariable" }],
+        [/@variables/, "type.identifier"],
+        [/\.(?!\d|\.)[\w\-]*/, "operator.sql"],
+        // numbers
+        [/\d+(\.\d+)?/, "number"],
+        [/\d+/, "number"],
+        // delimiter
+        [/;/, "delimiter"],
+        // strings
+        [/"/, { token: "string.quote", bracket: "@open", next: "@dstring" }],
+        [/'/, { token: "string.quote", bracket: "@open", next: "@sstring" }]
+      ],
+      dstring: [
+        [/\[/, { token: "@brackets", next: "@nestedCall" }],
+        [/\$+(?:\:\:)?\{/, { token: "identifier", next: "@nestedVariable" }],
+        [/@variables/, "type.identifier"],
+        [/[^\\$\[\]"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/"/, { token: "string.quote", bracket: "@close", next: "@pop" }]
+      ],
+      sstring: [
+        [/\[/, { token: "@brackets", next: "@nestedCall" }],
+        [/\$+(?:\:\:)?\{/, { token: "identifier", next: "@nestedVariable" }],
+        [/@variables/, "type.identifier"],
+        [/[^\\$\[\]']+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/'/, { token: "string.quote", bracket: "@close", next: "@pop" }]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, "white"],
+        [/#.*\\$/, { token: "comment", next: "@newlineComment" }],
+        [/#.*(?!\\)$/, "comment"]
+      ],
+      newlineComment: [
+        [/.*\\$/, "comment"],
+        [/.*(?!\\)$/, { token: "comment", next: "@pop" }]
+      ],
+      nestedVariable: [
+        [/[^\{\}\$]+/, "type.identifier"],
+        [/\}/, { token: "identifier", next: "@pop" }]
+      ],
+      nestedCall: [
+        [/\[/, { token: "@brackets", next: "@nestedCall" }],
+        [/\]/, { token: "@brackets", next: "@pop" }],
+        { include: "root" }
+      ],
+      specialFunc: [
+        [/"/, { token: "string", next: "@dstring" }],
+        [/'/, { token: "string", next: "@sstring" }],
+        [/\S+/, { token: "type", next: "@pop" }]
+      ]
+    }
+  };
+  return __toCommonJS(tcl_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/twig/twig.js

@@ -0,0 +1,426 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/twig/twig", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/twig/twig.ts
+  var twig_exports = {};
+  __export(twig_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g,
+    comments: {
+      blockComment: ["{#", "#}"]
+    },
+    brackets: [
+      ["{#", "#}"],
+      ["{%", "%}"],
+      ["{{", "}}"],
+      ["(", ")"],
+      ["[", "]"],
+      // HTML
+      ["<!--", "-->"],
+      ["<", ">"]
+    ],
+    autoClosingPairs: [
+      { open: "{# ", close: " #}" },
+      { open: "{% ", close: " %}" },
+      { open: "{{ ", close: " }}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      // HTML
+      { open: "<", close: ">" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: "",
+    ignoreCase: true,
+    keywords: [
+      // (opening) tags
+      "apply",
+      "autoescape",
+      "block",
+      "deprecated",
+      "do",
+      "embed",
+      "extends",
+      "flush",
+      "for",
+      "from",
+      "if",
+      "import",
+      "include",
+      "macro",
+      "sandbox",
+      "set",
+      "use",
+      "verbatim",
+      "with",
+      // closing tags
+      "endapply",
+      "endautoescape",
+      "endblock",
+      "endembed",
+      "endfor",
+      "endif",
+      "endmacro",
+      "endsandbox",
+      "endset",
+      "endwith",
+      // literals
+      "true",
+      "false"
+    ],
+    tokenizer: {
+      root: [
+        // whitespace
+        [/\s+/],
+        // Twig Tag Delimiters
+        [/{#/, "comment.twig", "@commentState"],
+        [/{%[-~]?/, "delimiter.twig", "@blockState"],
+        [/{{[-~]?/, "delimiter.twig", "@variableState"],
+        // HTML
+        [/<!DOCTYPE/, "metatag.html", "@doctype"],
+        [/<!--/, "comment.html", "@comment"],
+        [/(<)((?:[\w\-]+:)?[\w\-]+)(\s*)(\/>)/, ["delimiter.html", "tag.html", "", "delimiter.html"]],
+        [/(<)(script)/, ["delimiter.html", { token: "tag.html", next: "@script" }]],
+        [/(<)(style)/, ["delimiter.html", { token: "tag.html", next: "@style" }]],
+        [/(<)((?:[\w\-]+:)?[\w\-]+)/, ["delimiter.html", { token: "tag.html", next: "@otherTag" }]],
+        [/(<\/)((?:[\w\-]+:)?[\w\-]+)/, ["delimiter.html", { token: "tag.html", next: "@otherTag" }]],
+        [/</, "delimiter.html"],
+        [/[^<{]+/]
+        // text
+      ],
+      /**
+       * Comment Tag Handling
+       */
+      commentState: [
+        [/#}/, "comment.twig", "@pop"],
+        [/./, "comment.twig"]
+      ],
+      /**
+       * Block Tag Handling
+       */
+      blockState: [
+        [/[-~]?%}/, "delimiter.twig", "@pop"],
+        // whitespace
+        [/\s+/],
+        // verbatim
+        // Unlike other blocks, verbatim ehas its own state
+        // transition to ensure we mark its contents as strings.
+        [
+          /(verbatim)(\s*)([-~]?%})/,
+          ["keyword.twig", "", { token: "delimiter.twig", next: "@rawDataState" }]
+        ],
+        { include: "expression" }
+      ],
+      rawDataState: [
+        // endverbatim
+        [
+          /({%[-~]?)(\s*)(endverbatim)(\s*)([-~]?%})/,
+          ["delimiter.twig", "", "keyword.twig", "", { token: "delimiter.twig", next: "@popall" }]
+        ],
+        [/./, "string.twig"]
+      ],
+      /**
+       * Variable Tag Handling
+       */
+      variableState: [[/[-~]?}}/, "delimiter.twig", "@pop"], { include: "expression" }],
+      stringState: [
+        // closing double quoted string
+        [/"/, "string.twig", "@pop"],
+        // interpolation start
+        [/#{\s*/, "string.twig", "@interpolationState"],
+        // string part
+        [/[^#"\\]*(?:(?:\\.|#(?!\{))[^#"\\]*)*/, "string.twig"]
+      ],
+      interpolationState: [
+        // interpolation end
+        [/}/, "string.twig", "@pop"],
+        { include: "expression" }
+      ],
+      /**
+       * Expression Handling
+       */
+      expression: [
+        // whitespace
+        [/\s+/],
+        // operators - math
+        [/\+|-|\/{1,2}|%|\*{1,2}/, "operators.twig"],
+        // operators - logic
+        [/(and|or|not|b-and|b-xor|b-or)(\s+)/, ["operators.twig", ""]],
+        // operators - comparison (symbols)
+        [/==|!=|<|>|>=|<=/, "operators.twig"],
+        // operators - comparison (words)
+        [/(starts with|ends with|matches)(\s+)/, ["operators.twig", ""]],
+        // operators - containment
+        [/(in)(\s+)/, ["operators.twig", ""]],
+        // operators - test
+        [/(is)(\s+)/, ["operators.twig", ""]],
+        // operators - misc
+        [/\||~|:|\.{1,2}|\?{1,2}/, "operators.twig"],
+        // names
+        [
+          /[^\W\d][\w]*/,
+          {
+            cases: {
+              "@keywords": "keyword.twig",
+              "@default": "variable.twig"
+            }
+          }
+        ],
+        // numbers
+        [/\d+(\.\d+)?/, "number.twig"],
+        // punctuation
+        [/\(|\)|\[|\]|{|}|,/, "delimiter.twig"],
+        // strings
+        [/"([^#"\\]*(?:\\.[^#"\\]*)*)"|\'([^\'\\]*(?:\\.[^\'\\]*)*)\'/, "string.twig"],
+        // opening double quoted string
+        [/"/, "string.twig", "@stringState"],
+        // misc syntactic constructs
+        // These are not operators per se, but for the purposes of lexical analysis we
+        // can treat them as such.
+        // arrow functions
+        [/=>/, "operators.twig"],
+        // assignment
+        [/=/, "operators.twig"]
+      ],
+      /**
+       * HTML
+       */
+      doctype: [
+        [/[^>]+/, "metatag.content.html"],
+        [/>/, "metatag.html", "@pop"]
+      ],
+      comment: [
+        [/-->/, "comment.html", "@pop"],
+        [/[^-]+/, "comment.content.html"],
+        [/./, "comment.content.html"]
+      ],
+      otherTag: [
+        [/\/?>/, "delimiter.html", "@pop"],
+        [/"([^"]*)"/, "attribute.value.html"],
+        [/'([^']*)'/, "attribute.value.html"],
+        [/[\w\-]+/, "attribute.name.html"],
+        [/=/, "delimiter.html"],
+        [/[ \t\r\n]+/]
+        // whitespace
+      ],
+      // -- BEGIN <script> tags handling
+      // After <script
+      script: [
+        [/type/, "attribute.name.html", "@scriptAfterType"],
+        [/"([^"]*)"/, "attribute.value.html"],
+        [/'([^']*)'/, "attribute.value.html"],
+        [/[\w\-]+/, "attribute.name.html"],
+        [/=/, "delimiter.html"],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@scriptEmbedded",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        // whitespace
+        [
+          /(<\/)(script\s*)(>)/,
+          ["delimiter.html", "tag.html", { token: "delimiter.html", next: "@pop" }]
+        ]
+      ],
+      // After <script ... type
+      scriptAfterType: [
+        [/=/, "delimiter.html", "@scriptAfterTypeEquals"],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@scriptEmbedded",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        // cover invalid e.g. <script type>
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      // After <script ... type =
+      scriptAfterTypeEquals: [
+        [
+          /"([^"]*)"/,
+          {
+            token: "attribute.value.html",
+            switchTo: "@scriptWithCustomType.$1"
+          }
+        ],
+        [
+          /'([^']*)'/,
+          {
+            token: "attribute.value.html",
+            switchTo: "@scriptWithCustomType.$1"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@scriptEmbedded",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        // cover invalid e.g. <script type=>
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      // After <script ... type = $S2
+      scriptWithCustomType: [
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@scriptEmbedded.$S2",
+            nextEmbedded: "$S2"
+          }
+        ],
+        [/"([^"]*)"/, "attribute.value.html"],
+        [/'([^']*)'/, "attribute.value.html"],
+        [/[\w\-]+/, "attribute.name.html"],
+        [/=/, "delimiter.html"],
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      scriptEmbedded: [
+        [/<\/script/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }],
+        [/[^<]+/, ""]
+      ],
+      // -- END <script> tags handling
+      // -- BEGIN <style> tags handling
+      // After <style
+      style: [
+        [/type/, "attribute.name.html", "@styleAfterType"],
+        [/"([^"]*)"/, "attribute.value.html"],
+        [/'([^']*)'/, "attribute.value.html"],
+        [/[\w\-]+/, "attribute.name.html"],
+        [/=/, "delimiter.html"],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@styleEmbedded",
+            nextEmbedded: "text/css"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        // whitespace
+        [
+          /(<\/)(style\s*)(>)/,
+          ["delimiter.html", "tag.html", { token: "delimiter.html", next: "@pop" }]
+        ]
+      ],
+      // After <style ... type
+      styleAfterType: [
+        [/=/, "delimiter.html", "@styleAfterTypeEquals"],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@styleEmbedded",
+            nextEmbedded: "text/css"
+          }
+        ],
+        // cover invalid e.g. <style type>
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      // After <style ... type =
+      styleAfterTypeEquals: [
+        [
+          /"([^"]*)"/,
+          {
+            token: "attribute.value.html",
+            switchTo: "@styleWithCustomType.$1"
+          }
+        ],
+        [
+          /'([^']*)'/,
+          {
+            token: "attribute.value.html",
+            switchTo: "@styleWithCustomType.$1"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@styleEmbedded",
+            nextEmbedded: "text/css"
+          }
+        ],
+        // cover invalid e.g. <style type=>
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      // After <style ... type = $S2
+      styleWithCustomType: [
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@styleEmbedded.$S2",
+            nextEmbedded: "$S2"
+          }
+        ],
+        [/"([^"]*)"/, "attribute.value.html"],
+        [/'([^']*)'/, "attribute.value.html"],
+        [/[\w\-]+/, "attribute.name.html"],
+        [/=/, "delimiter.html"],
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      styleEmbedded: [
+        [/<\/style/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }],
+        [/[^<]+/, ""]
+      ]
+    }
+  };
+  return __toCommonJS(twig_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/typescript/typescript.js

@@ -0,0 +1,404 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/typescript/typescript", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __commonJS = (cb, mod) => function __require2() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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"));
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/fillers/monaco-editor-core-amd.ts
+  var require_monaco_editor_core_amd = __commonJS({
+    "src/fillers/monaco-editor-core-amd.ts"(exports, module) {
+      var api = __toESM(__require("vs/editor/editor.api"));
+      module.exports = api;
+    }
+  });
+
+  // src/basic-languages/typescript/typescript.ts
+  var typescript_exports = {};
+  __export(typescript_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+
+  // src/fillers/monaco-editor-core.ts
+  var monaco_editor_core_exports = {};
+  __reExport(monaco_editor_core_exports, __toESM(require_monaco_editor_core_amd()));
+
+  // src/basic-languages/typescript/typescript.ts
+  var conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    onEnterRules: [
+      {
+        // e.g. /** | */
+        beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
+        afterText: /^\s*\*\/$/,
+        action: {
+          indentAction: monaco_editor_core_exports.languages.IndentAction.IndentOutdent,
+          appendText: " * "
+        }
+      },
+      {
+        // e.g. /** ...|
+        beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
+        action: {
+          indentAction: monaco_editor_core_exports.languages.IndentAction.None,
+          appendText: " * "
+        }
+      },
+      {
+        // e.g.  * ...|
+        beforeText: /^(\t|(\ \ ))*\ \*(\ ([^\*]|\*(?!\/))*)?$/,
+        action: {
+          indentAction: monaco_editor_core_exports.languages.IndentAction.None,
+          appendText: "* "
+        }
+      },
+      {
+        // e.g.  */|
+        beforeText: /^(\t|(\ \ ))*\ \*\/\s*$/,
+        action: {
+          indentAction: monaco_editor_core_exports.languages.IndentAction.None,
+          removeText: 1
+        }
+      }
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"', notIn: ["string"] },
+      { open: "'", close: "'", notIn: ["string", "comment"] },
+      { open: "`", close: "`", notIn: ["string", "comment"] },
+      { open: "/**", close: " */", notIn: ["string"] }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*//\\s*#?region\\b"),
+        end: new RegExp("^\\s*//\\s*#?endregion\\b")
+      }
+    }
+  };
+  var language = {
+    // Set defaultToken to invalid to see what you do not tokenize yet
+    defaultToken: "invalid",
+    tokenPostfix: ".ts",
+    keywords: [
+      // Should match the keys of textToKeywordObj in
+      // https://github.com/microsoft/TypeScript/blob/master/src/compiler/scanner.ts
+      "abstract",
+      "any",
+      "as",
+      "asserts",
+      "bigint",
+      "boolean",
+      "break",
+      "case",
+      "catch",
+      "class",
+      "continue",
+      "const",
+      "constructor",
+      "debugger",
+      "declare",
+      "default",
+      "delete",
+      "do",
+      "else",
+      "enum",
+      "export",
+      "extends",
+      "false",
+      "finally",
+      "for",
+      "from",
+      "function",
+      "get",
+      "if",
+      "implements",
+      "import",
+      "in",
+      "infer",
+      "instanceof",
+      "interface",
+      "is",
+      "keyof",
+      "let",
+      "module",
+      "namespace",
+      "never",
+      "new",
+      "null",
+      "number",
+      "object",
+      "out",
+      "package",
+      "private",
+      "protected",
+      "public",
+      "override",
+      "readonly",
+      "require",
+      "global",
+      "return",
+      "satisfies",
+      "set",
+      "static",
+      "string",
+      "super",
+      "switch",
+      "symbol",
+      "this",
+      "throw",
+      "true",
+      "try",
+      "type",
+      "typeof",
+      "undefined",
+      "unique",
+      "unknown",
+      "var",
+      "void",
+      "while",
+      "with",
+      "yield",
+      "async",
+      "await",
+      "of"
+    ],
+    operators: [
+      "<=",
+      ">=",
+      "==",
+      "!=",
+      "===",
+      "!==",
+      "=>",
+      "+",
+      "-",
+      "**",
+      "*",
+      "/",
+      "%",
+      "++",
+      "--",
+      "<<",
+      "</",
+      ">>",
+      ">>>",
+      "&",
+      "|",
+      "^",
+      "!",
+      "~",
+      "&&",
+      "||",
+      "??",
+      "?",
+      ":",
+      "=",
+      "+=",
+      "-=",
+      "*=",
+      "**=",
+      "/=",
+      "%=",
+      "<<=",
+      ">>=",
+      ">>>=",
+      "&=",
+      "|=",
+      "^=",
+      "@"
+    ],
+    // we include these common regular expressions
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    digits: /\d+(_+\d+)*/,
+    octaldigits: /[0-7]+(_+[0-7]+)*/,
+    binarydigits: /[0-1]+(_+[0-1]+)*/,
+    hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+    regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
+    regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [[/[{}]/, "delimiter.bracket"], { include: "common" }],
+      common: [
+        // identifiers and keywords
+        [
+          /#?[a-z_$][\w$]*/,
+          {
+            cases: {
+              "@keywords": "keyword",
+              "@default": "identifier"
+            }
+          }
+        ],
+        [/[A-Z][\w\$]*/, "type.identifier"],
+        // to show class names nicely
+        // [/[A-Z][\w\$]*/, 'identifier'],
+        // whitespace
+        { include: "@whitespace" },
+        // regular expression: ensure it is terminated before beginning (otherwise it is an opeator)
+        [
+          /\/(?=([^\\\/]|\\.)+\/([dgimsuy]*)(\s*)(\.|;|,|\)|\]|\}|$))/,
+          { token: "regexp", bracket: "@open", next: "@regexp" }
+        ],
+        // delimiters and operators
+        [/[()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [/!(?=([^=]|$))/, "delimiter"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        // numbers
+        [/(@digits)[eE]([\-+]?(@digits))?/, "number.float"],
+        [/(@digits)\.(@digits)([eE][\-+]?(@digits))?/, "number.float"],
+        [/0[xX](@hexdigits)n?/, "number.hex"],
+        [/0[oO]?(@octaldigits)n?/, "number.octal"],
+        [/0[bB](@binarydigits)n?/, "number.binary"],
+        [/(@digits)n?/, "number"],
+        // delimiter: after number because of .\d floats
+        [/[;,.]/, "delimiter"],
+        // strings
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/'([^'\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/"/, "string", "@string_double"],
+        [/'/, "string", "@string_single"],
+        [/`/, "string", "@string_backtick"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*\*(?!\/)/, "comment.doc", "@jsdoc"],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      jsdoc: [
+        [/[^\/*]+/, "comment.doc"],
+        [/\*\//, "comment.doc", "@pop"],
+        [/[\/*]/, "comment.doc"]
+      ],
+      // We match regular expression quite precisely
+      regexp: [
+        [
+          /(\{)(\d+(?:,\d*)?)(\})/,
+          ["regexp.escape.control", "regexp.escape.control", "regexp.escape.control"]
+        ],
+        [
+          /(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/,
+          ["regexp.escape.control", { token: "regexp.escape.control", next: "@regexrange" }]
+        ],
+        [/(\()(\?:|\?=|\?!)/, ["regexp.escape.control", "regexp.escape.control"]],
+        [/[()]/, "regexp.escape.control"],
+        [/@regexpctl/, "regexp.escape.control"],
+        [/[^\\\/]/, "regexp"],
+        [/@regexpesc/, "regexp.escape"],
+        [/\\\./, "regexp.invalid"],
+        [/(\/)([dgimsuy]*)/, [{ token: "regexp", bracket: "@close", next: "@pop" }, "keyword.other"]]
+      ],
+      regexrange: [
+        [/-/, "regexp.escape.control"],
+        [/\^/, "regexp.invalid"],
+        [/@regexpesc/, "regexp.escape"],
+        [/[^\]]/, "regexp"],
+        [
+          /\]/,
+          {
+            token: "regexp.escape.control",
+            next: "@pop",
+            bracket: "@close"
+          }
+        ]
+      ],
+      string_double: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"]
+      ],
+      string_single: [
+        [/[^\\']+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/'/, "string", "@pop"]
+      ],
+      string_backtick: [
+        [/\$\{/, { token: "delimiter.bracket", next: "@bracketCounting" }],
+        [/[^\\`$]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/`/, "string", "@pop"]
+      ],
+      bracketCounting: [
+        [/\{/, "delimiter.bracket", "@bracketCounting"],
+        [/\}/, "delimiter.bracket", "@pop"],
+        { include: "common" }
+      ]
+    }
+  };
+  return __toCommonJS(typescript_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/typespec/typespec.js

@@ -0,0 +1,161 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/typespec/typespec", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/typespec/typespec.ts
+  var typespec_exports = {};
+  __export(typespec_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var bounded = (text) => `\\b${text}\\b`;
+  var notBefore = (regex) => `(?!${regex})`;
+  var identifierStart = "[_a-zA-Z]";
+  var identifierContinue = "[_a-zA-Z0-9]";
+  var identifier = bounded(`${identifierStart}${identifierContinue}*`);
+  var directive = bounded(`[_a-zA-Z-0-9]+`);
+  var keywords = [
+    "import",
+    "model",
+    "scalar",
+    "namespace",
+    "op",
+    "interface",
+    "union",
+    "using",
+    "is",
+    "extends",
+    "enum",
+    "alias",
+    "return",
+    "void",
+    "if",
+    "else",
+    "projection",
+    "dec",
+    "extern",
+    "fn"
+  ];
+  var namedLiterals = ["true", "false", "null", "unknown", "never"];
+  var nonCommentWs = `[ \\t\\r\\n]`;
+  var numericLiteral = `[0-9]+`;
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "/**", close: " */", notIn: ["string"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' }
+    ],
+    indentationRules: {
+      decreaseIndentPattern: new RegExp("^((?!.*?/\\*).*\\*/)?\\s*[\\}\\]].*$"),
+      increaseIndentPattern: new RegExp(
+        "^((?!//).)*(\\{([^}\"'`/]*|(\\t|[ ])*//.*)|\\([^)\"'`/]*|\\[[^\\]\"'`/]*)$"
+      ),
+      // e.g.  * ...| or */| or *-----*/|
+      unIndentedLinePattern: new RegExp(
+        "^(\\t|[ ])*[ ]\\*[^/]*\\*/\\s*$|^(\\t|[ ])*[ ]\\*/\\s*$|^(\\t|[ ])*[ ]\\*([ ]([^\\*]|\\*(?!/))*)?$"
+      )
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".tsp",
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" }
+    ],
+    symbols: /[=:;<>]+/,
+    keywords,
+    namedLiterals,
+    escapes: `\\\\(u{[0-9A-Fa-f]+}|n|r|t|\\\\|"|\\\${)`,
+    tokenizer: {
+      root: [{ include: "@expression" }, { include: "@whitespace" }],
+      stringVerbatim: [
+        { regex: `(|"|"")[^"]`, action: { token: "string" } },
+        { regex: `"""${notBefore(`"`)}`, action: { token: "string", next: "@pop" } }
+      ],
+      stringLiteral: [
+        { regex: `\\\${`, action: { token: "delimiter.bracket", next: "@bracketCounting" } },
+        { regex: `[^\\\\"$]+`, action: { token: "string" } },
+        { regex: "@escapes", action: { token: "string.escape" } },
+        { regex: `\\\\.`, action: { token: "string.escape.invalid" } },
+        { regex: `"`, action: { token: "string", next: "@pop" } }
+      ],
+      bracketCounting: [
+        { regex: `{`, action: { token: "delimiter.bracket", next: "@bracketCounting" } },
+        { regex: `}`, action: { token: "delimiter.bracket", next: "@pop" } },
+        { include: "@expression" }
+      ],
+      comment: [
+        { regex: `[^\\*]+`, action: { token: "comment" } },
+        { regex: `\\*\\/`, action: { token: "comment", next: "@pop" } },
+        { regex: `[\\/*]`, action: { token: "comment" } }
+      ],
+      whitespace: [
+        { regex: nonCommentWs },
+        { regex: `\\/\\*`, action: { token: "comment", next: "@comment" } },
+        { regex: `\\/\\/.*$`, action: { token: "comment" } }
+      ],
+      expression: [
+        { regex: `"""`, action: { token: "string", next: "@stringVerbatim" } },
+        { regex: `"${notBefore(`""`)}`, action: { token: "string", next: "@stringLiteral" } },
+        { regex: numericLiteral, action: { token: "number" } },
+        {
+          regex: identifier,
+          action: {
+            cases: {
+              "@keywords": { token: "keyword" },
+              "@namedLiterals": { token: "keyword" },
+              "@default": { token: "identifier" }
+            }
+          }
+        },
+        { regex: `@${identifier}`, action: { token: "tag" } },
+        { regex: `#${directive}`, action: { token: "directive" } }
+      ]
+    }
+  };
+  return __toCommonJS(typespec_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/yaml/yaml.js

@@ -0,0 +1,267 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/yaml/yaml", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __commonJS = (cb, mod) => function __require2() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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"));
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/fillers/monaco-editor-core-amd.ts
+  var require_monaco_editor_core_amd = __commonJS({
+    "src/fillers/monaco-editor-core-amd.ts"(exports, module) {
+      var api = __toESM(__require("vs/editor/editor.api"));
+      module.exports = api;
+    }
+  });
+
+  // src/basic-languages/yaml/yaml.ts
+  var yaml_exports = {};
+  __export(yaml_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+
+  // src/fillers/monaco-editor-core.ts
+  var monaco_editor_core_exports = {};
+  __reExport(monaco_editor_core_exports, __toESM(require_monaco_editor_core_amd()));
+
+  // src/basic-languages/yaml/yaml.ts
+  var conf = {
+    comments: {
+      lineComment: "#"
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    folding: {
+      offSide: true
+    },
+    onEnterRules: [
+      {
+        beforeText: /:\s*$/,
+        action: {
+          indentAction: monaco_editor_core_exports.languages.IndentAction.Indent
+        }
+      }
+    ]
+  };
+  var language = {
+    tokenPostfix: ".yaml",
+    brackets: [
+      { token: "delimiter.bracket", open: "{", close: "}" },
+      { token: "delimiter.square", open: "[", close: "]" }
+    ],
+    keywords: ["true", "True", "TRUE", "false", "False", "FALSE", "null", "Null", "Null", "~"],
+    numberInteger: /(?:0|[+-]?[0-9]+)/,
+    numberFloat: /(?:0|[+-]?[0-9]+)(?:\.[0-9]+)?(?:e[-+][1-9][0-9]*)?/,
+    numberOctal: /0o[0-7]+/,
+    numberHex: /0x[0-9a-fA-F]+/,
+    numberInfinity: /[+-]?\.(?:inf|Inf|INF)/,
+    numberNaN: /\.(?:nan|Nan|NAN)/,
+    numberDate: /\d{4}-\d\d-\d\d([Tt ]\d\d:\d\d:\d\d(\.\d+)?(( ?[+-]\d\d?(:\d\d)?)|Z)?)?/,
+    escapes: /\\(?:[btnfr\\"']|[0-7][0-7]?|[0-3][0-7]{2})/,
+    tokenizer: {
+      root: [
+        { include: "@whitespace" },
+        { include: "@comment" },
+        // Directive
+        [/%[^ ]+.*$/, "meta.directive"],
+        // Document Markers
+        [/---/, "operators.directivesEnd"],
+        [/\.{3}/, "operators.documentEnd"],
+        // Block Structure Indicators
+        [/[-?:](?= )/, "operators"],
+        { include: "@anchor" },
+        { include: "@tagHandle" },
+        { include: "@flowCollections" },
+        { include: "@blockStyle" },
+        // Numbers
+        [/@numberInteger(?![ \t]*\S+)/, "number"],
+        [/@numberFloat(?![ \t]*\S+)/, "number.float"],
+        [/@numberOctal(?![ \t]*\S+)/, "number.octal"],
+        [/@numberHex(?![ \t]*\S+)/, "number.hex"],
+        [/@numberInfinity(?![ \t]*\S+)/, "number.infinity"],
+        [/@numberNaN(?![ \t]*\S+)/, "number.nan"],
+        [/@numberDate(?![ \t]*\S+)/, "number.date"],
+        // Key:Value pair
+        [/(".*?"|'.*?'|[^#'"]*?)([ \t]*)(:)( |$)/, ["type", "white", "operators", "white"]],
+        { include: "@flowScalars" },
+        // String nodes
+        [
+          /.+?(?=(\s+#|$))/,
+          {
+            cases: {
+              "@keywords": "keyword",
+              "@default": "string"
+            }
+          }
+        ]
+      ],
+      // Flow Collection: Flow Mapping
+      object: [
+        { include: "@whitespace" },
+        { include: "@comment" },
+        // Flow Mapping termination
+        [/\}/, "@brackets", "@pop"],
+        // Flow Mapping delimiter
+        [/,/, "delimiter.comma"],
+        // Flow Mapping Key:Value delimiter
+        [/:(?= )/, "operators"],
+        // Flow Mapping Key:Value key
+        [/(?:".*?"|'.*?'|[^,\{\[]+?)(?=: )/, "type"],
+        // Start Flow Style
+        { include: "@flowCollections" },
+        { include: "@flowScalars" },
+        // Scalar Data types
+        { include: "@tagHandle" },
+        { include: "@anchor" },
+        { include: "@flowNumber" },
+        // Other value (keyword or string)
+        [
+          /[^\},]+/,
+          {
+            cases: {
+              "@keywords": "keyword",
+              "@default": "string"
+            }
+          }
+        ]
+      ],
+      // Flow Collection: Flow Sequence
+      array: [
+        { include: "@whitespace" },
+        { include: "@comment" },
+        // Flow Sequence termination
+        [/\]/, "@brackets", "@pop"],
+        // Flow Sequence delimiter
+        [/,/, "delimiter.comma"],
+        // Start Flow Style
+        { include: "@flowCollections" },
+        { include: "@flowScalars" },
+        // Scalar Data types
+        { include: "@tagHandle" },
+        { include: "@anchor" },
+        { include: "@flowNumber" },
+        // Other value (keyword or string)
+        [
+          /[^\],]+/,
+          {
+            cases: {
+              "@keywords": "keyword",
+              "@default": "string"
+            }
+          }
+        ]
+      ],
+      // First line of a Block Style
+      multiString: [[/^( +).+$/, "string", "@multiStringContinued.$1"]],
+      // Further lines of a Block Style
+      //   Workaround for indentation detection
+      multiStringContinued: [
+        [
+          /^( *).+$/,
+          {
+            cases: {
+              "$1==$S2": "string",
+              "@default": { token: "@rematch", next: "@popall" }
+            }
+          }
+        ]
+      ],
+      whitespace: [[/[ \t\r\n]+/, "white"]],
+      // Only line comments
+      comment: [[/#.*$/, "comment"]],
+      // Start Flow Collections
+      flowCollections: [
+        [/\[/, "@brackets", "@array"],
+        [/\{/, "@brackets", "@object"]
+      ],
+      // Start Flow Scalars (quoted strings)
+      flowScalars: [
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        [/'([^'\\]|\\.)*$/, "string.invalid"],
+        [/'[^']*'/, "string"],
+        [/"/, "string", "@doubleQuotedString"]
+      ],
+      doubleQuotedString: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"]
+      ],
+      // Start Block Scalar
+      blockStyle: [[/[>|][0-9]*[+-]?$/, "operators", "@multiString"]],
+      // Numbers in Flow Collections (terminate with ,]})
+      flowNumber: [
+        [/@numberInteger(?=[ \t]*[,\]\}])/, "number"],
+        [/@numberFloat(?=[ \t]*[,\]\}])/, "number.float"],
+        [/@numberOctal(?=[ \t]*[,\]\}])/, "number.octal"],
+        [/@numberHex(?=[ \t]*[,\]\}])/, "number.hex"],
+        [/@numberInfinity(?=[ \t]*[,\]\}])/, "number.infinity"],
+        [/@numberNaN(?=[ \t]*[,\]\}])/, "number.nan"],
+        [/@numberDate(?=[ \t]*[,\]\}])/, "number.date"]
+      ],
+      tagHandle: [[/\![^ ]*/, "tag"]],
+      anchor: [[/[&*][^ ]+/, "namespace"]]
+    }
+  };
+  return __toCommonJS(yaml_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/language/css/cssMode.js

@@ -0,0 +1,2094 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/language/css/cssMode", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __commonJS = (cb, mod) => function __require2() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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"));
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/fillers/monaco-editor-core-amd.ts
+  var require_monaco_editor_core_amd = __commonJS({
+    "src/fillers/monaco-editor-core-amd.ts"(exports, module) {
+      var api = __toESM(__require("vs/editor/editor.api"));
+      module.exports = api;
+    }
+  });
+
+  // src/language/css/cssMode.ts
+  var cssMode_exports = {};
+  __export(cssMode_exports, {
+    CompletionAdapter: () => CompletionAdapter,
+    DefinitionAdapter: () => DefinitionAdapter,
+    DiagnosticsAdapter: () => DiagnosticsAdapter,
+    DocumentColorAdapter: () => DocumentColorAdapter,
+    DocumentFormattingEditProvider: () => DocumentFormattingEditProvider,
+    DocumentHighlightAdapter: () => DocumentHighlightAdapter,
+    DocumentLinkAdapter: () => DocumentLinkAdapter,
+    DocumentRangeFormattingEditProvider: () => DocumentRangeFormattingEditProvider,
+    DocumentSymbolAdapter: () => DocumentSymbolAdapter,
+    FoldingRangeAdapter: () => FoldingRangeAdapter,
+    HoverAdapter: () => HoverAdapter,
+    ReferenceAdapter: () => ReferenceAdapter,
+    RenameAdapter: () => RenameAdapter,
+    SelectionRangeAdapter: () => SelectionRangeAdapter,
+    WorkerManager: () => WorkerManager,
+    fromPosition: () => fromPosition,
+    fromRange: () => fromRange,
+    setupMode: () => setupMode,
+    toRange: () => toRange,
+    toTextEdit: () => toTextEdit
+  });
+
+  // src/fillers/monaco-editor-core.ts
+  var monaco_editor_core_exports = {};
+  __reExport(monaco_editor_core_exports, __toESM(require_monaco_editor_core_amd()));
+
+  // src/language/css/workerManager.ts
+  var STOP_WHEN_IDLE_FOR = 2 * 60 * 1e3;
+  var WorkerManager = class {
+    constructor(defaults) {
+      this._defaults = defaults;
+      this._worker = null;
+      this._client = null;
+      this._idleCheckInterval = window.setInterval(() => this._checkIfIdle(), 30 * 1e3);
+      this._lastUsedTime = 0;
+      this._configChangeListener = this._defaults.onDidChange(() => this._stopWorker());
+    }
+    _stopWorker() {
+      if (this._worker) {
+        this._worker.dispose();
+        this._worker = null;
+      }
+      this._client = null;
+    }
+    dispose() {
+      clearInterval(this._idleCheckInterval);
+      this._configChangeListener.dispose();
+      this._stopWorker();
+    }
+    _checkIfIdle() {
+      if (!this._worker) {
+        return;
+      }
+      let timePassedSinceLastUsed = Date.now() - this._lastUsedTime;
+      if (timePassedSinceLastUsed > STOP_WHEN_IDLE_FOR) {
+        this._stopWorker();
+      }
+    }
+    _getClient() {
+      this._lastUsedTime = Date.now();
+      if (!this._client) {
+        this._worker = monaco_editor_core_exports.editor.createWebWorker({
+          // module that exports the create() method and returns a `CSSWorker` instance
+          moduleId: "vs/language/css/cssWorker",
+          label: this._defaults.languageId,
+          // passed in to the create() method
+          createData: {
+            options: this._defaults.options,
+            languageId: this._defaults.languageId
+          }
+        });
+        this._client = this._worker.getProxy();
+      }
+      return this._client;
+    }
+    getLanguageServiceWorker(...resources) {
+      let _client;
+      return this._getClient().then((client) => {
+        _client = client;
+      }).then((_) => {
+        if (this._worker) {
+          return this._worker.withSyncedResources(resources);
+        }
+      }).then((_) => _client);
+    }
+  };
+
+  // node_modules/vscode-languageserver-types/lib/esm/main.js
+  var DocumentUri;
+  (function(DocumentUri2) {
+    function is(value) {
+      return typeof value === "string";
+    }
+    DocumentUri2.is = is;
+  })(DocumentUri || (DocumentUri = {}));
+  var URI;
+  (function(URI2) {
+    function is(value) {
+      return typeof value === "string";
+    }
+    URI2.is = is;
+  })(URI || (URI = {}));
+  var integer;
+  (function(integer2) {
+    integer2.MIN_VALUE = -2147483648;
+    integer2.MAX_VALUE = 2147483647;
+    function is(value) {
+      return typeof value === "number" && integer2.MIN_VALUE <= value && value <= integer2.MAX_VALUE;
+    }
+    integer2.is = is;
+  })(integer || (integer = {}));
+  var uinteger;
+  (function(uinteger2) {
+    uinteger2.MIN_VALUE = 0;
+    uinteger2.MAX_VALUE = 2147483647;
+    function is(value) {
+      return typeof value === "number" && uinteger2.MIN_VALUE <= value && value <= uinteger2.MAX_VALUE;
+    }
+    uinteger2.is = is;
+  })(uinteger || (uinteger = {}));
+  var Position;
+  (function(Position3) {
+    function create(line, character) {
+      if (line === Number.MAX_VALUE) {
+        line = uinteger.MAX_VALUE;
+      }
+      if (character === Number.MAX_VALUE) {
+        character = uinteger.MAX_VALUE;
+      }
+      return { line, character };
+    }
+    Position3.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);
+    }
+    Position3.is = is;
+  })(Position || (Position = {}));
+  var Range;
+  (function(Range3) {
+    function create(one, two, three, four) {
+      if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {
+        return { start: Position.create(one, two), end: Position.create(three, four) };
+      } else if (Position.is(one) && Position.is(two)) {
+        return { start: one, end: two };
+      } else {
+        throw new Error(`Range#create called with invalid arguments[${one}, ${two}, ${three}, ${four}]`);
+      }
+    }
+    Range3.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end);
+    }
+    Range3.is = is;
+  })(Range || (Range = {}));
+  var Location;
+  (function(Location2) {
+    function create(uri, range) {
+      return { uri, range };
+    }
+    Location2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.objectLiteral(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
+    }
+    Location2.is = is;
+  })(Location || (Location = {}));
+  var LocationLink;
+  (function(LocationLink2) {
+    function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {
+      return { targetUri, targetRange, targetSelectionRange, originSelectionRange };
+    }
+    LocationLink2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.objectLiteral(candidate) && Range.is(candidate.targetRange) && Is.string(candidate.targetUri) && Range.is(candidate.targetSelectionRange) && (Range.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));
+    }
+    LocationLink2.is = is;
+  })(LocationLink || (LocationLink = {}));
+  var Color;
+  (function(Color2) {
+    function create(red, green, blue, alpha) {
+      return {
+        red,
+        green,
+        blue,
+        alpha
+      };
+    }
+    Color2.create = create;
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && Is.numberRange(candidate.red, 0, 1) && Is.numberRange(candidate.green, 0, 1) && Is.numberRange(candidate.blue, 0, 1) && Is.numberRange(candidate.alpha, 0, 1);
+    }
+    Color2.is = is;
+  })(Color || (Color = {}));
+  var ColorInformation;
+  (function(ColorInformation2) {
+    function create(range, color) {
+      return {
+        range,
+        color
+      };
+    }
+    ColorInformation2.create = create;
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && Range.is(candidate.range) && Color.is(candidate.color);
+    }
+    ColorInformation2.is = is;
+  })(ColorInformation || (ColorInformation = {}));
+  var ColorPresentation;
+  (function(ColorPresentation2) {
+    function create(label, textEdit, additionalTextEdits) {
+      return {
+        label,
+        textEdit,
+        additionalTextEdits
+      };
+    }
+    ColorPresentation2.create = create;
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate)) && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));
+    }
+    ColorPresentation2.is = is;
+  })(ColorPresentation || (ColorPresentation = {}));
+  var FoldingRangeKind;
+  (function(FoldingRangeKind2) {
+    FoldingRangeKind2.Comment = "comment";
+    FoldingRangeKind2.Imports = "imports";
+    FoldingRangeKind2.Region = "region";
+  })(FoldingRangeKind || (FoldingRangeKind = {}));
+  var FoldingRange;
+  (function(FoldingRange2) {
+    function create(startLine, endLine, startCharacter, endCharacter, kind, collapsedText) {
+      const result = {
+        startLine,
+        endLine
+      };
+      if (Is.defined(startCharacter)) {
+        result.startCharacter = startCharacter;
+      }
+      if (Is.defined(endCharacter)) {
+        result.endCharacter = endCharacter;
+      }
+      if (Is.defined(kind)) {
+        result.kind = kind;
+      }
+      if (Is.defined(collapsedText)) {
+        result.collapsedText = collapsedText;
+      }
+      return result;
+    }
+    FoldingRange2.create = create;
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine) && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter)) && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter)) && (Is.undefined(candidate.kind) || Is.string(candidate.kind));
+    }
+    FoldingRange2.is = is;
+  })(FoldingRange || (FoldingRange = {}));
+  var DiagnosticRelatedInformation;
+  (function(DiagnosticRelatedInformation2) {
+    function create(location, message) {
+      return {
+        location,
+        message
+      };
+    }
+    DiagnosticRelatedInformation2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);
+    }
+    DiagnosticRelatedInformation2.is = is;
+  })(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {}));
+  var DiagnosticSeverity;
+  (function(DiagnosticSeverity2) {
+    DiagnosticSeverity2.Error = 1;
+    DiagnosticSeverity2.Warning = 2;
+    DiagnosticSeverity2.Information = 3;
+    DiagnosticSeverity2.Hint = 4;
+  })(DiagnosticSeverity || (DiagnosticSeverity = {}));
+  var DiagnosticTag;
+  (function(DiagnosticTag2) {
+    DiagnosticTag2.Unnecessary = 1;
+    DiagnosticTag2.Deprecated = 2;
+  })(DiagnosticTag || (DiagnosticTag = {}));
+  var CodeDescription;
+  (function(CodeDescription2) {
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && Is.string(candidate.href);
+    }
+    CodeDescription2.is = is;
+  })(CodeDescription || (CodeDescription = {}));
+  var Diagnostic;
+  (function(Diagnostic2) {
+    function create(range, message, severity, code, source, relatedInformation) {
+      let result = { range, message };
+      if (Is.defined(severity)) {
+        result.severity = severity;
+      }
+      if (Is.defined(code)) {
+        result.code = code;
+      }
+      if (Is.defined(source)) {
+        result.source = source;
+      }
+      if (Is.defined(relatedInformation)) {
+        result.relatedInformation = relatedInformation;
+      }
+      return result;
+    }
+    Diagnostic2.create = create;
+    function is(value) {
+      var _a;
+      let candidate = value;
+      return Is.defined(candidate) && Range.is(candidate.range) && Is.string(candidate.message) && (Is.number(candidate.severity) || Is.undefined(candidate.severity)) && (Is.integer(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code)) && (Is.undefined(candidate.codeDescription) || Is.string((_a = candidate.codeDescription) === null || _a === void 0 ? void 0 : _a.href)) && (Is.string(candidate.source) || Is.undefined(candidate.source)) && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));
+    }
+    Diagnostic2.is = is;
+  })(Diagnostic || (Diagnostic = {}));
+  var Command;
+  (function(Command2) {
+    function create(title, command, ...args) {
+      let result = { title, command };
+      if (Is.defined(args) && args.length > 0) {
+        result.arguments = args;
+      }
+      return result;
+    }
+    Command2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);
+    }
+    Command2.is = is;
+  })(Command || (Command = {}));
+  var TextEdit;
+  (function(TextEdit2) {
+    function replace(range, newText) {
+      return { range, newText };
+    }
+    TextEdit2.replace = replace;
+    function insert(position, newText) {
+      return { range: { start: position, end: position }, newText };
+    }
+    TextEdit2.insert = insert;
+    function del(range) {
+      return { range, newText: "" };
+    }
+    TextEdit2.del = del;
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && Is.string(candidate.newText) && Range.is(candidate.range);
+    }
+    TextEdit2.is = is;
+  })(TextEdit || (TextEdit = {}));
+  var ChangeAnnotation;
+  (function(ChangeAnnotation2) {
+    function create(label, needsConfirmation, description) {
+      const result = { label };
+      if (needsConfirmation !== void 0) {
+        result.needsConfirmation = needsConfirmation;
+      }
+      if (description !== void 0) {
+        result.description = description;
+      }
+      return result;
+    }
+    ChangeAnnotation2.create = create;
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.boolean(candidate.needsConfirmation) || candidate.needsConfirmation === void 0) && (Is.string(candidate.description) || candidate.description === void 0);
+    }
+    ChangeAnnotation2.is = is;
+  })(ChangeAnnotation || (ChangeAnnotation = {}));
+  var ChangeAnnotationIdentifier;
+  (function(ChangeAnnotationIdentifier2) {
+    function is(value) {
+      const candidate = value;
+      return Is.string(candidate);
+    }
+    ChangeAnnotationIdentifier2.is = is;
+  })(ChangeAnnotationIdentifier || (ChangeAnnotationIdentifier = {}));
+  var AnnotatedTextEdit;
+  (function(AnnotatedTextEdit2) {
+    function replace(range, newText, annotation) {
+      return { range, newText, annotationId: annotation };
+    }
+    AnnotatedTextEdit2.replace = replace;
+    function insert(position, newText, annotation) {
+      return { range: { start: position, end: position }, newText, annotationId: annotation };
+    }
+    AnnotatedTextEdit2.insert = insert;
+    function del(range, annotation) {
+      return { range, newText: "", annotationId: annotation };
+    }
+    AnnotatedTextEdit2.del = del;
+    function is(value) {
+      const candidate = value;
+      return TextEdit.is(candidate) && (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId));
+    }
+    AnnotatedTextEdit2.is = is;
+  })(AnnotatedTextEdit || (AnnotatedTextEdit = {}));
+  var TextDocumentEdit;
+  (function(TextDocumentEdit2) {
+    function create(textDocument, edits) {
+      return { textDocument, edits };
+    }
+    TextDocumentEdit2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && OptionalVersionedTextDocumentIdentifier.is(candidate.textDocument) && Array.isArray(candidate.edits);
+    }
+    TextDocumentEdit2.is = is;
+  })(TextDocumentEdit || (TextDocumentEdit = {}));
+  var CreateFile;
+  (function(CreateFile2) {
+    function create(uri, options, annotation) {
+      let result = {
+        kind: "create",
+        uri
+      };
+      if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
+        result.options = options;
+      }
+      if (annotation !== void 0) {
+        result.annotationId = annotation;
+      }
+      return result;
+    }
+    CreateFile2.create = create;
+    function is(value) {
+      let candidate = value;
+      return candidate && candidate.kind === "create" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
+    }
+    CreateFile2.is = is;
+  })(CreateFile || (CreateFile = {}));
+  var RenameFile;
+  (function(RenameFile2) {
+    function create(oldUri, newUri, options, annotation) {
+      let result = {
+        kind: "rename",
+        oldUri,
+        newUri
+      };
+      if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
+        result.options = options;
+      }
+      if (annotation !== void 0) {
+        result.annotationId = annotation;
+      }
+      return result;
+    }
+    RenameFile2.create = create;
+    function is(value) {
+      let candidate = value;
+      return candidate && candidate.kind === "rename" && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
+    }
+    RenameFile2.is = is;
+  })(RenameFile || (RenameFile = {}));
+  var DeleteFile;
+  (function(DeleteFile2) {
+    function create(uri, options, annotation) {
+      let result = {
+        kind: "delete",
+        uri
+      };
+      if (options !== void 0 && (options.recursive !== void 0 || options.ignoreIfNotExists !== void 0)) {
+        result.options = options;
+      }
+      if (annotation !== void 0) {
+        result.annotationId = annotation;
+      }
+      return result;
+    }
+    DeleteFile2.create = create;
+    function is(value) {
+      let candidate = value;
+      return candidate && candidate.kind === "delete" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.recursive === void 0 || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === void 0 || Is.boolean(candidate.options.ignoreIfNotExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
+    }
+    DeleteFile2.is = is;
+  })(DeleteFile || (DeleteFile = {}));
+  var WorkspaceEdit;
+  (function(WorkspaceEdit2) {
+    function is(value) {
+      let candidate = value;
+      return candidate && (candidate.changes !== void 0 || candidate.documentChanges !== void 0) && (candidate.documentChanges === void 0 || candidate.documentChanges.every((change) => {
+        if (Is.string(change.kind)) {
+          return CreateFile.is(change) || RenameFile.is(change) || DeleteFile.is(change);
+        } else {
+          return TextDocumentEdit.is(change);
+        }
+      }));
+    }
+    WorkspaceEdit2.is = is;
+  })(WorkspaceEdit || (WorkspaceEdit = {}));
+  var TextDocumentIdentifier;
+  (function(TextDocumentIdentifier2) {
+    function create(uri) {
+      return { uri };
+    }
+    TextDocumentIdentifier2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Is.string(candidate.uri);
+    }
+    TextDocumentIdentifier2.is = is;
+  })(TextDocumentIdentifier || (TextDocumentIdentifier = {}));
+  var VersionedTextDocumentIdentifier;
+  (function(VersionedTextDocumentIdentifier2) {
+    function create(uri, version) {
+      return { uri, version };
+    }
+    VersionedTextDocumentIdentifier2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Is.string(candidate.uri) && Is.integer(candidate.version);
+    }
+    VersionedTextDocumentIdentifier2.is = is;
+  })(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));
+  var OptionalVersionedTextDocumentIdentifier;
+  (function(OptionalVersionedTextDocumentIdentifier2) {
+    function create(uri, version) {
+      return { uri, version };
+    }
+    OptionalVersionedTextDocumentIdentifier2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.integer(candidate.version));
+    }
+    OptionalVersionedTextDocumentIdentifier2.is = is;
+  })(OptionalVersionedTextDocumentIdentifier || (OptionalVersionedTextDocumentIdentifier = {}));
+  var TextDocumentItem;
+  (function(TextDocumentItem2) {
+    function create(uri, languageId, version, text) {
+      return { uri, languageId, version, text };
+    }
+    TextDocumentItem2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.integer(candidate.version) && Is.string(candidate.text);
+    }
+    TextDocumentItem2.is = is;
+  })(TextDocumentItem || (TextDocumentItem = {}));
+  var MarkupKind;
+  (function(MarkupKind2) {
+    MarkupKind2.PlainText = "plaintext";
+    MarkupKind2.Markdown = "markdown";
+    function is(value) {
+      const candidate = value;
+      return candidate === MarkupKind2.PlainText || candidate === MarkupKind2.Markdown;
+    }
+    MarkupKind2.is = is;
+  })(MarkupKind || (MarkupKind = {}));
+  var MarkupContent;
+  (function(MarkupContent2) {
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);
+    }
+    MarkupContent2.is = is;
+  })(MarkupContent || (MarkupContent = {}));
+  var CompletionItemKind;
+  (function(CompletionItemKind2) {
+    CompletionItemKind2.Text = 1;
+    CompletionItemKind2.Method = 2;
+    CompletionItemKind2.Function = 3;
+    CompletionItemKind2.Constructor = 4;
+    CompletionItemKind2.Field = 5;
+    CompletionItemKind2.Variable = 6;
+    CompletionItemKind2.Class = 7;
+    CompletionItemKind2.Interface = 8;
+    CompletionItemKind2.Module = 9;
+    CompletionItemKind2.Property = 10;
+    CompletionItemKind2.Unit = 11;
+    CompletionItemKind2.Value = 12;
+    CompletionItemKind2.Enum = 13;
+    CompletionItemKind2.Keyword = 14;
+    CompletionItemKind2.Snippet = 15;
+    CompletionItemKind2.Color = 16;
+    CompletionItemKind2.File = 17;
+    CompletionItemKind2.Reference = 18;
+    CompletionItemKind2.Folder = 19;
+    CompletionItemKind2.EnumMember = 20;
+    CompletionItemKind2.Constant = 21;
+    CompletionItemKind2.Struct = 22;
+    CompletionItemKind2.Event = 23;
+    CompletionItemKind2.Operator = 24;
+    CompletionItemKind2.TypeParameter = 25;
+  })(CompletionItemKind || (CompletionItemKind = {}));
+  var InsertTextFormat;
+  (function(InsertTextFormat2) {
+    InsertTextFormat2.PlainText = 1;
+    InsertTextFormat2.Snippet = 2;
+  })(InsertTextFormat || (InsertTextFormat = {}));
+  var CompletionItemTag;
+  (function(CompletionItemTag2) {
+    CompletionItemTag2.Deprecated = 1;
+  })(CompletionItemTag || (CompletionItemTag = {}));
+  var InsertReplaceEdit;
+  (function(InsertReplaceEdit2) {
+    function create(newText, insert, replace) {
+      return { newText, insert, replace };
+    }
+    InsertReplaceEdit2.create = create;
+    function is(value) {
+      const candidate = value;
+      return candidate && Is.string(candidate.newText) && Range.is(candidate.insert) && Range.is(candidate.replace);
+    }
+    InsertReplaceEdit2.is = is;
+  })(InsertReplaceEdit || (InsertReplaceEdit = {}));
+  var InsertTextMode;
+  (function(InsertTextMode2) {
+    InsertTextMode2.asIs = 1;
+    InsertTextMode2.adjustIndentation = 2;
+  })(InsertTextMode || (InsertTextMode = {}));
+  var CompletionItemLabelDetails;
+  (function(CompletionItemLabelDetails2) {
+    function is(value) {
+      const candidate = value;
+      return candidate && (Is.string(candidate.detail) || candidate.detail === void 0) && (Is.string(candidate.description) || candidate.description === void 0);
+    }
+    CompletionItemLabelDetails2.is = is;
+  })(CompletionItemLabelDetails || (CompletionItemLabelDetails = {}));
+  var CompletionItem;
+  (function(CompletionItem2) {
+    function create(label) {
+      return { label };
+    }
+    CompletionItem2.create = create;
+  })(CompletionItem || (CompletionItem = {}));
+  var CompletionList;
+  (function(CompletionList2) {
+    function create(items, isIncomplete) {
+      return { items: items ? items : [], isIncomplete: !!isIncomplete };
+    }
+    CompletionList2.create = create;
+  })(CompletionList || (CompletionList = {}));
+  var MarkedString;
+  (function(MarkedString2) {
+    function fromPlainText(plainText) {
+      return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&");
+    }
+    MarkedString2.fromPlainText = fromPlainText;
+    function is(value) {
+      const candidate = value;
+      return Is.string(candidate) || Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value);
+    }
+    MarkedString2.is = is;
+  })(MarkedString || (MarkedString = {}));
+  var Hover;
+  (function(Hover2) {
+    function is(value) {
+      let candidate = value;
+      return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) || MarkedString.is(candidate.contents) || Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === void 0 || Range.is(value.range));
+    }
+    Hover2.is = is;
+  })(Hover || (Hover = {}));
+  var ParameterInformation;
+  (function(ParameterInformation2) {
+    function create(label, documentation) {
+      return documentation ? { label, documentation } : { label };
+    }
+    ParameterInformation2.create = create;
+  })(ParameterInformation || (ParameterInformation = {}));
+  var SignatureInformation;
+  (function(SignatureInformation2) {
+    function create(label, documentation, ...parameters) {
+      let result = { label };
+      if (Is.defined(documentation)) {
+        result.documentation = documentation;
+      }
+      if (Is.defined(parameters)) {
+        result.parameters = parameters;
+      } else {
+        result.parameters = [];
+      }
+      return result;
+    }
+    SignatureInformation2.create = create;
+  })(SignatureInformation || (SignatureInformation = {}));
+  var DocumentHighlightKind;
+  (function(DocumentHighlightKind2) {
+    DocumentHighlightKind2.Text = 1;
+    DocumentHighlightKind2.Read = 2;
+    DocumentHighlightKind2.Write = 3;
+  })(DocumentHighlightKind || (DocumentHighlightKind = {}));
+  var DocumentHighlight;
+  (function(DocumentHighlight2) {
+    function create(range, kind) {
+      let result = { range };
+      if (Is.number(kind)) {
+        result.kind = kind;
+      }
+      return result;
+    }
+    DocumentHighlight2.create = create;
+  })(DocumentHighlight || (DocumentHighlight = {}));
+  var SymbolKind;
+  (function(SymbolKind2) {
+    SymbolKind2.File = 1;
+    SymbolKind2.Module = 2;
+    SymbolKind2.Namespace = 3;
+    SymbolKind2.Package = 4;
+    SymbolKind2.Class = 5;
+    SymbolKind2.Method = 6;
+    SymbolKind2.Property = 7;
+    SymbolKind2.Field = 8;
+    SymbolKind2.Constructor = 9;
+    SymbolKind2.Enum = 10;
+    SymbolKind2.Interface = 11;
+    SymbolKind2.Function = 12;
+    SymbolKind2.Variable = 13;
+    SymbolKind2.Constant = 14;
+    SymbolKind2.String = 15;
+    SymbolKind2.Number = 16;
+    SymbolKind2.Boolean = 17;
+    SymbolKind2.Array = 18;
+    SymbolKind2.Object = 19;
+    SymbolKind2.Key = 20;
+    SymbolKind2.Null = 21;
+    SymbolKind2.EnumMember = 22;
+    SymbolKind2.Struct = 23;
+    SymbolKind2.Event = 24;
+    SymbolKind2.Operator = 25;
+    SymbolKind2.TypeParameter = 26;
+  })(SymbolKind || (SymbolKind = {}));
+  var SymbolTag;
+  (function(SymbolTag2) {
+    SymbolTag2.Deprecated = 1;
+  })(SymbolTag || (SymbolTag = {}));
+  var SymbolInformation;
+  (function(SymbolInformation2) {
+    function create(name, kind, range, uri, containerName) {
+      let result = {
+        name,
+        kind,
+        location: { uri, range }
+      };
+      if (containerName) {
+        result.containerName = containerName;
+      }
+      return result;
+    }
+    SymbolInformation2.create = create;
+  })(SymbolInformation || (SymbolInformation = {}));
+  var WorkspaceSymbol;
+  (function(WorkspaceSymbol2) {
+    function create(name, kind, uri, range) {
+      return range !== void 0 ? { name, kind, location: { uri, range } } : { name, kind, location: { uri } };
+    }
+    WorkspaceSymbol2.create = create;
+  })(WorkspaceSymbol || (WorkspaceSymbol = {}));
+  var DocumentSymbol;
+  (function(DocumentSymbol2) {
+    function create(name, detail, kind, range, selectionRange, children) {
+      let result = {
+        name,
+        detail,
+        kind,
+        range,
+        selectionRange
+      };
+      if (children !== void 0) {
+        result.children = children;
+      }
+      return result;
+    }
+    DocumentSymbol2.create = create;
+    function is(value) {
+      let candidate = value;
+      return candidate && Is.string(candidate.name) && Is.number(candidate.kind) && Range.is(candidate.range) && Range.is(candidate.selectionRange) && (candidate.detail === void 0 || Is.string(candidate.detail)) && (candidate.deprecated === void 0 || Is.boolean(candidate.deprecated)) && (candidate.children === void 0 || Array.isArray(candidate.children)) && (candidate.tags === void 0 || Array.isArray(candidate.tags));
+    }
+    DocumentSymbol2.is = is;
+  })(DocumentSymbol || (DocumentSymbol = {}));
+  var CodeActionKind;
+  (function(CodeActionKind2) {
+    CodeActionKind2.Empty = "";
+    CodeActionKind2.QuickFix = "quickfix";
+    CodeActionKind2.Refactor = "refactor";
+    CodeActionKind2.RefactorExtract = "refactor.extract";
+    CodeActionKind2.RefactorInline = "refactor.inline";
+    CodeActionKind2.RefactorRewrite = "refactor.rewrite";
+    CodeActionKind2.Source = "source";
+    CodeActionKind2.SourceOrganizeImports = "source.organizeImports";
+    CodeActionKind2.SourceFixAll = "source.fixAll";
+  })(CodeActionKind || (CodeActionKind = {}));
+  var CodeActionTriggerKind;
+  (function(CodeActionTriggerKind2) {
+    CodeActionTriggerKind2.Invoked = 1;
+    CodeActionTriggerKind2.Automatic = 2;
+  })(CodeActionTriggerKind || (CodeActionTriggerKind = {}));
+  var CodeActionContext;
+  (function(CodeActionContext2) {
+    function create(diagnostics, only, triggerKind) {
+      let result = { diagnostics };
+      if (only !== void 0 && only !== null) {
+        result.only = only;
+      }
+      if (triggerKind !== void 0 && triggerKind !== null) {
+        result.triggerKind = triggerKind;
+      }
+      return result;
+    }
+    CodeActionContext2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is) && (candidate.only === void 0 || Is.typedArray(candidate.only, Is.string)) && (candidate.triggerKind === void 0 || candidate.triggerKind === CodeActionTriggerKind.Invoked || candidate.triggerKind === CodeActionTriggerKind.Automatic);
+    }
+    CodeActionContext2.is = is;
+  })(CodeActionContext || (CodeActionContext = {}));
+  var CodeAction;
+  (function(CodeAction2) {
+    function create(title, kindOrCommandOrEdit, kind) {
+      let result = { title };
+      let checkKind = true;
+      if (typeof kindOrCommandOrEdit === "string") {
+        checkKind = false;
+        result.kind = kindOrCommandOrEdit;
+      } else if (Command.is(kindOrCommandOrEdit)) {
+        result.command = kindOrCommandOrEdit;
+      } else {
+        result.edit = kindOrCommandOrEdit;
+      }
+      if (checkKind && kind !== void 0) {
+        result.kind = kind;
+      }
+      return result;
+    }
+    CodeAction2.create = create;
+    function is(value) {
+      let candidate = value;
+      return candidate && Is.string(candidate.title) && (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, Diagnostic.is)) && (candidate.kind === void 0 || Is.string(candidate.kind)) && (candidate.edit !== void 0 || candidate.command !== void 0) && (candidate.command === void 0 || Command.is(candidate.command)) && (candidate.isPreferred === void 0 || Is.boolean(candidate.isPreferred)) && (candidate.edit === void 0 || WorkspaceEdit.is(candidate.edit));
+    }
+    CodeAction2.is = is;
+  })(CodeAction || (CodeAction = {}));
+  var CodeLens;
+  (function(CodeLens2) {
+    function create(range, data) {
+      let result = { range };
+      if (Is.defined(data)) {
+        result.data = data;
+      }
+      return result;
+    }
+    CodeLens2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));
+    }
+    CodeLens2.is = is;
+  })(CodeLens || (CodeLens = {}));
+  var FormattingOptions;
+  (function(FormattingOptions2) {
+    function create(tabSize, insertSpaces) {
+      return { tabSize, insertSpaces };
+    }
+    FormattingOptions2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Is.uinteger(candidate.tabSize) && Is.boolean(candidate.insertSpaces);
+    }
+    FormattingOptions2.is = is;
+  })(FormattingOptions || (FormattingOptions = {}));
+  var DocumentLink;
+  (function(DocumentLink2) {
+    function create(range, target, data) {
+      return { range, target, data };
+    }
+    DocumentLink2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
+    }
+    DocumentLink2.is = is;
+  })(DocumentLink || (DocumentLink = {}));
+  var SelectionRange;
+  (function(SelectionRange2) {
+    function create(range, parent) {
+      return { range, parent };
+    }
+    SelectionRange2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.objectLiteral(candidate) && Range.is(candidate.range) && (candidate.parent === void 0 || SelectionRange2.is(candidate.parent));
+    }
+    SelectionRange2.is = is;
+  })(SelectionRange || (SelectionRange = {}));
+  var SemanticTokenTypes;
+  (function(SemanticTokenTypes2) {
+    SemanticTokenTypes2["namespace"] = "namespace";
+    SemanticTokenTypes2["type"] = "type";
+    SemanticTokenTypes2["class"] = "class";
+    SemanticTokenTypes2["enum"] = "enum";
+    SemanticTokenTypes2["interface"] = "interface";
+    SemanticTokenTypes2["struct"] = "struct";
+    SemanticTokenTypes2["typeParameter"] = "typeParameter";
+    SemanticTokenTypes2["parameter"] = "parameter";
+    SemanticTokenTypes2["variable"] = "variable";
+    SemanticTokenTypes2["property"] = "property";
+    SemanticTokenTypes2["enumMember"] = "enumMember";
+    SemanticTokenTypes2["event"] = "event";
+    SemanticTokenTypes2["function"] = "function";
+    SemanticTokenTypes2["method"] = "method";
+    SemanticTokenTypes2["macro"] = "macro";
+    SemanticTokenTypes2["keyword"] = "keyword";
+    SemanticTokenTypes2["modifier"] = "modifier";
+    SemanticTokenTypes2["comment"] = "comment";
+    SemanticTokenTypes2["string"] = "string";
+    SemanticTokenTypes2["number"] = "number";
+    SemanticTokenTypes2["regexp"] = "regexp";
+    SemanticTokenTypes2["operator"] = "operator";
+    SemanticTokenTypes2["decorator"] = "decorator";
+  })(SemanticTokenTypes || (SemanticTokenTypes = {}));
+  var SemanticTokenModifiers;
+  (function(SemanticTokenModifiers2) {
+    SemanticTokenModifiers2["declaration"] = "declaration";
+    SemanticTokenModifiers2["definition"] = "definition";
+    SemanticTokenModifiers2["readonly"] = "readonly";
+    SemanticTokenModifiers2["static"] = "static";
+    SemanticTokenModifiers2["deprecated"] = "deprecated";
+    SemanticTokenModifiers2["abstract"] = "abstract";
+    SemanticTokenModifiers2["async"] = "async";
+    SemanticTokenModifiers2["modification"] = "modification";
+    SemanticTokenModifiers2["documentation"] = "documentation";
+    SemanticTokenModifiers2["defaultLibrary"] = "defaultLibrary";
+  })(SemanticTokenModifiers || (SemanticTokenModifiers = {}));
+  var SemanticTokens;
+  (function(SemanticTokens2) {
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && (candidate.resultId === void 0 || typeof candidate.resultId === "string") && Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === "number");
+    }
+    SemanticTokens2.is = is;
+  })(SemanticTokens || (SemanticTokens = {}));
+  var InlineValueText;
+  (function(InlineValueText2) {
+    function create(range, text) {
+      return { range, text };
+    }
+    InlineValueText2.create = create;
+    function is(value) {
+      const candidate = value;
+      return candidate !== void 0 && candidate !== null && Range.is(candidate.range) && Is.string(candidate.text);
+    }
+    InlineValueText2.is = is;
+  })(InlineValueText || (InlineValueText = {}));
+  var InlineValueVariableLookup;
+  (function(InlineValueVariableLookup2) {
+    function create(range, variableName, caseSensitiveLookup) {
+      return { range, variableName, caseSensitiveLookup };
+    }
+    InlineValueVariableLookup2.create = create;
+    function is(value) {
+      const candidate = value;
+      return candidate !== void 0 && candidate !== null && Range.is(candidate.range) && Is.boolean(candidate.caseSensitiveLookup) && (Is.string(candidate.variableName) || candidate.variableName === void 0);
+    }
+    InlineValueVariableLookup2.is = is;
+  })(InlineValueVariableLookup || (InlineValueVariableLookup = {}));
+  var InlineValueEvaluatableExpression;
+  (function(InlineValueEvaluatableExpression2) {
+    function create(range, expression) {
+      return { range, expression };
+    }
+    InlineValueEvaluatableExpression2.create = create;
+    function is(value) {
+      const candidate = value;
+      return candidate !== void 0 && candidate !== null && Range.is(candidate.range) && (Is.string(candidate.expression) || candidate.expression === void 0);
+    }
+    InlineValueEvaluatableExpression2.is = is;
+  })(InlineValueEvaluatableExpression || (InlineValueEvaluatableExpression = {}));
+  var InlineValueContext;
+  (function(InlineValueContext2) {
+    function create(frameId, stoppedLocation) {
+      return { frameId, stoppedLocation };
+    }
+    InlineValueContext2.create = create;
+    function is(value) {
+      const candidate = value;
+      return Is.defined(candidate) && Range.is(value.stoppedLocation);
+    }
+    InlineValueContext2.is = is;
+  })(InlineValueContext || (InlineValueContext = {}));
+  var InlayHintKind;
+  (function(InlayHintKind2) {
+    InlayHintKind2.Type = 1;
+    InlayHintKind2.Parameter = 2;
+    function is(value) {
+      return value === 1 || value === 2;
+    }
+    InlayHintKind2.is = is;
+  })(InlayHintKind || (InlayHintKind = {}));
+  var InlayHintLabelPart;
+  (function(InlayHintLabelPart2) {
+    function create(value) {
+      return { value };
+    }
+    InlayHintLabelPart2.create = create;
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && (candidate.tooltip === void 0 || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip)) && (candidate.location === void 0 || Location.is(candidate.location)) && (candidate.command === void 0 || Command.is(candidate.command));
+    }
+    InlayHintLabelPart2.is = is;
+  })(InlayHintLabelPart || (InlayHintLabelPart = {}));
+  var InlayHint;
+  (function(InlayHint2) {
+    function create(position, label, kind) {
+      const result = { position, label };
+      if (kind !== void 0) {
+        result.kind = kind;
+      }
+      return result;
+    }
+    InlayHint2.create = create;
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && Position.is(candidate.position) && (Is.string(candidate.label) || Is.typedArray(candidate.label, InlayHintLabelPart.is)) && (candidate.kind === void 0 || InlayHintKind.is(candidate.kind)) && candidate.textEdits === void 0 || Is.typedArray(candidate.textEdits, TextEdit.is) && (candidate.tooltip === void 0 || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip)) && (candidate.paddingLeft === void 0 || Is.boolean(candidate.paddingLeft)) && (candidate.paddingRight === void 0 || Is.boolean(candidate.paddingRight));
+    }
+    InlayHint2.is = is;
+  })(InlayHint || (InlayHint = {}));
+  var StringValue;
+  (function(StringValue2) {
+    function createSnippet(value) {
+      return { kind: "snippet", value };
+    }
+    StringValue2.createSnippet = createSnippet;
+  })(StringValue || (StringValue = {}));
+  var InlineCompletionItem;
+  (function(InlineCompletionItem2) {
+    function create(insertText, filterText, range, command) {
+      return { insertText, filterText, range, command };
+    }
+    InlineCompletionItem2.create = create;
+  })(InlineCompletionItem || (InlineCompletionItem = {}));
+  var InlineCompletionList;
+  (function(InlineCompletionList2) {
+    function create(items) {
+      return { items };
+    }
+    InlineCompletionList2.create = create;
+  })(InlineCompletionList || (InlineCompletionList = {}));
+  var InlineCompletionTriggerKind;
+  (function(InlineCompletionTriggerKind2) {
+    InlineCompletionTriggerKind2.Invoked = 0;
+    InlineCompletionTriggerKind2.Automatic = 1;
+  })(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {}));
+  var SelectedCompletionInfo;
+  (function(SelectedCompletionInfo2) {
+    function create(range, text) {
+      return { range, text };
+    }
+    SelectedCompletionInfo2.create = create;
+  })(SelectedCompletionInfo || (SelectedCompletionInfo = {}));
+  var InlineCompletionContext;
+  (function(InlineCompletionContext2) {
+    function create(triggerKind, selectedCompletionInfo) {
+      return { triggerKind, selectedCompletionInfo };
+    }
+    InlineCompletionContext2.create = create;
+  })(InlineCompletionContext || (InlineCompletionContext = {}));
+  var WorkspaceFolder;
+  (function(WorkspaceFolder2) {
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && URI.is(candidate.uri) && Is.string(candidate.name);
+    }
+    WorkspaceFolder2.is = is;
+  })(WorkspaceFolder || (WorkspaceFolder = {}));
+  var TextDocument;
+  (function(TextDocument2) {
+    function create(uri, languageId, version, content) {
+      return new FullTextDocument(uri, languageId, version, content);
+    }
+    TextDocument2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.uinteger(candidate.lineCount) && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;
+    }
+    TextDocument2.is = is;
+    function applyEdits(document, edits) {
+      let text = document.getText();
+      let sortedEdits = mergeSort(edits, (a, b) => {
+        let diff = a.range.start.line - b.range.start.line;
+        if (diff === 0) {
+          return a.range.start.character - b.range.start.character;
+        }
+        return diff;
+      });
+      let lastModifiedOffset = text.length;
+      for (let i = sortedEdits.length - 1; i >= 0; i--) {
+        let e = sortedEdits[i];
+        let startOffset = document.offsetAt(e.range.start);
+        let endOffset = document.offsetAt(e.range.end);
+        if (endOffset <= lastModifiedOffset) {
+          text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);
+        } else {
+          throw new Error("Overlapping edit");
+        }
+        lastModifiedOffset = startOffset;
+      }
+      return text;
+    }
+    TextDocument2.applyEdits = applyEdits;
+    function mergeSort(data, compare) {
+      if (data.length <= 1) {
+        return data;
+      }
+      const p = data.length / 2 | 0;
+      const left = data.slice(0, p);
+      const right = data.slice(p);
+      mergeSort(left, compare);
+      mergeSort(right, compare);
+      let leftIdx = 0;
+      let rightIdx = 0;
+      let i = 0;
+      while (leftIdx < left.length && rightIdx < right.length) {
+        let ret = compare(left[leftIdx], right[rightIdx]);
+        if (ret <= 0) {
+          data[i++] = left[leftIdx++];
+        } else {
+          data[i++] = right[rightIdx++];
+        }
+      }
+      while (leftIdx < left.length) {
+        data[i++] = left[leftIdx++];
+      }
+      while (rightIdx < right.length) {
+        data[i++] = right[rightIdx++];
+      }
+      return data;
+    }
+  })(TextDocument || (TextDocument = {}));
+  var FullTextDocument = class {
+    constructor(uri, languageId, version, content) {
+      this._uri = uri;
+      this._languageId = languageId;
+      this._version = version;
+      this._content = content;
+      this._lineOffsets = void 0;
+    }
+    get uri() {
+      return this._uri;
+    }
+    get languageId() {
+      return this._languageId;
+    }
+    get version() {
+      return this._version;
+    }
+    getText(range) {
+      if (range) {
+        let start = this.offsetAt(range.start);
+        let end = this.offsetAt(range.end);
+        return this._content.substring(start, end);
+      }
+      return this._content;
+    }
+    update(event, version) {
+      this._content = event.text;
+      this._version = version;
+      this._lineOffsets = void 0;
+    }
+    getLineOffsets() {
+      if (this._lineOffsets === void 0) {
+        let lineOffsets = [];
+        let text = this._content;
+        let isLineStart = true;
+        for (let i = 0; i < text.length; i++) {
+          if (isLineStart) {
+            lineOffsets.push(i);
+            isLineStart = false;
+          }
+          let ch = text.charAt(i);
+          isLineStart = ch === "\r" || ch === "\n";
+          if (ch === "\r" && i + 1 < text.length && text.charAt(i + 1) === "\n") {
+            i++;
+          }
+        }
+        if (isLineStart && text.length > 0) {
+          lineOffsets.push(text.length);
+        }
+        this._lineOffsets = lineOffsets;
+      }
+      return this._lineOffsets;
+    }
+    positionAt(offset) {
+      offset = Math.max(Math.min(offset, this._content.length), 0);
+      let lineOffsets = this.getLineOffsets();
+      let low = 0, high = lineOffsets.length;
+      if (high === 0) {
+        return Position.create(0, offset);
+      }
+      while (low < high) {
+        let mid = Math.floor((low + high) / 2);
+        if (lineOffsets[mid] > offset) {
+          high = mid;
+        } else {
+          low = mid + 1;
+        }
+      }
+      let line = low - 1;
+      return Position.create(line, offset - lineOffsets[line]);
+    }
+    offsetAt(position) {
+      let lineOffsets = this.getLineOffsets();
+      if (position.line >= lineOffsets.length) {
+        return this._content.length;
+      } else if (position.line < 0) {
+        return 0;
+      }
+      let lineOffset = lineOffsets[position.line];
+      let nextLineOffset = position.line + 1 < lineOffsets.length ? lineOffsets[position.line + 1] : this._content.length;
+      return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);
+    }
+    get lineCount() {
+      return this.getLineOffsets().length;
+    }
+  };
+  var Is;
+  (function(Is2) {
+    const toString = Object.prototype.toString;
+    function defined(value) {
+      return typeof value !== "undefined";
+    }
+    Is2.defined = defined;
+    function undefined2(value) {
+      return typeof value === "undefined";
+    }
+    Is2.undefined = undefined2;
+    function boolean(value) {
+      return value === true || value === false;
+    }
+    Is2.boolean = boolean;
+    function string(value) {
+      return toString.call(value) === "[object String]";
+    }
+    Is2.string = string;
+    function number(value) {
+      return toString.call(value) === "[object Number]";
+    }
+    Is2.number = number;
+    function numberRange(value, min, max) {
+      return toString.call(value) === "[object Number]" && min <= value && value <= max;
+    }
+    Is2.numberRange = numberRange;
+    function integer2(value) {
+      return toString.call(value) === "[object Number]" && -2147483648 <= value && value <= 2147483647;
+    }
+    Is2.integer = integer2;
+    function uinteger2(value) {
+      return toString.call(value) === "[object Number]" && 0 <= value && value <= 2147483647;
+    }
+    Is2.uinteger = uinteger2;
+    function func(value) {
+      return toString.call(value) === "[object Function]";
+    }
+    Is2.func = func;
+    function objectLiteral(value) {
+      return value !== null && typeof value === "object";
+    }
+    Is2.objectLiteral = objectLiteral;
+    function typedArray(value, check) {
+      return Array.isArray(value) && value.every(check);
+    }
+    Is2.typedArray = typedArray;
+  })(Is || (Is = {}));
+
+  // src/language/common/lspLanguageFeatures.ts
+  var DiagnosticsAdapter = class {
+    constructor(_languageId, _worker, configChangeEvent) {
+      this._languageId = _languageId;
+      this._worker = _worker;
+      this._disposables = [];
+      this._listener = /* @__PURE__ */ Object.create(null);
+      const onModelAdd = (model) => {
+        let modeId = model.getLanguageId();
+        if (modeId !== this._languageId) {
+          return;
+        }
+        let handle;
+        this._listener[model.uri.toString()] = model.onDidChangeContent(() => {
+          window.clearTimeout(handle);
+          handle = window.setTimeout(() => this._doValidate(model.uri, modeId), 500);
+        });
+        this._doValidate(model.uri, modeId);
+      };
+      const onModelRemoved = (model) => {
+        monaco_editor_core_exports.editor.setModelMarkers(model, this._languageId, []);
+        let uriStr = model.uri.toString();
+        let listener = this._listener[uriStr];
+        if (listener) {
+          listener.dispose();
+          delete this._listener[uriStr];
+        }
+      };
+      this._disposables.push(monaco_editor_core_exports.editor.onDidCreateModel(onModelAdd));
+      this._disposables.push(monaco_editor_core_exports.editor.onWillDisposeModel(onModelRemoved));
+      this._disposables.push(
+        monaco_editor_core_exports.editor.onDidChangeModelLanguage((event) => {
+          onModelRemoved(event.model);
+          onModelAdd(event.model);
+        })
+      );
+      this._disposables.push(
+        configChangeEvent((_) => {
+          monaco_editor_core_exports.editor.getModels().forEach((model) => {
+            if (model.getLanguageId() === this._languageId) {
+              onModelRemoved(model);
+              onModelAdd(model);
+            }
+          });
+        })
+      );
+      this._disposables.push({
+        dispose: () => {
+          monaco_editor_core_exports.editor.getModels().forEach(onModelRemoved);
+          for (let key in this._listener) {
+            this._listener[key].dispose();
+          }
+        }
+      });
+      monaco_editor_core_exports.editor.getModels().forEach(onModelAdd);
+    }
+    dispose() {
+      this._disposables.forEach((d) => d && d.dispose());
+      this._disposables.length = 0;
+    }
+    _doValidate(resource, languageId) {
+      this._worker(resource).then((worker) => {
+        return worker.doValidation(resource.toString());
+      }).then((diagnostics) => {
+        const markers = diagnostics.map((d) => toDiagnostics(resource, d));
+        let model = monaco_editor_core_exports.editor.getModel(resource);
+        if (model && model.getLanguageId() === languageId) {
+          monaco_editor_core_exports.editor.setModelMarkers(model, languageId, markers);
+        }
+      }).then(void 0, (err) => {
+        console.error(err);
+      });
+    }
+  };
+  function toSeverity(lsSeverity) {
+    switch (lsSeverity) {
+      case DiagnosticSeverity.Error:
+        return monaco_editor_core_exports.MarkerSeverity.Error;
+      case DiagnosticSeverity.Warning:
+        return monaco_editor_core_exports.MarkerSeverity.Warning;
+      case DiagnosticSeverity.Information:
+        return monaco_editor_core_exports.MarkerSeverity.Info;
+      case DiagnosticSeverity.Hint:
+        return monaco_editor_core_exports.MarkerSeverity.Hint;
+      default:
+        return monaco_editor_core_exports.MarkerSeverity.Info;
+    }
+  }
+  function toDiagnostics(resource, diag) {
+    let code = typeof diag.code === "number" ? String(diag.code) : diag.code;
+    return {
+      severity: toSeverity(diag.severity),
+      startLineNumber: diag.range.start.line + 1,
+      startColumn: diag.range.start.character + 1,
+      endLineNumber: diag.range.end.line + 1,
+      endColumn: diag.range.end.character + 1,
+      message: diag.message,
+      code,
+      source: diag.source
+    };
+  }
+  var CompletionAdapter = class {
+    constructor(_worker, _triggerCharacters) {
+      this._worker = _worker;
+      this._triggerCharacters = _triggerCharacters;
+    }
+    get triggerCharacters() {
+      return this._triggerCharacters;
+    }
+    provideCompletionItems(model, position, context, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => {
+        return worker.doComplete(resource.toString(), fromPosition(position));
+      }).then((info) => {
+        if (!info) {
+          return;
+        }
+        const wordInfo = model.getWordUntilPosition(position);
+        const wordRange = new monaco_editor_core_exports.Range(
+          position.lineNumber,
+          wordInfo.startColumn,
+          position.lineNumber,
+          wordInfo.endColumn
+        );
+        const items = info.items.map((entry) => {
+          const item = {
+            label: entry.label,
+            insertText: entry.insertText || entry.label,
+            sortText: entry.sortText,
+            filterText: entry.filterText,
+            documentation: entry.documentation,
+            detail: entry.detail,
+            command: toCommand(entry.command),
+            range: wordRange,
+            kind: toCompletionItemKind(entry.kind)
+          };
+          if (entry.textEdit) {
+            if (isInsertReplaceEdit(entry.textEdit)) {
+              item.range = {
+                insert: toRange(entry.textEdit.insert),
+                replace: toRange(entry.textEdit.replace)
+              };
+            } else {
+              item.range = toRange(entry.textEdit.range);
+            }
+            item.insertText = entry.textEdit.newText;
+          }
+          if (entry.additionalTextEdits) {
+            item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit);
+          }
+          if (entry.insertTextFormat === InsertTextFormat.Snippet) {
+            item.insertTextRules = monaco_editor_core_exports.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+          }
+          return item;
+        });
+        return {
+          isIncomplete: info.isIncomplete,
+          suggestions: items
+        };
+      });
+    }
+  };
+  function fromPosition(position) {
+    if (!position) {
+      return void 0;
+    }
+    return { character: position.column - 1, line: position.lineNumber - 1 };
+  }
+  function fromRange(range) {
+    if (!range) {
+      return void 0;
+    }
+    return {
+      start: {
+        line: range.startLineNumber - 1,
+        character: range.startColumn - 1
+      },
+      end: { line: range.endLineNumber - 1, character: range.endColumn - 1 }
+    };
+  }
+  function toRange(range) {
+    if (!range) {
+      return void 0;
+    }
+    return new monaco_editor_core_exports.Range(
+      range.start.line + 1,
+      range.start.character + 1,
+      range.end.line + 1,
+      range.end.character + 1
+    );
+  }
+  function isInsertReplaceEdit(edit) {
+    return typeof edit.insert !== "undefined" && typeof edit.replace !== "undefined";
+  }
+  function toCompletionItemKind(kind) {
+    const mItemKind = monaco_editor_core_exports.languages.CompletionItemKind;
+    switch (kind) {
+      case CompletionItemKind.Text:
+        return mItemKind.Text;
+      case CompletionItemKind.Method:
+        return mItemKind.Method;
+      case CompletionItemKind.Function:
+        return mItemKind.Function;
+      case CompletionItemKind.Constructor:
+        return mItemKind.Constructor;
+      case CompletionItemKind.Field:
+        return mItemKind.Field;
+      case CompletionItemKind.Variable:
+        return mItemKind.Variable;
+      case CompletionItemKind.Class:
+        return mItemKind.Class;
+      case CompletionItemKind.Interface:
+        return mItemKind.Interface;
+      case CompletionItemKind.Module:
+        return mItemKind.Module;
+      case CompletionItemKind.Property:
+        return mItemKind.Property;
+      case CompletionItemKind.Unit:
+        return mItemKind.Unit;
+      case CompletionItemKind.Value:
+        return mItemKind.Value;
+      case CompletionItemKind.Enum:
+        return mItemKind.Enum;
+      case CompletionItemKind.Keyword:
+        return mItemKind.Keyword;
+      case CompletionItemKind.Snippet:
+        return mItemKind.Snippet;
+      case CompletionItemKind.Color:
+        return mItemKind.Color;
+      case CompletionItemKind.File:
+        return mItemKind.File;
+      case CompletionItemKind.Reference:
+        return mItemKind.Reference;
+    }
+    return mItemKind.Property;
+  }
+  function toTextEdit(textEdit) {
+    if (!textEdit) {
+      return void 0;
+    }
+    return {
+      range: toRange(textEdit.range),
+      text: textEdit.newText
+    };
+  }
+  function toCommand(c) {
+    return c && c.command === "editor.action.triggerSuggest" ? { id: c.command, title: c.title, arguments: c.arguments } : void 0;
+  }
+  var HoverAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideHover(model, position, token) {
+      let resource = model.uri;
+      return this._worker(resource).then((worker) => {
+        return worker.doHover(resource.toString(), fromPosition(position));
+      }).then((info) => {
+        if (!info) {
+          return;
+        }
+        return {
+          range: toRange(info.range),
+          contents: toMarkedStringArray(info.contents)
+        };
+      });
+    }
+  };
+  function isMarkupContent(thing) {
+    return thing && typeof thing === "object" && typeof thing.kind === "string";
+  }
+  function toMarkdownString(entry) {
+    if (typeof entry === "string") {
+      return {
+        value: entry
+      };
+    }
+    if (isMarkupContent(entry)) {
+      if (entry.kind === "plaintext") {
+        return {
+          value: entry.value.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&")
+        };
+      }
+      return {
+        value: entry.value
+      };
+    }
+    return { value: "```" + entry.language + "\n" + entry.value + "\n```\n" };
+  }
+  function toMarkedStringArray(contents) {
+    if (!contents) {
+      return void 0;
+    }
+    if (Array.isArray(contents)) {
+      return contents.map(toMarkdownString);
+    }
+    return [toMarkdownString(contents)];
+  }
+  var DocumentHighlightAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideDocumentHighlights(model, position, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => worker.findDocumentHighlights(resource.toString(), fromPosition(position))).then((entries) => {
+        if (!entries) {
+          return;
+        }
+        return entries.map((entry) => {
+          return {
+            range: toRange(entry.range),
+            kind: toDocumentHighlightKind(entry.kind)
+          };
+        });
+      });
+    }
+  };
+  function toDocumentHighlightKind(kind) {
+    switch (kind) {
+      case DocumentHighlightKind.Read:
+        return monaco_editor_core_exports.languages.DocumentHighlightKind.Read;
+      case DocumentHighlightKind.Write:
+        return monaco_editor_core_exports.languages.DocumentHighlightKind.Write;
+      case DocumentHighlightKind.Text:
+        return monaco_editor_core_exports.languages.DocumentHighlightKind.Text;
+    }
+    return monaco_editor_core_exports.languages.DocumentHighlightKind.Text;
+  }
+  var DefinitionAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideDefinition(model, position, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => {
+        return worker.findDefinition(resource.toString(), fromPosition(position));
+      }).then((definition) => {
+        if (!definition) {
+          return;
+        }
+        return [toLocation(definition)];
+      });
+    }
+  };
+  function toLocation(location) {
+    return {
+      uri: monaco_editor_core_exports.Uri.parse(location.uri),
+      range: toRange(location.range)
+    };
+  }
+  var ReferenceAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideReferences(model, position, context, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => {
+        return worker.findReferences(resource.toString(), fromPosition(position));
+      }).then((entries) => {
+        if (!entries) {
+          return;
+        }
+        return entries.map(toLocation);
+      });
+    }
+  };
+  var RenameAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideRenameEdits(model, position, newName, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => {
+        return worker.doRename(resource.toString(), fromPosition(position), newName);
+      }).then((edit) => {
+        return toWorkspaceEdit(edit);
+      });
+    }
+  };
+  function toWorkspaceEdit(edit) {
+    if (!edit || !edit.changes) {
+      return void 0;
+    }
+    let resourceEdits = [];
+    for (let uri in edit.changes) {
+      const _uri = monaco_editor_core_exports.Uri.parse(uri);
+      for (let e of edit.changes[uri]) {
+        resourceEdits.push({
+          resource: _uri,
+          versionId: void 0,
+          textEdit: {
+            range: toRange(e.range),
+            text: e.newText
+          }
+        });
+      }
+    }
+    return {
+      edits: resourceEdits
+    };
+  }
+  var DocumentSymbolAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideDocumentSymbols(model, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => worker.findDocumentSymbols(resource.toString())).then((items) => {
+        if (!items) {
+          return;
+        }
+        return items.map((item) => {
+          if (isDocumentSymbol(item)) {
+            return toDocumentSymbol(item);
+          }
+          return {
+            name: item.name,
+            detail: "",
+            containerName: item.containerName,
+            kind: toSymbolKind(item.kind),
+            range: toRange(item.location.range),
+            selectionRange: toRange(item.location.range),
+            tags: []
+          };
+        });
+      });
+    }
+  };
+  function isDocumentSymbol(symbol) {
+    return "children" in symbol;
+  }
+  function toDocumentSymbol(symbol) {
+    return {
+      name: symbol.name,
+      detail: symbol.detail ?? "",
+      kind: toSymbolKind(symbol.kind),
+      range: toRange(symbol.range),
+      selectionRange: toRange(symbol.selectionRange),
+      tags: symbol.tags ?? [],
+      children: (symbol.children ?? []).map((item) => toDocumentSymbol(item))
+    };
+  }
+  function toSymbolKind(kind) {
+    let mKind = monaco_editor_core_exports.languages.SymbolKind;
+    switch (kind) {
+      case SymbolKind.File:
+        return mKind.File;
+      case SymbolKind.Module:
+        return mKind.Module;
+      case SymbolKind.Namespace:
+        return mKind.Namespace;
+      case SymbolKind.Package:
+        return mKind.Package;
+      case SymbolKind.Class:
+        return mKind.Class;
+      case SymbolKind.Method:
+        return mKind.Method;
+      case SymbolKind.Property:
+        return mKind.Property;
+      case SymbolKind.Field:
+        return mKind.Field;
+      case SymbolKind.Constructor:
+        return mKind.Constructor;
+      case SymbolKind.Enum:
+        return mKind.Enum;
+      case SymbolKind.Interface:
+        return mKind.Interface;
+      case SymbolKind.Function:
+        return mKind.Function;
+      case SymbolKind.Variable:
+        return mKind.Variable;
+      case SymbolKind.Constant:
+        return mKind.Constant;
+      case SymbolKind.String:
+        return mKind.String;
+      case SymbolKind.Number:
+        return mKind.Number;
+      case SymbolKind.Boolean:
+        return mKind.Boolean;
+      case SymbolKind.Array:
+        return mKind.Array;
+    }
+    return mKind.Function;
+  }
+  var DocumentLinkAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideLinks(model, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => worker.findDocumentLinks(resource.toString())).then((items) => {
+        if (!items) {
+          return;
+        }
+        return {
+          links: items.map((item) => ({
+            range: toRange(item.range),
+            url: item.target
+          }))
+        };
+      });
+    }
+  };
+  var DocumentFormattingEditProvider = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideDocumentFormattingEdits(model, options, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => {
+        return worker.format(resource.toString(), null, fromFormattingOptions(options)).then((edits) => {
+          if (!edits || edits.length === 0) {
+            return;
+          }
+          return edits.map(toTextEdit);
+        });
+      });
+    }
+  };
+  var DocumentRangeFormattingEditProvider = class {
+    constructor(_worker) {
+      this._worker = _worker;
+      this.canFormatMultipleRanges = false;
+    }
+    provideDocumentRangeFormattingEdits(model, range, options, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => {
+        return worker.format(resource.toString(), fromRange(range), fromFormattingOptions(options)).then((edits) => {
+          if (!edits || edits.length === 0) {
+            return;
+          }
+          return edits.map(toTextEdit);
+        });
+      });
+    }
+  };
+  function fromFormattingOptions(options) {
+    return {
+      tabSize: options.tabSize,
+      insertSpaces: options.insertSpaces
+    };
+  }
+  var DocumentColorAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideDocumentColors(model, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => worker.findDocumentColors(resource.toString())).then((infos) => {
+        if (!infos) {
+          return;
+        }
+        return infos.map((item) => ({
+          color: item.color,
+          range: toRange(item.range)
+        }));
+      });
+    }
+    provideColorPresentations(model, info, token) {
+      const resource = model.uri;
+      return this._worker(resource).then(
+        (worker) => worker.getColorPresentations(resource.toString(), info.color, fromRange(info.range))
+      ).then((presentations) => {
+        if (!presentations) {
+          return;
+        }
+        return presentations.map((presentation) => {
+          let item = {
+            label: presentation.label
+          };
+          if (presentation.textEdit) {
+            item.textEdit = toTextEdit(presentation.textEdit);
+          }
+          if (presentation.additionalTextEdits) {
+            item.additionalTextEdits = presentation.additionalTextEdits.map(toTextEdit);
+          }
+          return item;
+        });
+      });
+    }
+  };
+  var FoldingRangeAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideFoldingRanges(model, context, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => worker.getFoldingRanges(resource.toString(), context)).then((ranges) => {
+        if (!ranges) {
+          return;
+        }
+        return ranges.map((range) => {
+          const result = {
+            start: range.startLine + 1,
+            end: range.endLine + 1
+          };
+          if (typeof range.kind !== "undefined") {
+            result.kind = toFoldingRangeKind(range.kind);
+          }
+          return result;
+        });
+      });
+    }
+  };
+  function toFoldingRangeKind(kind) {
+    switch (kind) {
+      case FoldingRangeKind.Comment:
+        return monaco_editor_core_exports.languages.FoldingRangeKind.Comment;
+      case FoldingRangeKind.Imports:
+        return monaco_editor_core_exports.languages.FoldingRangeKind.Imports;
+      case FoldingRangeKind.Region:
+        return monaco_editor_core_exports.languages.FoldingRangeKind.Region;
+    }
+    return void 0;
+  }
+  var SelectionRangeAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideSelectionRanges(model, positions, token) {
+      const resource = model.uri;
+      return this._worker(resource).then(
+        (worker) => worker.getSelectionRanges(
+          resource.toString(),
+          positions.map(fromPosition)
+        )
+      ).then((selectionRanges) => {
+        if (!selectionRanges) {
+          return;
+        }
+        return selectionRanges.map((selectionRange) => {
+          const result = [];
+          while (selectionRange) {
+            result.push({ range: toRange(selectionRange.range) });
+            selectionRange = selectionRange.parent;
+          }
+          return result;
+        });
+      });
+    }
+  };
+
+  // src/language/css/cssMode.ts
+  function setupMode(defaults) {
+    const disposables = [];
+    const providers = [];
+    const client = new WorkerManager(defaults);
+    disposables.push(client);
+    const worker = (...uris) => {
+      return client.getLanguageServiceWorker(...uris);
+    };
+    function registerProviders() {
+      const { languageId, modeConfiguration } = defaults;
+      disposeAll(providers);
+      if (modeConfiguration.completionItems) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerCompletionItemProvider(
+            languageId,
+            new CompletionAdapter(worker, ["/", "-", ":"])
+          )
+        );
+      }
+      if (modeConfiguration.hovers) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerHoverProvider(languageId, new HoverAdapter(worker))
+        );
+      }
+      if (modeConfiguration.documentHighlights) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerDocumentHighlightProvider(
+            languageId,
+            new DocumentHighlightAdapter(worker)
+          )
+        );
+      }
+      if (modeConfiguration.definitions) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerDefinitionProvider(
+            languageId,
+            new DefinitionAdapter(worker)
+          )
+        );
+      }
+      if (modeConfiguration.references) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerReferenceProvider(
+            languageId,
+            new ReferenceAdapter(worker)
+          )
+        );
+      }
+      if (modeConfiguration.documentSymbols) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerDocumentSymbolProvider(
+            languageId,
+            new DocumentSymbolAdapter(worker)
+          )
+        );
+      }
+      if (modeConfiguration.rename) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerRenameProvider(languageId, new RenameAdapter(worker))
+        );
+      }
+      if (modeConfiguration.colors) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerColorProvider(
+            languageId,
+            new DocumentColorAdapter(worker)
+          )
+        );
+      }
+      if (modeConfiguration.foldingRanges) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerFoldingRangeProvider(
+            languageId,
+            new FoldingRangeAdapter(worker)
+          )
+        );
+      }
+      if (modeConfiguration.diagnostics) {
+        providers.push(
+          new DiagnosticsAdapter(languageId, worker, defaults.onDidChange)
+        );
+      }
+      if (modeConfiguration.selectionRanges) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerSelectionRangeProvider(
+            languageId,
+            new SelectionRangeAdapter(worker)
+          )
+        );
+      }
+      if (modeConfiguration.documentFormattingEdits) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerDocumentFormattingEditProvider(
+            languageId,
+            new DocumentFormattingEditProvider(worker)
+          )
+        );
+      }
+      if (modeConfiguration.documentRangeFormattingEdits) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerDocumentRangeFormattingEditProvider(
+            languageId,
+            new DocumentRangeFormattingEditProvider(worker)
+          )
+        );
+      }
+    }
+    registerProviders();
+    disposables.push(asDisposable(providers));
+    return asDisposable(disposables);
+  }
+  function asDisposable(disposables) {
+    return { dispose: () => disposeAll(disposables) };
+  }
+  function disposeAll(disposables) {
+    while (disposables.length) {
+      disposables.pop().dispose();
+    }
+  }
+  return __toCommonJS(cssMode_exports);
+})();
+return moduleExports;
+});

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/language/html/htmlMode.js

@@ -0,0 +1,2110 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/language/html/htmlMode", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __commonJS = (cb, mod) => function __require2() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  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"));
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/fillers/monaco-editor-core-amd.ts
+  var require_monaco_editor_core_amd = __commonJS({
+    "src/fillers/monaco-editor-core-amd.ts"(exports, module) {
+      var api = __toESM(__require("vs/editor/editor.api"));
+      module.exports = api;
+    }
+  });
+
+  // src/language/html/htmlMode.ts
+  var htmlMode_exports = {};
+  __export(htmlMode_exports, {
+    CompletionAdapter: () => CompletionAdapter,
+    DefinitionAdapter: () => DefinitionAdapter,
+    DiagnosticsAdapter: () => DiagnosticsAdapter,
+    DocumentColorAdapter: () => DocumentColorAdapter,
+    DocumentFormattingEditProvider: () => DocumentFormattingEditProvider,
+    DocumentHighlightAdapter: () => DocumentHighlightAdapter,
+    DocumentLinkAdapter: () => DocumentLinkAdapter,
+    DocumentRangeFormattingEditProvider: () => DocumentRangeFormattingEditProvider,
+    DocumentSymbolAdapter: () => DocumentSymbolAdapter,
+    FoldingRangeAdapter: () => FoldingRangeAdapter,
+    HoverAdapter: () => HoverAdapter,
+    ReferenceAdapter: () => ReferenceAdapter,
+    RenameAdapter: () => RenameAdapter,
+    SelectionRangeAdapter: () => SelectionRangeAdapter,
+    WorkerManager: () => WorkerManager,
+    fromPosition: () => fromPosition,
+    fromRange: () => fromRange,
+    setupMode: () => setupMode,
+    setupMode1: () => setupMode1,
+    toRange: () => toRange,
+    toTextEdit: () => toTextEdit
+  });
+
+  // src/fillers/monaco-editor-core.ts
+  var monaco_editor_core_exports = {};
+  __reExport(monaco_editor_core_exports, __toESM(require_monaco_editor_core_amd()));
+
+  // src/language/html/workerManager.ts
+  var STOP_WHEN_IDLE_FOR = 2 * 60 * 1e3;
+  var WorkerManager = class {
+    constructor(defaults) {
+      this._defaults = defaults;
+      this._worker = null;
+      this._client = null;
+      this._idleCheckInterval = window.setInterval(() => this._checkIfIdle(), 30 * 1e3);
+      this._lastUsedTime = 0;
+      this._configChangeListener = this._defaults.onDidChange(() => this._stopWorker());
+    }
+    _stopWorker() {
+      if (this._worker) {
+        this._worker.dispose();
+        this._worker = null;
+      }
+      this._client = null;
+    }
+    dispose() {
+      clearInterval(this._idleCheckInterval);
+      this._configChangeListener.dispose();
+      this._stopWorker();
+    }
+    _checkIfIdle() {
+      if (!this._worker) {
+        return;
+      }
+      let timePassedSinceLastUsed = Date.now() - this._lastUsedTime;
+      if (timePassedSinceLastUsed > STOP_WHEN_IDLE_FOR) {
+        this._stopWorker();
+      }
+    }
+    _getClient() {
+      this._lastUsedTime = Date.now();
+      if (!this._client) {
+        this._worker = monaco_editor_core_exports.editor.createWebWorker({
+          // module that exports the create() method and returns a `HTMLWorker` instance
+          moduleId: "vs/language/html/htmlWorker",
+          // passed in to the create() method
+          createData: {
+            languageSettings: this._defaults.options,
+            languageId: this._defaults.languageId
+          },
+          label: this._defaults.languageId
+        });
+        this._client = this._worker.getProxy();
+      }
+      return this._client;
+    }
+    getLanguageServiceWorker(...resources) {
+      let _client;
+      return this._getClient().then((client) => {
+        _client = client;
+      }).then((_) => {
+        if (this._worker) {
+          return this._worker.withSyncedResources(resources);
+        }
+      }).then((_) => _client);
+    }
+  };
+
+  // node_modules/vscode-languageserver-types/lib/esm/main.js
+  var DocumentUri;
+  (function(DocumentUri2) {
+    function is(value) {
+      return typeof value === "string";
+    }
+    DocumentUri2.is = is;
+  })(DocumentUri || (DocumentUri = {}));
+  var URI;
+  (function(URI2) {
+    function is(value) {
+      return typeof value === "string";
+    }
+    URI2.is = is;
+  })(URI || (URI = {}));
+  var integer;
+  (function(integer2) {
+    integer2.MIN_VALUE = -2147483648;
+    integer2.MAX_VALUE = 2147483647;
+    function is(value) {
+      return typeof value === "number" && integer2.MIN_VALUE <= value && value <= integer2.MAX_VALUE;
+    }
+    integer2.is = is;
+  })(integer || (integer = {}));
+  var uinteger;
+  (function(uinteger2) {
+    uinteger2.MIN_VALUE = 0;
+    uinteger2.MAX_VALUE = 2147483647;
+    function is(value) {
+      return typeof value === "number" && uinteger2.MIN_VALUE <= value && value <= uinteger2.MAX_VALUE;
+    }
+    uinteger2.is = is;
+  })(uinteger || (uinteger = {}));
+  var Position;
+  (function(Position3) {
+    function create(line, character) {
+      if (line === Number.MAX_VALUE) {
+        line = uinteger.MAX_VALUE;
+      }
+      if (character === Number.MAX_VALUE) {
+        character = uinteger.MAX_VALUE;
+      }
+      return { line, character };
+    }
+    Position3.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);
+    }
+    Position3.is = is;
+  })(Position || (Position = {}));
+  var Range;
+  (function(Range3) {
+    function create(one, two, three, four) {
+      if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {
+        return { start: Position.create(one, two), end: Position.create(three, four) };
+      } else if (Position.is(one) && Position.is(two)) {
+        return { start: one, end: two };
+      } else {
+        throw new Error(`Range#create called with invalid arguments[${one}, ${two}, ${three}, ${four}]`);
+      }
+    }
+    Range3.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end);
+    }
+    Range3.is = is;
+  })(Range || (Range = {}));
+  var Location;
+  (function(Location2) {
+    function create(uri, range) {
+      return { uri, range };
+    }
+    Location2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.objectLiteral(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
+    }
+    Location2.is = is;
+  })(Location || (Location = {}));
+  var LocationLink;
+  (function(LocationLink2) {
+    function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {
+      return { targetUri, targetRange, targetSelectionRange, originSelectionRange };
+    }
+    LocationLink2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.objectLiteral(candidate) && Range.is(candidate.targetRange) && Is.string(candidate.targetUri) && Range.is(candidate.targetSelectionRange) && (Range.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));
+    }
+    LocationLink2.is = is;
+  })(LocationLink || (LocationLink = {}));
+  var Color;
+  (function(Color2) {
+    function create(red, green, blue, alpha) {
+      return {
+        red,
+        green,
+        blue,
+        alpha
+      };
+    }
+    Color2.create = create;
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && Is.numberRange(candidate.red, 0, 1) && Is.numberRange(candidate.green, 0, 1) && Is.numberRange(candidate.blue, 0, 1) && Is.numberRange(candidate.alpha, 0, 1);
+    }
+    Color2.is = is;
+  })(Color || (Color = {}));
+  var ColorInformation;
+  (function(ColorInformation2) {
+    function create(range, color) {
+      return {
+        range,
+        color
+      };
+    }
+    ColorInformation2.create = create;
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && Range.is(candidate.range) && Color.is(candidate.color);
+    }
+    ColorInformation2.is = is;
+  })(ColorInformation || (ColorInformation = {}));
+  var ColorPresentation;
+  (function(ColorPresentation2) {
+    function create(label, textEdit, additionalTextEdits) {
+      return {
+        label,
+        textEdit,
+        additionalTextEdits
+      };
+    }
+    ColorPresentation2.create = create;
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate)) && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));
+    }
+    ColorPresentation2.is = is;
+  })(ColorPresentation || (ColorPresentation = {}));
+  var FoldingRangeKind;
+  (function(FoldingRangeKind2) {
+    FoldingRangeKind2.Comment = "comment";
+    FoldingRangeKind2.Imports = "imports";
+    FoldingRangeKind2.Region = "region";
+  })(FoldingRangeKind || (FoldingRangeKind = {}));
+  var FoldingRange;
+  (function(FoldingRange2) {
+    function create(startLine, endLine, startCharacter, endCharacter, kind, collapsedText) {
+      const result = {
+        startLine,
+        endLine
+      };
+      if (Is.defined(startCharacter)) {
+        result.startCharacter = startCharacter;
+      }
+      if (Is.defined(endCharacter)) {
+        result.endCharacter = endCharacter;
+      }
+      if (Is.defined(kind)) {
+        result.kind = kind;
+      }
+      if (Is.defined(collapsedText)) {
+        result.collapsedText = collapsedText;
+      }
+      return result;
+    }
+    FoldingRange2.create = create;
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine) && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter)) && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter)) && (Is.undefined(candidate.kind) || Is.string(candidate.kind));
+    }
+    FoldingRange2.is = is;
+  })(FoldingRange || (FoldingRange = {}));
+  var DiagnosticRelatedInformation;
+  (function(DiagnosticRelatedInformation2) {
+    function create(location, message) {
+      return {
+        location,
+        message
+      };
+    }
+    DiagnosticRelatedInformation2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);
+    }
+    DiagnosticRelatedInformation2.is = is;
+  })(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {}));
+  var DiagnosticSeverity;
+  (function(DiagnosticSeverity2) {
+    DiagnosticSeverity2.Error = 1;
+    DiagnosticSeverity2.Warning = 2;
+    DiagnosticSeverity2.Information = 3;
+    DiagnosticSeverity2.Hint = 4;
+  })(DiagnosticSeverity || (DiagnosticSeverity = {}));
+  var DiagnosticTag;
+  (function(DiagnosticTag2) {
+    DiagnosticTag2.Unnecessary = 1;
+    DiagnosticTag2.Deprecated = 2;
+  })(DiagnosticTag || (DiagnosticTag = {}));
+  var CodeDescription;
+  (function(CodeDescription2) {
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && Is.string(candidate.href);
+    }
+    CodeDescription2.is = is;
+  })(CodeDescription || (CodeDescription = {}));
+  var Diagnostic;
+  (function(Diagnostic2) {
+    function create(range, message, severity, code, source, relatedInformation) {
+      let result = { range, message };
+      if (Is.defined(severity)) {
+        result.severity = severity;
+      }
+      if (Is.defined(code)) {
+        result.code = code;
+      }
+      if (Is.defined(source)) {
+        result.source = source;
+      }
+      if (Is.defined(relatedInformation)) {
+        result.relatedInformation = relatedInformation;
+      }
+      return result;
+    }
+    Diagnostic2.create = create;
+    function is(value) {
+      var _a;
+      let candidate = value;
+      return Is.defined(candidate) && Range.is(candidate.range) && Is.string(candidate.message) && (Is.number(candidate.severity) || Is.undefined(candidate.severity)) && (Is.integer(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code)) && (Is.undefined(candidate.codeDescription) || Is.string((_a = candidate.codeDescription) === null || _a === void 0 ? void 0 : _a.href)) && (Is.string(candidate.source) || Is.undefined(candidate.source)) && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));
+    }
+    Diagnostic2.is = is;
+  })(Diagnostic || (Diagnostic = {}));
+  var Command;
+  (function(Command2) {
+    function create(title, command, ...args) {
+      let result = { title, command };
+      if (Is.defined(args) && args.length > 0) {
+        result.arguments = args;
+      }
+      return result;
+    }
+    Command2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);
+    }
+    Command2.is = is;
+  })(Command || (Command = {}));
+  var TextEdit;
+  (function(TextEdit2) {
+    function replace(range, newText) {
+      return { range, newText };
+    }
+    TextEdit2.replace = replace;
+    function insert(position, newText) {
+      return { range: { start: position, end: position }, newText };
+    }
+    TextEdit2.insert = insert;
+    function del(range) {
+      return { range, newText: "" };
+    }
+    TextEdit2.del = del;
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && Is.string(candidate.newText) && Range.is(candidate.range);
+    }
+    TextEdit2.is = is;
+  })(TextEdit || (TextEdit = {}));
+  var ChangeAnnotation;
+  (function(ChangeAnnotation2) {
+    function create(label, needsConfirmation, description) {
+      const result = { label };
+      if (needsConfirmation !== void 0) {
+        result.needsConfirmation = needsConfirmation;
+      }
+      if (description !== void 0) {
+        result.description = description;
+      }
+      return result;
+    }
+    ChangeAnnotation2.create = create;
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.boolean(candidate.needsConfirmation) || candidate.needsConfirmation === void 0) && (Is.string(candidate.description) || candidate.description === void 0);
+    }
+    ChangeAnnotation2.is = is;
+  })(ChangeAnnotation || (ChangeAnnotation = {}));
+  var ChangeAnnotationIdentifier;
+  (function(ChangeAnnotationIdentifier2) {
+    function is(value) {
+      const candidate = value;
+      return Is.string(candidate);
+    }
+    ChangeAnnotationIdentifier2.is = is;
+  })(ChangeAnnotationIdentifier || (ChangeAnnotationIdentifier = {}));
+  var AnnotatedTextEdit;
+  (function(AnnotatedTextEdit2) {
+    function replace(range, newText, annotation) {
+      return { range, newText, annotationId: annotation };
+    }
+    AnnotatedTextEdit2.replace = replace;
+    function insert(position, newText, annotation) {
+      return { range: { start: position, end: position }, newText, annotationId: annotation };
+    }
+    AnnotatedTextEdit2.insert = insert;
+    function del(range, annotation) {
+      return { range, newText: "", annotationId: annotation };
+    }
+    AnnotatedTextEdit2.del = del;
+    function is(value) {
+      const candidate = value;
+      return TextEdit.is(candidate) && (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId));
+    }
+    AnnotatedTextEdit2.is = is;
+  })(AnnotatedTextEdit || (AnnotatedTextEdit = {}));
+  var TextDocumentEdit;
+  (function(TextDocumentEdit2) {
+    function create(textDocument, edits) {
+      return { textDocument, edits };
+    }
+    TextDocumentEdit2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && OptionalVersionedTextDocumentIdentifier.is(candidate.textDocument) && Array.isArray(candidate.edits);
+    }
+    TextDocumentEdit2.is = is;
+  })(TextDocumentEdit || (TextDocumentEdit = {}));
+  var CreateFile;
+  (function(CreateFile2) {
+    function create(uri, options, annotation) {
+      let result = {
+        kind: "create",
+        uri
+      };
+      if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
+        result.options = options;
+      }
+      if (annotation !== void 0) {
+        result.annotationId = annotation;
+      }
+      return result;
+    }
+    CreateFile2.create = create;
+    function is(value) {
+      let candidate = value;
+      return candidate && candidate.kind === "create" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
+    }
+    CreateFile2.is = is;
+  })(CreateFile || (CreateFile = {}));
+  var RenameFile;
+  (function(RenameFile2) {
+    function create(oldUri, newUri, options, annotation) {
+      let result = {
+        kind: "rename",
+        oldUri,
+        newUri
+      };
+      if (options !== void 0 && (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)) {
+        result.options = options;
+      }
+      if (annotation !== void 0) {
+        result.annotationId = annotation;
+      }
+      return result;
+    }
+    RenameFile2.create = create;
+    function is(value) {
+      let candidate = value;
+      return candidate && candidate.kind === "rename" && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === void 0 || (candidate.options.overwrite === void 0 || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === void 0 || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
+    }
+    RenameFile2.is = is;
+  })(RenameFile || (RenameFile = {}));
+  var DeleteFile;
+  (function(DeleteFile2) {
+    function create(uri, options, annotation) {
+      let result = {
+        kind: "delete",
+        uri
+      };
+      if (options !== void 0 && (options.recursive !== void 0 || options.ignoreIfNotExists !== void 0)) {
+        result.options = options;
+      }
+      if (annotation !== void 0) {
+        result.annotationId = annotation;
+      }
+      return result;
+    }
+    DeleteFile2.create = create;
+    function is(value) {
+      let candidate = value;
+      return candidate && candidate.kind === "delete" && Is.string(candidate.uri) && (candidate.options === void 0 || (candidate.options.recursive === void 0 || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === void 0 || Is.boolean(candidate.options.ignoreIfNotExists))) && (candidate.annotationId === void 0 || ChangeAnnotationIdentifier.is(candidate.annotationId));
+    }
+    DeleteFile2.is = is;
+  })(DeleteFile || (DeleteFile = {}));
+  var WorkspaceEdit;
+  (function(WorkspaceEdit2) {
+    function is(value) {
+      let candidate = value;
+      return candidate && (candidate.changes !== void 0 || candidate.documentChanges !== void 0) && (candidate.documentChanges === void 0 || candidate.documentChanges.every((change) => {
+        if (Is.string(change.kind)) {
+          return CreateFile.is(change) || RenameFile.is(change) || DeleteFile.is(change);
+        } else {
+          return TextDocumentEdit.is(change);
+        }
+      }));
+    }
+    WorkspaceEdit2.is = is;
+  })(WorkspaceEdit || (WorkspaceEdit = {}));
+  var TextDocumentIdentifier;
+  (function(TextDocumentIdentifier2) {
+    function create(uri) {
+      return { uri };
+    }
+    TextDocumentIdentifier2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Is.string(candidate.uri);
+    }
+    TextDocumentIdentifier2.is = is;
+  })(TextDocumentIdentifier || (TextDocumentIdentifier = {}));
+  var VersionedTextDocumentIdentifier;
+  (function(VersionedTextDocumentIdentifier2) {
+    function create(uri, version) {
+      return { uri, version };
+    }
+    VersionedTextDocumentIdentifier2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Is.string(candidate.uri) && Is.integer(candidate.version);
+    }
+    VersionedTextDocumentIdentifier2.is = is;
+  })(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));
+  var OptionalVersionedTextDocumentIdentifier;
+  (function(OptionalVersionedTextDocumentIdentifier2) {
+    function create(uri, version) {
+      return { uri, version };
+    }
+    OptionalVersionedTextDocumentIdentifier2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.integer(candidate.version));
+    }
+    OptionalVersionedTextDocumentIdentifier2.is = is;
+  })(OptionalVersionedTextDocumentIdentifier || (OptionalVersionedTextDocumentIdentifier = {}));
+  var TextDocumentItem;
+  (function(TextDocumentItem2) {
+    function create(uri, languageId, version, text) {
+      return { uri, languageId, version, text };
+    }
+    TextDocumentItem2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.integer(candidate.version) && Is.string(candidate.text);
+    }
+    TextDocumentItem2.is = is;
+  })(TextDocumentItem || (TextDocumentItem = {}));
+  var MarkupKind;
+  (function(MarkupKind2) {
+    MarkupKind2.PlainText = "plaintext";
+    MarkupKind2.Markdown = "markdown";
+    function is(value) {
+      const candidate = value;
+      return candidate === MarkupKind2.PlainText || candidate === MarkupKind2.Markdown;
+    }
+    MarkupKind2.is = is;
+  })(MarkupKind || (MarkupKind = {}));
+  var MarkupContent;
+  (function(MarkupContent2) {
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);
+    }
+    MarkupContent2.is = is;
+  })(MarkupContent || (MarkupContent = {}));
+  var CompletionItemKind;
+  (function(CompletionItemKind2) {
+    CompletionItemKind2.Text = 1;
+    CompletionItemKind2.Method = 2;
+    CompletionItemKind2.Function = 3;
+    CompletionItemKind2.Constructor = 4;
+    CompletionItemKind2.Field = 5;
+    CompletionItemKind2.Variable = 6;
+    CompletionItemKind2.Class = 7;
+    CompletionItemKind2.Interface = 8;
+    CompletionItemKind2.Module = 9;
+    CompletionItemKind2.Property = 10;
+    CompletionItemKind2.Unit = 11;
+    CompletionItemKind2.Value = 12;
+    CompletionItemKind2.Enum = 13;
+    CompletionItemKind2.Keyword = 14;
+    CompletionItemKind2.Snippet = 15;
+    CompletionItemKind2.Color = 16;
+    CompletionItemKind2.File = 17;
+    CompletionItemKind2.Reference = 18;
+    CompletionItemKind2.Folder = 19;
+    CompletionItemKind2.EnumMember = 20;
+    CompletionItemKind2.Constant = 21;
+    CompletionItemKind2.Struct = 22;
+    CompletionItemKind2.Event = 23;
+    CompletionItemKind2.Operator = 24;
+    CompletionItemKind2.TypeParameter = 25;
+  })(CompletionItemKind || (CompletionItemKind = {}));
+  var InsertTextFormat;
+  (function(InsertTextFormat2) {
+    InsertTextFormat2.PlainText = 1;
+    InsertTextFormat2.Snippet = 2;
+  })(InsertTextFormat || (InsertTextFormat = {}));
+  var CompletionItemTag;
+  (function(CompletionItemTag2) {
+    CompletionItemTag2.Deprecated = 1;
+  })(CompletionItemTag || (CompletionItemTag = {}));
+  var InsertReplaceEdit;
+  (function(InsertReplaceEdit2) {
+    function create(newText, insert, replace) {
+      return { newText, insert, replace };
+    }
+    InsertReplaceEdit2.create = create;
+    function is(value) {
+      const candidate = value;
+      return candidate && Is.string(candidate.newText) && Range.is(candidate.insert) && Range.is(candidate.replace);
+    }
+    InsertReplaceEdit2.is = is;
+  })(InsertReplaceEdit || (InsertReplaceEdit = {}));
+  var InsertTextMode;
+  (function(InsertTextMode2) {
+    InsertTextMode2.asIs = 1;
+    InsertTextMode2.adjustIndentation = 2;
+  })(InsertTextMode || (InsertTextMode = {}));
+  var CompletionItemLabelDetails;
+  (function(CompletionItemLabelDetails2) {
+    function is(value) {
+      const candidate = value;
+      return candidate && (Is.string(candidate.detail) || candidate.detail === void 0) && (Is.string(candidate.description) || candidate.description === void 0);
+    }
+    CompletionItemLabelDetails2.is = is;
+  })(CompletionItemLabelDetails || (CompletionItemLabelDetails = {}));
+  var CompletionItem;
+  (function(CompletionItem2) {
+    function create(label) {
+      return { label };
+    }
+    CompletionItem2.create = create;
+  })(CompletionItem || (CompletionItem = {}));
+  var CompletionList;
+  (function(CompletionList2) {
+    function create(items, isIncomplete) {
+      return { items: items ? items : [], isIncomplete: !!isIncomplete };
+    }
+    CompletionList2.create = create;
+  })(CompletionList || (CompletionList = {}));
+  var MarkedString;
+  (function(MarkedString2) {
+    function fromPlainText(plainText) {
+      return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&");
+    }
+    MarkedString2.fromPlainText = fromPlainText;
+    function is(value) {
+      const candidate = value;
+      return Is.string(candidate) || Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value);
+    }
+    MarkedString2.is = is;
+  })(MarkedString || (MarkedString = {}));
+  var Hover;
+  (function(Hover2) {
+    function is(value) {
+      let candidate = value;
+      return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) || MarkedString.is(candidate.contents) || Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === void 0 || Range.is(value.range));
+    }
+    Hover2.is = is;
+  })(Hover || (Hover = {}));
+  var ParameterInformation;
+  (function(ParameterInformation2) {
+    function create(label, documentation) {
+      return documentation ? { label, documentation } : { label };
+    }
+    ParameterInformation2.create = create;
+  })(ParameterInformation || (ParameterInformation = {}));
+  var SignatureInformation;
+  (function(SignatureInformation2) {
+    function create(label, documentation, ...parameters) {
+      let result = { label };
+      if (Is.defined(documentation)) {
+        result.documentation = documentation;
+      }
+      if (Is.defined(parameters)) {
+        result.parameters = parameters;
+      } else {
+        result.parameters = [];
+      }
+      return result;
+    }
+    SignatureInformation2.create = create;
+  })(SignatureInformation || (SignatureInformation = {}));
+  var DocumentHighlightKind;
+  (function(DocumentHighlightKind2) {
+    DocumentHighlightKind2.Text = 1;
+    DocumentHighlightKind2.Read = 2;
+    DocumentHighlightKind2.Write = 3;
+  })(DocumentHighlightKind || (DocumentHighlightKind = {}));
+  var DocumentHighlight;
+  (function(DocumentHighlight2) {
+    function create(range, kind) {
+      let result = { range };
+      if (Is.number(kind)) {
+        result.kind = kind;
+      }
+      return result;
+    }
+    DocumentHighlight2.create = create;
+  })(DocumentHighlight || (DocumentHighlight = {}));
+  var SymbolKind;
+  (function(SymbolKind2) {
+    SymbolKind2.File = 1;
+    SymbolKind2.Module = 2;
+    SymbolKind2.Namespace = 3;
+    SymbolKind2.Package = 4;
+    SymbolKind2.Class = 5;
+    SymbolKind2.Method = 6;
+    SymbolKind2.Property = 7;
+    SymbolKind2.Field = 8;
+    SymbolKind2.Constructor = 9;
+    SymbolKind2.Enum = 10;
+    SymbolKind2.Interface = 11;
+    SymbolKind2.Function = 12;
+    SymbolKind2.Variable = 13;
+    SymbolKind2.Constant = 14;
+    SymbolKind2.String = 15;
+    SymbolKind2.Number = 16;
+    SymbolKind2.Boolean = 17;
+    SymbolKind2.Array = 18;
+    SymbolKind2.Object = 19;
+    SymbolKind2.Key = 20;
+    SymbolKind2.Null = 21;
+    SymbolKind2.EnumMember = 22;
+    SymbolKind2.Struct = 23;
+    SymbolKind2.Event = 24;
+    SymbolKind2.Operator = 25;
+    SymbolKind2.TypeParameter = 26;
+  })(SymbolKind || (SymbolKind = {}));
+  var SymbolTag;
+  (function(SymbolTag2) {
+    SymbolTag2.Deprecated = 1;
+  })(SymbolTag || (SymbolTag = {}));
+  var SymbolInformation;
+  (function(SymbolInformation2) {
+    function create(name, kind, range, uri, containerName) {
+      let result = {
+        name,
+        kind,
+        location: { uri, range }
+      };
+      if (containerName) {
+        result.containerName = containerName;
+      }
+      return result;
+    }
+    SymbolInformation2.create = create;
+  })(SymbolInformation || (SymbolInformation = {}));
+  var WorkspaceSymbol;
+  (function(WorkspaceSymbol2) {
+    function create(name, kind, uri, range) {
+      return range !== void 0 ? { name, kind, location: { uri, range } } : { name, kind, location: { uri } };
+    }
+    WorkspaceSymbol2.create = create;
+  })(WorkspaceSymbol || (WorkspaceSymbol = {}));
+  var DocumentSymbol;
+  (function(DocumentSymbol2) {
+    function create(name, detail, kind, range, selectionRange, children) {
+      let result = {
+        name,
+        detail,
+        kind,
+        range,
+        selectionRange
+      };
+      if (children !== void 0) {
+        result.children = children;
+      }
+      return result;
+    }
+    DocumentSymbol2.create = create;
+    function is(value) {
+      let candidate = value;
+      return candidate && Is.string(candidate.name) && Is.number(candidate.kind) && Range.is(candidate.range) && Range.is(candidate.selectionRange) && (candidate.detail === void 0 || Is.string(candidate.detail)) && (candidate.deprecated === void 0 || Is.boolean(candidate.deprecated)) && (candidate.children === void 0 || Array.isArray(candidate.children)) && (candidate.tags === void 0 || Array.isArray(candidate.tags));
+    }
+    DocumentSymbol2.is = is;
+  })(DocumentSymbol || (DocumentSymbol = {}));
+  var CodeActionKind;
+  (function(CodeActionKind2) {
+    CodeActionKind2.Empty = "";
+    CodeActionKind2.QuickFix = "quickfix";
+    CodeActionKind2.Refactor = "refactor";
+    CodeActionKind2.RefactorExtract = "refactor.extract";
+    CodeActionKind2.RefactorInline = "refactor.inline";
+    CodeActionKind2.RefactorRewrite = "refactor.rewrite";
+    CodeActionKind2.Source = "source";
+    CodeActionKind2.SourceOrganizeImports = "source.organizeImports";
+    CodeActionKind2.SourceFixAll = "source.fixAll";
+  })(CodeActionKind || (CodeActionKind = {}));
+  var CodeActionTriggerKind;
+  (function(CodeActionTriggerKind2) {
+    CodeActionTriggerKind2.Invoked = 1;
+    CodeActionTriggerKind2.Automatic = 2;
+  })(CodeActionTriggerKind || (CodeActionTriggerKind = {}));
+  var CodeActionContext;
+  (function(CodeActionContext2) {
+    function create(diagnostics, only, triggerKind) {
+      let result = { diagnostics };
+      if (only !== void 0 && only !== null) {
+        result.only = only;
+      }
+      if (triggerKind !== void 0 && triggerKind !== null) {
+        result.triggerKind = triggerKind;
+      }
+      return result;
+    }
+    CodeActionContext2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is) && (candidate.only === void 0 || Is.typedArray(candidate.only, Is.string)) && (candidate.triggerKind === void 0 || candidate.triggerKind === CodeActionTriggerKind.Invoked || candidate.triggerKind === CodeActionTriggerKind.Automatic);
+    }
+    CodeActionContext2.is = is;
+  })(CodeActionContext || (CodeActionContext = {}));
+  var CodeAction;
+  (function(CodeAction2) {
+    function create(title, kindOrCommandOrEdit, kind) {
+      let result = { title };
+      let checkKind = true;
+      if (typeof kindOrCommandOrEdit === "string") {
+        checkKind = false;
+        result.kind = kindOrCommandOrEdit;
+      } else if (Command.is(kindOrCommandOrEdit)) {
+        result.command = kindOrCommandOrEdit;
+      } else {
+        result.edit = kindOrCommandOrEdit;
+      }
+      if (checkKind && kind !== void 0) {
+        result.kind = kind;
+      }
+      return result;
+    }
+    CodeAction2.create = create;
+    function is(value) {
+      let candidate = value;
+      return candidate && Is.string(candidate.title) && (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, Diagnostic.is)) && (candidate.kind === void 0 || Is.string(candidate.kind)) && (candidate.edit !== void 0 || candidate.command !== void 0) && (candidate.command === void 0 || Command.is(candidate.command)) && (candidate.isPreferred === void 0 || Is.boolean(candidate.isPreferred)) && (candidate.edit === void 0 || WorkspaceEdit.is(candidate.edit));
+    }
+    CodeAction2.is = is;
+  })(CodeAction || (CodeAction = {}));
+  var CodeLens;
+  (function(CodeLens2) {
+    function create(range, data) {
+      let result = { range };
+      if (Is.defined(data)) {
+        result.data = data;
+      }
+      return result;
+    }
+    CodeLens2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));
+    }
+    CodeLens2.is = is;
+  })(CodeLens || (CodeLens = {}));
+  var FormattingOptions;
+  (function(FormattingOptions2) {
+    function create(tabSize, insertSpaces) {
+      return { tabSize, insertSpaces };
+    }
+    FormattingOptions2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Is.uinteger(candidate.tabSize) && Is.boolean(candidate.insertSpaces);
+    }
+    FormattingOptions2.is = is;
+  })(FormattingOptions || (FormattingOptions = {}));
+  var DocumentLink;
+  (function(DocumentLink2) {
+    function create(range, target, data) {
+      return { range, target, data };
+    }
+    DocumentLink2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
+    }
+    DocumentLink2.is = is;
+  })(DocumentLink || (DocumentLink = {}));
+  var SelectionRange;
+  (function(SelectionRange2) {
+    function create(range, parent) {
+      return { range, parent };
+    }
+    SelectionRange2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.objectLiteral(candidate) && Range.is(candidate.range) && (candidate.parent === void 0 || SelectionRange2.is(candidate.parent));
+    }
+    SelectionRange2.is = is;
+  })(SelectionRange || (SelectionRange = {}));
+  var SemanticTokenTypes;
+  (function(SemanticTokenTypes2) {
+    SemanticTokenTypes2["namespace"] = "namespace";
+    SemanticTokenTypes2["type"] = "type";
+    SemanticTokenTypes2["class"] = "class";
+    SemanticTokenTypes2["enum"] = "enum";
+    SemanticTokenTypes2["interface"] = "interface";
+    SemanticTokenTypes2["struct"] = "struct";
+    SemanticTokenTypes2["typeParameter"] = "typeParameter";
+    SemanticTokenTypes2["parameter"] = "parameter";
+    SemanticTokenTypes2["variable"] = "variable";
+    SemanticTokenTypes2["property"] = "property";
+    SemanticTokenTypes2["enumMember"] = "enumMember";
+    SemanticTokenTypes2["event"] = "event";
+    SemanticTokenTypes2["function"] = "function";
+    SemanticTokenTypes2["method"] = "method";
+    SemanticTokenTypes2["macro"] = "macro";
+    SemanticTokenTypes2["keyword"] = "keyword";
+    SemanticTokenTypes2["modifier"] = "modifier";
+    SemanticTokenTypes2["comment"] = "comment";
+    SemanticTokenTypes2["string"] = "string";
+    SemanticTokenTypes2["number"] = "number";
+    SemanticTokenTypes2["regexp"] = "regexp";
+    SemanticTokenTypes2["operator"] = "operator";
+    SemanticTokenTypes2["decorator"] = "decorator";
+  })(SemanticTokenTypes || (SemanticTokenTypes = {}));
+  var SemanticTokenModifiers;
+  (function(SemanticTokenModifiers2) {
+    SemanticTokenModifiers2["declaration"] = "declaration";
+    SemanticTokenModifiers2["definition"] = "definition";
+    SemanticTokenModifiers2["readonly"] = "readonly";
+    SemanticTokenModifiers2["static"] = "static";
+    SemanticTokenModifiers2["deprecated"] = "deprecated";
+    SemanticTokenModifiers2["abstract"] = "abstract";
+    SemanticTokenModifiers2["async"] = "async";
+    SemanticTokenModifiers2["modification"] = "modification";
+    SemanticTokenModifiers2["documentation"] = "documentation";
+    SemanticTokenModifiers2["defaultLibrary"] = "defaultLibrary";
+  })(SemanticTokenModifiers || (SemanticTokenModifiers = {}));
+  var SemanticTokens;
+  (function(SemanticTokens2) {
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && (candidate.resultId === void 0 || typeof candidate.resultId === "string") && Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === "number");
+    }
+    SemanticTokens2.is = is;
+  })(SemanticTokens || (SemanticTokens = {}));
+  var InlineValueText;
+  (function(InlineValueText2) {
+    function create(range, text) {
+      return { range, text };
+    }
+    InlineValueText2.create = create;
+    function is(value) {
+      const candidate = value;
+      return candidate !== void 0 && candidate !== null && Range.is(candidate.range) && Is.string(candidate.text);
+    }
+    InlineValueText2.is = is;
+  })(InlineValueText || (InlineValueText = {}));
+  var InlineValueVariableLookup;
+  (function(InlineValueVariableLookup2) {
+    function create(range, variableName, caseSensitiveLookup) {
+      return { range, variableName, caseSensitiveLookup };
+    }
+    InlineValueVariableLookup2.create = create;
+    function is(value) {
+      const candidate = value;
+      return candidate !== void 0 && candidate !== null && Range.is(candidate.range) && Is.boolean(candidate.caseSensitiveLookup) && (Is.string(candidate.variableName) || candidate.variableName === void 0);
+    }
+    InlineValueVariableLookup2.is = is;
+  })(InlineValueVariableLookup || (InlineValueVariableLookup = {}));
+  var InlineValueEvaluatableExpression;
+  (function(InlineValueEvaluatableExpression2) {
+    function create(range, expression) {
+      return { range, expression };
+    }
+    InlineValueEvaluatableExpression2.create = create;
+    function is(value) {
+      const candidate = value;
+      return candidate !== void 0 && candidate !== null && Range.is(candidate.range) && (Is.string(candidate.expression) || candidate.expression === void 0);
+    }
+    InlineValueEvaluatableExpression2.is = is;
+  })(InlineValueEvaluatableExpression || (InlineValueEvaluatableExpression = {}));
+  var InlineValueContext;
+  (function(InlineValueContext2) {
+    function create(frameId, stoppedLocation) {
+      return { frameId, stoppedLocation };
+    }
+    InlineValueContext2.create = create;
+    function is(value) {
+      const candidate = value;
+      return Is.defined(candidate) && Range.is(value.stoppedLocation);
+    }
+    InlineValueContext2.is = is;
+  })(InlineValueContext || (InlineValueContext = {}));
+  var InlayHintKind;
+  (function(InlayHintKind2) {
+    InlayHintKind2.Type = 1;
+    InlayHintKind2.Parameter = 2;
+    function is(value) {
+      return value === 1 || value === 2;
+    }
+    InlayHintKind2.is = is;
+  })(InlayHintKind || (InlayHintKind = {}));
+  var InlayHintLabelPart;
+  (function(InlayHintLabelPart2) {
+    function create(value) {
+      return { value };
+    }
+    InlayHintLabelPart2.create = create;
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && (candidate.tooltip === void 0 || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip)) && (candidate.location === void 0 || Location.is(candidate.location)) && (candidate.command === void 0 || Command.is(candidate.command));
+    }
+    InlayHintLabelPart2.is = is;
+  })(InlayHintLabelPart || (InlayHintLabelPart = {}));
+  var InlayHint;
+  (function(InlayHint2) {
+    function create(position, label, kind) {
+      const result = { position, label };
+      if (kind !== void 0) {
+        result.kind = kind;
+      }
+      return result;
+    }
+    InlayHint2.create = create;
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && Position.is(candidate.position) && (Is.string(candidate.label) || Is.typedArray(candidate.label, InlayHintLabelPart.is)) && (candidate.kind === void 0 || InlayHintKind.is(candidate.kind)) && candidate.textEdits === void 0 || Is.typedArray(candidate.textEdits, TextEdit.is) && (candidate.tooltip === void 0 || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip)) && (candidate.paddingLeft === void 0 || Is.boolean(candidate.paddingLeft)) && (candidate.paddingRight === void 0 || Is.boolean(candidate.paddingRight));
+    }
+    InlayHint2.is = is;
+  })(InlayHint || (InlayHint = {}));
+  var StringValue;
+  (function(StringValue2) {
+    function createSnippet(value) {
+      return { kind: "snippet", value };
+    }
+    StringValue2.createSnippet = createSnippet;
+  })(StringValue || (StringValue = {}));
+  var InlineCompletionItem;
+  (function(InlineCompletionItem2) {
+    function create(insertText, filterText, range, command) {
+      return { insertText, filterText, range, command };
+    }
+    InlineCompletionItem2.create = create;
+  })(InlineCompletionItem || (InlineCompletionItem = {}));
+  var InlineCompletionList;
+  (function(InlineCompletionList2) {
+    function create(items) {
+      return { items };
+    }
+    InlineCompletionList2.create = create;
+  })(InlineCompletionList || (InlineCompletionList = {}));
+  var InlineCompletionTriggerKind;
+  (function(InlineCompletionTriggerKind2) {
+    InlineCompletionTriggerKind2.Invoked = 0;
+    InlineCompletionTriggerKind2.Automatic = 1;
+  })(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {}));
+  var SelectedCompletionInfo;
+  (function(SelectedCompletionInfo2) {
+    function create(range, text) {
+      return { range, text };
+    }
+    SelectedCompletionInfo2.create = create;
+  })(SelectedCompletionInfo || (SelectedCompletionInfo = {}));
+  var InlineCompletionContext;
+  (function(InlineCompletionContext2) {
+    function create(triggerKind, selectedCompletionInfo) {
+      return { triggerKind, selectedCompletionInfo };
+    }
+    InlineCompletionContext2.create = create;
+  })(InlineCompletionContext || (InlineCompletionContext = {}));
+  var WorkspaceFolder;
+  (function(WorkspaceFolder2) {
+    function is(value) {
+      const candidate = value;
+      return Is.objectLiteral(candidate) && URI.is(candidate.uri) && Is.string(candidate.name);
+    }
+    WorkspaceFolder2.is = is;
+  })(WorkspaceFolder || (WorkspaceFolder = {}));
+  var TextDocument;
+  (function(TextDocument2) {
+    function create(uri, languageId, version, content) {
+      return new FullTextDocument(uri, languageId, version, content);
+    }
+    TextDocument2.create = create;
+    function is(value) {
+      let candidate = value;
+      return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.uinteger(candidate.lineCount) && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;
+    }
+    TextDocument2.is = is;
+    function applyEdits(document, edits) {
+      let text = document.getText();
+      let sortedEdits = mergeSort(edits, (a, b) => {
+        let diff = a.range.start.line - b.range.start.line;
+        if (diff === 0) {
+          return a.range.start.character - b.range.start.character;
+        }
+        return diff;
+      });
+      let lastModifiedOffset = text.length;
+      for (let i = sortedEdits.length - 1; i >= 0; i--) {
+        let e = sortedEdits[i];
+        let startOffset = document.offsetAt(e.range.start);
+        let endOffset = document.offsetAt(e.range.end);
+        if (endOffset <= lastModifiedOffset) {
+          text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);
+        } else {
+          throw new Error("Overlapping edit");
+        }
+        lastModifiedOffset = startOffset;
+      }
+      return text;
+    }
+    TextDocument2.applyEdits = applyEdits;
+    function mergeSort(data, compare) {
+      if (data.length <= 1) {
+        return data;
+      }
+      const p = data.length / 2 | 0;
+      const left = data.slice(0, p);
+      const right = data.slice(p);
+      mergeSort(left, compare);
+      mergeSort(right, compare);
+      let leftIdx = 0;
+      let rightIdx = 0;
+      let i = 0;
+      while (leftIdx < left.length && rightIdx < right.length) {
+        let ret = compare(left[leftIdx], right[rightIdx]);
+        if (ret <= 0) {
+          data[i++] = left[leftIdx++];
+        } else {
+          data[i++] = right[rightIdx++];
+        }
+      }
+      while (leftIdx < left.length) {
+        data[i++] = left[leftIdx++];
+      }
+      while (rightIdx < right.length) {
+        data[i++] = right[rightIdx++];
+      }
+      return data;
+    }
+  })(TextDocument || (TextDocument = {}));
+  var FullTextDocument = class {
+    constructor(uri, languageId, version, content) {
+      this._uri = uri;
+      this._languageId = languageId;
+      this._version = version;
+      this._content = content;
+      this._lineOffsets = void 0;
+    }
+    get uri() {
+      return this._uri;
+    }
+    get languageId() {
+      return this._languageId;
+    }
+    get version() {
+      return this._version;
+    }
+    getText(range) {
+      if (range) {
+        let start = this.offsetAt(range.start);
+        let end = this.offsetAt(range.end);
+        return this._content.substring(start, end);
+      }
+      return this._content;
+    }
+    update(event, version) {
+      this._content = event.text;
+      this._version = version;
+      this._lineOffsets = void 0;
+    }
+    getLineOffsets() {
+      if (this._lineOffsets === void 0) {
+        let lineOffsets = [];
+        let text = this._content;
+        let isLineStart = true;
+        for (let i = 0; i < text.length; i++) {
+          if (isLineStart) {
+            lineOffsets.push(i);
+            isLineStart = false;
+          }
+          let ch = text.charAt(i);
+          isLineStart = ch === "\r" || ch === "\n";
+          if (ch === "\r" && i + 1 < text.length && text.charAt(i + 1) === "\n") {
+            i++;
+          }
+        }
+        if (isLineStart && text.length > 0) {
+          lineOffsets.push(text.length);
+        }
+        this._lineOffsets = lineOffsets;
+      }
+      return this._lineOffsets;
+    }
+    positionAt(offset) {
+      offset = Math.max(Math.min(offset, this._content.length), 0);
+      let lineOffsets = this.getLineOffsets();
+      let low = 0, high = lineOffsets.length;
+      if (high === 0) {
+        return Position.create(0, offset);
+      }
+      while (low < high) {
+        let mid = Math.floor((low + high) / 2);
+        if (lineOffsets[mid] > offset) {
+          high = mid;
+        } else {
+          low = mid + 1;
+        }
+      }
+      let line = low - 1;
+      return Position.create(line, offset - lineOffsets[line]);
+    }
+    offsetAt(position) {
+      let lineOffsets = this.getLineOffsets();
+      if (position.line >= lineOffsets.length) {
+        return this._content.length;
+      } else if (position.line < 0) {
+        return 0;
+      }
+      let lineOffset = lineOffsets[position.line];
+      let nextLineOffset = position.line + 1 < lineOffsets.length ? lineOffsets[position.line + 1] : this._content.length;
+      return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);
+    }
+    get lineCount() {
+      return this.getLineOffsets().length;
+    }
+  };
+  var Is;
+  (function(Is2) {
+    const toString = Object.prototype.toString;
+    function defined(value) {
+      return typeof value !== "undefined";
+    }
+    Is2.defined = defined;
+    function undefined2(value) {
+      return typeof value === "undefined";
+    }
+    Is2.undefined = undefined2;
+    function boolean(value) {
+      return value === true || value === false;
+    }
+    Is2.boolean = boolean;
+    function string(value) {
+      return toString.call(value) === "[object String]";
+    }
+    Is2.string = string;
+    function number(value) {
+      return toString.call(value) === "[object Number]";
+    }
+    Is2.number = number;
+    function numberRange(value, min, max) {
+      return toString.call(value) === "[object Number]" && min <= value && value <= max;
+    }
+    Is2.numberRange = numberRange;
+    function integer2(value) {
+      return toString.call(value) === "[object Number]" && -2147483648 <= value && value <= 2147483647;
+    }
+    Is2.integer = integer2;
+    function uinteger2(value) {
+      return toString.call(value) === "[object Number]" && 0 <= value && value <= 2147483647;
+    }
+    Is2.uinteger = uinteger2;
+    function func(value) {
+      return toString.call(value) === "[object Function]";
+    }
+    Is2.func = func;
+    function objectLiteral(value) {
+      return value !== null && typeof value === "object";
+    }
+    Is2.objectLiteral = objectLiteral;
+    function typedArray(value, check) {
+      return Array.isArray(value) && value.every(check);
+    }
+    Is2.typedArray = typedArray;
+  })(Is || (Is = {}));
+
+  // src/language/common/lspLanguageFeatures.ts
+  var DiagnosticsAdapter = class {
+    constructor(_languageId, _worker, configChangeEvent) {
+      this._languageId = _languageId;
+      this._worker = _worker;
+      this._disposables = [];
+      this._listener = /* @__PURE__ */ Object.create(null);
+      const onModelAdd = (model) => {
+        let modeId = model.getLanguageId();
+        if (modeId !== this._languageId) {
+          return;
+        }
+        let handle;
+        this._listener[model.uri.toString()] = model.onDidChangeContent(() => {
+          window.clearTimeout(handle);
+          handle = window.setTimeout(() => this._doValidate(model.uri, modeId), 500);
+        });
+        this._doValidate(model.uri, modeId);
+      };
+      const onModelRemoved = (model) => {
+        monaco_editor_core_exports.editor.setModelMarkers(model, this._languageId, []);
+        let uriStr = model.uri.toString();
+        let listener = this._listener[uriStr];
+        if (listener) {
+          listener.dispose();
+          delete this._listener[uriStr];
+        }
+      };
+      this._disposables.push(monaco_editor_core_exports.editor.onDidCreateModel(onModelAdd));
+      this._disposables.push(monaco_editor_core_exports.editor.onWillDisposeModel(onModelRemoved));
+      this._disposables.push(
+        monaco_editor_core_exports.editor.onDidChangeModelLanguage((event) => {
+          onModelRemoved(event.model);
+          onModelAdd(event.model);
+        })
+      );
+      this._disposables.push(
+        configChangeEvent((_) => {
+          monaco_editor_core_exports.editor.getModels().forEach((model) => {
+            if (model.getLanguageId() === this._languageId) {
+              onModelRemoved(model);
+              onModelAdd(model);
+            }
+          });
+        })
+      );
+      this._disposables.push({
+        dispose: () => {
+          monaco_editor_core_exports.editor.getModels().forEach(onModelRemoved);
+          for (let key in this._listener) {
+            this._listener[key].dispose();
+          }
+        }
+      });
+      monaco_editor_core_exports.editor.getModels().forEach(onModelAdd);
+    }
+    dispose() {
+      this._disposables.forEach((d) => d && d.dispose());
+      this._disposables.length = 0;
+    }
+    _doValidate(resource, languageId) {
+      this._worker(resource).then((worker) => {
+        return worker.doValidation(resource.toString());
+      }).then((diagnostics) => {
+        const markers = diagnostics.map((d) => toDiagnostics(resource, d));
+        let model = monaco_editor_core_exports.editor.getModel(resource);
+        if (model && model.getLanguageId() === languageId) {
+          monaco_editor_core_exports.editor.setModelMarkers(model, languageId, markers);
+        }
+      }).then(void 0, (err) => {
+        console.error(err);
+      });
+    }
+  };
+  function toSeverity(lsSeverity) {
+    switch (lsSeverity) {
+      case DiagnosticSeverity.Error:
+        return monaco_editor_core_exports.MarkerSeverity.Error;
+      case DiagnosticSeverity.Warning:
+        return monaco_editor_core_exports.MarkerSeverity.Warning;
+      case DiagnosticSeverity.Information:
+        return monaco_editor_core_exports.MarkerSeverity.Info;
+      case DiagnosticSeverity.Hint:
+        return monaco_editor_core_exports.MarkerSeverity.Hint;
+      default:
+        return monaco_editor_core_exports.MarkerSeverity.Info;
+    }
+  }
+  function toDiagnostics(resource, diag) {
+    let code = typeof diag.code === "number" ? String(diag.code) : diag.code;
+    return {
+      severity: toSeverity(diag.severity),
+      startLineNumber: diag.range.start.line + 1,
+      startColumn: diag.range.start.character + 1,
+      endLineNumber: diag.range.end.line + 1,
+      endColumn: diag.range.end.character + 1,
+      message: diag.message,
+      code,
+      source: diag.source
+    };
+  }
+  var CompletionAdapter = class {
+    constructor(_worker, _triggerCharacters) {
+      this._worker = _worker;
+      this._triggerCharacters = _triggerCharacters;
+    }
+    get triggerCharacters() {
+      return this._triggerCharacters;
+    }
+    provideCompletionItems(model, position, context, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => {
+        return worker.doComplete(resource.toString(), fromPosition(position));
+      }).then((info) => {
+        if (!info) {
+          return;
+        }
+        const wordInfo = model.getWordUntilPosition(position);
+        const wordRange = new monaco_editor_core_exports.Range(
+          position.lineNumber,
+          wordInfo.startColumn,
+          position.lineNumber,
+          wordInfo.endColumn
+        );
+        const items = info.items.map((entry) => {
+          const item = {
+            label: entry.label,
+            insertText: entry.insertText || entry.label,
+            sortText: entry.sortText,
+            filterText: entry.filterText,
+            documentation: entry.documentation,
+            detail: entry.detail,
+            command: toCommand(entry.command),
+            range: wordRange,
+            kind: toCompletionItemKind(entry.kind)
+          };
+          if (entry.textEdit) {
+            if (isInsertReplaceEdit(entry.textEdit)) {
+              item.range = {
+                insert: toRange(entry.textEdit.insert),
+                replace: toRange(entry.textEdit.replace)
+              };
+            } else {
+              item.range = toRange(entry.textEdit.range);
+            }
+            item.insertText = entry.textEdit.newText;
+          }
+          if (entry.additionalTextEdits) {
+            item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit);
+          }
+          if (entry.insertTextFormat === InsertTextFormat.Snippet) {
+            item.insertTextRules = monaco_editor_core_exports.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+          }
+          return item;
+        });
+        return {
+          isIncomplete: info.isIncomplete,
+          suggestions: items
+        };
+      });
+    }
+  };
+  function fromPosition(position) {
+    if (!position) {
+      return void 0;
+    }
+    return { character: position.column - 1, line: position.lineNumber - 1 };
+  }
+  function fromRange(range) {
+    if (!range) {
+      return void 0;
+    }
+    return {
+      start: {
+        line: range.startLineNumber - 1,
+        character: range.startColumn - 1
+      },
+      end: { line: range.endLineNumber - 1, character: range.endColumn - 1 }
+    };
+  }
+  function toRange(range) {
+    if (!range) {
+      return void 0;
+    }
+    return new monaco_editor_core_exports.Range(
+      range.start.line + 1,
+      range.start.character + 1,
+      range.end.line + 1,
+      range.end.character + 1
+    );
+  }
+  function isInsertReplaceEdit(edit) {
+    return typeof edit.insert !== "undefined" && typeof edit.replace !== "undefined";
+  }
+  function toCompletionItemKind(kind) {
+    const mItemKind = monaco_editor_core_exports.languages.CompletionItemKind;
+    switch (kind) {
+      case CompletionItemKind.Text:
+        return mItemKind.Text;
+      case CompletionItemKind.Method:
+        return mItemKind.Method;
+      case CompletionItemKind.Function:
+        return mItemKind.Function;
+      case CompletionItemKind.Constructor:
+        return mItemKind.Constructor;
+      case CompletionItemKind.Field:
+        return mItemKind.Field;
+      case CompletionItemKind.Variable:
+        return mItemKind.Variable;
+      case CompletionItemKind.Class:
+        return mItemKind.Class;
+      case CompletionItemKind.Interface:
+        return mItemKind.Interface;
+      case CompletionItemKind.Module:
+        return mItemKind.Module;
+      case CompletionItemKind.Property:
+        return mItemKind.Property;
+      case CompletionItemKind.Unit:
+        return mItemKind.Unit;
+      case CompletionItemKind.Value:
+        return mItemKind.Value;
+      case CompletionItemKind.Enum:
+        return mItemKind.Enum;
+      case CompletionItemKind.Keyword:
+        return mItemKind.Keyword;
+      case CompletionItemKind.Snippet:
+        return mItemKind.Snippet;
+      case CompletionItemKind.Color:
+        return mItemKind.Color;
+      case CompletionItemKind.File:
+        return mItemKind.File;
+      case CompletionItemKind.Reference:
+        return mItemKind.Reference;
+    }
+    return mItemKind.Property;
+  }
+  function toTextEdit(textEdit) {
+    if (!textEdit) {
+      return void 0;
+    }
+    return {
+      range: toRange(textEdit.range),
+      text: textEdit.newText
+    };
+  }
+  function toCommand(c) {
+    return c && c.command === "editor.action.triggerSuggest" ? { id: c.command, title: c.title, arguments: c.arguments } : void 0;
+  }
+  var HoverAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideHover(model, position, token) {
+      let resource = model.uri;
+      return this._worker(resource).then((worker) => {
+        return worker.doHover(resource.toString(), fromPosition(position));
+      }).then((info) => {
+        if (!info) {
+          return;
+        }
+        return {
+          range: toRange(info.range),
+          contents: toMarkedStringArray(info.contents)
+        };
+      });
+    }
+  };
+  function isMarkupContent(thing) {
+    return thing && typeof thing === "object" && typeof thing.kind === "string";
+  }
+  function toMarkdownString(entry) {
+    if (typeof entry === "string") {
+      return {
+        value: entry
+      };
+    }
+    if (isMarkupContent(entry)) {
+      if (entry.kind === "plaintext") {
+        return {
+          value: entry.value.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&")
+        };
+      }
+      return {
+        value: entry.value
+      };
+    }
+    return { value: "```" + entry.language + "\n" + entry.value + "\n```\n" };
+  }
+  function toMarkedStringArray(contents) {
+    if (!contents) {
+      return void 0;
+    }
+    if (Array.isArray(contents)) {
+      return contents.map(toMarkdownString);
+    }
+    return [toMarkdownString(contents)];
+  }
+  var DocumentHighlightAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideDocumentHighlights(model, position, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => worker.findDocumentHighlights(resource.toString(), fromPosition(position))).then((entries) => {
+        if (!entries) {
+          return;
+        }
+        return entries.map((entry) => {
+          return {
+            range: toRange(entry.range),
+            kind: toDocumentHighlightKind(entry.kind)
+          };
+        });
+      });
+    }
+  };
+  function toDocumentHighlightKind(kind) {
+    switch (kind) {
+      case DocumentHighlightKind.Read:
+        return monaco_editor_core_exports.languages.DocumentHighlightKind.Read;
+      case DocumentHighlightKind.Write:
+        return monaco_editor_core_exports.languages.DocumentHighlightKind.Write;
+      case DocumentHighlightKind.Text:
+        return monaco_editor_core_exports.languages.DocumentHighlightKind.Text;
+    }
+    return monaco_editor_core_exports.languages.DocumentHighlightKind.Text;
+  }
+  var DefinitionAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideDefinition(model, position, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => {
+        return worker.findDefinition(resource.toString(), fromPosition(position));
+      }).then((definition) => {
+        if (!definition) {
+          return;
+        }
+        return [toLocation(definition)];
+      });
+    }
+  };
+  function toLocation(location) {
+    return {
+      uri: monaco_editor_core_exports.Uri.parse(location.uri),
+      range: toRange(location.range)
+    };
+  }
+  var ReferenceAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideReferences(model, position, context, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => {
+        return worker.findReferences(resource.toString(), fromPosition(position));
+      }).then((entries) => {
+        if (!entries) {
+          return;
+        }
+        return entries.map(toLocation);
+      });
+    }
+  };
+  var RenameAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideRenameEdits(model, position, newName, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => {
+        return worker.doRename(resource.toString(), fromPosition(position), newName);
+      }).then((edit) => {
+        return toWorkspaceEdit(edit);
+      });
+    }
+  };
+  function toWorkspaceEdit(edit) {
+    if (!edit || !edit.changes) {
+      return void 0;
+    }
+    let resourceEdits = [];
+    for (let uri in edit.changes) {
+      const _uri = monaco_editor_core_exports.Uri.parse(uri);
+      for (let e of edit.changes[uri]) {
+        resourceEdits.push({
+          resource: _uri,
+          versionId: void 0,
+          textEdit: {
+            range: toRange(e.range),
+            text: e.newText
+          }
+        });
+      }
+    }
+    return {
+      edits: resourceEdits
+    };
+  }
+  var DocumentSymbolAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideDocumentSymbols(model, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => worker.findDocumentSymbols(resource.toString())).then((items) => {
+        if (!items) {
+          return;
+        }
+        return items.map((item) => {
+          if (isDocumentSymbol(item)) {
+            return toDocumentSymbol(item);
+          }
+          return {
+            name: item.name,
+            detail: "",
+            containerName: item.containerName,
+            kind: toSymbolKind(item.kind),
+            range: toRange(item.location.range),
+            selectionRange: toRange(item.location.range),
+            tags: []
+          };
+        });
+      });
+    }
+  };
+  function isDocumentSymbol(symbol) {
+    return "children" in symbol;
+  }
+  function toDocumentSymbol(symbol) {
+    return {
+      name: symbol.name,
+      detail: symbol.detail ?? "",
+      kind: toSymbolKind(symbol.kind),
+      range: toRange(symbol.range),
+      selectionRange: toRange(symbol.selectionRange),
+      tags: symbol.tags ?? [],
+      children: (symbol.children ?? []).map((item) => toDocumentSymbol(item))
+    };
+  }
+  function toSymbolKind(kind) {
+    let mKind = monaco_editor_core_exports.languages.SymbolKind;
+    switch (kind) {
+      case SymbolKind.File:
+        return mKind.File;
+      case SymbolKind.Module:
+        return mKind.Module;
+      case SymbolKind.Namespace:
+        return mKind.Namespace;
+      case SymbolKind.Package:
+        return mKind.Package;
+      case SymbolKind.Class:
+        return mKind.Class;
+      case SymbolKind.Method:
+        return mKind.Method;
+      case SymbolKind.Property:
+        return mKind.Property;
+      case SymbolKind.Field:
+        return mKind.Field;
+      case SymbolKind.Constructor:
+        return mKind.Constructor;
+      case SymbolKind.Enum:
+        return mKind.Enum;
+      case SymbolKind.Interface:
+        return mKind.Interface;
+      case SymbolKind.Function:
+        return mKind.Function;
+      case SymbolKind.Variable:
+        return mKind.Variable;
+      case SymbolKind.Constant:
+        return mKind.Constant;
+      case SymbolKind.String:
+        return mKind.String;
+      case SymbolKind.Number:
+        return mKind.Number;
+      case SymbolKind.Boolean:
+        return mKind.Boolean;
+      case SymbolKind.Array:
+        return mKind.Array;
+    }
+    return mKind.Function;
+  }
+  var DocumentLinkAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideLinks(model, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => worker.findDocumentLinks(resource.toString())).then((items) => {
+        if (!items) {
+          return;
+        }
+        return {
+          links: items.map((item) => ({
+            range: toRange(item.range),
+            url: item.target
+          }))
+        };
+      });
+    }
+  };
+  var DocumentFormattingEditProvider = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideDocumentFormattingEdits(model, options, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => {
+        return worker.format(resource.toString(), null, fromFormattingOptions(options)).then((edits) => {
+          if (!edits || edits.length === 0) {
+            return;
+          }
+          return edits.map(toTextEdit);
+        });
+      });
+    }
+  };
+  var DocumentRangeFormattingEditProvider = class {
+    constructor(_worker) {
+      this._worker = _worker;
+      this.canFormatMultipleRanges = false;
+    }
+    provideDocumentRangeFormattingEdits(model, range, options, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => {
+        return worker.format(resource.toString(), fromRange(range), fromFormattingOptions(options)).then((edits) => {
+          if (!edits || edits.length === 0) {
+            return;
+          }
+          return edits.map(toTextEdit);
+        });
+      });
+    }
+  };
+  function fromFormattingOptions(options) {
+    return {
+      tabSize: options.tabSize,
+      insertSpaces: options.insertSpaces
+    };
+  }
+  var DocumentColorAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideDocumentColors(model, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => worker.findDocumentColors(resource.toString())).then((infos) => {
+        if (!infos) {
+          return;
+        }
+        return infos.map((item) => ({
+          color: item.color,
+          range: toRange(item.range)
+        }));
+      });
+    }
+    provideColorPresentations(model, info, token) {
+      const resource = model.uri;
+      return this._worker(resource).then(
+        (worker) => worker.getColorPresentations(resource.toString(), info.color, fromRange(info.range))
+      ).then((presentations) => {
+        if (!presentations) {
+          return;
+        }
+        return presentations.map((presentation) => {
+          let item = {
+            label: presentation.label
+          };
+          if (presentation.textEdit) {
+            item.textEdit = toTextEdit(presentation.textEdit);
+          }
+          if (presentation.additionalTextEdits) {
+            item.additionalTextEdits = presentation.additionalTextEdits.map(toTextEdit);
+          }
+          return item;
+        });
+      });
+    }
+  };
+  var FoldingRangeAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideFoldingRanges(model, context, token) {
+      const resource = model.uri;
+      return this._worker(resource).then((worker) => worker.getFoldingRanges(resource.toString(), context)).then((ranges) => {
+        if (!ranges) {
+          return;
+        }
+        return ranges.map((range) => {
+          const result = {
+            start: range.startLine + 1,
+            end: range.endLine + 1
+          };
+          if (typeof range.kind !== "undefined") {
+            result.kind = toFoldingRangeKind(range.kind);
+          }
+          return result;
+        });
+      });
+    }
+  };
+  function toFoldingRangeKind(kind) {
+    switch (kind) {
+      case FoldingRangeKind.Comment:
+        return monaco_editor_core_exports.languages.FoldingRangeKind.Comment;
+      case FoldingRangeKind.Imports:
+        return monaco_editor_core_exports.languages.FoldingRangeKind.Imports;
+      case FoldingRangeKind.Region:
+        return monaco_editor_core_exports.languages.FoldingRangeKind.Region;
+    }
+    return void 0;
+  }
+  var SelectionRangeAdapter = class {
+    constructor(_worker) {
+      this._worker = _worker;
+    }
+    provideSelectionRanges(model, positions, token) {
+      const resource = model.uri;
+      return this._worker(resource).then(
+        (worker) => worker.getSelectionRanges(
+          resource.toString(),
+          positions.map(fromPosition)
+        )
+      ).then((selectionRanges) => {
+        if (!selectionRanges) {
+          return;
+        }
+        return selectionRanges.map((selectionRange) => {
+          const result = [];
+          while (selectionRange) {
+            result.push({ range: toRange(selectionRange.range) });
+            selectionRange = selectionRange.parent;
+          }
+          return result;
+        });
+      });
+    }
+  };
+
+  // src/language/html/htmlMode.ts
+  var HTMLCompletionAdapter = class extends CompletionAdapter {
+    constructor(worker) {
+      super(worker, [".", ":", "<", '"', "=", "/"]);
+    }
+  };
+  function setupMode1(defaults) {
+    const client = new WorkerManager(defaults);
+    const worker = (...uris) => {
+      return client.getLanguageServiceWorker(...uris);
+    };
+    let languageId = defaults.languageId;
+    monaco_editor_core_exports.languages.registerCompletionItemProvider(languageId, new HTMLCompletionAdapter(worker));
+    monaco_editor_core_exports.languages.registerHoverProvider(languageId, new HoverAdapter(worker));
+    monaco_editor_core_exports.languages.registerDocumentHighlightProvider(
+      languageId,
+      new DocumentHighlightAdapter(worker)
+    );
+    monaco_editor_core_exports.languages.registerLinkProvider(languageId, new DocumentLinkAdapter(worker));
+    monaco_editor_core_exports.languages.registerFoldingRangeProvider(
+      languageId,
+      new FoldingRangeAdapter(worker)
+    );
+    monaco_editor_core_exports.languages.registerDocumentSymbolProvider(
+      languageId,
+      new DocumentSymbolAdapter(worker)
+    );
+    monaco_editor_core_exports.languages.registerSelectionRangeProvider(
+      languageId,
+      new SelectionRangeAdapter(worker)
+    );
+    monaco_editor_core_exports.languages.registerRenameProvider(languageId, new RenameAdapter(worker));
+    if (languageId === "html") {
+      monaco_editor_core_exports.languages.registerDocumentFormattingEditProvider(
+        languageId,
+        new DocumentFormattingEditProvider(worker)
+      );
+      monaco_editor_core_exports.languages.registerDocumentRangeFormattingEditProvider(
+        languageId,
+        new DocumentRangeFormattingEditProvider(worker)
+      );
+    }
+  }
+  function setupMode(defaults) {
+    const disposables = [];
+    const providers = [];
+    const client = new WorkerManager(defaults);
+    disposables.push(client);
+    const worker = (...uris) => {
+      return client.getLanguageServiceWorker(...uris);
+    };
+    function registerProviders() {
+      const { languageId, modeConfiguration } = defaults;
+      disposeAll(providers);
+      if (modeConfiguration.completionItems) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerCompletionItemProvider(languageId, new HTMLCompletionAdapter(worker))
+        );
+      }
+      if (modeConfiguration.hovers) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerHoverProvider(languageId, new HoverAdapter(worker))
+        );
+      }
+      if (modeConfiguration.documentHighlights) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerDocumentHighlightProvider(
+            languageId,
+            new DocumentHighlightAdapter(worker)
+          )
+        );
+      }
+      if (modeConfiguration.links) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerLinkProvider(languageId, new DocumentLinkAdapter(worker))
+        );
+      }
+      if (modeConfiguration.documentSymbols) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerDocumentSymbolProvider(
+            languageId,
+            new DocumentSymbolAdapter(worker)
+          )
+        );
+      }
+      if (modeConfiguration.rename) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerRenameProvider(languageId, new RenameAdapter(worker))
+        );
+      }
+      if (modeConfiguration.foldingRanges) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerFoldingRangeProvider(
+            languageId,
+            new FoldingRangeAdapter(worker)
+          )
+        );
+      }
+      if (modeConfiguration.selectionRanges) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerSelectionRangeProvider(
+            languageId,
+            new SelectionRangeAdapter(worker)
+          )
+        );
+      }
+      if (modeConfiguration.documentFormattingEdits) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerDocumentFormattingEditProvider(
+            languageId,
+            new DocumentFormattingEditProvider(worker)
+          )
+        );
+      }
+      if (modeConfiguration.documentRangeFormattingEdits) {
+        providers.push(
+          monaco_editor_core_exports.languages.registerDocumentRangeFormattingEditProvider(
+            languageId,
+            new DocumentRangeFormattingEditProvider(worker)
+          )
+        );
+      }
+    }
+    registerProviders();
+    disposables.push(asDisposable(providers));
+    return asDisposable(disposables);
+  }
+  function asDisposable(disposables) {
+    return { dispose: () => disposeAll(disposables) };
+  }
+  function disposeAll(disposables) {
+    while (disposables.length) {
+      disposables.pop().dispose();
+    }
+  }
+  return __toCommonJS(htmlMode_exports);
+})();
+return moduleExports;
+});