diff --git a/.gitattributes b/.gitattributes index 82384d8480457c397e0a7234e37d1aaac778350b..95c709bf9f17112de54d80b61a14b804f48f2311 100644 --- a/.gitattributes +++ b/.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 diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..4b8af9c76f533b8b18409a1068c6d17a137e1e17 --- /dev/null +++ b/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"); + } + } +}); diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..63dcabbb2bc32d6f3c2030cb8e328e064b88b9b0 --- /dev/null +++ b/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 +}; diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..336ce12bb9106afdf843063ee67c0c1970f70d37 --- /dev/null +++ b/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 {} diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..93ee7c6ca6e385d855cd33ae9c4617664991e472 --- /dev/null +++ b/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"); + } + } +}); diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..f0fe18e864142eb91aaabb9e938b38bdc75af162 --- /dev/null +++ b/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 := ((<.>)*)? + 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 +}; diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..336ce12bb9106afdf843063ee67c0c1970f70d37 --- /dev/null +++ b/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 {} diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..bbeeebbe06daf4472665be2d9a871cda56d0df33 --- /dev/null +++ b/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"); + } + } +}); diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..4f5b93c860490bfd0d64ddfa6131ee22b9e2bce9 --- /dev/null +++ b/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: /[=> { + 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"); + } + } +}); diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..5888ff9effaf87f7ef8a3f5c6f41020ea4c680db --- /dev/null +++ b/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: /[=>\[\]]/, "@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 +}; diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..336ce12bb9106afdf843063ee67c0c1970f70d37 --- /dev/null +++ b/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 {} diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..79638784c9056649cdf1620c5ce44094ba74f1c3 --- /dev/null +++ b/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"); + } + } +}); diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..8ecdbc2c8fc38c48e58a53a8c6c3712547ea38da --- /dev/null +++ b/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: /[=>](?!@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 +}; diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..336ce12bb9106afdf843063ee67c0c1970f70d37 --- /dev/null +++ b/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 {} diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..d0f2926aca15dcd00622ce6091603ea05a2923da --- /dev/null +++ b/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"); + } + } +}); diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..927c2160b13dbc2e745750261a68baaa2bc3bbf2 --- /dev/null +++ b/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: /[=> { + if (false) { + return new Promise((resolve, reject) => { + __require(["vs/basic-languages/css/css"], resolve, reject); + }); + } else { + return import("./css.js"); + } + } +}); diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..a739f8f7837ef2b3b8f22a0fca2cb7c4627f591f --- /dev/null +++ b/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 +}; diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..336ce12bb9106afdf843063ee67c0c1970f70d37 --- /dev/null +++ b/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 {} diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..f3cb7a98a9dbff0bda7a0348c5be7c021dc9f1c8 --- /dev/null +++ b/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"); + } + } +}); diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..aad50f95302136573046cdeea8c966267a586780 --- /dev/null +++ b/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 +}; diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..336ce12bb9106afdf843063ee67c0c1970f70d37 --- /dev/null +++ b/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 {} diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..7d03c36c431347cd9e29046f948aa5512a381757 --- /dev/null +++ b/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"); + } + } +}); diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..7134990c279e43a5477754a0dbe17787c4c295aa --- /dev/null +++ b/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: /[=>](?!@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 +}; diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..336ce12bb9106afdf843063ee67c0c1970f70d37 --- /dev/null +++ b/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 {} diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..fd47b283644469e66548b0b16efdac3876683e34 --- /dev/null +++ b/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"); + } + } +}); diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..204528188f1bf61a9c1bbec60c8bf8ace1c251cf --- /dev/null +++ b/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 +}; diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..336ce12bb9106afdf843063ee67c0c1970f70d37 --- /dev/null +++ b/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 {} diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..bc3f380f313ab72f252a50d59ae49388feea6bf0 --- /dev/null +++ b/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"); + } + } +}); diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..da1c3dd5325f48f3bdf98d749e65694bd450008c --- /dev/null +++ b/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: /[=>](?!@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 +}; diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..336ce12bb9106afdf843063ee67c0c1970f70d37 --- /dev/null +++ b/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 {} diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..c46925cfb4ba4ed5a1c9bda5aa72e62d344a1704 --- /dev/null +++ b/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"); + } + } +}); diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..5f7f3d59ef7bee7304079b3ca447004c879028cf --- /dev/null +++ b/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]+)\" }], + [ + /~([a-z]|[A-Z]+)(@sigilSymmetricDelimiter)/, + { token: "@rematch", switchTo: "@sigilStart.$S2.$1.$2.$2" } + ] + ], + // The definitions below expect states to be of the form: + // + // sigilStart.... + // sigilContinue.... + // + // 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 +}; diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..336ce12bb9106afdf843063ee67c0c1970f70d37 --- /dev/null +++ b/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 {} diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..42cb4e66ec8907c4ca975f764e6ff22b1604c35b --- /dev/null +++ b/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"); + } + } +}); diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..659847b2242e80ed01baebd5daafb0d0ed2bee08 --- /dev/null +++ b/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: /[@$=>](?!@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 +}; diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..336ce12bb9106afdf843063ee67c0c1970f70d37 --- /dev/null +++ b/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 {} diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..fe221f8f07f3d5a9a43b779b43b8a3803c7fcec1 --- /dev/null +++ b/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); + } + } +}); diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..d710845402b4730eb6102958d17fd3e300843743 --- /dev/null +++ b/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 : ()* (">" | "]")> + [s("closeTag1__id__")]: r(/((?:@blank)*)(@close__id__)/), + // <#CLOSE_TAG2 : ()* ("/")? (">" | "]")> + [s("closeTag2__id__")]: r(/((?:@blank)*\/?)(@close__id__)/), + // Static RegExp + // <#BLANK : " " | "\t" | "\n" | "\r"> + blank: /[ \t\n\r]/, + // + // + // + // + // + keywords: ["false", "true", "in", "as", "using"], + // Directive names that cannot have an expression parameters and cannot be self-closing + // E.g. <#if id==2> ... + 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> ... + // E.g. <#if> ... <#else /> + 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> ... + 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. + 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]+/, + // <#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: |> + idStartChar: /(?:@nonEscapedIdStartChar)|(?:@escapedIdChar)/, + // (|)*> + id: /(?:@idStartChar)(?:(?:@idStartChar)|(?:@asciiDigit))*/, + // Certain keywords / operators are allowed to index hashes + // + // Expression DotVariable(Expression exp) : + // { + // Token t; + // } + // { + // + // ( + // t = | t = | t = + // | + // ( + // t = + // | + // t = + // | + // t = + // | + // t = + // | + // t = + // | + // t = + // | + // t = + // | + // t = + // | + // t = + // ) + // { + // 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/, + // + // + // + // + // + // + // + // + // + // + // + // + // + // + // + // + // + // + // + // + // + // + // + // " | "->"> + namedSymbols: /<=|>=|\\lte|\\lt|<|\\gte|\\gt|>|&&|\\and|->|->|==|!=|\+=|-=|\*=|\/=|%=|\+\+|--|<=|&&|\|\||:|\.\.\.|\.\.\*|\.\.<|\.\.!|\?\?|=|<|\+|-|\*|\/|%|\||\.\.|\?|!|&|\.|,|;/, + arrows: ["->", "->"], + 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> ... + // For <#noParse> ... + // For <#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" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "recover" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "sep" > + // "auto" ("e"|"E") "sc" > { + // handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 4), DEFAULT); + // } + // "no" ("autoe"|"AutoE") "sc" > { + // handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 2), DEFAULT); + // } + // "compress" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "default" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "no" ("e" | "E") "scape" > { + // handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 2), DEFAULT); + // } + // + // "comment" > { + // handleTagSyntaxAndSwitch(matchedToken, NO_PARSE); noparseTag = "comment"; + // } + // "no" ("p" | "P") "arse" > { + // 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" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "break" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "continue" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "return" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "stop" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "flush" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "t" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "lt" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "rt" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "nt" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "nested" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "recurse" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "fallback" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // " | "]")> { 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" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "else" ("i" | "I") "f" > { + // handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 4), FM_EXPRESSION); + // } + // "list" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "for" ("e" | "E") "ach" > { + // handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 3), FM_EXPRESSION); + // } + // "switch" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "case" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "assign" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "global" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "local" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // <_INCLUDE : "include" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "import" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "function" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "macro" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "transform" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "visit" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "stop" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "return" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "call" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "setting" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "output" ("f"|"F") "ormat" > { + // handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 6), FM_EXPRESSION); + // } + // "nested" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "recurse" > { handleTagSyntaxAndSwitch(matchedToken, FM_EXPRESSION); } + // "escape" > { 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. + // > { 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" ()+ > { 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") } + ] + ], + // "if" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "list" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "sep" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "recover" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "attempt" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "for" ("e" | "E") "ach" > { + // handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 3), DEFAULT); + // } + // "local" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "global" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "assign" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "function" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "macro" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "output" ("f" | "F") "ormat" > { + // handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 6), DEFAULT); + // } + // "auto" ("e" | "E") "sc" > { + // handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 4), DEFAULT); + // } + // "no" ("autoe"|"AutoE") "sc" > { + // handleTagSyntaxAndSwitch(matchedToken, getTagNamingConvention(matchedToken, 2), DEFAULT); + // } + // "compress" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "transform" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "switch" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "escape" > { handleTagSyntaxAndSwitch(matchedToken, DEFAULT); } + // "no" ("e" | "E") "scape" > { + // 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" } + ] + ], + // { 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__") } + ] + ], + // ) (".")*)? > { unifiedCallEnd(matchedToken); } + [ + r(/(@open__id__)(\/@)((?:(?:@id)(?:\.(?:@id))*)?)(?:@closeTag1__id__)/), + [ + { token: "@brackets.directive" }, + { token: "delimiter.directive" }, + { token: "tag" }, + { token: "delimiter.directive" }, + { token: "@brackets.directive" } + ] + ], + // { 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__") } + ], + // + [ + 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") } + ] + ] + ], + // TOKEN : + [s("interpolation_and_text_token__id__")]: [ + // { startInterpolation(matchedToken); } + // // to handle a lone dollar sign or "<" or "# or <@ with whitespace after" + // + // + [/[\$#<\[\{]|(?:@blank)+|[^\$<#\[\{\n\r\t ]+/, { token: "source" }] + ], + // )* + // "\"" + // ) + // | + // ( + // "'" + // ((~["'", "\\"]) | )* + // "'" + // ) + // > + [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" }] + ], + // + [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" }] + ], + // 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)(?:\.(?:@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" } + } + } + ], + // + // + // + // + // + // + [ + /[\[\]\(\)\{\}]/, + { + 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" } + } + } + } + } + ], + // SKIP : + [s("blank_and_expression_comment_token__id__")]: [ + // < ( " " | "\t" | "\n" | "\r" )+ > + [/(?:@blank)+/, { token: "" }], + // < ("<" | "[") ("#" | "!") "--"> : EXPRESSION_COMMENT + [/[<\[][#!]--/, { token: "comment", next: s("@expressionComment__id__") }] + ], + // TOKEN : + [s("directive_end_token__id__")]: [ + // "> + // { + // 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" } + ], + // " | "/]"> + // 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" }] + ] + ], + // TOKEN : + [s("greater_operators_token__id__")]: [ + // "> + [/>/, { token: "operators" }], + // ="> + [/>=/, { token: "operators" }] + ], + // TOKEN : + [s("no_space_expression_end_token__id__")]: [ + // : 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 + // + + [ + /(@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__") }] + ], + // TOKEN : + [s("no_parse_token__id__")]: [ + // " | "]") + // > + [ + 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" } + ] + } + } + ], + // + // + [ + /[^<\[\-]+|[<\[\-]/, + { + cases: { + "$S2==comment": { token: "comment" }, + "@default": { token: "source" } + } + } + ] + ], + // SKIP: + [s("expression_comment_token__id__")]: [ + // < "-->" | "--]"> + [ + /--[>\]]/, + { + token: "comment", + next: "@pop" + } + ], + // < (~["-", ">", "]"])+ > + // < ">"> + // < "]"> + // < "-"> + [/[^\->\]]+|[>\]\-]/, { token: "comment" }] + ], + [s("terse_comment_token__id__")]: [ + // " | "--]"> + [r(/--(?:@close__id__)/), { token: "comment", next: "@popall" }], + // + // + [/[^<\[\-]+|[<\[\-]/, { 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 +}; diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..336ce12bb9106afdf843063ee67c0c1970f70d37 --- /dev/null +++ b/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 {} diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..d894454546b17866dd7b1789df24c60e57ce71e6 --- /dev/null +++ b/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"); + } + } +}); diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..7e749ca867fd4cba7dd81240b5b228cd20195faa --- /dev/null +++ b/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: /[=>]. + [/\[<.*>\]/, "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 +}; diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..336ce12bb9106afdf843063ee67c0c1970f70d37 --- /dev/null +++ b/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 {} diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..febba6102cf1216a37d04db24e68e4df2ca1c378 --- /dev/null +++ b/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"); + } + } +}); diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..93cef08e37f90211dcf25b921099abd173f8cf19 --- /dev/null +++ b/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: /[=>](?!@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 +}; diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..336ce12bb9106afdf843063ee67c0c1970f70d37 --- /dev/null +++ b/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 {} diff --git a/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 b/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 new file mode 100644 index 0000000000000000000000000000000000000000..cf6c80a3e889422852112f85ad2898cb7ba9c4ad --- /dev/null +++ b/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"); + } + } +}); diff --git a/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.js b/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.js new file mode 100644 index 0000000000000000000000000000000000000000..e45bae81e5c0762151727c02087737fc6ebc0c31 --- /dev/null +++ b/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.js @@ -0,0 +1,161 @@ +/*!----------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1) + * Released under the MIT license + * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt + *-----------------------------------------------------------------------------*/ + + +// src/basic-languages/graphql/graphql.ts +var conf = { + comments: { + lineComment: "#" + }, + 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: '"' } + ], + folding: { + offSide: true + } +}; +var language = { + // Set defaultToken to invalid to see what you do not tokenize yet + defaultToken: "invalid", + tokenPostfix: ".gql", + keywords: [ + "null", + "true", + "false", + "query", + "mutation", + "subscription", + "extend", + "schema", + "directive", + "scalar", + "type", + "interface", + "union", + "enum", + "input", + "implements", + "fragment", + "on" + ], + typeKeywords: ["Int", "Float", "String", "Boolean", "ID"], + directiveLocations: [ + "SCHEMA", + "SCALAR", + "OBJECT", + "FIELD_DEFINITION", + "ARGUMENT_DEFINITION", + "INTERFACE", + "UNION", + "ENUM", + "ENUM_VALUE", + "INPUT_OBJECT", + "INPUT_FIELD_DEFINITION", + "QUERY", + "MUTATION", + "SUBSCRIPTION", + "FIELD", + "FRAGMENT_DEFINITION", + "FRAGMENT_SPREAD", + "INLINE_FRAGMENT", + "VARIABLE_DEFINITION" + ], + operators: ["=", "!", "?", ":", "&", "|"], + // we include these common regular expressions + symbols: /[=!?:&|]+/, + // https://facebook.github.io/graphql/draft/#sec-String-Value + escapes: /\\(?:["\\\/bfnrt]|u[0-9A-Fa-f]{4})/, + // The main tokenizer for our languages + tokenizer: { + root: [ + // fields and argument names + [ + /[a-z_][\w$]*/, + { + cases: { + "@keywords": "keyword", + "@default": "key.identifier" + } + } + ], + // identify typed input variables + [ + /[$][\w$]*/, + { + cases: { + "@keywords": "keyword", + "@default": "argument.identifier" + } + } + ], + // to show class names nicely + [ + /[A-Z][\w\$]*/, + { + cases: { + "@typeKeywords": "keyword", + "@default": "type.identifier" + } + } + ], + // whitespace + { include: "@whitespace" }, + // delimiters and operators + [/[{}()\[\]]/, "@brackets"], + [/@symbols/, { cases: { "@operators": "operator", "@default": "" } }], + // @ annotations. + // As an example, we emit a debugging log message on these tokens. + // Note: message are supressed during the first load -- change some lines to see them. + [/@\s*[a-zA-Z_\$][\w\$]*/, { token: "annotation", log: "annotation token: $0" }], + // numbers + [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"], + [/0[xX][0-9a-fA-F]+/, "number.hex"], + [/\d+/, "number"], + // delimiter: after number because of .\d floats + [/[;,.]/, "delimiter"], + [/"""/, { token: "string", next: "@mlstring", nextEmbedded: "markdown" }], + // strings + [/"([^"\\]|\\.)*$/, "string.invalid"], + // non-teminated string + [/"/, { token: "string.quote", bracket: "@open", next: "@string" }] + ], + mlstring: [ + [/[^"]+/, "string"], + ['"""', { token: "string", next: "@pop", nextEmbedded: "@pop" }] + ], + string: [ + [/[^\\"]+/, "string"], + [/@escapes/, "string.escape"], + [/\\./, "string.escape.invalid"], + [/"/, { token: "string.quote", bracket: "@close", next: "@pop" }] + ], + whitespace: [ + [/[ \t\r\n]+/, ""], + [/#.*$/, "comment"] + ] + } +}; +export { + conf, + language +}; diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/handlebars/handlebars.contribution.d.ts b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/handlebars/handlebars.contribution.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..336ce12bb9106afdf843063ee67c0c1970f70d37 --- /dev/null +++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/handlebars/handlebars.contribution.d.ts @@ -0,0 +1 @@ +export {} diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/handlebars/handlebars.contribution.js b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/handlebars/handlebars.contribution.js new file mode 100644 index 0000000000000000000000000000000000000000..3bf3e831658033ea04d8968f0e6d9ae85c643fc9 --- /dev/null +++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/handlebars/handlebars.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/handlebars/handlebars.contribution.ts +import { registerLanguage } from "../_.contribution.js"; +registerLanguage({ + id: "handlebars", + extensions: [".handlebars", ".hbs"], + aliases: ["Handlebars", "handlebars", "hbs"], + mimetypes: ["text/x-handlebars-template"], + loader: () => { + if (false) { + return new Promise((resolve, reject) => { + __require(["vs/basic-languages/handlebars/handlebars"], resolve, reject); + }); + } else { + return import("./handlebars.js"); + } + } +}); diff --git a/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/handlebars/handlebars.js b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/handlebars/handlebars.js new file mode 100644 index 0000000000000000000000000000000000000000..d8a85d71e9fad08f255d690867d80881bb7e3f28 --- /dev/null +++ b/platform/dbops/archive/databases_old/data/home/x/india-h200-1-workspace/claude-code-router/ui/node_modules/monaco-editor/esm/vs/basic-languages/handlebars/handlebars.js @@ -0,0 +1,440 @@ +/*!----------------------------------------------------------------------------- + * 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/handlebars/handlebars.ts +var EMPTY_ELEMENTS = [ + "area", + "base", + "br", + "col", + "embed", + "hr", + "img", + "input", + "keygen", + "link", + "menuitem", + "meta", + "param", + "source", + "track", + "wbr" +]; +var conf = { + wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\$\^\&\*\(\)\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\s]+)/g, + comments: { + blockComment: ["{{!--", "--}}"] + }, + brackets: [ + [""], + ["<", ">"], + ["{{", "}}"], + ["{", "}"], + ["(", ")"] + ], + autoClosingPairs: [ + { open: "{", close: "}" }, + { open: "[", close: "]" }, + { open: "(", close: ")" }, + { open: '"', close: '"' }, + { open: "'", close: "'" } + ], + surroundingPairs: [ + { open: "<", close: ">" }, + { open: '"', close: '"' }, + { open: "'", close: "'" } + ], + onEnterRules: [ + { + beforeText: new RegExp( + `<(?!(?:${EMPTY_ELEMENTS.join("|")}))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$`, + "i" + ), + afterText: /^<\/(\w[\w\d]*)\s*>$/i, + action: { + indentAction: monaco_editor_core_exports.languages.IndentAction.IndentOutdent + } + }, + { + beforeText: new RegExp( + `<(?!(?:${EMPTY_ELEMENTS.join("|")}))(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$`, + "i" + ), + action: { indentAction: monaco_editor_core_exports.languages.IndentAction.Indent } + } + ] +}; +var language = { + defaultToken: "", + tokenPostfix: "", + // ignoreCase: true, + // The main tokenizer for our languages + tokenizer: { + root: [ + [/\{\{!--/, "comment.block.start.handlebars", "@commentBlock"], + [/\{\{!/, "comment.start.handlebars", "@comment"], + [/\{\{/, { token: "@rematch", switchTo: "@handlebarsInSimpleState.root" }], + [/)/, ["delimiter.html", "tag.html", "delimiter.html"]], + [/(<)(script)/, ["delimiter.html", { token: "tag.html", next: "@script" }]], + [/(<)(style)/, ["delimiter.html", { token: "tag.html", next: "@style" }]], + [/(<)([:\w]+)/, ["delimiter.html", { token: "tag.html", next: "@otherTag" }]], + [/(<\/)(\w+)/, ["delimiter.html", { token: "tag.html", next: "@otherTag" }]], + [/]+/, "metatag.content.html"], + [/>/, "metatag.html", "@pop"] + ], + comment: [ + [/\}\}/, "comment.end.handlebars", "@pop"], + [/./, "comment.content.handlebars"] + ], + commentBlock: [ + [/--\}\}/, "comment.block.end.handlebars", "@pop"], + [/./, "comment.content.handlebars"] + ], + commentHtml: [ + [ + /\{\{/, + { + token: "@rematch", + switchTo: "@handlebarsInSimpleState.comment" + } + ], + [/-->/, "comment.html", "@pop"], + [/[^-]+/, "comment.content.html"], + [/./, "comment.content.html"] + ], + otherTag: [ + [ + /\{\{/, + { + token: "@rematch", + switchTo: "@handlebarsInSimpleState.otherTag" + } + ], + [/\/?>/, "delimiter.html", "@pop"], + [/"([^"]*)"/, "attribute.value"], + [/'([^']*)'/, "attribute.value"], + [/[\w\-]+/, "attribute.name"], + [/=/, "delimiter"], + [/[ \t\r\n]+/] + // whitespace + ], + // -- BEGIN