Add files using upload-large-folder tool

.gitattributes

@@ -1952,3 +1952,4 @@ platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-c
 platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/esbuild/bin/esbuild filter=lfs diff=lfs merge=lfs -text
 platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/editor/editor.main.js.map filter=lfs diff=lfs merge=lfs -text
 platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/dev/vs/language/typescript/tsWorker.js filter=lfs diff=lfs merge=lfs -text
+platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/language/typescript/ts.worker.js filter=lfs diff=lfs merge=lfs -text

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

@@ -0,0 +1,24 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/cameligo/cameligo.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "cameligo",
+  extensions: [".mligo"],
+  aliases: ["Cameligo"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/cameligo/cameligo"], resolve, reject);
+      });
+    } else {
+      return import("./cameligo.js");
+    }
+  }
+});

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

@@ -0,0 +1,184 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/cameligo/cameligo.ts
+var conf = {
+  comments: {
+    lineComment: "//",
+    blockComment: ["(*", "*)"]
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["<", ">"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { 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: '"' },
+    { open: "(*", close: "*)" }
+  ]
+};
+var language = {
+  defaultToken: "",
+  tokenPostfix: ".cameligo",
+  ignoreCase: true,
+  brackets: [
+    { open: "{", close: "}", token: "delimiter.curly" },
+    { open: "[", close: "]", token: "delimiter.square" },
+    { open: "(", close: ")", token: "delimiter.parenthesis" },
+    { open: "<", close: ">", token: "delimiter.angle" }
+  ],
+  keywords: [
+    "abs",
+    "assert",
+    "block",
+    "Bytes",
+    "case",
+    "Crypto",
+    "Current",
+    "else",
+    "failwith",
+    "false",
+    "for",
+    "fun",
+    "if",
+    "in",
+    "let",
+    "let%entry",
+    "let%init",
+    "List",
+    "list",
+    "Map",
+    "map",
+    "match",
+    "match%nat",
+    "mod",
+    "not",
+    "operation",
+    "Operation",
+    "of",
+    "record",
+    "Set",
+    "set",
+    "sender",
+    "skip",
+    "source",
+    "String",
+    "then",
+    "to",
+    "true",
+    "type",
+    "with"
+  ],
+  typeKeywords: ["int", "unit", "string", "tz", "nat", "bool"],
+  operators: [
+    "=",
+    ">",
+    "<",
+    "<=",
+    ">=",
+    "<>",
+    ":",
+    ":=",
+    "and",
+    "mod",
+    "or",
+    "+",
+    "-",
+    "*",
+    "/",
+    "@",
+    "&",
+    "^",
+    "%",
+    "->",
+    "<-",
+    "&&",
+    "||"
+  ],
+  // we include these common regular expressions
+  symbols: /[=><:@\^&|+\-*\/\^%]+/,
+  // 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" },
+      // delimiters and operators
+      [/[{}()\[\]]/, "@brackets"],
+      [/[<>](?!@symbols)/, "@brackets"],
+      [
+        /@symbols/,
+        {
+          cases: {
+            "@operators": "delimiter",
+            "@default": ""
+          }
+        }
+      ],
+      // numbers
+      [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+      [/\$[0-9a-fA-F]{1,16}/, "number.hex"],
+      [/\d+/, "number"],
+      // delimiter: after number because of .\d floats
+      [/[;,.]/, "delimiter"],
+      // strings
+      [/'([^'\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
+      [/'/, "string", "@string"],
+      // characters
+      [/'[^\\']'/, "string"],
+      [/'/, "string.invalid"],
+      [/\#\d+/, "string"]
+    ],
+    /* */
+    comment: [
+      [/[^\(\*]+/, "comment"],
+      //[/\(\*/,    'comment', '@push' ],    // nested comment  not allowed :-(
+      [/\*\)/, "comment", "@pop"],
+      [/\(\*/, "comment"]
+    ],
+    string: [
+      [/[^\\']+/, "string"],
+      [/\\./, "string.escape.invalid"],
+      [/'/, { token: "string.quote", bracket: "@close", next: "@pop" }]
+    ],
+    whitespace: [
+      [/[ \t\r\n]+/, "white"],
+      [/\(\*/, "comment", "@comment"],
+      [/\/\/.*$/, "comment"]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/clojure/clojure.contribution.d.ts

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

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

@@ -0,0 +1,24 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/clojure/clojure.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "clojure",
+  extensions: [".clj", ".cljs", ".cljc", ".edn"],
+  aliases: ["clojure", "Clojure"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/clojure/clojure"], resolve, reject);
+      });
+    } else {
+      return import("./clojure.js");
+    }
+  }
+});

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

@@ -0,0 +1,771 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/clojure/clojure.ts
+var conf = {
+  comments: {
+    lineComment: ";;"
+  },
+  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: ".clj",
+  brackets: [
+    { open: "[", close: "]", token: "delimiter.square" },
+    { open: "(", close: ")", token: "delimiter.parenthesis" },
+    { open: "{", close: "}", token: "delimiter.curly" }
+  ],
+  constants: ["true", "false", "nil"],
+  // delimiters: /[\\\[\]\s"#'(),;@^`{}~]|$/,
+  numbers: /^(?:[+\-]?\d+(?:(?:N|(?:[eE][+\-]?\d+))|(?:\.?\d*(?:M|(?:[eE][+\-]?\d+))?)|\/\d+|[xX][0-9a-fA-F]+|r[0-9a-zA-Z]+)?(?=[\\\[\]\s"#'(),;@^`{}~]|$))/,
+  characters: /^(?:\\(?:backspace|formfeed|newline|return|space|tab|o[0-7]{3}|u[0-9A-Fa-f]{4}|x[0-9A-Fa-f]{4}|.)?(?=[\\\[\]\s"(),;@^`{}~]|$))/,
+  escapes: /^\\(?:["'\\bfnrt]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  // simple-namespace := /^[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*/
+  // simple-symbol    := /^(?:\/|[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)/
+  // qualified-symbol := (<simple-namespace>(<.><simple-namespace>)*</>)?<simple-symbol>
+  qualifiedSymbols: /^(?:(?:[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*(?:\.[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)*\/)?(?:\/|[^\\\/\[\]\d\s"#'(),;@^`{}~][^\\\[\]\s"(),;@^`{}~]*)*(?=[\\\[\]\s"(),;@^`{}~]|$))/,
+  specialForms: [
+    ".",
+    "catch",
+    "def",
+    "do",
+    "if",
+    "monitor-enter",
+    "monitor-exit",
+    "new",
+    "quote",
+    "recur",
+    "set!",
+    "throw",
+    "try",
+    "var"
+  ],
+  coreSymbols: [
+    "*",
+    "*'",
+    "*1",
+    "*2",
+    "*3",
+    "*agent*",
+    "*allow-unresolved-vars*",
+    "*assert*",
+    "*clojure-version*",
+    "*command-line-args*",
+    "*compile-files*",
+    "*compile-path*",
+    "*compiler-options*",
+    "*data-readers*",
+    "*default-data-reader-fn*",
+    "*e",
+    "*err*",
+    "*file*",
+    "*flush-on-newline*",
+    "*fn-loader*",
+    "*in*",
+    "*math-context*",
+    "*ns*",
+    "*out*",
+    "*print-dup*",
+    "*print-length*",
+    "*print-level*",
+    "*print-meta*",
+    "*print-namespace-maps*",
+    "*print-readably*",
+    "*read-eval*",
+    "*reader-resolver*",
+    "*source-path*",
+    "*suppress-read*",
+    "*unchecked-math*",
+    "*use-context-classloader*",
+    "*verbose-defrecords*",
+    "*warn-on-reflection*",
+    "+",
+    "+'",
+    "-",
+    "-'",
+    "->",
+    "->>",
+    "->ArrayChunk",
+    "->Eduction",
+    "->Vec",
+    "->VecNode",
+    "->VecSeq",
+    "-cache-protocol-fn",
+    "-reset-methods",
+    "..",
+    "/",
+    "<",
+    "<=",
+    "=",
+    "==",
+    ">",
+    ">=",
+    "EMPTY-NODE",
+    "Inst",
+    "StackTraceElement->vec",
+    "Throwable->map",
+    "accessor",
+    "aclone",
+    "add-classpath",
+    "add-watch",
+    "agent",
+    "agent-error",
+    "agent-errors",
+    "aget",
+    "alength",
+    "alias",
+    "all-ns",
+    "alter",
+    "alter-meta!",
+    "alter-var-root",
+    "amap",
+    "ancestors",
+    "and",
+    "any?",
+    "apply",
+    "areduce",
+    "array-map",
+    "as->",
+    "aset",
+    "aset-boolean",
+    "aset-byte",
+    "aset-char",
+    "aset-double",
+    "aset-float",
+    "aset-int",
+    "aset-long",
+    "aset-short",
+    "assert",
+    "assoc",
+    "assoc!",
+    "assoc-in",
+    "associative?",
+    "atom",
+    "await",
+    "await-for",
+    "await1",
+    "bases",
+    "bean",
+    "bigdec",
+    "bigint",
+    "biginteger",
+    "binding",
+    "bit-and",
+    "bit-and-not",
+    "bit-clear",
+    "bit-flip",
+    "bit-not",
+    "bit-or",
+    "bit-set",
+    "bit-shift-left",
+    "bit-shift-right",
+    "bit-test",
+    "bit-xor",
+    "boolean",
+    "boolean-array",
+    "boolean?",
+    "booleans",
+    "bound-fn",
+    "bound-fn*",
+    "bound?",
+    "bounded-count",
+    "butlast",
+    "byte",
+    "byte-array",
+    "bytes",
+    "bytes?",
+    "case",
+    "cast",
+    "cat",
+    "char",
+    "char-array",
+    "char-escape-string",
+    "char-name-string",
+    "char?",
+    "chars",
+    "chunk",
+    "chunk-append",
+    "chunk-buffer",
+    "chunk-cons",
+    "chunk-first",
+    "chunk-next",
+    "chunk-rest",
+    "chunked-seq?",
+    "class",
+    "class?",
+    "clear-agent-errors",
+    "clojure-version",
+    "coll?",
+    "comment",
+    "commute",
+    "comp",
+    "comparator",
+    "compare",
+    "compare-and-set!",
+    "compile",
+    "complement",
+    "completing",
+    "concat",
+    "cond",
+    "cond->",
+    "cond->>",
+    "condp",
+    "conj",
+    "conj!",
+    "cons",
+    "constantly",
+    "construct-proxy",
+    "contains?",
+    "count",
+    "counted?",
+    "create-ns",
+    "create-struct",
+    "cycle",
+    "dec",
+    "dec'",
+    "decimal?",
+    "declare",
+    "dedupe",
+    "default-data-readers",
+    "definline",
+    "definterface",
+    "defmacro",
+    "defmethod",
+    "defmulti",
+    "defn",
+    "defn-",
+    "defonce",
+    "defprotocol",
+    "defrecord",
+    "defstruct",
+    "deftype",
+    "delay",
+    "delay?",
+    "deliver",
+    "denominator",
+    "deref",
+    "derive",
+    "descendants",
+    "destructure",
+    "disj",
+    "disj!",
+    "dissoc",
+    "dissoc!",
+    "distinct",
+    "distinct?",
+    "doall",
+    "dorun",
+    "doseq",
+    "dosync",
+    "dotimes",
+    "doto",
+    "double",
+    "double-array",
+    "double?",
+    "doubles",
+    "drop",
+    "drop-last",
+    "drop-while",
+    "eduction",
+    "empty",
+    "empty?",
+    "ensure",
+    "ensure-reduced",
+    "enumeration-seq",
+    "error-handler",
+    "error-mode",
+    "eval",
+    "even?",
+    "every-pred",
+    "every?",
+    "ex-data",
+    "ex-info",
+    "extend",
+    "extend-protocol",
+    "extend-type",
+    "extenders",
+    "extends?",
+    "false?",
+    "ffirst",
+    "file-seq",
+    "filter",
+    "filterv",
+    "find",
+    "find-keyword",
+    "find-ns",
+    "find-protocol-impl",
+    "find-protocol-method",
+    "find-var",
+    "first",
+    "flatten",
+    "float",
+    "float-array",
+    "float?",
+    "floats",
+    "flush",
+    "fn",
+    "fn?",
+    "fnext",
+    "fnil",
+    "for",
+    "force",
+    "format",
+    "frequencies",
+    "future",
+    "future-call",
+    "future-cancel",
+    "future-cancelled?",
+    "future-done?",
+    "future?",
+    "gen-class",
+    "gen-interface",
+    "gensym",
+    "get",
+    "get-in",
+    "get-method",
+    "get-proxy-class",
+    "get-thread-bindings",
+    "get-validator",
+    "group-by",
+    "halt-when",
+    "hash",
+    "hash-combine",
+    "hash-map",
+    "hash-ordered-coll",
+    "hash-set",
+    "hash-unordered-coll",
+    "ident?",
+    "identical?",
+    "identity",
+    "if-let",
+    "if-not",
+    "if-some",
+    "ifn?",
+    "import",
+    "in-ns",
+    "inc",
+    "inc'",
+    "indexed?",
+    "init-proxy",
+    "inst-ms",
+    "inst-ms*",
+    "inst?",
+    "instance?",
+    "int",
+    "int-array",
+    "int?",
+    "integer?",
+    "interleave",
+    "intern",
+    "interpose",
+    "into",
+    "into-array",
+    "ints",
+    "io!",
+    "isa?",
+    "iterate",
+    "iterator-seq",
+    "juxt",
+    "keep",
+    "keep-indexed",
+    "key",
+    "keys",
+    "keyword",
+    "keyword?",
+    "last",
+    "lazy-cat",
+    "lazy-seq",
+    "let",
+    "letfn",
+    "line-seq",
+    "list",
+    "list*",
+    "list?",
+    "load",
+    "load-file",
+    "load-reader",
+    "load-string",
+    "loaded-libs",
+    "locking",
+    "long",
+    "long-array",
+    "longs",
+    "loop",
+    "macroexpand",
+    "macroexpand-1",
+    "make-array",
+    "make-hierarchy",
+    "map",
+    "map-entry?",
+    "map-indexed",
+    "map?",
+    "mapcat",
+    "mapv",
+    "max",
+    "max-key",
+    "memfn",
+    "memoize",
+    "merge",
+    "merge-with",
+    "meta",
+    "method-sig",
+    "methods",
+    "min",
+    "min-key",
+    "mix-collection-hash",
+    "mod",
+    "munge",
+    "name",
+    "namespace",
+    "namespace-munge",
+    "nat-int?",
+    "neg-int?",
+    "neg?",
+    "newline",
+    "next",
+    "nfirst",
+    "nil?",
+    "nnext",
+    "not",
+    "not-any?",
+    "not-empty",
+    "not-every?",
+    "not=",
+    "ns",
+    "ns-aliases",
+    "ns-imports",
+    "ns-interns",
+    "ns-map",
+    "ns-name",
+    "ns-publics",
+    "ns-refers",
+    "ns-resolve",
+    "ns-unalias",
+    "ns-unmap",
+    "nth",
+    "nthnext",
+    "nthrest",
+    "num",
+    "number?",
+    "numerator",
+    "object-array",
+    "odd?",
+    "or",
+    "parents",
+    "partial",
+    "partition",
+    "partition-all",
+    "partition-by",
+    "pcalls",
+    "peek",
+    "persistent!",
+    "pmap",
+    "pop",
+    "pop!",
+    "pop-thread-bindings",
+    "pos-int?",
+    "pos?",
+    "pr",
+    "pr-str",
+    "prefer-method",
+    "prefers",
+    "primitives-classnames",
+    "print",
+    "print-ctor",
+    "print-dup",
+    "print-method",
+    "print-simple",
+    "print-str",
+    "printf",
+    "println",
+    "println-str",
+    "prn",
+    "prn-str",
+    "promise",
+    "proxy",
+    "proxy-call-with-super",
+    "proxy-mappings",
+    "proxy-name",
+    "proxy-super",
+    "push-thread-bindings",
+    "pvalues",
+    "qualified-ident?",
+    "qualified-keyword?",
+    "qualified-symbol?",
+    "quot",
+    "rand",
+    "rand-int",
+    "rand-nth",
+    "random-sample",
+    "range",
+    "ratio?",
+    "rational?",
+    "rationalize",
+    "re-find",
+    "re-groups",
+    "re-matcher",
+    "re-matches",
+    "re-pattern",
+    "re-seq",
+    "read",
+    "read-line",
+    "read-string",
+    "reader-conditional",
+    "reader-conditional?",
+    "realized?",
+    "record?",
+    "reduce",
+    "reduce-kv",
+    "reduced",
+    "reduced?",
+    "reductions",
+    "ref",
+    "ref-history-count",
+    "ref-max-history",
+    "ref-min-history",
+    "ref-set",
+    "refer",
+    "refer-clojure",
+    "reify",
+    "release-pending-sends",
+    "rem",
+    "remove",
+    "remove-all-methods",
+    "remove-method",
+    "remove-ns",
+    "remove-watch",
+    "repeat",
+    "repeatedly",
+    "replace",
+    "replicate",
+    "require",
+    "reset!",
+    "reset-meta!",
+    "reset-vals!",
+    "resolve",
+    "rest",
+    "restart-agent",
+    "resultset-seq",
+    "reverse",
+    "reversible?",
+    "rseq",
+    "rsubseq",
+    "run!",
+    "satisfies?",
+    "second",
+    "select-keys",
+    "send",
+    "send-off",
+    "send-via",
+    "seq",
+    "seq?",
+    "seqable?",
+    "seque",
+    "sequence",
+    "sequential?",
+    "set",
+    "set-agent-send-executor!",
+    "set-agent-send-off-executor!",
+    "set-error-handler!",
+    "set-error-mode!",
+    "set-validator!",
+    "set?",
+    "short",
+    "short-array",
+    "shorts",
+    "shuffle",
+    "shutdown-agents",
+    "simple-ident?",
+    "simple-keyword?",
+    "simple-symbol?",
+    "slurp",
+    "some",
+    "some->",
+    "some->>",
+    "some-fn",
+    "some?",
+    "sort",
+    "sort-by",
+    "sorted-map",
+    "sorted-map-by",
+    "sorted-set",
+    "sorted-set-by",
+    "sorted?",
+    "special-symbol?",
+    "spit",
+    "split-at",
+    "split-with",
+    "str",
+    "string?",
+    "struct",
+    "struct-map",
+    "subs",
+    "subseq",
+    "subvec",
+    "supers",
+    "swap!",
+    "swap-vals!",
+    "symbol",
+    "symbol?",
+    "sync",
+    "tagged-literal",
+    "tagged-literal?",
+    "take",
+    "take-last",
+    "take-nth",
+    "take-while",
+    "test",
+    "the-ns",
+    "thread-bound?",
+    "time",
+    "to-array",
+    "to-array-2d",
+    "trampoline",
+    "transduce",
+    "transient",
+    "tree-seq",
+    "true?",
+    "type",
+    "unchecked-add",
+    "unchecked-add-int",
+    "unchecked-byte",
+    "unchecked-char",
+    "unchecked-dec",
+    "unchecked-dec-int",
+    "unchecked-divide-int",
+    "unchecked-double",
+    "unchecked-float",
+    "unchecked-inc",
+    "unchecked-inc-int",
+    "unchecked-int",
+    "unchecked-long",
+    "unchecked-multiply",
+    "unchecked-multiply-int",
+    "unchecked-negate",
+    "unchecked-negate-int",
+    "unchecked-remainder-int",
+    "unchecked-short",
+    "unchecked-subtract",
+    "unchecked-subtract-int",
+    "underive",
+    "unquote",
+    "unquote-splicing",
+    "unreduced",
+    "unsigned-bit-shift-right",
+    "update",
+    "update-in",
+    "update-proxy",
+    "uri?",
+    "use",
+    "uuid?",
+    "val",
+    "vals",
+    "var-get",
+    "var-set",
+    "var?",
+    "vary-meta",
+    "vec",
+    "vector",
+    "vector-of",
+    "vector?",
+    "volatile!",
+    "volatile?",
+    "vreset!",
+    "vswap!",
+    "when",
+    "when-first",
+    "when-let",
+    "when-not",
+    "when-some",
+    "while",
+    "with-bindings",
+    "with-bindings*",
+    "with-in-str",
+    "with-loading-context",
+    "with-local-vars",
+    "with-meta",
+    "with-open",
+    "with-out-str",
+    "with-precision",
+    "with-redefs",
+    "with-redefs-fn",
+    "xml-seq",
+    "zero?",
+    "zipmap"
+  ],
+  tokenizer: {
+    root: [
+      // whitespaces and comments
+      { include: "@whitespace" },
+      // numbers
+      [/@numbers/, "number"],
+      // characters
+      [/@characters/, "string"],
+      // strings
+      { include: "@string" },
+      // brackets
+      [/[()\[\]{}]/, "@brackets"],
+      // regular expressions
+      [/\/#"(?:\.|(?:")|[^"\n])*"\/g/, "regexp"],
+      // reader macro characters
+      [/[#'@^`~]/, "meta"],
+      // symbols
+      [
+        /@qualifiedSymbols/,
+        {
+          cases: {
+            "^:.+$": "constant",
+            // Clojure keywords (e.g., `:foo/bar`)
+            "@specialForms": "keyword",
+            "@coreSymbols": "keyword",
+            "@constants": "constant",
+            "@default": "identifier"
+          }
+        }
+      ]
+    ],
+    whitespace: [
+      [/[\s,]+/, "white"],
+      [/;.*$/, "comment"],
+      [/\(comment\b/, "comment", "@comment"]
+    ],
+    comment: [
+      [/\(/, "comment", "@push"],
+      [/\)/, "comment", "@pop"],
+      [/[^()]/, "comment"]
+    ],
+    string: [[/"/, "string", "@multiLineString"]],
+    multiLineString: [
+      [/"/, "string", "@popall"],
+      [/@escapes/, "string.escape"],
+      [/./, "string"]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/coffee/coffee.contribution.d.ts

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

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

@@ -0,0 +1,25 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/coffee/coffee.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "coffeescript",
+  extensions: [".coffee"],
+  aliases: ["CoffeeScript", "coffeescript", "coffee"],
+  mimetypes: ["text/x-coffeescript", "text/coffeescript"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/coffee/coffee"], resolve, reject);
+      });
+    } else {
+      return import("./coffee.js");
+    }
+  }
+});

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

@@ -0,0 +1,242 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/coffee/coffee.ts
+var conf = {
+  wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\$\-\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+  comments: {
+    blockComment: ["###", "###"],
+    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: {
+    markers: {
+      start: new RegExp("^\\s*#region\\b"),
+      end: new RegExp("^\\s*#endregion\\b")
+    }
+  }
+};
+var language = {
+  defaultToken: "",
+  ignoreCase: true,
+  tokenPostfix: ".coffee",
+  brackets: [
+    { open: "{", close: "}", token: "delimiter.curly" },
+    { open: "[", close: "]", token: "delimiter.square" },
+    { open: "(", close: ")", token: "delimiter.parenthesis" }
+  ],
+  regEx: /\/(?!\/\/)(?:[^\/\\]|\\.)*\/[igm]*/,
+  keywords: [
+    "and",
+    "or",
+    "is",
+    "isnt",
+    "not",
+    "on",
+    "yes",
+    "@",
+    "no",
+    "off",
+    "true",
+    "false",
+    "null",
+    "this",
+    "new",
+    "delete",
+    "typeof",
+    "in",
+    "instanceof",
+    "return",
+    "throw",
+    "break",
+    "continue",
+    "debugger",
+    "if",
+    "else",
+    "switch",
+    "for",
+    "while",
+    "do",
+    "try",
+    "catch",
+    "finally",
+    "class",
+    "extends",
+    "super",
+    "undefined",
+    "then",
+    "unless",
+    "until",
+    "loop",
+    "of",
+    "by",
+    "when"
+  ],
+  // 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})/,
+  // The main tokenizer for our languages
+  tokenizer: {
+    root: [
+      // identifiers and keywords
+      [/\@[a-zA-Z_]\w*/, "variable.predefined"],
+      [
+        /[a-zA-Z_]\w*/,
+        {
+          cases: {
+            this: "variable.predefined",
+            "@keywords": { token: "keyword.$0" },
+            "@default": ""
+          }
+        }
+      ],
+      // whitespace
+      [/[ \t\r\n]+/, ""],
+      // Comments
+      [/###/, "comment", "@comment"],
+      [/#.*$/, "comment"],
+      // regular expressions
+      ["///", { token: "regexp", next: "@hereregexp" }],
+      [/^(\s*)(@regEx)/, ["", "regexp"]],
+      [/(\()(\s*)(@regEx)/, ["@brackets", "", "regexp"]],
+      [/(\,)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+      [/(\=)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+      [/(\:)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+      [/(\[)(\s*)(@regEx)/, ["@brackets", "", "regexp"]],
+      [/(\!)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+      [/(\&)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+      [/(\|)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+      [/(\?)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+      [/(\{)(\s*)(@regEx)/, ["@brackets", "", "regexp"]],
+      [/(\;)(\s*)(@regEx)/, ["", "", "regexp"]],
+      // delimiters
+      [
+        /}/,
+        {
+          cases: {
+            "$S2==interpolatedstring": {
+              token: "string",
+              next: "@pop"
+            },
+            "@default": "@brackets"
+          }
+        }
+      ],
+      [/[{}()\[\]]/, "@brackets"],
+      [/@symbols/, "delimiter"],
+      // numbers
+      [/\d+[eE]([\-+]?\d+)?/, "number.float"],
+      [/\d+\.\d+([eE][\-+]?\d+)?/, "number.float"],
+      [/0[xX][0-9a-fA-F]+/, "number.hex"],
+      [/0[0-7]+(?!\d)/, "number.octal"],
+      [/\d+/, "number"],
+      // delimiter: after number because of .\d floats
+      [/[,.]/, "delimiter"],
+      // strings:
+      [/"""/, "string", '@herestring."""'],
+      [/'''/, "string", "@herestring.'''"],
+      [
+        /"/,
+        {
+          cases: {
+            "@eos": "string",
+            "@default": { token: "string", next: '@string."' }
+          }
+        }
+      ],
+      [
+        /'/,
+        {
+          cases: {
+            "@eos": "string",
+            "@default": { token: "string", next: "@string.'" }
+          }
+        }
+      ]
+    ],
+    string: [
+      [/[^"'\#\\]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\./, "string.escape.invalid"],
+      [/\./, "string.escape.invalid"],
+      [
+        /#{/,
+        {
+          cases: {
+            '$S2=="': {
+              token: "string",
+              next: "root.interpolatedstring"
+            },
+            "@default": "string"
+          }
+        }
+      ],
+      [
+        /["']/,
+        {
+          cases: {
+            "$#==$S2": { token: "string", next: "@pop" },
+            "@default": "string"
+          }
+        }
+      ],
+      [/#/, "string"]
+    ],
+    herestring: [
+      [
+        /("""|''')/,
+        {
+          cases: {
+            "$1==$S2": { token: "string", next: "@pop" },
+            "@default": "string"
+          }
+        }
+      ],
+      [/[^#\\'"]+/, "string"],
+      [/['"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\./, "string.escape.invalid"],
+      [/#{/, { token: "string.quote", next: "root.interpolatedstring" }],
+      [/#/, "string"]
+    ],
+    comment: [
+      [/[^#]+/, "comment"],
+      [/###/, "comment", "@pop"],
+      [/#/, "comment"]
+    ],
+    hereregexp: [
+      [/[^\\\/#]+/, "regexp"],
+      [/\\./, "regexp"],
+      [/#.*$/, "comment"],
+      ["///[igm]*", { token: "regexp", next: "@pop" }],
+      [/\//, "regexp"]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/cpp/cpp.contribution.d.ts

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

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

@@ -0,0 +1,38 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/cpp/cpp.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "c",
+  extensions: [".c", ".h"],
+  aliases: ["C", "c"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/cpp/cpp"], resolve, reject);
+      });
+    } else {
+      return import("./cpp.js");
+    }
+  }
+});
+registerLanguage({
+  id: "cpp",
+  extensions: [".cpp", ".cc", ".cxx", ".hpp", ".hh", ".hxx"],
+  aliases: ["C++", "Cpp", "cpp"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/cpp/cpp"], resolve, reject);
+      });
+    } else {
+      return import("./cpp.js");
+    }
+  }
+});

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

@@ -0,0 +1,399 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/cpp/cpp.ts
+var conf = {
+  comments: {
+    lineComment: "//",
+    blockComment: ["/*", "*/"]
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  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: {
+    markers: {
+      start: new RegExp("^\\s*#pragma\\s+region\\b"),
+      end: new RegExp("^\\s*#pragma\\s+endregion\\b")
+    }
+  }
+};
+var language = {
+  defaultToken: "",
+  tokenPostfix: ".cpp",
+  brackets: [
+    { token: "delimiter.curly", open: "{", close: "}" },
+    { token: "delimiter.parenthesis", open: "(", close: ")" },
+    { token: "delimiter.square", open: "[", close: "]" },
+    { token: "delimiter.angle", open: "<", close: ">" }
+  ],
+  keywords: [
+    "abstract",
+    "amp",
+    "array",
+    "auto",
+    "bool",
+    "break",
+    "case",
+    "catch",
+    "char",
+    "class",
+    "const",
+    "constexpr",
+    "const_cast",
+    "continue",
+    "cpu",
+    "decltype",
+    "default",
+    "delegate",
+    "delete",
+    "do",
+    "double",
+    "dynamic_cast",
+    "each",
+    "else",
+    "enum",
+    "event",
+    "explicit",
+    "export",
+    "extern",
+    "false",
+    "final",
+    "finally",
+    "float",
+    "for",
+    "friend",
+    "gcnew",
+    "generic",
+    "goto",
+    "if",
+    "in",
+    "initonly",
+    "inline",
+    "int",
+    "interface",
+    "interior_ptr",
+    "internal",
+    "literal",
+    "long",
+    "mutable",
+    "namespace",
+    "new",
+    "noexcept",
+    "nullptr",
+    "__nullptr",
+    "operator",
+    "override",
+    "partial",
+    "pascal",
+    "pin_ptr",
+    "private",
+    "property",
+    "protected",
+    "public",
+    "ref",
+    "register",
+    "reinterpret_cast",
+    "restrict",
+    "return",
+    "safe_cast",
+    "sealed",
+    "short",
+    "signed",
+    "sizeof",
+    "static",
+    "static_assert",
+    "static_cast",
+    "struct",
+    "switch",
+    "template",
+    "this",
+    "thread_local",
+    "throw",
+    "tile_static",
+    "true",
+    "try",
+    "typedef",
+    "typeid",
+    "typename",
+    "union",
+    "unsigned",
+    "using",
+    "virtual",
+    "void",
+    "volatile",
+    "wchar_t",
+    "where",
+    "while",
+    "_asm",
+    // reserved word with one underscores
+    "_based",
+    "_cdecl",
+    "_declspec",
+    "_fastcall",
+    "_if_exists",
+    "_if_not_exists",
+    "_inline",
+    "_multiple_inheritance",
+    "_pascal",
+    "_single_inheritance",
+    "_stdcall",
+    "_virtual_inheritance",
+    "_w64",
+    "__abstract",
+    // reserved word with two underscores
+    "__alignof",
+    "__asm",
+    "__assume",
+    "__based",
+    "__box",
+    "__builtin_alignof",
+    "__cdecl",
+    "__clrcall",
+    "__declspec",
+    "__delegate",
+    "__event",
+    "__except",
+    "__fastcall",
+    "__finally",
+    "__forceinline",
+    "__gc",
+    "__hook",
+    "__identifier",
+    "__if_exists",
+    "__if_not_exists",
+    "__inline",
+    "__int128",
+    "__int16",
+    "__int32",
+    "__int64",
+    "__int8",
+    "__interface",
+    "__leave",
+    "__m128",
+    "__m128d",
+    "__m128i",
+    "__m256",
+    "__m256d",
+    "__m256i",
+    "__m512",
+    "__m512d",
+    "__m512i",
+    "__m64",
+    "__multiple_inheritance",
+    "__newslot",
+    "__nogc",
+    "__noop",
+    "__nounwind",
+    "__novtordisp",
+    "__pascal",
+    "__pin",
+    "__pragma",
+    "__property",
+    "__ptr32",
+    "__ptr64",
+    "__raise",
+    "__restrict",
+    "__resume",
+    "__sealed",
+    "__single_inheritance",
+    "__stdcall",
+    "__super",
+    "__thiscall",
+    "__try",
+    "__try_cast",
+    "__typeof",
+    "__unaligned",
+    "__unhook",
+    "__uuidof",
+    "__value",
+    "__virtual_inheritance",
+    "__w64",
+    "__wchar_t"
+  ],
+  operators: [
+    "=",
+    ">",
+    "<",
+    "!",
+    "~",
+    "?",
+    ":",
+    "==",
+    "<=",
+    ">=",
+    "!=",
+    "&&",
+    "||",
+    "++",
+    "--",
+    "+",
+    "-",
+    "*",
+    "/",
+    "&",
+    "|",
+    "^",
+    "%",
+    "<<",
+    ">>",
+    "+=",
+    "-=",
+    "*=",
+    "/=",
+    "&=",
+    "|=",
+    "^=",
+    "%=",
+    "<<=",
+    ">>="
+  ],
+  // we include these common regular expressions
+  symbols: /[=><!~?:&|+\-*\/\^%]+/,
+  escapes: /\\(?:[0abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  integersuffix: /([uU](ll|LL|l|L)|(ll|LL|l|L)?[uU]?)/,
+  floatsuffix: /[fFlL]?/,
+  encoding: /u|u8|U|L/,
+  // The main tokenizer for our languages
+  tokenizer: {
+    root: [
+      // C++ 11 Raw String
+      [/@encoding?R\"(?:([^ ()\\\t]*))\(/, { token: "string.raw.begin", next: "@raw.$1" }],
+      // identifiers and keywords
+      [
+        /[a-zA-Z_]\w*/,
+        {
+          cases: {
+            "@keywords": { token: "keyword.$0" },
+            "@default": "identifier"
+          }
+        }
+      ],
+      // The preprocessor checks must be before whitespace as they check /^\s*#/ which
+      // otherwise fails to match later after other whitespace has been removed.
+      // Inclusion
+      [/^\s*#\s*include/, { token: "keyword.directive.include", next: "@include" }],
+      // Preprocessor directive
+      [/^\s*#\s*\w+/, "keyword.directive"],
+      // whitespace
+      { include: "@whitespace" },
+      // [[ attributes ]].
+      [/\[\s*\[/, { token: "annotation", next: "@annotation" }],
+      // delimiters and operators
+      [/[{}()<>\[\]]/, "@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", "@linecomment"],
+      [/\/\/.*$/, "comment"]
+    ],
+    comment: [
+      [/[^\/*]+/, "comment"],
+      [/\*\//, "comment", "@pop"],
+      [/[\/*]/, "comment"]
+    ],
+    //For use with continuous line comments
+    linecomment: [
+      [/.*[^\\]$/, "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"]
+    ],
+    raw: [
+      [/[^)]+/, "string.raw"],
+      [/\)$S2\"/, { token: "string.raw.end", next: "@pop" }],
+      [/\)/, "string.raw"]
+    ],
+    annotation: [
+      { include: "@whitespace" },
+      [/using|alignas/, "keyword"],
+      [/[a-zA-Z0-9_]+/, "annotation"],
+      [/[,:]/, "delimiter"],
+      [/[()]/, "@brackets"],
+      [/\]\s*\]/, { token: "annotation", next: "@pop" }]
+    ],
+    include: [
+      [
+        /(\s*)(<)([^<>]*)(>)/,
+        [
+          "",
+          "keyword.directive.include.begin",
+          "string.include.identifier",
+          { token: "keyword.directive.include.end", next: "@pop" }
+        ]
+      ],
+      [
+        /(\s*)(")([^"]*)(")/,
+        [
+          "",
+          "keyword.directive.include.begin",
+          "string.include.identifier",
+          { token: "keyword.directive.include.end", next: "@pop" }
+        ]
+      ]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/csharp/csharp.contribution.d.ts

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

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

@@ -0,0 +1,24 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/csharp/csharp.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "csharp",
+  extensions: [".cs", ".csx", ".cake"],
+  aliases: ["C#", "csharp"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/csharp/csharp"], resolve, reject);
+      });
+    } else {
+      return import("./csharp.js");
+    }
+  }
+});

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

@@ -0,0 +1,336 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/csharp/csharp.ts
+var conf = {
+  wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\$\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+  comments: {
+    lineComment: "//",
+    blockComment: ["/*", "*/"]
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: "'", close: "'", notIn: ["string", "comment"] },
+    { open: '"', close: '"', notIn: ["string", "comment"] }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: "<", close: ">" },
+    { open: "'", close: "'" },
+    { open: '"', close: '"' }
+  ],
+  folding: {
+    markers: {
+      start: new RegExp("^\\s*#region\\b"),
+      end: new RegExp("^\\s*#endregion\\b")
+    }
+  }
+};
+var language = {
+  defaultToken: "",
+  tokenPostfix: ".cs",
+  brackets: [
+    { open: "{", close: "}", token: "delimiter.curly" },
+    { open: "[", close: "]", token: "delimiter.square" },
+    { open: "(", close: ")", token: "delimiter.parenthesis" },
+    { open: "<", close: ">", token: "delimiter.angle" }
+  ],
+  keywords: [
+    "extern",
+    "alias",
+    "using",
+    "bool",
+    "decimal",
+    "sbyte",
+    "byte",
+    "short",
+    "ushort",
+    "int",
+    "uint",
+    "long",
+    "ulong",
+    "char",
+    "float",
+    "double",
+    "object",
+    "dynamic",
+    "string",
+    "assembly",
+    "is",
+    "as",
+    "ref",
+    "out",
+    "this",
+    "base",
+    "new",
+    "typeof",
+    "void",
+    "checked",
+    "unchecked",
+    "default",
+    "delegate",
+    "var",
+    "const",
+    "if",
+    "else",
+    "switch",
+    "case",
+    "while",
+    "do",
+    "for",
+    "foreach",
+    "in",
+    "break",
+    "continue",
+    "goto",
+    "return",
+    "throw",
+    "try",
+    "catch",
+    "finally",
+    "lock",
+    "yield",
+    "from",
+    "let",
+    "where",
+    "join",
+    "on",
+    "equals",
+    "into",
+    "orderby",
+    "ascending",
+    "descending",
+    "select",
+    "group",
+    "by",
+    "namespace",
+    "partial",
+    "class",
+    "field",
+    "event",
+    "method",
+    "param",
+    "public",
+    "protected",
+    "internal",
+    "private",
+    "abstract",
+    "sealed",
+    "static",
+    "struct",
+    "readonly",
+    "volatile",
+    "virtual",
+    "override",
+    "params",
+    "get",
+    "set",
+    "add",
+    "remove",
+    "operator",
+    "true",
+    "false",
+    "implicit",
+    "explicit",
+    "interface",
+    "enum",
+    "null",
+    "async",
+    "await",
+    "fixed",
+    "sizeof",
+    "stackalloc",
+    "unsafe",
+    "nameof",
+    "when"
+  ],
+  namespaceFollows: ["namespace", "using"],
+  parenFollows: ["if", "for", "while", "switch", "foreach", "using", "catch", "when"],
+  operators: [
+    "=",
+    "??",
+    "||",
+    "&&",
+    "|",
+    "^",
+    "&",
+    "==",
+    "!=",
+    "<=",
+    ">=",
+    "<<",
+    "+",
+    "-",
+    "*",
+    "/",
+    "%",
+    "!",
+    "~",
+    "++",
+    "--",
+    "+=",
+    "-=",
+    "*=",
+    "/=",
+    "%=",
+    "&=",
+    "|=",
+    "^=",
+    "<<=",
+    ">>=",
+    ">>",
+    "=>"
+  ],
+  symbols: /[=><!~?:&|+\-*\/\^%]+/,
+  // escape sequences
+  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: [
+      // identifiers and keywords
+      [
+        /\@?[a-zA-Z_]\w*/,
+        {
+          cases: {
+            "@namespaceFollows": {
+              token: "keyword.$0",
+              next: "@namespace"
+            },
+            "@keywords": {
+              token: "keyword.$0",
+              next: "@qualified"
+            },
+            "@default": { token: "identifier", next: "@qualified" }
+          }
+        }
+      ],
+      // whitespace
+      { include: "@whitespace" },
+      // delimiters and operators
+      [
+        /}/,
+        {
+          cases: {
+            "$S2==interpolatedstring": {
+              token: "string.quote",
+              next: "@pop"
+            },
+            "$S2==litinterpstring": {
+              token: "string.quote",
+              next: "@pop"
+            },
+            "@default": "@brackets"
+          }
+        }
+      ],
+      [/[{}()\[\]]/, "@brackets"],
+      [/[<>](?!@symbols)/, "@brackets"],
+      [
+        /@symbols/,
+        {
+          cases: {
+            "@operators": "delimiter",
+            "@default": ""
+          }
+        }
+      ],
+      // numbers
+      [/[0-9_]*\.[0-9_]+([eE][\-+]?\d+)?[fFdD]?/, "number.float"],
+      [/0[xX][0-9a-fA-F_]+/, "number.hex"],
+      [/0[bB][01_]+/, "number.hex"],
+      // binary: use same theme style as hex
+      [/[0-9_]+/, "number"],
+      // delimiter: after number because of .\d floats
+      [/[;,.]/, "delimiter"],
+      // strings
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
+      [/"/, { token: "string.quote", next: "@string" }],
+      [/\$\@"/, { token: "string.quote", next: "@litinterpstring" }],
+      [/\@"/, { token: "string.quote", next: "@litstring" }],
+      [/\$"/, { token: "string.quote", next: "@interpolatedstring" }],
+      // characters
+      [/'[^\\']'/, "string"],
+      [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+      [/'/, "string.invalid"]
+    ],
+    qualified: [
+      [
+        /[a-zA-Z_][\w]*/,
+        {
+          cases: {
+            "@keywords": { token: "keyword.$0" },
+            "@default": "identifier"
+          }
+        }
+      ],
+      [/\./, "delimiter"],
+      ["", "", "@pop"]
+    ],
+    namespace: [
+      { include: "@whitespace" },
+      [/[A-Z]\w*/, "namespace"],
+      [/[\.=]/, "delimiter"],
+      ["", "", "@pop"]
+    ],
+    comment: [
+      [/[^\/*]+/, "comment"],
+      // [/\/\*/,    'comment', '@push' ],    // no nested comments :-(
+      ["\\*/", "comment", "@pop"],
+      [/[\/*]/, "comment"]
+    ],
+    string: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/"/, { token: "string.quote", next: "@pop" }]
+    ],
+    litstring: [
+      [/[^"]+/, "string"],
+      [/""/, "string.escape"],
+      [/"/, { token: "string.quote", next: "@pop" }]
+    ],
+    litinterpstring: [
+      [/[^"{]+/, "string"],
+      [/""/, "string.escape"],
+      [/{{/, "string.escape"],
+      [/}}/, "string.escape"],
+      [/{/, { token: "string.quote", next: "root.litinterpstring" }],
+      [/"/, { token: "string.quote", next: "@pop" }]
+    ],
+    interpolatedstring: [
+      [/[^\\"{]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/{{/, "string.escape"],
+      [/}}/, "string.escape"],
+      [/{/, { token: "string.quote", next: "root.interpolatedstring" }],
+      [/"/, { token: "string.quote", next: "@pop" }]
+    ],
+    whitespace: [
+      [/^[ \t\v\f]*#((r)|(load))(?=\s)/, "directive.csx"],
+      [/^[ \t\v\f]*#\w.*$/, "namespace.cpp"],
+      [/[ \t\v\f\r\n]+/, ""],
+      [/\/\*/, "comment", "@comment"],
+      [/\/\/.*$/, "comment"]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/csp/csp.contribution.d.ts

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

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

@@ -0,0 +1,24 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/csp/csp.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "csp",
+  extensions: [".csp"],
+  aliases: ["CSP", "csp"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/csp/csp"], resolve, reject);
+      });
+    } else {
+      return import("./csp.js");
+    }
+  }
+});

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

@@ -0,0 +1,63 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/csp/csp.ts
+var conf = {
+  brackets: [],
+  autoClosingPairs: [],
+  surroundingPairs: []
+};
+var language = {
+  // Set defaultToken to invalid to see what you do not tokenize yet
+  // defaultToken: 'invalid',
+  keywords: [],
+  typeKeywords: [],
+  tokenPostfix: ".csp",
+  operators: [],
+  symbols: /[=><!~?:&|+\-*\/\^%]+/,
+  escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  tokenizer: {
+    root: [
+      [/child-src/, "string.quote"],
+      [/connect-src/, "string.quote"],
+      [/default-src/, "string.quote"],
+      [/font-src/, "string.quote"],
+      [/frame-src/, "string.quote"],
+      [/img-src/, "string.quote"],
+      [/manifest-src/, "string.quote"],
+      [/media-src/, "string.quote"],
+      [/object-src/, "string.quote"],
+      [/script-src/, "string.quote"],
+      [/style-src/, "string.quote"],
+      [/worker-src/, "string.quote"],
+      [/base-uri/, "string.quote"],
+      [/plugin-types/, "string.quote"],
+      [/sandbox/, "string.quote"],
+      [/disown-opener/, "string.quote"],
+      [/form-action/, "string.quote"],
+      [/frame-ancestors/, "string.quote"],
+      [/report-uri/, "string.quote"],
+      [/report-to/, "string.quote"],
+      [/upgrade-insecure-requests/, "string.quote"],
+      [/block-all-mixed-content/, "string.quote"],
+      [/require-sri-for/, "string.quote"],
+      [/reflected-xss/, "string.quote"],
+      [/referrer/, "string.quote"],
+      [/policy-uri/, "string.quote"],
+      [/'self'/, "string.quote"],
+      [/'unsafe-inline'/, "string.quote"],
+      [/'unsafe-eval'/, "string.quote"],
+      [/'strict-dynamic'/, "string.quote"],
+      [/'unsafe-hashed-attributes'/, "string.quote"]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/css/css.contribution.d.ts

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

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

@@ -0,0 +1,25 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/css/css.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "css",
+  extensions: [".css"],
+  aliases: ["CSS", "css"],
+  mimetypes: ["text/css"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/css/css"], resolve, reject);
+      });
+    } else {
+      return import("./css.js");
+    }
+  }
+});

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

@@ -0,0 +1,195 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/css/css.ts
+var conf = {
+  wordPattern: /(#?-?\d*\.\d\w*%?)|((::|[@#.!:])?[\w-?]+%?)|::|[@#.!:]/g,
+  comments: {
+    blockComment: ["/*", "*/"]
+  },
+  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: ".css",
+  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.bracket" },
+    { 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: "@strings" },
+      [
+        "[@](keyframes|-webkit-keyframes|-moz-keyframes|-o-keyframes)",
+        { token: "keyword", next: "@keyframedeclaration" }
+      ],
+      ["[@](page|content|font-face|-moz-document)", { token: "keyword" }],
+      ["[@](charset|namespace)", { token: "keyword", next: "@declarationbody" }],
+      [
+        "(url-prefix)(\\()",
+        ["attribute.value", { token: "delimiter.parenthesis", next: "@urldeclaration" }]
+      ],
+      [
+        "(url)(\\()",
+        ["attribute.value", { token: "delimiter.parenthesis", next: "@urldeclaration" }]
+      ],
+      { include: "@selectorname" },
+      ["[\\*]", "tag"],
+      // selector symbols
+      ["[>\\+,]", "delimiter"],
+      // selector operators
+      ["\\[", { token: "delimiter.bracket", next: "@selectorattribute" }],
+      ["{", { token: "delimiter.bracket", next: "@selectorbody" }]
+    ],
+    selectorbody: [
+      { include: "@comments" },
+      ["[*_]?@identifier@ws:(?=(\\s|\\d|[^{;}]*[;}]))", "attribute.name", "@rulevalue"],
+      // rule definition: to distinguish from a nested selector check for whitespace, number or a semicolon
+      ["}", { token: "delimiter.bracket", next: "@pop" }]
+    ],
+    selectorname: [
+      ["(\\.|#(?=[^{])|%|(@identifier)|:)+", "tag"]
+      // selector (.foo, div, ...)
+    ],
+    selectorattribute: [{ include: "@term" }, ["]", { token: "delimiter.bracket", next: "@pop" }]],
+    term: [
+      { include: "@comments" },
+      [
+        "(url-prefix)(\\()",
+        ["attribute.value", { token: "delimiter.parenthesis", next: "@urldeclaration" }]
+      ],
+      [
+        "(url)(\\()",
+        ["attribute.value", { token: "delimiter.parenthesis", next: "@urldeclaration" }]
+      ],
+      { include: "@functioninvocation" },
+      { include: "@numbers" },
+      { include: "@name" },
+      { include: "@strings" },
+      ["([<>=\\+\\-\\*\\/\\^\\|\\~,])", "delimiter"],
+      [",", "delimiter"]
+    ],
+    rulevalue: [
+      { include: "@comments" },
+      { include: "@strings" },
+      { include: "@term" },
+      ["!important", "keyword"],
+      [";", "delimiter", "@pop"],
+      ["(?=})", { token: "", next: "@pop" }]
+      // missing semicolon
+    ],
+    warndebug: [["[@](warn|debug)", { token: "keyword", next: "@declarationbody" }]],
+    import: [["[@](import)", { token: "keyword", next: "@declarationbody" }]],
+    urldeclaration: [
+      { include: "@strings" },
+      ["[^)\r\n]+", "string"],
+      ["\\)", { token: "delimiter.parenthesis", next: "@pop" }]
+    ],
+    parenthizedterm: [
+      { include: "@term" },
+      ["\\)", { token: "delimiter.parenthesis", next: "@pop" }]
+    ],
+    declarationbody: [
+      { include: "@term" },
+      [";", "delimiter", "@pop"],
+      ["(?=})", { token: "", next: "@pop" }]
+      // missing semicolon
+    ],
+    comments: [
+      ["\\/\\*", "comment", "@comment"],
+      ["\\/\\/+.*", "comment"]
+    ],
+    comment: [
+      ["\\*\\/", "comment", "@pop"],
+      [/[^*/]+/, "comment"],
+      [/./, "comment"]
+    ],
+    name: [["@identifier", "attribute.value"]],
+    numbers: [
+      ["-?(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?", { token: "attribute.value.number", next: "@units" }],
+      ["#[0-9a-fA-F_]+(?!\\w)", "attribute.value.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|%)?",
+        "attribute.value.unit",
+        "@pop"
+      ]
+    ],
+    keyframedeclaration: [
+      ["@identifier", "attribute.value"],
+      ["{", { token: "delimiter.bracket", switchTo: "@keyframebody" }]
+    ],
+    keyframebody: [
+      { include: "@term" },
+      ["{", { token: "delimiter.bracket", next: "@selectorbody" }],
+      ["}", { token: "delimiter.bracket", next: "@pop" }]
+    ],
+    functioninvocation: [
+      ["@identifier\\(", { token: "attribute.value", next: "@functionarguments" }]
+    ],
+    functionarguments: [
+      ["\\$@identifier@ws:", "attribute.name"],
+      ["[,]", "delimiter"],
+      { include: "@term" },
+      ["\\)", { token: "attribute.value", next: "@pop" }]
+    ],
+    strings: [
+      ['~?"', { token: "string", next: "@stringenddoublequote" }],
+      ["~?'", { token: "string", next: "@stringendquote" }]
+    ],
+    stringenddoublequote: [
+      ["\\\\.", "string"],
+      ['"', { token: "string", next: "@pop" }],
+      [/[^\\"]+/, "string"],
+      [".", "string"]
+    ],
+    stringendquote: [
+      ["\\\\.", "string"],
+      ["'", { token: "string", next: "@pop" }],
+      [/[^\\']+/, "string"],
+      [".", "string"]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/cypher/cypher.contribution.d.ts

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

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

@@ -0,0 +1,24 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/cypher/cypher.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "cypher",
+  extensions: [".cypher", ".cyp"],
+  aliases: ["Cypher", "OpenCypher"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/cypher/cypher"], resolve, reject);
+      });
+    } else {
+      return import("./cypher.js");
+    }
+  }
+});

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

@@ -0,0 +1,273 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/cypher/cypher.ts
+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: `.cypher`,
+  ignoreCase: true,
+  brackets: [
+    { open: "{", close: "}", token: "delimiter.curly" },
+    { open: "[", close: "]", token: "delimiter.bracket" },
+    { open: "(", close: ")", token: "delimiter.parenthesis" }
+  ],
+  keywords: [
+    "ALL",
+    "AND",
+    "AS",
+    "ASC",
+    "ASCENDING",
+    "BY",
+    "CALL",
+    "CASE",
+    "CONTAINS",
+    "CREATE",
+    "DELETE",
+    "DESC",
+    "DESCENDING",
+    "DETACH",
+    "DISTINCT",
+    "ELSE",
+    "END",
+    "ENDS",
+    "EXISTS",
+    "IN",
+    "IS",
+    "LIMIT",
+    "MANDATORY",
+    "MATCH",
+    "MERGE",
+    "NOT",
+    "ON",
+    "ON",
+    "OPTIONAL",
+    "OR",
+    "ORDER",
+    "REMOVE",
+    "RETURN",
+    "SET",
+    "SKIP",
+    "STARTS",
+    "THEN",
+    "UNION",
+    "UNWIND",
+    "WHEN",
+    "WHERE",
+    "WITH",
+    "XOR",
+    "YIELD"
+  ],
+  builtinLiterals: ["true", "TRUE", "false", "FALSE", "null", "NULL"],
+  builtinFunctions: [
+    "abs",
+    "acos",
+    "asin",
+    "atan",
+    "atan2",
+    "avg",
+    "ceil",
+    "coalesce",
+    "collect",
+    "cos",
+    "cot",
+    "count",
+    "degrees",
+    "e",
+    "endNode",
+    "exists",
+    "exp",
+    "floor",
+    "head",
+    "id",
+    "keys",
+    "labels",
+    "last",
+    "left",
+    "length",
+    "log",
+    "log10",
+    "lTrim",
+    "max",
+    "min",
+    "nodes",
+    "percentileCont",
+    "percentileDisc",
+    "pi",
+    "properties",
+    "radians",
+    "rand",
+    "range",
+    "relationships",
+    "replace",
+    "reverse",
+    "right",
+    "round",
+    "rTrim",
+    "sign",
+    "sin",
+    "size",
+    "split",
+    "sqrt",
+    "startNode",
+    "stDev",
+    "stDevP",
+    "substring",
+    "sum",
+    "tail",
+    "tan",
+    "timestamp",
+    "toBoolean",
+    "toFloat",
+    "toInteger",
+    "toLower",
+    "toString",
+    "toUpper",
+    "trim",
+    "type"
+  ],
+  operators: [
+    // Math operators
+    "+",
+    "-",
+    "*",
+    "/",
+    "%",
+    "^",
+    // Comparison operators
+    "=",
+    "<>",
+    "<",
+    ">",
+    "<=",
+    ">=",
+    // Pattern operators
+    "->",
+    "<-",
+    "-->",
+    "<--"
+  ],
+  escapes: /\\(?:[tbnrf\\"'`]|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  digits: /\d+/,
+  octaldigits: /[0-7]+/,
+  hexdigits: /[0-9a-fA-F]+/,
+  tokenizer: {
+    root: [[/[{}[\]()]/, "@brackets"], { include: "common" }],
+    common: [
+      { include: "@whitespace" },
+      { include: "@numbers" },
+      { include: "@strings" },
+      // Cypher labels on nodes/relationships, e.g. (n:NodeLabel)-[e:RelationshipLabel]
+      [/:[a-zA-Z_][\w]*/, "type.identifier"],
+      [
+        /[a-zA-Z_][\w]*(?=\()/,
+        {
+          cases: {
+            "@builtinFunctions": "predefined.function"
+          }
+        }
+      ],
+      [
+        /[a-zA-Z_$][\w$]*/,
+        {
+          cases: {
+            "@keywords": "keyword",
+            "@builtinLiterals": "predefined.literal",
+            "@default": "identifier"
+          }
+        }
+      ],
+      [/`/, "identifier.escape", "@identifierBacktick"],
+      // delimiter and operator after number because of `.\d` floats and `:` in labels
+      [/[;,.:|]/, "delimiter"],
+      [
+        /[<>=%+\-*/^]+/,
+        {
+          cases: {
+            "@operators": "delimiter",
+            "@default": ""
+          }
+        }
+      ]
+    ],
+    numbers: [
+      [/-?(@digits)[eE](-?(@digits))?/, "number.float"],
+      [/-?(@digits)?\.(@digits)([eE]-?(@digits))?/, "number.float"],
+      [/-?0x(@hexdigits)/, "number.hex"],
+      [/-?0(@octaldigits)/, "number.octal"],
+      [/-?(@digits)/, "number"]
+    ],
+    strings: [
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
+      [/'([^'\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
+      [/"/, "string", "@stringDouble"],
+      [/'/, "string", "@stringSingle"]
+    ],
+    whitespace: [
+      [/[ \t\r\n]+/, "white"],
+      [/\/\*/, "comment", "@comment"],
+      [/\/\/.*$/, "comment"]
+    ],
+    comment: [
+      [/\/\/.*/, "comment"],
+      [/[^/*]+/, "comment"],
+      [/\*\//, "comment", "@pop"],
+      [/[/*]/, "comment"]
+    ],
+    stringDouble: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string"],
+      [/\\./, "string.invalid"],
+      [/"/, "string", "@pop"]
+    ],
+    stringSingle: [
+      [/[^\\']+/, "string"],
+      [/@escapes/, "string"],
+      [/\\./, "string.invalid"],
+      [/'/, "string", "@pop"]
+    ],
+    identifierBacktick: [
+      [/[^\\`]+/, "identifier.escape"],
+      [/@escapes/, "identifier.escape"],
+      [/\\./, "identifier.escape.invalid"],
+      [/`/, "identifier.escape", "@pop"]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/dart/dart.contribution.d.ts

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

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

@@ -0,0 +1,25 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/dart/dart.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "dart",
+  extensions: [".dart"],
+  aliases: ["Dart", "dart"],
+  mimetypes: ["text/x-dart-source", "text/x-dart"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/dart/dart"], resolve, reject);
+      });
+    } else {
+      return import("./dart.js");
+    }
+  }
+});

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

@@ -0,0 +1,291 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/dart/dart.ts
+var conf = {
+  comments: {
+    lineComment: "//",
+    blockComment: ["/*", "*/"]
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: "'", close: "'", notIn: ["string", "comment"] },
+    { open: '"', close: '"', notIn: ["string"] },
+    { open: "`", close: "`", notIn: ["string", "comment"] },
+    { open: "/**", close: " */", notIn: ["string"] }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: "<", close: ">" },
+    { open: "'", close: "'" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "`", close: "`" }
+  ],
+  folding: {
+    markers: {
+      start: /^\s*\s*#?region\b/,
+      end: /^\s*\s*#?endregion\b/
+    }
+  }
+};
+var language = {
+  defaultToken: "invalid",
+  tokenPostfix: ".dart",
+  keywords: [
+    "abstract",
+    "dynamic",
+    "implements",
+    "show",
+    "as",
+    "else",
+    "import",
+    "static",
+    "assert",
+    "enum",
+    "in",
+    "super",
+    "async",
+    "export",
+    "interface",
+    "switch",
+    "await",
+    "extends",
+    "is",
+    "sync",
+    "break",
+    "external",
+    "library",
+    "this",
+    "case",
+    "factory",
+    "mixin",
+    "throw",
+    "catch",
+    "false",
+    "new",
+    "true",
+    "class",
+    "final",
+    "null",
+    "try",
+    "const",
+    "finally",
+    "on",
+    "typedef",
+    "continue",
+    "for",
+    "operator",
+    "var",
+    "covariant",
+    "Function",
+    "part",
+    "void",
+    "default",
+    "get",
+    "rethrow",
+    "while",
+    "deferred",
+    "hide",
+    "return",
+    "with",
+    "do",
+    "if",
+    "set",
+    "yield"
+  ],
+  typeKeywords: ["int", "double", "String", "bool"],
+  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: {
+            "@typeKeywords": "type.identifier",
+            "@keywords": "keyword",
+            "@default": "identifier"
+          }
+        }
+      ],
+      [/[A-Z_$][\w\$]*/, "type.identifier"],
+      // show class names
+      // [/[A-Z][\w\$]*/, 'identifier'],
+      // whitespace
+      { include: "@whitespace" },
+      // regular expression: ensure it is terminated before beginning (otherwise it is an opeator)
+      [
+        /\/(?=([^\\\/]|\\.)+\/([gimsuy]*)(\s*)(\.|;|,|\)|\]|\}|$))/,
+        { token: "regexp", bracket: "@open", next: "@regexp" }
+      ],
+      // @ annotations.
+      [/@[a-zA-Z]+/, "annotation"],
+      // variable
+      // 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"]
+      //   [/[a-zA-Z]+/, "variable"]
+    ],
+    whitespace: [
+      [/[ \t\r\n]+/, ""],
+      [/\/\*\*(?!\/)/, "comment.doc", "@jsdoc"],
+      [/\/\*/, "comment", "@comment"],
+      [/\/\/\/.*$/, "comment.doc"],
+      [/\/\/.*$/, "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"],
+      [/(\/)([gimsuy]*)/, [{ 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"],
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/"/, "string", "@pop"],
+      [/\$\w+/, "identifier"]
+    ],
+    string_single: [
+      [/[^\\'\$]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/'/, "string", "@pop"],
+      [/\$\w+/, "identifier"]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/dockerfile/dockerfile.contribution.d.ts

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

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

@@ -0,0 +1,25 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/dockerfile/dockerfile.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "dockerfile",
+  extensions: [".dockerfile"],
+  filenames: ["Dockerfile"],
+  aliases: ["Dockerfile"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/dockerfile/dockerfile"], resolve, reject);
+      });
+    } else {
+      return import("./dockerfile.js");
+    }
+  }
+});

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

@@ -0,0 +1,140 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/dockerfile/dockerfile.ts
+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 = {
+  defaultToken: "",
+  tokenPostfix: ".dockerfile",
+  variable: /\${?[\w]+}?/,
+  tokenizer: {
+    root: [
+      { include: "@whitespace" },
+      { include: "@comment" },
+      [/(ONBUILD)(\s+)/, ["keyword", ""]],
+      [/(ENV)(\s+)([\w]+)/, ["keyword", "", { token: "variable", next: "@arguments" }]],
+      [
+        /(FROM|MAINTAINER|RUN|EXPOSE|ENV|ADD|ARG|VOLUME|LABEL|USER|WORKDIR|COPY|CMD|STOPSIGNAL|SHELL|HEALTHCHECK|ENTRYPOINT)/,
+        { token: "keyword", next: "@arguments" }
+      ]
+    ],
+    arguments: [
+      { include: "@whitespace" },
+      { include: "@strings" },
+      [
+        /(@variable)/,
+        {
+          cases: {
+            "@eos": { token: "variable", next: "@popall" },
+            "@default": "variable"
+          }
+        }
+      ],
+      [
+        /\\/,
+        {
+          cases: {
+            "@eos": "",
+            "@default": ""
+          }
+        }
+      ],
+      [
+        /./,
+        {
+          cases: {
+            "@eos": { token: "", next: "@popall" },
+            "@default": ""
+          }
+        }
+      ]
+    ],
+    // Deal with white space, including comments
+    whitespace: [
+      [
+        /\s+/,
+        {
+          cases: {
+            "@eos": { token: "", next: "@popall" },
+            "@default": ""
+          }
+        }
+      ]
+    ],
+    comment: [[/(^#.*$)/, "comment", "@popall"]],
+    // Recognize strings, including those broken across lines with \ (but not without)
+    strings: [
+      [/\\'$/, "", "@popall"],
+      // \' leaves @arguments at eol
+      [/\\'/, ""],
+      // \' is not a string
+      [/'$/, "string", "@popall"],
+      [/'/, "string", "@stringBody"],
+      [/"$/, "string", "@popall"],
+      [/"/, "string", "@dblStringBody"]
+    ],
+    stringBody: [
+      [
+        /[^\\\$']/,
+        {
+          cases: {
+            "@eos": { token: "string", next: "@popall" },
+            "@default": "string"
+          }
+        }
+      ],
+      [/\\./, "string.escape"],
+      [/'$/, "string", "@popall"],
+      [/'/, "string", "@pop"],
+      [/(@variable)/, "variable"],
+      [/\\$/, "string"],
+      [/$/, "string", "@popall"]
+    ],
+    dblStringBody: [
+      [
+        /[^\\\$"]/,
+        {
+          cases: {
+            "@eos": { token: "string", next: "@popall" },
+            "@default": "string"
+          }
+        }
+      ],
+      [/\\./, "string.escape"],
+      [/"$/, "string", "@popall"],
+      [/"/, "string", "@pop"],
+      [/(@variable)/, "variable"],
+      [/\\$/, "string"],
+      [/$/, "string", "@popall"]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/ecl/ecl.contribution.d.ts

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

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

@@ -0,0 +1,24 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/ecl/ecl.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "ecl",
+  extensions: [".ecl"],
+  aliases: ["ECL", "Ecl", "ecl"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/ecl/ecl"], resolve, reject);
+      });
+    } else {
+      return import("./ecl.js");
+    }
+  }
+});

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

@@ -0,0 +1,466 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/ecl/ecl.ts
+var conf = {
+  comments: {
+    lineComment: "//",
+    blockComment: ["/*", "*/"]
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: "'", close: "'", notIn: ["string", "comment"] },
+    { open: '"', close: '"', notIn: ["string", "comment"] }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: "<", close: ">" },
+    { open: "'", close: "'" },
+    { open: '"', close: '"' }
+  ]
+};
+var language = {
+  defaultToken: "",
+  tokenPostfix: ".ecl",
+  ignoreCase: true,
+  brackets: [
+    { open: "{", close: "}", token: "delimiter.curly" },
+    { open: "[", close: "]", token: "delimiter.square" },
+    { open: "(", close: ")", token: "delimiter.parenthesis" },
+    { open: "<", close: ">", token: "delimiter.angle" }
+  ],
+  pounds: [
+    "append",
+    "break",
+    "declare",
+    "demangle",
+    "end",
+    "for",
+    "getdatatype",
+    "if",
+    "inmodule",
+    "loop",
+    "mangle",
+    "onwarning",
+    "option",
+    "set",
+    "stored",
+    "uniquename"
+  ].join("|"),
+  keywords: [
+    "__compressed__",
+    "after",
+    "all",
+    "and",
+    "any",
+    "as",
+    "atmost",
+    "before",
+    "beginc",
+    "best",
+    "between",
+    "case",
+    "cluster",
+    "compressed",
+    "compression",
+    "const",
+    "counter",
+    "csv",
+    "default",
+    "descend",
+    "embed",
+    "encoding",
+    "encrypt",
+    "end",
+    "endc",
+    "endembed",
+    "endmacro",
+    "enum",
+    "escape",
+    "except",
+    "exclusive",
+    "expire",
+    "export",
+    "extend",
+    "fail",
+    "few",
+    "fileposition",
+    "first",
+    "flat",
+    "forward",
+    "from",
+    "full",
+    "function",
+    "functionmacro",
+    "group",
+    "grouped",
+    "heading",
+    "hole",
+    "ifblock",
+    "import",
+    "in",
+    "inner",
+    "interface",
+    "internal",
+    "joined",
+    "keep",
+    "keyed",
+    "last",
+    "left",
+    "limit",
+    "linkcounted",
+    "literal",
+    "little_endian",
+    "load",
+    "local",
+    "locale",
+    "lookup",
+    "lzw",
+    "macro",
+    "many",
+    "maxcount",
+    "maxlength",
+    "min skew",
+    "module",
+    "mofn",
+    "multiple",
+    "named",
+    "namespace",
+    "nocase",
+    "noroot",
+    "noscan",
+    "nosort",
+    "not",
+    "noxpath",
+    "of",
+    "onfail",
+    "only",
+    "opt",
+    "or",
+    "outer",
+    "overwrite",
+    "packed",
+    "partition",
+    "penalty",
+    "physicallength",
+    "pipe",
+    "prefetch",
+    "quote",
+    "record",
+    "repeat",
+    "retry",
+    "return",
+    "right",
+    "right1",
+    "right2",
+    "rows",
+    "rowset",
+    "scan",
+    "scope",
+    "self",
+    "separator",
+    "service",
+    "shared",
+    "skew",
+    "skip",
+    "smart",
+    "soapaction",
+    "sql",
+    "stable",
+    "store",
+    "terminator",
+    "thor",
+    "threshold",
+    "timelimit",
+    "timeout",
+    "token",
+    "transform",
+    "trim",
+    "type",
+    "unicodeorder",
+    "unordered",
+    "unsorted",
+    "unstable",
+    "update",
+    "use",
+    "validate",
+    "virtual",
+    "whole",
+    "width",
+    "wild",
+    "within",
+    "wnotrim",
+    "xml",
+    "xpath"
+  ],
+  functions: [
+    "abs",
+    "acos",
+    "aggregate",
+    "allnodes",
+    "apply",
+    "ascii",
+    "asin",
+    "assert",
+    "asstring",
+    "atan",
+    "atan2",
+    "ave",
+    "build",
+    "buildindex",
+    "case",
+    "catch",
+    "choose",
+    "choosen",
+    "choosesets",
+    "clustersize",
+    "combine",
+    "correlation",
+    "cos",
+    "cosh",
+    "count",
+    "covariance",
+    "cron",
+    "dataset",
+    "dedup",
+    "define",
+    "denormalize",
+    "dictionary",
+    "distribute",
+    "distributed",
+    "distribution",
+    "ebcdic",
+    "enth",
+    "error",
+    "evaluate",
+    "event",
+    "eventextra",
+    "eventname",
+    "exists",
+    "exp",
+    "fail",
+    "failcode",
+    "failmessage",
+    "fetch",
+    "fromunicode",
+    "fromxml",
+    "getenv",
+    "getisvalid",
+    "global",
+    "graph",
+    "group",
+    "hash",
+    "hash32",
+    "hash64",
+    "hashcrc",
+    "hashmd5",
+    "having",
+    "httpcall",
+    "httpheader",
+    "if",
+    "iff",
+    "index",
+    "intformat",
+    "isvalid",
+    "iterate",
+    "join",
+    "keydiff",
+    "keypatch",
+    "keyunicode",
+    "length",
+    "library",
+    "limit",
+    "ln",
+    "loadxml",
+    "local",
+    "log",
+    "loop",
+    "map",
+    "matched",
+    "matchlength",
+    "matchposition",
+    "matchtext",
+    "matchunicode",
+    "max",
+    "merge",
+    "mergejoin",
+    "min",
+    "nofold",
+    "nolocal",
+    "nonempty",
+    "normalize",
+    "nothor",
+    "notify",
+    "output",
+    "parallel",
+    "parse",
+    "pipe",
+    "power",
+    "preload",
+    "process",
+    "project",
+    "pull",
+    "random",
+    "range",
+    "rank",
+    "ranked",
+    "realformat",
+    "recordof",
+    "regexfind",
+    "regexreplace",
+    "regroup",
+    "rejected",
+    "rollup",
+    "round",
+    "roundup",
+    "row",
+    "rowdiff",
+    "sample",
+    "sequential",
+    "set",
+    "sin",
+    "sinh",
+    "sizeof",
+    "soapcall",
+    "sort",
+    "sorted",
+    "sqrt",
+    "stepped",
+    "stored",
+    "sum",
+    "table",
+    "tan",
+    "tanh",
+    "thisnode",
+    "topn",
+    "tounicode",
+    "toxml",
+    "transfer",
+    "transform",
+    "trim",
+    "truncate",
+    "typeof",
+    "ungroup",
+    "unicodeorder",
+    "variance",
+    "wait",
+    "which",
+    "workunit",
+    "xmldecode",
+    "xmlencode",
+    "xmltext",
+    "xmlunicode"
+  ],
+  typesint: ["integer", "unsigned"].join("|"),
+  typesnum: ["data", "qstring", "string", "unicode", "utf8", "varstring", "varunicode"],
+  typesone: [
+    "ascii",
+    "big_endian",
+    "boolean",
+    "data",
+    "decimal",
+    "ebcdic",
+    "grouped",
+    "integer",
+    "linkcounted",
+    "pattern",
+    "qstring",
+    "real",
+    "record",
+    "rule",
+    "set of",
+    "streamed",
+    "string",
+    "token",
+    "udecimal",
+    "unicode",
+    "unsigned",
+    "utf8",
+    "varstring",
+    "varunicode"
+  ].join("|"),
+  operators: ["+", "-", "/", ":=", "<", "<>", "=", ">", "\\", "and", "in", "not", "or"],
+  symbols: /[=><!~?:&|+\-*\/\^%]+/,
+  // escape sequences
+  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: [
+      [/@typesint[4|8]/, "type"],
+      [/#(@pounds)/, "type"],
+      [/@typesone/, "type"],
+      [
+        /[a-zA-Z_$][\w-$]*/,
+        {
+          cases: {
+            "@functions": "keyword.function",
+            "@keywords": "keyword",
+            "@operators": "operator"
+          }
+        }
+      ],
+      // whitespace
+      { include: "@whitespace" },
+      [/[{}()\[\]]/, "@brackets"],
+      [/[<>](?!@symbols)/, "@brackets"],
+      [
+        /@symbols/,
+        {
+          cases: {
+            "@operators": "delimiter",
+            "@default": ""
+          }
+        }
+      ],
+      // numbers
+      [/[0-9_]*\.[0-9_]+([eE][\-+]?\d+)?/, "number.float"],
+      [/0[xX][0-9a-fA-F_]+/, "number.hex"],
+      [/0[bB][01]+/, "number.hex"],
+      // binary: use same theme style as hex
+      [/[0-9_]+/, "number"],
+      // delimiter: after number because of .\d floats
+      [/[;,.]/, "delimiter"],
+      // strings
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      [/"/, "string", "@string"],
+      // characters
+      [/'[^\\']'/, "string"],
+      [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+      [/'/, "string.invalid"]
+    ],
+    whitespace: [
+      [/[ \t\v\f\r\n]+/, ""],
+      [/\/\*/, "comment", "@comment"],
+      [/\/\/.*$/, "comment"]
+    ],
+    comment: [
+      [/[^\/*]+/, "comment"],
+      [/\*\//, "comment", "@pop"],
+      [/[\/*]/, "comment"]
+    ],
+    string: [
+      [/[^\\']+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/'/, "string", "@pop"]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/elixir/elixir.contribution.d.ts

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

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

@@ -0,0 +1,24 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/elixir/elixir.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "elixir",
+  extensions: [".ex", ".exs"],
+  aliases: ["Elixir", "elixir", "ex"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/elixir/elixir"], resolve, reject);
+      });
+    } else {
+      return import("./elixir.js");
+    }
+  }
+});

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

@@ -0,0 +1,579 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/elixir/elixir.ts
+var conf = {
+  comments: {
+    lineComment: "#"
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: "'", close: "'" },
+    { open: '"', close: '"' }
+  ],
+  autoClosingPairs: [
+    { open: "'", close: "'", notIn: ["string", "comment"] },
+    { open: '"', close: '"', notIn: ["comment"] },
+    { open: '"""', close: '"""' },
+    { open: "`", close: "`", notIn: ["string", "comment"] },
+    { open: "(", close: ")" },
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "<<", close: ">>" }
+  ],
+  indentationRules: {
+    increaseIndentPattern: /^\s*(after|else|catch|rescue|fn|[^#]*(do|<\-|\->|\{|\[|\=))\s*$/,
+    decreaseIndentPattern: /^\s*((\}|\])\s*$|(after|else|catch|rescue|end)\b)/
+  }
+};
+var language = {
+  defaultToken: "source",
+  tokenPostfix: ".elixir",
+  brackets: [
+    { open: "[", close: "]", token: "delimiter.square" },
+    { open: "(", close: ")", token: "delimiter.parenthesis" },
+    { open: "{", close: "}", token: "delimiter.curly" },
+    { open: "<<", close: ">>", token: "delimiter.angle.special" }
+  ],
+  // Below are lists/regexps to which we reference later.
+  declarationKeywords: [
+    "def",
+    "defp",
+    "defn",
+    "defnp",
+    "defguard",
+    "defguardp",
+    "defmacro",
+    "defmacrop",
+    "defdelegate",
+    "defcallback",
+    "defmacrocallback",
+    "defmodule",
+    "defprotocol",
+    "defexception",
+    "defimpl",
+    "defstruct"
+  ],
+  operatorKeywords: ["and", "in", "not", "or", "when"],
+  namespaceKeywords: ["alias", "import", "require", "use"],
+  otherKeywords: [
+    "after",
+    "case",
+    "catch",
+    "cond",
+    "do",
+    "else",
+    "end",
+    "fn",
+    "for",
+    "if",
+    "quote",
+    "raise",
+    "receive",
+    "rescue",
+    "super",
+    "throw",
+    "try",
+    "unless",
+    "unquote_splicing",
+    "unquote",
+    "with"
+  ],
+  constants: ["true", "false", "nil"],
+  nameBuiltin: ["__MODULE__", "__DIR__", "__ENV__", "__CALLER__", "__STACKTRACE__"],
+  // Matches any of the operator names:
+  // <<< >>> ||| &&& ^^^ ~~~ === !== ~>> <~> |~> <|> == != <= >= && || \\ <> ++ -- |> =~ -> <- ~> <~ :: .. = < > + - * / | . ^ & !
+  operator: /-[->]?|!={0,2}|\*{1,2}|\/|\\\\|&{1,3}|\.\.?|\^(?:\^\^)?|\+\+?|<(?:-|<<|=|>|\|>|~>?)?|=~|={1,3}|>(?:=|>>)?|\|~>|\|>|\|{1,3}|~>>?|~~~|::/,
+  // See https://hexdocs.pm/elixir/syntax-reference.html#variables
+  variableName: /[a-z_][a-zA-Z0-9_]*[?!]?/,
+  // See https://hexdocs.pm/elixir/syntax-reference.html#atoms
+  atomName: /[a-zA-Z_][a-zA-Z0-9_@]*[?!]?|@specialAtomName|@operator/,
+  specialAtomName: /\.\.\.|<<>>|%\{\}|%|\{\}/,
+  aliasPart: /[A-Z][a-zA-Z0-9_]*/,
+  moduleName: /@aliasPart(?:\.@aliasPart)*/,
+  // Sigil pairs are: """ """, ''' ''', " ", ' ', / /, | |, < >, { }, [ ], ( )
+  sigilSymmetricDelimiter: /"""|'''|"|'|\/|\|/,
+  sigilStartDelimiter: /@sigilSymmetricDelimiter|<|\{|\[|\(/,
+  sigilEndDelimiter: /@sigilSymmetricDelimiter|>|\}|\]|\)/,
+  sigilModifiers: /[a-zA-Z0-9]*/,
+  decimal: /\d(?:_?\d)*/,
+  hex: /[0-9a-fA-F](_?[0-9a-fA-F])*/,
+  octal: /[0-7](_?[0-7])*/,
+  binary: /[01](_?[01])*/,
+  // See https://hexdocs.pm/elixir/master/String.html#module-escape-characters
+  escape: /\\u[0-9a-fA-F]{4}|\\x[0-9a-fA-F]{2}|\\./,
+  // The keys below correspond to tokenizer states.
+  // We start from the root state and match against its rules
+  // until we explicitly transition into another state.
+  // The `include` simply brings in all operations from the given state
+  // and is useful for improving readability.
+  tokenizer: {
+    root: [
+      { include: "@whitespace" },
+      { include: "@comments" },
+      // Keywords start as either an identifier or a string,
+      // but end with a : so it's important to match this first.
+      { include: "@keywordsShorthand" },
+      { include: "@numbers" },
+      { include: "@identifiers" },
+      { include: "@strings" },
+      { include: "@atoms" },
+      { include: "@sigils" },
+      { include: "@attributes" },
+      { include: "@symbols" }
+    ],
+    // Whitespace
+    whitespace: [[/\s+/, "white"]],
+    // Comments
+    comments: [[/(#)(.*)/, ["comment.punctuation", "comment"]]],
+    // Keyword list shorthand
+    keywordsShorthand: [
+      [/(@atomName)(:)(\s+)/, ["constant", "constant.punctuation", "white"]],
+      // Use positive look-ahead to ensure the string is followed by :
+      // and should be considered a keyword.
+      [
+        /"(?=([^"]|#\{.*?\}|\\")*":)/,
+        { token: "constant.delimiter", next: "@doubleQuotedStringKeyword" }
+      ],
+      [
+        /'(?=([^']|#\{.*?\}|\\')*':)/,
+        { token: "constant.delimiter", next: "@singleQuotedStringKeyword" }
+      ]
+    ],
+    doubleQuotedStringKeyword: [
+      [/":/, { token: "constant.delimiter", next: "@pop" }],
+      { include: "@stringConstantContentInterpol" }
+    ],
+    singleQuotedStringKeyword: [
+      [/':/, { token: "constant.delimiter", next: "@pop" }],
+      { include: "@stringConstantContentInterpol" }
+    ],
+    // Numbers
+    numbers: [
+      [/0b@binary/, "number.binary"],
+      [/0o@octal/, "number.octal"],
+      [/0x@hex/, "number.hex"],
+      [/@decimal\.@decimal([eE]-?@decimal)?/, "number.float"],
+      [/@decimal/, "number"]
+    ],
+    // Identifiers
+    identifiers: [
+      // Tokenize identifier name in function-like definitions.
+      // Note: given `def a + b, do: nil`, `a` is not a function name,
+      // so we use negative look-ahead to ensure there's no operator.
+      [
+        /\b(defp?|defnp?|defmacrop?|defguardp?|defdelegate)(\s+)(@variableName)(?!\s+@operator)/,
+        [
+          "keyword.declaration",
+          "white",
+          {
+            cases: {
+              unquote: "keyword",
+              "@default": "function"
+            }
+          }
+        ]
+      ],
+      // Tokenize function calls
+      [
+        // In-scope call - an identifier followed by ( or .(
+        /(@variableName)(?=\s*\.?\s*\()/,
+        {
+          cases: {
+            // Tokenize as keyword in cases like `if(..., do: ..., else: ...)`
+            "@declarationKeywords": "keyword.declaration",
+            "@namespaceKeywords": "keyword",
+            "@otherKeywords": "keyword",
+            "@default": "function.call"
+          }
+        }
+      ],
+      [
+        // Referencing function in a module
+        /(@moduleName)(\s*)(\.)(\s*)(@variableName)/,
+        ["type.identifier", "white", "operator", "white", "function.call"]
+      ],
+      [
+        // Referencing function in an Erlang module
+        /(:)(@atomName)(\s*)(\.)(\s*)(@variableName)/,
+        ["constant.punctuation", "constant", "white", "operator", "white", "function.call"]
+      ],
+      [
+        // Piping into a function (tokenized separately as it may not have parentheses)
+        /(\|>)(\s*)(@variableName)/,
+        [
+          "operator",
+          "white",
+          {
+            cases: {
+              "@otherKeywords": "keyword",
+              "@default": "function.call"
+            }
+          }
+        ]
+      ],
+      [
+        // Function reference passed to another function
+        /(&)(\s*)(@variableName)/,
+        ["operator", "white", "function.call"]
+      ],
+      // Language keywords, builtins, constants and variables
+      [
+        /@variableName/,
+        {
+          cases: {
+            "@declarationKeywords": "keyword.declaration",
+            "@operatorKeywords": "keyword.operator",
+            "@namespaceKeywords": "keyword",
+            "@otherKeywords": "keyword",
+            "@constants": "constant.language",
+            "@nameBuiltin": "variable.language",
+            "_.*": "comment.unused",
+            "@default": "identifier"
+          }
+        }
+      ],
+      // Module names
+      [/@moduleName/, "type.identifier"]
+    ],
+    // Strings
+    strings: [
+      [/"""/, { token: "string.delimiter", next: "@doubleQuotedHeredoc" }],
+      [/'''/, { token: "string.delimiter", next: "@singleQuotedHeredoc" }],
+      [/"/, { token: "string.delimiter", next: "@doubleQuotedString" }],
+      [/'/, { token: "string.delimiter", next: "@singleQuotedString" }]
+    ],
+    doubleQuotedHeredoc: [
+      [/"""/, { token: "string.delimiter", next: "@pop" }],
+      { include: "@stringContentInterpol" }
+    ],
+    singleQuotedHeredoc: [
+      [/'''/, { token: "string.delimiter", next: "@pop" }],
+      { include: "@stringContentInterpol" }
+    ],
+    doubleQuotedString: [
+      [/"/, { token: "string.delimiter", next: "@pop" }],
+      { include: "@stringContentInterpol" }
+    ],
+    singleQuotedString: [
+      [/'/, { token: "string.delimiter", next: "@pop" }],
+      { include: "@stringContentInterpol" }
+    ],
+    // Atoms
+    atoms: [
+      [/(:)(@atomName)/, ["constant.punctuation", "constant"]],
+      [/:"/, { token: "constant.delimiter", next: "@doubleQuotedStringAtom" }],
+      [/:'/, { token: "constant.delimiter", next: "@singleQuotedStringAtom" }]
+    ],
+    doubleQuotedStringAtom: [
+      [/"/, { token: "constant.delimiter", next: "@pop" }],
+      { include: "@stringConstantContentInterpol" }
+    ],
+    singleQuotedStringAtom: [
+      [/'/, { token: "constant.delimiter", next: "@pop" }],
+      { include: "@stringConstantContentInterpol" }
+    ],
+    // Sigils
+    // See https://elixir-lang.org/getting-started/sigils.html
+    // Sigils allow for typing values using their textual representation.
+    // All sigils start with ~ followed by a letter or
+    // multi-letter uppercase starting at Elixir v1.15.0, indicating sigil type
+    // and then a delimiter pair enclosing the textual representation.
+    // Optional modifiers are allowed after the closing delimiter.
+    // For instance a regular expressions can be written as:
+    // ~r/foo|bar/ ~r{foo|bar} ~r/foo|bar/g
+    //
+    // In general lowercase sigils allow for interpolation
+    // and escaped characters, whereas uppercase sigils don't
+    //
+    // During tokenization we want to distinguish some
+    // specific sigil types, namely string and regexp,
+    // so that they cen be themed separately.
+    //
+    // To reasonably handle all those combinations we leverage
+    // dot-separated states, so if we transition to @sigilStart.interpol.s.{.}
+    // then "sigilStart.interpol.s" state will match and also all
+    // the individual dot-separated parameters can be accessed.
+    sigils: [
+      [/~[a-z]@sigilStartDelimiter/, { token: "@rematch", next: "@sigil.interpol" }],
+      [/~([A-Z]+)@sigilStartDelimiter/, { token: "@rematch", next: "@sigil.noInterpol" }]
+    ],
+    sigil: [
+      [/~([a-z]|[A-Z]+)\{/, { token: "@rematch", switchTo: "@sigilStart.$S2.$1.{.}" }],
+      [/~([a-z]|[A-Z]+)\[/, { token: "@rematch", switchTo: "@sigilStart.$S2.$1.[.]" }],
+      [/~([a-z]|[A-Z]+)\(/, { token: "@rematch", switchTo: "@sigilStart.$S2.$1.(.)" }],
+      [/~([a-z]|[A-Z]+)\</, { token: "@rematch", switchTo: "@sigilStart.$S2.$1.<.>" }],
+      [
+        /~([a-z]|[A-Z]+)(@sigilSymmetricDelimiter)/,
+        { token: "@rematch", switchTo: "@sigilStart.$S2.$1.$2.$2" }
+      ]
+    ],
+    // The definitions below expect states to be of the form:
+    //
+    // sigilStart.<interpol-or-noInterpol>.<sigil-letter>.<start-delimiter>.<end-delimiter>
+    // sigilContinue.<interpol-or-noInterpol>.<sigil-letter>.<start-delimiter>.<end-delimiter>
+    //
+    // The sigilStart state is used only to properly classify the token (as string/regex/sigil)
+    // and immediately switches to the sigilContinue sate, which handles the actual content
+    // and waits for the corresponding end delimiter.
+    "sigilStart.interpol.s": [
+      [
+        /~s@sigilStartDelimiter/,
+        {
+          token: "string.delimiter",
+          switchTo: "@sigilContinue.$S2.$S3.$S4.$S5"
+        }
+      ]
+    ],
+    "sigilContinue.interpol.s": [
+      [
+        /(@sigilEndDelimiter)@sigilModifiers/,
+        {
+          cases: {
+            "$1==$S5": { token: "string.delimiter", next: "@pop" },
+            "@default": "string"
+          }
+        }
+      ],
+      { include: "@stringContentInterpol" }
+    ],
+    "sigilStart.noInterpol.S": [
+      [
+        /~S@sigilStartDelimiter/,
+        {
+          token: "string.delimiter",
+          switchTo: "@sigilContinue.$S2.$S3.$S4.$S5"
+        }
+      ]
+    ],
+    "sigilContinue.noInterpol.S": [
+      // Ignore escaped sigil end
+      [/(^|[^\\])\\@sigilEndDelimiter/, "string"],
+      [
+        /(@sigilEndDelimiter)@sigilModifiers/,
+        {
+          cases: {
+            "$1==$S5": { token: "string.delimiter", next: "@pop" },
+            "@default": "string"
+          }
+        }
+      ],
+      { include: "@stringContent" }
+    ],
+    "sigilStart.interpol.r": [
+      [
+        /~r@sigilStartDelimiter/,
+        {
+          token: "regexp.delimiter",
+          switchTo: "@sigilContinue.$S2.$S3.$S4.$S5"
+        }
+      ]
+    ],
+    "sigilContinue.interpol.r": [
+      [
+        /(@sigilEndDelimiter)@sigilModifiers/,
+        {
+          cases: {
+            "$1==$S5": { token: "regexp.delimiter", next: "@pop" },
+            "@default": "regexp"
+          }
+        }
+      ],
+      { include: "@regexpContentInterpol" }
+    ],
+    "sigilStart.noInterpol.R": [
+      [
+        /~R@sigilStartDelimiter/,
+        {
+          token: "regexp.delimiter",
+          switchTo: "@sigilContinue.$S2.$S3.$S4.$S5"
+        }
+      ]
+    ],
+    "sigilContinue.noInterpol.R": [
+      // Ignore escaped sigil end
+      [/(^|[^\\])\\@sigilEndDelimiter/, "regexp"],
+      [
+        /(@sigilEndDelimiter)@sigilModifiers/,
+        {
+          cases: {
+            "$1==$S5": { token: "regexp.delimiter", next: "@pop" },
+            "@default": "regexp"
+          }
+        }
+      ],
+      { include: "@regexpContent" }
+    ],
+    // Fallback to the generic sigil by default
+    "sigilStart.interpol": [
+      [
+        /~([a-z]|[A-Z]+)@sigilStartDelimiter/,
+        {
+          token: "sigil.delimiter",
+          switchTo: "@sigilContinue.$S2.$S3.$S4.$S5"
+        }
+      ]
+    ],
+    "sigilContinue.interpol": [
+      [
+        /(@sigilEndDelimiter)@sigilModifiers/,
+        {
+          cases: {
+            "$1==$S5": { token: "sigil.delimiter", next: "@pop" },
+            "@default": "sigil"
+          }
+        }
+      ],
+      { include: "@sigilContentInterpol" }
+    ],
+    "sigilStart.noInterpol": [
+      [
+        /~([a-z]|[A-Z]+)@sigilStartDelimiter/,
+        {
+          token: "sigil.delimiter",
+          switchTo: "@sigilContinue.$S2.$S3.$S4.$S5"
+        }
+      ]
+    ],
+    "sigilContinue.noInterpol": [
+      // Ignore escaped sigil end
+      [/(^|[^\\])\\@sigilEndDelimiter/, "sigil"],
+      [
+        /(@sigilEndDelimiter)@sigilModifiers/,
+        {
+          cases: {
+            "$1==$S5": { token: "sigil.delimiter", next: "@pop" },
+            "@default": "sigil"
+          }
+        }
+      ],
+      { include: "@sigilContent" }
+    ],
+    // Attributes
+    attributes: [
+      // Module @doc* attributes - tokenized as comments
+      [
+        /\@(module|type)?doc (~[sS])?"""/,
+        {
+          token: "comment.block.documentation",
+          next: "@doubleQuotedHeredocDocstring"
+        }
+      ],
+      [
+        /\@(module|type)?doc (~[sS])?'''/,
+        {
+          token: "comment.block.documentation",
+          next: "@singleQuotedHeredocDocstring"
+        }
+      ],
+      [
+        /\@(module|type)?doc (~[sS])?"/,
+        {
+          token: "comment.block.documentation",
+          next: "@doubleQuotedStringDocstring"
+        }
+      ],
+      [
+        /\@(module|type)?doc (~[sS])?'/,
+        {
+          token: "comment.block.documentation",
+          next: "@singleQuotedStringDocstring"
+        }
+      ],
+      [/\@(module|type)?doc false/, "comment.block.documentation"],
+      // Module attributes
+      [/\@(@variableName)/, "variable"]
+    ],
+    doubleQuotedHeredocDocstring: [
+      [/"""/, { token: "comment.block.documentation", next: "@pop" }],
+      { include: "@docstringContent" }
+    ],
+    singleQuotedHeredocDocstring: [
+      [/'''/, { token: "comment.block.documentation", next: "@pop" }],
+      { include: "@docstringContent" }
+    ],
+    doubleQuotedStringDocstring: [
+      [/"/, { token: "comment.block.documentation", next: "@pop" }],
+      { include: "@docstringContent" }
+    ],
+    singleQuotedStringDocstring: [
+      [/'/, { token: "comment.block.documentation", next: "@pop" }],
+      { include: "@docstringContent" }
+    ],
+    // Operators, punctuation, brackets
+    symbols: [
+      // Code point operator (either with regular character ?a or an escaped one ?\n)
+      [/\?(\\.|[^\\\s])/, "number.constant"],
+      // Anonymous function arguments
+      [/&\d+/, "operator"],
+      // Bitshift operators (must go before delimiters, so that << >> don't match first)
+      [/<<<|>>>/, "operator"],
+      // Delimiter pairs
+      [/[()\[\]\{\}]|<<|>>/, "@brackets"],
+      // Triple dot is a valid name (must go before operators, so that .. doesn't match instead)
+      [/\.\.\./, "identifier"],
+      // Punctuation => (must go before operators, so it's not tokenized as = then >)
+      [/=>/, "punctuation"],
+      // Operators
+      [/@operator/, "operator"],
+      // Punctuation
+      [/[:;,.%]/, "punctuation"]
+    ],
+    // Generic helpers
+    stringContentInterpol: [
+      { include: "@interpolation" },
+      { include: "@escapeChar" },
+      { include: "@stringContent" }
+    ],
+    stringContent: [[/./, "string"]],
+    stringConstantContentInterpol: [
+      { include: "@interpolation" },
+      { include: "@escapeChar" },
+      { include: "@stringConstantContent" }
+    ],
+    stringConstantContent: [[/./, "constant"]],
+    regexpContentInterpol: [
+      { include: "@interpolation" },
+      { include: "@escapeChar" },
+      { include: "@regexpContent" }
+    ],
+    regexpContent: [
+      // # may be a regular regexp char, so we use a heuristic
+      // assuming a # surrounded by whitespace is actually a comment.
+      [/(\s)(#)(\s.*)$/, ["white", "comment.punctuation", "comment"]],
+      [/./, "regexp"]
+    ],
+    sigilContentInterpol: [
+      { include: "@interpolation" },
+      { include: "@escapeChar" },
+      { include: "@sigilContent" }
+    ],
+    sigilContent: [[/./, "sigil"]],
+    docstringContent: [[/./, "comment.block.documentation"]],
+    escapeChar: [[/@escape/, "constant.character.escape"]],
+    interpolation: [[/#{/, { token: "delimiter.bracket.embed", next: "@interpolationContinue" }]],
+    interpolationContinue: [
+      [/}/, { token: "delimiter.bracket.embed", next: "@pop" }],
+      // Interpolation brackets may contain arbitrary code,
+      // so we simply match against all the root rules,
+      // until we reach interpolation end (the above matches).
+      { include: "@root" }
+    ]
+  }
+};
+export {
+  conf,
+  language
+};

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/flow9/flow9.contribution.d.ts

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

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

@@ -0,0 +1,24 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/flow9/flow9.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "flow9",
+  extensions: [".flow"],
+  aliases: ["Flow9", "Flow", "flow9", "flow"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/flow9/flow9"], resolve, reject);
+      });
+    } else {
+      return import("./flow9.js");
+    }
+  }
+});

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

@@ -0,0 +1,152 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/flow9/flow9.ts
+var conf = {
+  comments: {
+    blockComment: ["/*", "*/"],
+    lineComment: "//"
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}", notIn: ["string"] },
+    { open: "[", close: "]", notIn: ["string"] },
+    { open: "(", close: ")", notIn: ["string"] },
+    { open: '"', close: '"', notIn: ["string"] },
+    { open: "'", close: "'", notIn: ["string"] }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" },
+    { open: "<", close: ">" }
+  ]
+};
+var language = {
+  defaultToken: "",
+  tokenPostfix: ".flow",
+  keywords: [
+    "import",
+    "require",
+    "export",
+    "forbid",
+    "native",
+    "if",
+    "else",
+    "cast",
+    "unsafe",
+    "switch",
+    "default"
+  ],
+  types: [
+    "io",
+    "mutable",
+    "bool",
+    "int",
+    "double",
+    "string",
+    "flow",
+    "void",
+    "ref",
+    "true",
+    "false",
+    "with"
+  ],
+  operators: [
+    "=",
+    ">",
+    "<",
+    "<=",
+    ">=",
+    "==",
+    "!",
+    "!=",
+    ":=",
+    "::=",
+    "&&",
+    "||",
+    "+",
+    "-",
+    "*",
+    "/",
+    "@",
+    "&",
+    "%",
+    ":",
+    "->",
+    "\\",
+    "$",
+    "??",
+    "^"
+  ],
+  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: [
+      // identifiers and keywords
+      [
+        /[a-zA-Z_]\w*/,
+        {
+          cases: {
+            "@keywords": "keyword",
+            "@types": "type",
+            "@default": "identifier"
+          }
+        }
+      ],
+      // whitespace
+      { include: "@whitespace" },
+      // delimiters and operators
+      [/[{}()\[\]]/, "delimiter"],
+      [/[<>](?!@symbols)/, "delimiter"],
+      [
+        /@symbols/,
+        {
+          cases: {
+            "@operators": "delimiter",
+            "@default": ""
+          }
+        }
+      ],
+      // numbers
+      [/((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)/, "number"],
+      // delimiter: after number because of .\d floats
+      [/[;,.]/, "delimiter"],
+      // strings
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      [/"/, "string", "@string"]
+    ],
+    whitespace: [
+      [/[ \t\r\n]+/, ""],
+      [/\/\*/, "comment", "@comment"],
+      [/\/\/.*$/, "comment"]
+    ],
+    comment: [
+      [/[^\/*]+/, "comment"],
+      [/\*\//, "comment", "@pop"],
+      [/[\/*]/, "comment"]
+    ],
+    string: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/"/, "string", "@pop"]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/freemarker2/freemarker2.contribution.d.ts

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

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

@@ -0,0 +1,102 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/freemarker2/freemarker2.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "freemarker2",
+  extensions: [".ftl", ".ftlh", ".ftlx"],
+  aliases: ["FreeMarker2", "Apache FreeMarker2"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/freemarker2/freemarker2"], resolve, reject);
+      }).then((m) => m.TagAngleInterpolationDollar);
+    } else {
+      return import("./freemarker2.js").then((m) => m.TagAutoInterpolationDollar);
+    }
+  }
+});
+registerLanguage({
+  id: "freemarker2.tag-angle.interpolation-dollar",
+  aliases: ["FreeMarker2 (Angle/Dollar)", "Apache FreeMarker2 (Angle/Dollar)"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/freemarker2/freemarker2"], resolve, reject);
+      }).then((m) => m.TagAngleInterpolationDollar);
+    } else {
+      return import("./freemarker2.js").then((m) => m.TagAngleInterpolationDollar);
+    }
+  }
+});
+registerLanguage({
+  id: "freemarker2.tag-bracket.interpolation-dollar",
+  aliases: ["FreeMarker2 (Bracket/Dollar)", "Apache FreeMarker2 (Bracket/Dollar)"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/freemarker2/freemarker2"], resolve, reject);
+      }).then((m) => m.TagBracketInterpolationDollar);
+    } else {
+      return import("./freemarker2.js").then((m) => m.TagBracketInterpolationDollar);
+    }
+  }
+});
+registerLanguage({
+  id: "freemarker2.tag-angle.interpolation-bracket",
+  aliases: ["FreeMarker2 (Angle/Bracket)", "Apache FreeMarker2 (Angle/Bracket)"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/freemarker2/freemarker2"], resolve, reject);
+      }).then((m) => m.TagAngleInterpolationBracket);
+    } else {
+      return import("./freemarker2.js").then((m) => m.TagAngleInterpolationBracket);
+    }
+  }
+});
+registerLanguage({
+  id: "freemarker2.tag-bracket.interpolation-bracket",
+  aliases: ["FreeMarker2 (Bracket/Bracket)", "Apache FreeMarker2 (Bracket/Bracket)"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/freemarker2/freemarker2"], resolve, reject);
+      }).then((m) => m.TagBracketInterpolationBracket);
+    } else {
+      return import("./freemarker2.js").then((m) => m.TagBracketInterpolationBracket);
+    }
+  }
+});
+registerLanguage({
+  id: "freemarker2.tag-auto.interpolation-dollar",
+  aliases: ["FreeMarker2 (Auto/Dollar)", "Apache FreeMarker2 (Auto/Dollar)"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/freemarker2/freemarker2"], resolve, reject);
+      }).then((m) => m.TagAutoInterpolationDollar);
+    } else {
+      return import("./freemarker2.js").then((m) => m.TagAutoInterpolationDollar);
+    }
+  }
+});
+registerLanguage({
+  id: "freemarker2.tag-auto.interpolation-bracket",
+  aliases: ["FreeMarker2 (Auto/Bracket)", "Apache FreeMarker2 (Auto/Bracket)"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/freemarker2/freemarker2"], resolve, reject);
+      }).then((m) => m.TagAutoInterpolationBracket);
+    } else {
+      return import("./freemarker2.js").then((m) => m.TagAutoInterpolationBracket);
+    }
+  }
+});

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

@@ -0,0 +1,1021 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+// src/fillers/monaco-editor-core.ts
+var monaco_editor_core_exports = {};
+__reExport(monaco_editor_core_exports, monaco_editor_core_star);
+import * as monaco_editor_core_star from "../../editor/editor.api.js";
+
+// src/basic-languages/freemarker2/freemarker2.ts
+var EMPTY_ELEMENTS = [
+  "assign",
+  "flush",
+  "ftl",
+  "return",
+  "global",
+  "import",
+  "include",
+  "break",
+  "continue",
+  "local",
+  "nested",
+  "nt",
+  "setting",
+  "stop",
+  "t",
+  "lt",
+  "rt",
+  "fallback"
+];
+var BLOCK_ELEMENTS = [
+  "attempt",
+  "autoesc",
+  "autoEsc",
+  "compress",
+  "comment",
+  "escape",
+  "noescape",
+  "function",
+  "if",
+  "list",
+  "items",
+  "sep",
+  "macro",
+  "noparse",
+  "noParse",
+  "noautoesc",
+  "noAutoEsc",
+  "outputformat",
+  "switch",
+  "visit",
+  "recurse"
+];
+var TagSyntaxAngle = {
+  close: ">",
+  id: "angle",
+  open: "<"
+};
+var TagSyntaxBracket = {
+  close: "\\]",
+  id: "bracket",
+  open: "\\["
+};
+var TagSyntaxAuto = {
+  close: "[>\\]]",
+  id: "auto",
+  open: "[<\\[]"
+};
+var InterpolationSyntaxDollar = {
+  close: "\\}",
+  id: "dollar",
+  open1: "\\$",
+  open2: "\\{"
+};
+var InterpolationSyntaxBracket = {
+  close: "\\]",
+  id: "bracket",
+  open1: "\\[",
+  open2: "="
+};
+function createLangConfiguration(ts) {
+  return {
+    brackets: [
+      ["<", ">"],
+      ["[", "]"],
+      ["(", ")"],
+      ["{", "}"]
+    ],
+    comments: {
+      blockComment: [`${ts.open}--`, `--${ts.close}`]
+    },
+    autoCloseBefore: "\n\r	 }]),.:;=",
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"', notIn: ["string"] },
+      { open: "'", close: "'", notIn: ["string"] }
+    ],
+    surroundingPairs: [
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp(
+          `${ts.open}#(?:${BLOCK_ELEMENTS.join("|")})([^/${ts.close}]*(?!/)${ts.close})[^${ts.open}]*$`
+        ),
+        end: new RegExp(`${ts.open}/#(?:${BLOCK_ELEMENTS.join("|")})[\\r\\n\\t ]*>`)
+      }
+    },
+    onEnterRules: [
+      {
+        beforeText: new RegExp(
+          `${ts.open}#(?!(?:${EMPTY_ELEMENTS.join("|")}))([a-zA-Z_]+)([^/${ts.close}]*(?!/)${ts.close})[^${ts.open}]*$`
+        ),
+        afterText: new RegExp(`^${ts.open}/#([a-zA-Z_]+)[\\r\\n\\t ]*${ts.close}$`),
+        action: {
+          indentAction: monaco_editor_core_exports.languages.IndentAction.IndentOutdent
+        }
+      },
+      {
+        beforeText: new RegExp(
+          `${ts.open}#(?!(?:${EMPTY_ELEMENTS.join("|")}))([a-zA-Z_]+)([^/${ts.close}]*(?!/)${ts.close})[^${ts.open}]*$`
+        ),
+        action: { indentAction: monaco_editor_core_exports.languages.IndentAction.Indent }
+      }
+    ]
+  };
+}
+function createLangConfigurationAuto() {
+  return {
+    // Cannot set block comment delimiter in auto mode...
+    // It depends on the content and the cursor position of the file...
+    brackets: [
+      ["<", ">"],
+      ["[", "]"],
+      ["(", ")"],
+      ["{", "}"]
+    ],
+    autoCloseBefore: "\n\r	 }]),.:;=",
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"', notIn: ["string"] },
+      { open: "'", close: "'", notIn: ["string"] }
+    ],
+    surroundingPairs: [
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp(`[<\\[]#(?:${BLOCK_ELEMENTS.join("|")})([^/>\\]]*(?!/)[>\\]])[^<\\[]*$`),
+        end: new RegExp(`[<\\[]/#(?:${BLOCK_ELEMENTS.join("|")})[\\r\\n\\t ]*>`)
+      }
+    },
+    onEnterRules: [
+      {
+        beforeText: new RegExp(
+          `[<\\[]#(?!(?:${EMPTY_ELEMENTS.join("|")}))([a-zA-Z_]+)([^/>\\]]*(?!/)[>\\]])[^[<\\[]]*$`
+        ),
+        afterText: new RegExp(`^[<\\[]/#([a-zA-Z_]+)[\\r\\n\\t ]*[>\\]]$`),
+        action: {
+          indentAction: monaco_editor_core_exports.languages.IndentAction.IndentOutdent
+        }
+      },
+      {
+        beforeText: new RegExp(
+          `[<\\[]#(?!(?:${EMPTY_ELEMENTS.join("|")}))([a-zA-Z_]+)([^/>\\]]*(?!/)[>\\]])[^[<\\[]]*$`
+        ),
+        action: { indentAction: monaco_editor_core_exports.languages.IndentAction.Indent }
+      }
+    ]
+  };
+}
+function createMonarchLanguage(ts, is) {
+  const id = `_${ts.id}_${is.id}`;
+  const s = (name) => name.replace(/__id__/g, id);
+  const r = (regexp) => {
+    const source = regexp.source.replace(/__id__/g, id);
+    return new RegExp(source, regexp.flags);
+  };
+  return {
+    // Settings
+    unicode: true,
+    includeLF: false,
+    start: s("default__id__"),
+    ignoreCase: false,
+    defaultToken: "invalid",
+    tokenPostfix: `.freemarker2`,
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "<", close: ">", token: "delimiter.angle" }
+    ],
+    // Dynamic RegExp
+    [s("open__id__")]: new RegExp(ts.open),
+    [s("close__id__")]: new RegExp(ts.close),
+    [s("iOpen1__id__")]: new RegExp(is.open1),
+    [s("iOpen2__id__")]: new RegExp(is.open2),
+    [s("iClose__id__")]: new RegExp(is.close),
+    // <#START_TAG : "<" | "<#" | "[#">
+    // <#END_TAG : "</" | "</#" | "[/#">
+    [s("startTag__id__")]: r(/(@open__id__)(#)/),
+    [s("endTag__id__")]: r(/(@open__id__)(\/#)/),
+    [s("startOrEndTag__id__")]: r(/(@open__id__)(\/?#)/),
+    // <#CLOSE_TAG1 : (<BLANK>)* (">" | "]")>
+    [s("closeTag1__id__")]: r(/((?:@blank)*)(@close__id__)/),
+    // <#CLOSE_TAG2 : (<BLANK>)* ("/")? (">" | "]")>
+    [s("closeTag2__id__")]: r(/((?:@blank)*\/?)(@close__id__)/),
+    // Static RegExp
+    // <#BLANK : " " | "\t" | "\n" | "\r">
+    blank: /[ \t\n\r]/,
+    // <FALSE : "false">
+    // <TRUE : "true">
+    // <IN : "in">
+    // <AS : "as">
+    // <USING : "using">
+    keywords: ["false", "true", "in", "as", "using"],
+    // Directive names that cannot have an expression parameters and cannot be self-closing
+    // E.g. <#if id==2> ... </#if>
+    directiveStartCloseTag1: /attempt|recover|sep|auto[eE]sc|no(?:autoe|AutoE)sc|compress|default|no[eE]scape|comment|no[pP]arse/,
+    // Directive names that cannot have an expression parameter and can be self-closing
+    // E.g. <#if> ... <#else>  ... </#if>
+    // E.g. <#if> ... <#else /></#if>
+    directiveStartCloseTag2: /else|break|continue|return|stop|flush|t|lt|rt|nt|nested|recurse|fallback|ftl/,
+    // Directive names that can have an expression parameter and cannot be self-closing
+    // E.g. <#if id==2> ... </#if>
+    directiveStartBlank: /if|else[iI]f|list|for[eE]ach|switch|case|assign|global|local|include|import|function|macro|transform|visit|stop|return|call|setting|output[fF]ormat|nested|recurse|escape|ftl|items/,
+    // Directive names that can have an end tag
+    // E.g. </#if>
+    directiveEndCloseTag1: /if|list|items|sep|recover|attempt|for[eE]ach|local|global|assign|function|macro|output[fF]ormat|auto[eE]sc|no(?:autoe|AutoE)sc|compress|transform|switch|escape|no[eE]scape/,
+    // <#ESCAPED_CHAR :
+    //     "\\"
+    //     (
+    //         ("n" | "t" | "r" | "f" | "b" | "g" | "l" | "a" | "\\" | "'" | "\"" | "{" | "=")
+    //         |
+    //         ("x" ["0"-"9", "A"-"F", "a"-"f"])
+    //     )
+    // >
+    // Note: While the JavaCC tokenizer rule only specifies one hex digit,
+    // FreeMarker actually interprets up to 4 hex digits.
+    escapedChar: /\\(?:[ntrfbgla\\'"\{=]|(?:x[0-9A-Fa-f]{1,4}))/,
+    // <#ASCII_DIGIT: ["0" - "9"]>
+    asciiDigit: /[0-9]/,
+    // <INTEGER : (["0"-"9"])+>
+    integer: /[0-9]+/,
+    // <#NON_ESCAPED_ID_START_CHAR:
+    // [
+    // 	  // This was generated on JDK 1.8.0_20 Win64 with src/main/misc/identifierChars/IdentifierCharGenerator.java
+    //    ...
+    // ]
+    nonEscapedIdStartChar: /[\$@-Z_a-z\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u1FFF\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183-\u2184\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3006\u3031-\u3035\u303B-\u303C\u3040-\u318F\u31A0-\u31BA\u31F0-\u31FF\u3300-\u337F\u3400-\u4DB5\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8D0-\uA8D9\uA8F2-\uA8F7\uA8FB\uA900-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF-\uA9D9\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA50-\uAA59\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5-\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40-\uFB41\uFB43-\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/,
+    // <#ESCAPED_ID_CHAR: "\\" ("-" | "." | ":" | "#")>
+    escapedIdChar: /\\[\-\.:#]/,
+    // <#ID_START_CHAR: <NON_ESCAPED_ID_START_CHAR>|<ESCAPED_ID_CHAR>>
+    idStartChar: /(?:@nonEscapedIdStartChar)|(?:@escapedIdChar)/,
+    // <ID: <ID_START_CHAR> (<ID_START_CHAR>|<ASCII_DIGIT>)*>
+    id: /(?:@idStartChar)(?:(?:@idStartChar)|(?:@asciiDigit))*/,
+    // Certain keywords / operators are allowed to index hashes
+    //
+    // Expression DotVariable(Expression exp) :
+    // {
+    // 	Token t;
+    // }
+    // {
+    // 		<DOT>
+    // 		(
+    // 			t = <ID> | t = <TIMES> | t = <DOUBLE_STAR>
+    // 			|
+    // 			(
+    // 				t = <LESS_THAN>
+    // 				|
+    // 				t = <LESS_THAN_EQUALS>
+    // 				|
+    // 				t = <ESCAPED_GT>
+    // 				|
+    // 				t = <ESCAPED_GTE>
+    // 				|
+    // 				t = <FALSE>
+    // 				|
+    // 				t = <TRUE>
+    // 				|
+    // 				t = <IN>
+    // 				|
+    // 				t = <AS>
+    // 				|
+    // 				t = <USING>
+    // 			)
+    // 			{
+    // 				if (!Character.isLetter(t.image.charAt(0))) {
+    // 					throw new ParseException(t.image + " is not a valid identifier.", template, t);
+    // 				}
+    // 			}
+    // 		)
+    // 		{
+    // 			notListLiteral(exp, "hash");
+    // 			notStringLiteral(exp, "hash");
+    // 			notBooleanLiteral(exp, "hash");
+    // 			Dot dot = new Dot(exp, t.image);
+    // 			dot.setLocation(template, exp, t);
+    // 			return dot;
+    // 		}
+    // }
+    specialHashKeys: /\*\*|\*|false|true|in|as|using/,
+    // <DOUBLE_EQUALS : "==">
+    // <EQUALS : "=">
+    // <NOT_EQUALS : "!=">
+    // <PLUS_EQUALS : "+=">
+    // <MINUS_EQUALS : "-=">
+    // <TIMES_EQUALS : "*=">
+    // <DIV_EQUALS : "/=">
+    // <MOD_EQUALS : "%=">
+    // <PLUS_PLUS : "++">
+    // <MINUS_MINUS : "--">
+    // <LESS_THAN_EQUALS : "lte" | "\\lte" | "<=" | "&lt;=">
+    // <LESS_THAN : "lt" | "\\lt" | "<" | "&lt;">
+    // <ESCAPED_GTE : "gte" | "\\gte" | "&gt;=">
+    // <ESCAPED_GT: "gt" | "\\gt" |  "&gt;">
+    // <DOUBLE_STAR : "**">
+    // <PLUS : "+">
+    // <MINUS : "-">
+    // <TIMES : "*">
+    // <PERCENT : "%">
+    // <AND : "&" | "&&" | "&amp;&amp;" | "\\and" >
+    // <OR : "|" | "||">
+    // <EXCLAM : "!">
+    // <COMMA : ",">
+    // <SEMICOLON : ";">
+    // <COLON : ":">
+    // <ELLIPSIS : "...">
+    // <DOT_DOT_ASTERISK : "..*" >
+    // <DOT_DOT_LESS : "..<" | "..!" >
+    // <DOT_DOT : "..">
+    // <EXISTS : "??">
+    // <BUILT_IN : "?">
+    // <LAMBDA_ARROW : "->" | "-&gt;">
+    namedSymbols: /&lt;=|&gt;=|\\lte|\\lt|&lt;|\\gte|\\gt|&gt;|&amp;&amp;|\\and|-&gt;|->|==|!=|\+=|-=|\*=|\/=|%=|\+\+|--|<=|&&|\|\||:|\.\.\.|\.\.\*|\.\.<|\.\.!|\?\?|=|<|\+|-|\*|\/|%|\||\.\.|\?|!|&|\.|,|;/,
+    arrows: ["->", "-&gt;"],
+    delimiters: [";", ":", ",", "."],
+    stringOperators: ["lte", "lt", "gte", "gt"],
+    noParseTags: ["noparse", "noParse", "comment"],
+    tokenizer: {
+      // Parser states
+      // Plain text
+      [s("default__id__")]: [
+        { include: s("@directive_token__id__") },
+        { include: s("@interpolation_and_text_token__id__") }
+      ],
+      // A FreeMarker expression inside a directive, e.g. <#if 2<3>
+      [s("fmExpression__id__.directive")]: [
+        { include: s("@blank_and_expression_comment_token__id__") },
+        { include: s("@directive_end_token__id__") },
+        { include: s("@expression_token__id__") }
+      ],
+      // A FreeMarker expression inside an interpolation, e.g. ${2+3}
+      [s("fmExpression__id__.interpolation")]: [
+        { include: s("@blank_and_expression_comment_token__id__") },
+        { include: s("@expression_token__id__") },
+        { include: s("@greater_operators_token__id__") }
+      ],
+      // In an expression and inside a not-yet closed parenthesis / bracket
+      [s("inParen__id__.plain")]: [
+        { include: s("@blank_and_expression_comment_token__id__") },
+        { include: s("@directive_end_token__id__") },
+        { include: s("@expression_token__id__") }
+      ],
+      [s("inParen__id__.gt")]: [
+        { include: s("@blank_and_expression_comment_token__id__") },
+        { include: s("@expression_token__id__") },
+        { include: s("@greater_operators_token__id__") }
+      ],
+      // Expression for the unified call, e.g. <@createMacro() ... >
+      [s("noSpaceExpression__id__")]: [
+        { include: s("@no_space_expression_end_token__id__") },
+        { include: s("@directive_end_token__id__") },
+        { include: s("@expression_token__id__") }
+      ],
+      // For the function of a unified call. Special case for when the
+      // expression is a simple identifier.
+      // <@join [1,2] ",">
+      // <@null!join [1,2] ",">
+      [s("unifiedCall__id__")]: [{ include: s("@unified_call_token__id__") }],
+      // For singly and doubly quoted string (that may contain interpolations)
+      [s("singleString__id__")]: [{ include: s("@string_single_token__id__") }],
+      [s("doubleString__id__")]: [{ include: s("@string_double_token__id__") }],
+      // For singly and doubly quoted string (that may not contain interpolations)
+      [s("rawSingleString__id__")]: [{ include: s("@string_single_raw_token__id__") }],
+      [s("rawDoubleString__id__")]: [{ include: s("@string_double_raw_token__id__") }],
+      // For a comment in an expression
+      // ${ 1 + <#-- comment --> 2}
+      [s("expressionComment__id__")]: [{ include: s("@expression_comment_token__id__") }],
+      // For <#noparse> ... </#noparse>
+      // For <#noParse> ... </#noParse>
+      // For <#comment> ... </#comment>
+      [s("noParse__id__")]: [{ include: s("@no_parse_token__id__") }],
+      // For <#-- ... -->
+      [s("terseComment__id__")]: [{ include: s("@terse_comment_token__id__") }],
+      // Common rules
+      [s("directive_token__id__")]: [
+        // <ATTEMPT : <START_TAG> "attempt" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <RECOVER : <START_TAG> "recover" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <SEP : <START_TAG> "sep" <CLOSE_TAG1>>
+        // <AUTOESC : <START_TAG> "auto" ("e"|"E") "sc" <CLOSE_TAG1>> {
+        //     handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 4), DEFAULT);
+        // }
+        // <NOAUTOESC : <START_TAG> "no" ("autoe"|"AutoE") "sc" <CLOSE_TAG1>> {
+        //     handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 2), DEFAULT);
+        // }
+        // <COMPRESS : <START_TAG> "compress" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <DEFAUL : <START_TAG> "default" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <NOESCAPE : <START_TAG> "no" ("e" | "E") "scape" <CLOSE_TAG1>> {
+        //     handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 2), DEFAULT);
+        // }
+        //
+        // <COMMENT : <START_TAG> "comment" <CLOSE_TAG1>> {
+        //     handleTagSyntaxAndSwitch(matchedToken, NO_PARSE); noparseTag = "comment";
+        // }
+        // <NOPARSE: <START_TAG> "no" ("p" | "P") "arse" <CLOSE_TAG1>> {
+        //     int tagNamingConvention = getTagNamingConvention(matchedToken, 2);
+        //     handleTagSyntaxAndSwitch(matchedToken, tagNamingConvention, NO_PARSE);
+        //     noparseTag = tagNamingConvention == Configuration.CAMEL_CASE_NAMING_CONVENTION ? "noParse" : "noparse";
+        // }
+        [
+          r(/(?:@startTag__id__)(@directiveStartCloseTag1)(?:@closeTag1__id__)/),
+          ts.id === "auto" ? {
+            cases: {
+              "$1==<": { token: "@rematch", switchTo: `@default_angle_${is.id}` },
+              "$1==[": { token: "@rematch", switchTo: `@default_bracket_${is.id}` }
+            }
+          } : [
+            { token: "@brackets.directive" },
+            { token: "delimiter.directive" },
+            {
+              cases: {
+                "@noParseTags": { token: "tag", next: s("@noParse__id__.$3") },
+                "@default": { token: "tag" }
+              }
+            },
+            { token: "delimiter.directive" },
+            { token: "@brackets.directive" }
+          ]
+        ],
+        // <ELSE : <START_TAG> "else" <CLOSE_TAG2>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <BREAK : <START_TAG> "break" <CLOSE_TAG2>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <CONTINUE : <START_TAG> "continue" <CLOSE_TAG2>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <SIMPLE_RETURN : <START_TAG> "return" <CLOSE_TAG2>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <HALT : <START_TAG> "stop" <CLOSE_TAG2>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <FLUSH : <START_TAG> "flush" <CLOSE_TAG2>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <TRIM : <START_TAG> "t" <CLOSE_TAG2>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <LTRIM : <START_TAG> "lt" <CLOSE_TAG2>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <RTRIM : <START_TAG> "rt" <CLOSE_TAG2>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <NOTRIM : <START_TAG> "nt" <CLOSE_TAG2>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <SIMPLE_NESTED : <START_TAG> "nested" <CLOSE_TAG2>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <SIMPLE_RECURSE : <START_TAG> "recurse" <CLOSE_TAG2>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <FALLBACK : <START_TAG> "fallback" <CLOSE_TAG2>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <TRIVIAL_FTL_HEADER : ("<#ftl" | "[#ftl") ("/")? (">" | "]")> { ftlHeader(matchedToken); }
+        [
+          r(/(?:@startTag__id__)(@directiveStartCloseTag2)(?:@closeTag2__id__)/),
+          ts.id === "auto" ? {
+            cases: {
+              "$1==<": { token: "@rematch", switchTo: `@default_angle_${is.id}` },
+              "$1==[": { token: "@rematch", switchTo: `@default_bracket_${is.id}` }
+            }
+          } : [
+            { token: "@brackets.directive" },
+            { token: "delimiter.directive" },
+            { token: "tag" },
+            { token: "delimiter.directive" },
+            { token: "@brackets.directive" }
+          ]
+        ],
+        // <IF : <START_TAG> "if" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <ELSE_IF : <START_TAG> "else" ("i" | "I") "f" <BLANK>> {
+        // 	handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 4), FM_EXPRESSION);
+        // }
+        // <LIST : <START_TAG> "list" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <FOREACH : <START_TAG> "for" ("e" | "E") "ach" <BLANK>> {
+        //    handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 3), FM_EXPRESSION);
+        // }
+        // <SWITCH : <START_TAG> "switch" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <CASE : <START_TAG> "case" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <ASSIGN : <START_TAG> "assign" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <GLOBALASSIGN : <START_TAG> "global" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <LOCALASSIGN : <START_TAG> "local" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <_INCLUDE : <START_TAG> "include" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <IMPORT : <START_TAG> "import" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <FUNCTION : <START_TAG> "function" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <MACRO : <START_TAG> "macro" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <TRANSFORM : <START_TAG> "transform" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <VISIT : <START_TAG> "visit" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <STOP : <START_TAG> "stop" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <RETURN : <START_TAG> "return" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <CALL : <START_TAG> "call" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <SETTING : <START_TAG> "setting" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <OUTPUTFORMAT : <START_TAG> "output" ("f"|"F") "ormat" <BLANK>> {
+        //    handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 6), FM_EXPRESSION);
+        // }
+        // <NESTED : <START_TAG> "nested" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <RECURSE : <START_TAG> "recurse" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        // <ESCAPE : <START_TAG> "escape" <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        //
+        // Note: FreeMarker grammar appears to treat the FTL header as a special case,
+        // in order to remove new lines after the header (?), but since we only need
+        // to tokenize for highlighting, we can include this directive here.
+        // <FTL_HEADER : ("<#ftl" | "[#ftl") <BLANK>> { ftlHeader(matchedToken); }
+        //
+        // Note: FreeMarker grammar appears to treat the items directive as a special case for
+        // the AST parsing process, but since we only need to tokenize, we can include this
+        // directive here.
+        // <ITEMS : <START_TAG> "items" (<BLANK>)+ <AS> <BLANK>> { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); }
+        [
+          r(/(?:@startTag__id__)(@directiveStartBlank)(@blank)/),
+          ts.id === "auto" ? {
+            cases: {
+              "$1==<": { token: "@rematch", switchTo: `@default_angle_${is.id}` },
+              "$1==[": { token: "@rematch", switchTo: `@default_bracket_${is.id}` }
+            }
+          } : [
+            { token: "@brackets.directive" },
+            { token: "delimiter.directive" },
+            { token: "tag" },
+            { token: "", next: s("@fmExpression__id__.directive") }
+          ]
+        ],
+        // <END_IF : <END_TAG> "if" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <END_LIST : <END_TAG> "list" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <END_SEP : <END_TAG> "sep" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <END_RECOVER : <END_TAG> "recover" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <END_ATTEMPT : <END_TAG> "attempt" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <END_FOREACH : <END_TAG> "for" ("e" | "E") "ach" <CLOSE_TAG1>> {
+        //     handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 3), DEFAULT);
+        // }
+        // <END_LOCAL : <END_TAG> "local" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <END_GLOBAL : <END_TAG> "global" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <END_ASSIGN : <END_TAG> "assign" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <END_FUNCTION : <END_TAG> "function" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <END_MACRO : <END_TAG> "macro" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <END_OUTPUTFORMAT : <END_TAG> "output" ("f" | "F") "ormat" <CLOSE_TAG1>> {
+        //     handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 6), DEFAULT);
+        // }
+        // <END_AUTOESC : <END_TAG> "auto" ("e" | "E") "sc" <CLOSE_TAG1>> {
+        //     handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 4), DEFAULT);
+        // }
+        // <END_NOAUTOESC : <END_TAG> "no" ("autoe"|"AutoE") "sc" <CLOSE_TAG1>> {
+        //   handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 2), DEFAULT);
+        // }
+        // <END_COMPRESS : <END_TAG> "compress" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <END_TRANSFORM : <END_TAG> "transform" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <END_SWITCH : <END_TAG> "switch" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <END_ESCAPE : <END_TAG> "escape" <CLOSE_TAG1>> { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); }
+        // <END_NOESCAPE : <END_TAG> "no" ("e" | "E") "scape" <CLOSE_TAG1>> {
+        //     handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 2), DEFAULT);
+        // }
+        [
+          r(/(?:@endTag__id__)(@directiveEndCloseTag1)(?:@closeTag1__id__)/),
+          ts.id === "auto" ? {
+            cases: {
+              "$1==<": { token: "@rematch", switchTo: `@default_angle_${is.id}` },
+              "$1==[": { token: "@rematch", switchTo: `@default_bracket_${is.id}` }
+            }
+          } : [
+            { token: "@brackets.directive" },
+            { token: "delimiter.directive" },
+            { token: "tag" },
+            { token: "delimiter.directive" },
+            { token: "@brackets.directive" }
+          ]
+        ],
+        // <UNIFIED_CALL : "<@" | "[@" > { unifiedCall(matchedToken); }
+        [
+          r(/(@open__id__)(@)/),
+          ts.id === "auto" ? {
+            cases: {
+              "$1==<": { token: "@rematch", switchTo: `@default_angle_${is.id}` },
+              "$1==[": { token: "@rematch", switchTo: `@default_bracket_${is.id}` }
+            }
+          } : [
+            { token: "@brackets.directive" },
+            { token: "delimiter.directive", next: s("@unifiedCall__id__") }
+          ]
+        ],
+        // <UNIFIED_CALL_END : ("<" | "[") "/@" ((<ID>) ("."<ID>)*)? <CLOSE_TAG1>> { unifiedCallEnd(matchedToken); }
+        [
+          r(/(@open__id__)(\/@)((?:(?:@id)(?:\.(?:@id))*)?)(?:@closeTag1__id__)/),
+          [
+            { token: "@brackets.directive" },
+            { token: "delimiter.directive" },
+            { token: "tag" },
+            { token: "delimiter.directive" },
+            { token: "@brackets.directive" }
+          ]
+        ],
+        // <TERSE_COMMENT : ("<" | "[") "#--" > { noparseTag = "-->"; handleTagSyntaxAndSwitch(matchedToken, NO_PARSE); }
+        [
+          r(/(@open__id__)#--/),
+          ts.id === "auto" ? {
+            cases: {
+              "$1==<": { token: "@rematch", switchTo: `@default_angle_${is.id}` },
+              "$1==[": { token: "@rematch", switchTo: `@default_bracket_${is.id}` }
+            }
+          } : { token: "comment", next: s("@terseComment__id__") }
+        ],
+        // <UNKNOWN_DIRECTIVE : ("[#" | "[/#" | "<#" | "</#") (["a"-"z", "A"-"Z", "_"])+>
+        [
+          r(/(?:@startOrEndTag__id__)([a-zA-Z_]+)/),
+          ts.id === "auto" ? {
+            cases: {
+              "$1==<": { token: "@rematch", switchTo: `@default_angle_${is.id}` },
+              "$1==[": { token: "@rematch", switchTo: `@default_bracket_${is.id}` }
+            }
+          } : [
+            { token: "@brackets.directive" },
+            { token: "delimiter.directive" },
+            { token: "tag.invalid", next: s("@fmExpression__id__.directive") }
+          ]
+        ]
+      ],
+      // <DEFAULT, NO_DIRECTIVE> TOKEN :
+      [s("interpolation_and_text_token__id__")]: [
+        // <DOLLAR_INTERPOLATION_OPENING : "${"> { startInterpolation(matchedToken); }
+        // <SQUARE_BRACKET_INTERPOLATION_OPENING : "[="> { startInterpolation(matchedToken); }
+        [
+          r(/(@iOpen1__id__)(@iOpen2__id__)/),
+          [
+            { token: is.id === "bracket" ? "@brackets.interpolation" : "delimiter.interpolation" },
+            {
+              token: is.id === "bracket" ? "delimiter.interpolation" : "@brackets.interpolation",
+              next: s("@fmExpression__id__.interpolation")
+            }
+          ]
+        ],
+        // <STATIC_TEXT_FALSE_ALARM : "$" | "#" | "<" | "[" | "{"> // to handle a lone dollar sign or "<" or "# or <@ with whitespace after"
+        // <STATIC_TEXT_WS : ("\n" | "\r" | "\t" | " ")+>
+        // <STATIC_TEXT_NON_WS : (~["$", "<", "#", "[", "{", "\n", "\r", "\t", " "])+>
+        [/[\$#<\[\{]|(?:@blank)+|[^\$<#\[\{\n\r\t ]+/, { token: "source" }]
+      ],
+      // <STRING_LITERAL :
+      // 	(
+      // 		"\""
+      // 		((~["\"", "\\"]) | <ESCAPED_CHAR>)*
+      // 		"\""
+      // 	)
+      // 	|
+      // 	(
+      // 		"'"
+      // 		((~["'", "\\"]) | <ESCAPED_CHAR>)*
+      // 		"'"
+      // 	)
+      // >
+      [s("string_single_token__id__")]: [
+        [/[^'\\]/, { token: "string" }],
+        [/@escapedChar/, { token: "string.escape" }],
+        [/'/, { token: "string", next: "@pop" }]
+      ],
+      [s("string_double_token__id__")]: [
+        [/[^"\\]/, { token: "string" }],
+        [/@escapedChar/, { token: "string.escape" }],
+        [/"/, { token: "string", next: "@pop" }]
+      ],
+      // <RAW_STRING : "r" (("\"" (~["\""])* "\"") | ("'" (~["'"])* "'"))>
+      [s("string_single_raw_token__id__")]: [
+        [/[^']+/, { token: "string.raw" }],
+        [/'/, { token: "string.raw", next: "@pop" }]
+      ],
+      [s("string_double_raw_token__id__")]: [
+        [/[^"]+/, { token: "string.raw" }],
+        [/"/, { token: "string.raw", next: "@pop" }]
+      ],
+      // <FM_EXPRESSION, IN_PAREN, NO_SPACE_EXPRESSION, NAMED_PARAMETER_EXPRESSION> TOKEN :
+      [s("expression_token__id__")]: [
+        // Strings
+        [
+          /(r?)(['"])/,
+          {
+            cases: {
+              "r'": [
+                { token: "keyword" },
+                { token: "string.raw", next: s("@rawSingleString__id__") }
+              ],
+              'r"': [
+                { token: "keyword" },
+                { token: "string.raw", next: s("@rawDoubleString__id__") }
+              ],
+              "'": [{ token: "source" }, { token: "string", next: s("@singleString__id__") }],
+              '"': [{ token: "source" }, { token: "string", next: s("@doubleString__id__") }]
+            }
+          }
+        ],
+        // Numbers
+        // <INTEGER : (["0"-"9"])+>
+        // <DECIMAL : <INTEGER> "." <INTEGER>>
+        [
+          /(?:@integer)(?:\.(?:@integer))?/,
+          {
+            cases: {
+              "(?:@integer)": { token: "number" },
+              "@default": { token: "number.float" }
+            }
+          }
+        ],
+        // Special hash keys that must not be treated as identifiers
+        // after a period, e.g. a.** is accessing the key "**" of a
+        [
+          /(\.)(@blank*)(@specialHashKeys)/,
+          [{ token: "delimiter" }, { token: "" }, { token: "identifier" }]
+        ],
+        // Symbols / operators
+        [
+          /(?:@namedSymbols)/,
+          {
+            cases: {
+              "@arrows": { token: "meta.arrow" },
+              "@delimiters": { token: "delimiter" },
+              "@default": { token: "operators" }
+            }
+          }
+        ],
+        // Identifiers
+        [
+          /@id/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@stringOperators": { token: "operators" },
+              "@default": { token: "identifier" }
+            }
+          }
+        ],
+        // <OPEN_BRACKET : "[">
+        // <CLOSE_BRACKET : "]">
+        // <OPEN_PAREN : "(">
+        // <CLOSE_PAREN : ")">
+        // <OPENING_CURLY_BRACKET : "{">
+        // <CLOSING_CURLY_BRACKET : "}">
+        [
+          /[\[\]\(\)\{\}]/,
+          {
+            cases: {
+              "\\[": {
+                cases: {
+                  "$S2==gt": { token: "@brackets", next: s("@inParen__id__.gt") },
+                  "@default": { token: "@brackets", next: s("@inParen__id__.plain") }
+                }
+              },
+              "\\]": {
+                cases: {
+                  ...is.id === "bracket" ? {
+                    "$S2==interpolation": { token: "@brackets.interpolation", next: "@popall" }
+                  } : {},
+                  // This cannot happen while in auto mode, since this applies only to an
+                  // fmExpression inside a directive. But once we encounter the start of a
+                  // directive, we can establish the tag syntax mode.
+                  ...ts.id === "bracket" ? {
+                    "$S2==directive": { token: "@brackets.directive", next: "@popall" }
+                  } : {},
+                  // Ignore mismatched paren
+                  [s("$S1==inParen__id__")]: { token: "@brackets", next: "@pop" },
+                  "@default": { token: "@brackets" }
+                }
+              },
+              "\\(": { token: "@brackets", next: s("@inParen__id__.gt") },
+              "\\)": {
+                cases: {
+                  [s("$S1==inParen__id__")]: { token: "@brackets", next: "@pop" },
+                  "@default": { token: "@brackets" }
+                }
+              },
+              "\\{": {
+                cases: {
+                  "$S2==gt": { token: "@brackets", next: s("@inParen__id__.gt") },
+                  "@default": { token: "@brackets", next: s("@inParen__id__.plain") }
+                }
+              },
+              "\\}": {
+                cases: {
+                  ...is.id === "bracket" ? {} : {
+                    "$S2==interpolation": { token: "@brackets.interpolation", next: "@popall" }
+                  },
+                  // Ignore mismatched paren
+                  [s("$S1==inParen__id__")]: { token: "@brackets", next: "@pop" },
+                  "@default": { token: "@brackets" }
+                }
+              }
+            }
+          }
+        ],
+        // <OPEN_MISPLACED_INTERPOLATION : "${" | "#{" | "[=">
+        [/\$\{/, { token: "delimiter.invalid" }]
+      ],
+      // <FM_EXPRESSION, IN_PAREN, NAMED_PARAMETER_EXPRESSION> SKIP :
+      [s("blank_and_expression_comment_token__id__")]: [
+        // < ( " " | "\t" | "\n" | "\r" )+ >
+        [/(?:@blank)+/, { token: "" }],
+        // < ("<" | "[") ("#" | "!") "--"> : EXPRESSION_COMMENT
+        [/[<\[][#!]--/, { token: "comment", next: s("@expressionComment__id__") }]
+      ],
+      // <FM_EXPRESSION, NO_SPACE_EXPRESSION, NAMED_PARAMETER_EXPRESSION> TOKEN :
+      [s("directive_end_token__id__")]: [
+        // <DIRECTIVE_END : ">">
+        // {
+        //     if (inFTLHeader) {
+        //         eatNewline();
+        //         inFTLHeader = false;
+        //     }
+        //     if (squBracTagSyntax || postInterpolationLexState != -1 /* We are in an interpolation */) {
+        //         matchedToken.kind = NATURAL_GT;
+        //     } else {
+        //         SwitchTo(DEFAULT);
+        //     }
+        // }
+        // This cannot happen while in auto mode, since this applies only to an
+        // fmExpression inside a directive. But once we encounter the start of a
+        // directive, we can establish the tag syntax mode.
+        [
+          />/,
+          ts.id === "bracket" ? { token: "operators" } : { token: "@brackets.directive", next: "@popall" }
+        ],
+        // <EMPTY_DIRECTIVE_END : "/>" | "/]">
+        // It is a syntax error to end a tag with the wrong close token
+        // Let's indicate that to the user by not closing the tag
+        [
+          r(/(\/)(@close__id__)/),
+          [{ token: "delimiter.directive" }, { token: "@brackets.directive", next: "@popall" }]
+        ]
+      ],
+      // <IN_PAREN> TOKEN :
+      [s("greater_operators_token__id__")]: [
+        // <NATURAL_GT : ">">
+        [/>/, { token: "operators" }],
+        // <NATURAL_GTE : ">=">
+        [/>=/, { token: "operators" }]
+      ],
+      // <NO_SPACE_EXPRESSION> TOKEN :
+      [s("no_space_expression_end_token__id__")]: [
+        // <TERMINATING_WHITESPACE :  (["\n", "\r", "\t", " "])+> : FM_EXPRESSION
+        [/(?:@blank)+/, { token: "", switchTo: s("@fmExpression__id__.directive") }]
+      ],
+      [s("unified_call_token__id__")]: [
+        // Special case for a call where the expression is just an ID
+        // <UNIFIED_CALL> <ID> <BLANK>+
+        [
+          /(@id)((?:@blank)+)/,
+          [{ token: "tag" }, { token: "", next: s("@fmExpression__id__.directive") }]
+        ],
+        [
+          r(/(@id)(\/?)(@close__id__)/),
+          [
+            { token: "tag" },
+            { token: "delimiter.directive" },
+            { token: "@brackets.directive", next: "@popall" }
+          ]
+        ],
+        [/./, { token: "@rematch", next: s("@noSpaceExpression__id__") }]
+      ],
+      // <NO_PARSE> TOKEN :
+      [s("no_parse_token__id__")]: [
+        // <MAYBE_END :
+        // 	 ("<" | "[")
+        // 	 "/"
+        // 	 ("#")?
+        // 	 (["a"-"z", "A"-"Z"])+
+        // 	 ( " " | "\t" | "\n" | "\r" )*
+        // 	 (">" | "]")
+        // >
+        [
+          r(/(@open__id__)(\/#?)([a-zA-Z]+)((?:@blank)*)(@close__id__)/),
+          {
+            cases: {
+              "$S2==$3": [
+                { token: "@brackets.directive" },
+                { token: "delimiter.directive" },
+                { token: "tag" },
+                { token: "" },
+                { token: "@brackets.directive", next: "@popall" }
+              ],
+              "$S2==comment": [
+                { token: "comment" },
+                { token: "comment" },
+                { token: "comment" },
+                { token: "comment" },
+                { token: "comment" }
+              ],
+              "@default": [
+                { token: "source" },
+                { token: "source" },
+                { token: "source" },
+                { token: "source" },
+                { token: "source" }
+              ]
+            }
+          }
+        ],
+        // <KEEP_GOING : (~["<", "[", "-"])+>
+        // <LONE_LESS_THAN_OR_DASH : ["<", "[", "-"]>
+        [
+          /[^<\[\-]+|[<\[\-]/,
+          {
+            cases: {
+              "$S2==comment": { token: "comment" },
+              "@default": { token: "source" }
+            }
+          }
+        ]
+      ],
+      // <EXPRESSION_COMMENT> SKIP:
+      [s("expression_comment_token__id__")]: [
+        // < "-->" | "--]">
+        [
+          /--[>\]]/,
+          {
+            token: "comment",
+            next: "@pop"
+          }
+        ],
+        // < (~["-", ">", "]"])+ >
+        // < ">">
+        // < "]">
+        // < "-">
+        [/[^\->\]]+|[>\]\-]/, { token: "comment" }]
+      ],
+      [s("terse_comment_token__id__")]: [
+        //  <TERSE_COMMENT_END : "-->" | "--]">
+        [r(/--(?:@close__id__)/), { token: "comment", next: "@popall" }],
+        // <KEEP_GOING : (~["<", "[", "-"])+>
+        // <LONE_LESS_THAN_OR_DASH : ["<", "[", "-"]>
+        [/[^<\[\-]+|[<\[\-]/, { token: "comment" }]
+      ]
+    }
+  };
+}
+function createMonarchLanguageAuto(is) {
+  const angle = createMonarchLanguage(TagSyntaxAngle, is);
+  const bracket = createMonarchLanguage(TagSyntaxBracket, is);
+  const auto = createMonarchLanguage(TagSyntaxAuto, is);
+  return {
+    // Angle and bracket syntax mode
+    // We switch to one of these once we have determined the mode
+    ...angle,
+    ...bracket,
+    ...auto,
+    // Settings
+    unicode: true,
+    includeLF: false,
+    start: `default_auto_${is.id}`,
+    ignoreCase: false,
+    defaultToken: "invalid",
+    tokenPostfix: `.freemarker2`,
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "<", close: ">", token: "delimiter.angle" }
+    ],
+    tokenizer: {
+      ...angle.tokenizer,
+      ...bracket.tokenizer,
+      ...auto.tokenizer
+    }
+  };
+}
+var TagAngleInterpolationDollar = {
+  conf: createLangConfiguration(TagSyntaxAngle),
+  language: createMonarchLanguage(TagSyntaxAngle, InterpolationSyntaxDollar)
+};
+var TagBracketInterpolationDollar = {
+  conf: createLangConfiguration(TagSyntaxBracket),
+  language: createMonarchLanguage(TagSyntaxBracket, InterpolationSyntaxDollar)
+};
+var TagAngleInterpolationBracket = {
+  conf: createLangConfiguration(TagSyntaxAngle),
+  language: createMonarchLanguage(TagSyntaxAngle, InterpolationSyntaxBracket)
+};
+var TagBracketInterpolationBracket = {
+  conf: createLangConfiguration(TagSyntaxBracket),
+  language: createMonarchLanguage(TagSyntaxBracket, InterpolationSyntaxBracket)
+};
+var TagAutoInterpolationDollar = {
+  conf: createLangConfigurationAuto(),
+  language: createMonarchLanguageAuto(InterpolationSyntaxDollar)
+};
+var TagAutoInterpolationBracket = {
+  conf: createLangConfigurationAuto(),
+  language: createMonarchLanguageAuto(InterpolationSyntaxBracket)
+};
+export {
+  TagAngleInterpolationBracket,
+  TagAngleInterpolationDollar,
+  TagAutoInterpolationBracket,
+  TagAutoInterpolationDollar,
+  TagBracketInterpolationBracket,
+  TagBracketInterpolationDollar
+};

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/fsharp/fsharp.contribution.d.ts

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

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

@@ -0,0 +1,24 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/fsharp/fsharp.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "fsharp",
+  extensions: [".fs", ".fsi", ".ml", ".mli", ".fsx", ".fsscript"],
+  aliases: ["F#", "FSharp", "fsharp"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/fsharp/fsharp"], resolve, reject);
+      });
+    } else {
+      return import("./fsharp.js");
+    }
+  }
+});

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

@@ -0,0 +1,227 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/fsharp/fsharp.ts
+var conf = {
+  comments: {
+    lineComment: "//",
+    blockComment: ["(*", "*)"]
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { 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|^\\s*\\(\\*\\s*#region(.*)\\*\\)"),
+      end: new RegExp("^\\s*//\\s*#endregion\\b|^\\s*\\(\\*\\s*#endregion\\s*\\*\\)")
+    }
+  }
+};
+var language = {
+  defaultToken: "",
+  tokenPostfix: ".fs",
+  keywords: [
+    "abstract",
+    "and",
+    "atomic",
+    "as",
+    "assert",
+    "asr",
+    "base",
+    "begin",
+    "break",
+    "checked",
+    "component",
+    "const",
+    "constraint",
+    "constructor",
+    "continue",
+    "class",
+    "default",
+    "delegate",
+    "do",
+    "done",
+    "downcast",
+    "downto",
+    "elif",
+    "else",
+    "end",
+    "exception",
+    "eager",
+    "event",
+    "external",
+    "extern",
+    "false",
+    "finally",
+    "for",
+    "fun",
+    "function",
+    "fixed",
+    "functor",
+    "global",
+    "if",
+    "in",
+    "include",
+    "inherit",
+    "inline",
+    "interface",
+    "internal",
+    "land",
+    "lor",
+    "lsl",
+    "lsr",
+    "lxor",
+    "lazy",
+    "let",
+    "match",
+    "member",
+    "mod",
+    "module",
+    "mutable",
+    "namespace",
+    "method",
+    "mixin",
+    "new",
+    "not",
+    "null",
+    "of",
+    "open",
+    "or",
+    "object",
+    "override",
+    "private",
+    "parallel",
+    "process",
+    "protected",
+    "pure",
+    "public",
+    "rec",
+    "return",
+    "static",
+    "sealed",
+    "struct",
+    "sig",
+    "then",
+    "to",
+    "true",
+    "tailcall",
+    "trait",
+    "try",
+    "type",
+    "upcast",
+    "use",
+    "val",
+    "void",
+    "virtual",
+    "volatile",
+    "when",
+    "while",
+    "with",
+    "yield"
+  ],
+  // 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: /[uU]?[yslnLI]?/,
+  floatsuffix: /[fFmM]?/,
+  // 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
+      [/^#(if|else|endif)/, "keyword"],
+      // delimiters and operators
+      [/[{}()\[\]]/, "@brackets"],
+      [/[<>](?!@symbols)/, "@brackets"],
+      [/@symbols/, "delimiter"],
+      // numbers
+      [/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/, "number.float"],
+      [/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/, "number.float"],
+      [/0x[0-9a-fA-F]+LF/, "number.float"],
+      [/0x[0-9a-fA-F]+(@integersuffix)/, "number.hex"],
+      [/0b[0-1]+(@integersuffix)/, "number.bin"],
+      [/\d+(@integersuffix)/, "number"],
+      // delimiter: after number because of .\d floats
+      [/[;,.]/, "delimiter"],
+      // strings
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
+      [/"""/, "string", '@string."""'],
+      [/"/, "string", '@string."'],
+      // literal string
+      [/\@"/, { token: "string.quote", next: "@litstring" }],
+      // characters
+      [/'[^\\']'B?/, "string"],
+      [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+      [/'/, "string.invalid"]
+    ],
+    whitespace: [
+      [/[ \t\r\n]+/, ""],
+      [/\(\*(?!\))/, "comment", "@comment"],
+      [/\/\/.*$/, "comment"]
+    ],
+    comment: [
+      [/[^*(]+/, "comment"],
+      [/\*\)/, "comment", "@pop"],
+      [/\*/, "comment"],
+      [/\(\*\)/, "comment"],
+      [/\(/, "comment"]
+    ],
+    string: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [
+        /("""|"B?)/,
+        {
+          cases: {
+            "$#==$S2": { token: "string", next: "@pop" },
+            "@default": "string"
+          }
+        }
+      ]
+    ],
+    litstring: [
+      [/[^"]+/, "string"],
+      [/""/, "string.escape"],
+      [/"/, { token: "string.quote", next: "@pop" }]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/go/go.contribution.d.ts

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

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

@@ -0,0 +1,24 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/go/go.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "go",
+  extensions: [".go"],
+  aliases: ["Go"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/go/go"], resolve, reject);
+      });
+    } else {
+      return import("./go.js");
+    }
+  }
+});

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

@@ -0,0 +1,228 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/go/go.ts
+var conf = {
+  comments: {
+    lineComment: "//",
+    blockComment: ["/*", "*/"]
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: "`", close: "`", notIn: ["string"] },
+    { open: '"', close: '"', notIn: ["string"] },
+    { open: "'", close: "'", notIn: ["string", "comment"] }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: "`", close: "`" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" }
+  ]
+};
+var language = {
+  defaultToken: "",
+  tokenPostfix: ".go",
+  keywords: [
+    "break",
+    "case",
+    "chan",
+    "const",
+    "continue",
+    "default",
+    "defer",
+    "else",
+    "fallthrough",
+    "for",
+    "func",
+    "go",
+    "goto",
+    "if",
+    "import",
+    "interface",
+    "map",
+    "package",
+    "range",
+    "return",
+    "select",
+    "struct",
+    "switch",
+    "type",
+    "var",
+    "bool",
+    "true",
+    "false",
+    "uint8",
+    "uint16",
+    "uint32",
+    "uint64",
+    "int8",
+    "int16",
+    "int32",
+    "int64",
+    "float32",
+    "float64",
+    "complex64",
+    "complex128",
+    "byte",
+    "rune",
+    "uint",
+    "int",
+    "uintptr",
+    "string",
+    "nil"
+  ],
+  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})/,
+  // 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"],
+      // delimiters and operators
+      [/[{}()\[\]]/, "@brackets"],
+      [/[<>](?!@symbols)/, "@brackets"],
+      [
+        /@symbols/,
+        {
+          cases: {
+            "@operators": "delimiter",
+            "@default": ""
+          }
+        }
+      ],
+      // numbers
+      [/\d*\d+[eE]([\-+]?\d+)?/, "number.float"],
+      [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+      [/0[xX][0-9a-fA-F']*[0-9a-fA-F]/, "number.hex"],
+      [/0[0-7']*[0-7]/, "number.octal"],
+      [/0[bB][0-1']*[0-1]/, "number.binary"],
+      [/\d[\d']*/, "number"],
+      [/\d/, "number"],
+      // delimiter: after number because of .\d floats
+      [/[;,.]/, "delimiter"],
+      // strings
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
+      [/"/, "string", "@string"],
+      [/`/, "string", "@rawstring"],
+      // characters
+      [/'[^\\']'/, "string"],
+      [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+      [/'/, "string.invalid"]
+    ],
+    whitespace: [
+      [/[ \t\r\n]+/, ""],
+      [/\/\*\*(?!\/)/, "comment.doc", "@doccomment"],
+      [/\/\*/, "comment", "@comment"],
+      [/\/\/.*$/, "comment"]
+    ],
+    comment: [
+      [/[^\/*]+/, "comment"],
+      // [/\/\*/, 'comment', '@push' ],    // nested comment not allowed :-(
+      // [/\/\*/,    'comment.invalid' ],    // this breaks block comments in the shape of /* //*/
+      [/\*\//, "comment", "@pop"],
+      [/[\/*]/, "comment"]
+    ],
+    //Identical copy of comment above, except for the addition of .doc
+    doccomment: [
+      [/[^\/*]+/, "comment.doc"],
+      // [/\/\*/, 'comment.doc', '@push' ],    // nested comment not allowed :-(
+      [/\/\*/, "comment.doc.invalid"],
+      [/\*\//, "comment.doc", "@pop"],
+      [/[\/*]/, "comment.doc"]
+    ],
+    string: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/"/, "string", "@pop"]
+    ],
+    rawstring: [
+      [/[^\`]/, "string"],
+      [/`/, "string", "@pop"]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};

platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/graphql/graphql.contribution.d.ts

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

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

@@ -0,0 +1,25 @@
+/*!-----------------------------------------------------------------------------
+ * 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
+ *-----------------------------------------------------------------------------*/
+
+
+// src/basic-languages/graphql/graphql.contribution.ts
+import { registerLanguage } from "../_.contribution.js";
+registerLanguage({
+  id: "graphql",
+  extensions: [".graphql", ".gql"],
+  aliases: ["GraphQL", "graphql", "gql"],
+  mimetypes: ["application/graphql"],
+  loader: () => {
+    if (false) {
+      return new Promise((resolve, reject) => {
+        __require(["vs/basic-languages/graphql/graphql"], resolve, reject);
+      });
+    } else {
+      return import("./graphql.js");
+    }
+  }
+});