claude-flow-novice 2.2.1 → 2.2.3

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/dev/vs/basic-languages/clojure/clojure.js

@@ -0,0 +1,782 @@
+"use strict";
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.45.0(5e5af013f8d295555a7210df0d5f2cea0bf5dd56)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/clojure/clojure", ["require"],(require)=>{
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/clojure/clojure.ts
+  var clojure_exports = {};
+  __export(clojure_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  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"],
+    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})/,
+    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: [
+        { include: "@whitespace" },
+        [/@numbers/, "number"],
+        [/@characters/, "string"],
+        { include: "@string" },
+        [/[()\[\]{}]/, "@brackets"],
+        [/\/#"(?:\.|(?:")|[^"\n])*"\/g/, "regexp"],
+        [/[#'@^`~]/, "meta"],
+        [
+          /@qualifiedSymbols/,
+          {
+            cases: {
+              "^:.+$": "constant",
+              "@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"]
+      ]
+    }
+  };
+  return __toCommonJS(clojure_exports);
+})();
+return moduleExports;
+});