Add files using upload-large-folder tool

.gitattributes

@@ -3522,3 +3522,7 @@ novas/novacore-zephyr/claude-code-router/ui/node_modules/@tailwindcss/oxide-linu
 novas/novacore-zephyr/claude-code-router/ui/node_modules/@tailwindcss/oxide-linux-x64-musl/tailwindcss-oxide.linux-x64-musl.node filter=lfs diff=lfs merge=lfs -text
 novas/novacore-zephyr/claude-code-router/ui/node_modules/@esbuild/linux-x64/bin/esbuild filter=lfs diff=lfs merge=lfs -text
 novas/novacore-zephyr/claude-code-router/ui/node_modules/esbuild/bin/esbuild filter=lfs diff=lfs merge=lfs -text
+novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/esm/vs/language/typescript/ts.worker.js filter=lfs diff=lfs merge=lfs -text
+novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/editor/editor.main.js.map filter=lfs diff=lfs merge=lfs -text
+novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/language/typescript/tsWorker.js filter=lfs diff=lfs merge=lfs -text
+novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/min-maps/vs/editor/editor.main.js.map filter=lfs diff=lfs merge=lfs -text

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/abap/abap.js

@@ -0,0 +1,1432 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/abap/abap", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/abap/abap.ts
+  var abap_exports = {};
+  __export(abap_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "*"
+    },
+    brackets: [
+      ["[", "]"],
+      ["(", ")"]
+    ]
+  };
+  var language = {
+    defaultToken: "invalid",
+    ignoreCase: true,
+    tokenPostfix: ".abap",
+    keywords: [
+      "abap-source",
+      "abbreviated",
+      "abstract",
+      "accept",
+      "accepting",
+      "according",
+      "activation",
+      "actual",
+      "add",
+      "add-corresponding",
+      "adjacent",
+      "after",
+      "alias",
+      "aliases",
+      "align",
+      "all",
+      "allocate",
+      "alpha",
+      "analysis",
+      "analyzer",
+      "and",
+      // also an operator
+      "append",
+      "appendage",
+      "appending",
+      "application",
+      "archive",
+      "area",
+      "arithmetic",
+      "as",
+      "ascending",
+      "aspect",
+      "assert",
+      "assign",
+      "assigned",
+      "assigning",
+      "association",
+      "asynchronous",
+      "at",
+      "attributes",
+      "authority",
+      "authority-check",
+      "avg",
+      "back",
+      "background",
+      "backup",
+      "backward",
+      "badi",
+      "base",
+      "before",
+      "begin",
+      "between",
+      // also an operator
+      "big",
+      "binary",
+      "bintohex",
+      "bit",
+      "black",
+      "blank",
+      "blanks",
+      "blob",
+      "block",
+      "blocks",
+      "blue",
+      "bound",
+      "boundaries",
+      "bounds",
+      "boxed",
+      "break-point",
+      "buffer",
+      "by",
+      "bypassing",
+      "byte",
+      "byte-order",
+      "call",
+      "calling",
+      "case",
+      "cast",
+      "casting",
+      "catch",
+      "center",
+      "centered",
+      "chain",
+      "chain-input",
+      "chain-request",
+      "change",
+      "changing",
+      "channels",
+      "character",
+      "char-to-hex",
+      "check",
+      "checkbox",
+      "ci_",
+      "circular",
+      "class",
+      "class-coding",
+      "class-data",
+      "class-events",
+      "class-methods",
+      "class-pool",
+      "cleanup",
+      "clear",
+      "client",
+      "clob",
+      "clock",
+      "close",
+      "coalesce",
+      "code",
+      "coding",
+      "col_background",
+      "col_group",
+      "col_heading",
+      "col_key",
+      "col_negative",
+      "col_normal",
+      "col_positive",
+      "col_total",
+      "collect",
+      "color",
+      "column",
+      "columns",
+      "comment",
+      "comments",
+      "commit",
+      "common",
+      "communication",
+      "comparing",
+      "component",
+      "components",
+      "compression",
+      "compute",
+      "concat",
+      "concat_with_space",
+      "concatenate",
+      "cond",
+      "condense",
+      // also a built-in
+      "condition",
+      "connect",
+      "connection",
+      "constants",
+      "context",
+      "contexts",
+      "continue",
+      "control",
+      "controls",
+      "conv",
+      "conversion",
+      "convert",
+      "copies",
+      "copy",
+      "corresponding",
+      "country",
+      "cover",
+      "cpi",
+      "create",
+      "creating",
+      "critical",
+      "currency",
+      "currency_conversion",
+      "current",
+      "cursor",
+      "cursor-selection",
+      "customer",
+      "customer-function",
+      "dangerous",
+      "data",
+      "database",
+      "datainfo",
+      "dataset",
+      "date",
+      "dats_add_days",
+      "dats_add_months",
+      "dats_days_between",
+      "dats_is_valid",
+      "daylight",
+      "dd/mm/yy",
+      "dd/mm/yyyy",
+      "ddmmyy",
+      "deallocate",
+      "decimal_shift",
+      "decimals",
+      "declarations",
+      "deep",
+      "default",
+      "deferred",
+      "define",
+      "defining",
+      "definition",
+      "delete",
+      "deleting",
+      "demand",
+      "department",
+      "descending",
+      "describe",
+      "destination",
+      "detail",
+      "dialog",
+      "directory",
+      "disconnect",
+      "display",
+      "display-mode",
+      "distinct",
+      "divide",
+      "divide-corresponding",
+      "division",
+      "do",
+      "dummy",
+      "duplicate",
+      "duplicates",
+      "duration",
+      "during",
+      "dynamic",
+      "dynpro",
+      "edit",
+      "editor-call",
+      "else",
+      "elseif",
+      "empty",
+      "enabled",
+      "enabling",
+      "encoding",
+      "end",
+      "endat",
+      "endcase",
+      "endcatch",
+      "endchain",
+      "endclass",
+      "enddo",
+      "endenhancement",
+      "end-enhancement-section",
+      "endexec",
+      "endform",
+      "endfunction",
+      "endian",
+      "endif",
+      "ending",
+      "endinterface",
+      "end-lines",
+      "endloop",
+      "endmethod",
+      "endmodule",
+      "end-of-definition",
+      "end-of-editing",
+      "end-of-file",
+      "end-of-page",
+      "end-of-selection",
+      "endon",
+      "endprovide",
+      "endselect",
+      "end-test-injection",
+      "end-test-seam",
+      "endtry",
+      "endwhile",
+      "endwith",
+      "engineering",
+      "enhancement",
+      "enhancement-point",
+      "enhancements",
+      "enhancement-section",
+      "entries",
+      "entry",
+      "enum",
+      "environment",
+      "equiv",
+      // also an operator
+      "errormessage",
+      "errors",
+      "escaping",
+      "event",
+      "events",
+      "exact",
+      "except",
+      "exception",
+      "exceptions",
+      "exception-table",
+      "exclude",
+      "excluding",
+      "exec",
+      "execute",
+      "exists",
+      "exit",
+      "exit-command",
+      "expand",
+      "expanding",
+      "expiration",
+      "explicit",
+      "exponent",
+      "export",
+      "exporting",
+      "extend",
+      "extended",
+      "extension",
+      "extract",
+      "fail",
+      "fetch",
+      "field",
+      "field-groups",
+      "fields",
+      "field-symbol",
+      "field-symbols",
+      "file",
+      "filter",
+      "filters",
+      "filter-table",
+      "final",
+      "find",
+      // also a built-in
+      "first",
+      "first-line",
+      "fixed-point",
+      "fkeq",
+      "fkge",
+      "flush",
+      "font",
+      "for",
+      "form",
+      "format",
+      "forward",
+      "found",
+      "frame",
+      "frames",
+      "free",
+      "friends",
+      "from",
+      "function",
+      "functionality",
+      "function-pool",
+      "further",
+      "gaps",
+      "generate",
+      "get",
+      "giving",
+      "gkeq",
+      "gkge",
+      "global",
+      "grant",
+      "green",
+      "group",
+      "groups",
+      "handle",
+      "handler",
+      "harmless",
+      "hashed",
+      // also a table type
+      "having",
+      "hdb",
+      "header",
+      "headers",
+      "heading",
+      "head-lines",
+      "help-id",
+      "help-request",
+      "hextobin",
+      "hide",
+      "high",
+      "hint",
+      "hold",
+      "hotspot",
+      "icon",
+      "id",
+      "identification",
+      "identifier",
+      "ids",
+      "if",
+      "ignore",
+      "ignoring",
+      "immediately",
+      "implementation",
+      "implementations",
+      "implemented",
+      "implicit",
+      "import",
+      "importing",
+      "in",
+      // also an operator
+      "inactive",
+      "incl",
+      "include",
+      "includes",
+      "including",
+      "increment",
+      "index",
+      // also a table type
+      "index-line",
+      "infotypes",
+      "inheriting",
+      "init",
+      "initial",
+      "initialization",
+      "inner",
+      "inout",
+      "input",
+      "insert",
+      // also a built-in
+      "instance",
+      "instances",
+      "instr",
+      "intensified",
+      "interface",
+      "interface-pool",
+      "interfaces",
+      "internal",
+      "intervals",
+      "into",
+      "inverse",
+      "inverted-date",
+      "is",
+      "iso",
+      "job",
+      "join",
+      "keep",
+      "keeping",
+      "kernel",
+      "key",
+      "keys",
+      "keywords",
+      "kind",
+      "language",
+      "last",
+      "late",
+      "layout",
+      "leading",
+      "leave",
+      "left",
+      "left-justified",
+      "leftplus",
+      "leftspace",
+      "legacy",
+      "length",
+      "let",
+      "level",
+      "levels",
+      "like",
+      "line",
+      "lines",
+      // also a built-in
+      "line-count",
+      "linefeed",
+      "line-selection",
+      "line-size",
+      "list",
+      "listbox",
+      "list-processing",
+      "little",
+      "llang",
+      "load",
+      "load-of-program",
+      "lob",
+      "local",
+      "locale",
+      "locator",
+      "logfile",
+      "logical",
+      "log-point",
+      "long",
+      "loop",
+      "low",
+      "lower",
+      "lpad",
+      "lpi",
+      "ltrim",
+      "mail",
+      "main",
+      "major-id",
+      "mapping",
+      "margin",
+      "mark",
+      "mask",
+      "match",
+      // also a built-in
+      "matchcode",
+      "max",
+      "maximum",
+      "medium",
+      "members",
+      "memory",
+      "mesh",
+      "message",
+      "message-id",
+      "messages",
+      "messaging",
+      "method",
+      "methods",
+      "min",
+      "minimum",
+      "minor-id",
+      "mm/dd/yy",
+      "mm/dd/yyyy",
+      "mmddyy",
+      "mode",
+      "modif",
+      "modifier",
+      "modify",
+      "module",
+      "move",
+      "move-corresponding",
+      "multiply",
+      "multiply-corresponding",
+      "name",
+      "nametab",
+      "native",
+      "nested",
+      "nesting",
+      "new",
+      "new-line",
+      "new-page",
+      "new-section",
+      "next",
+      "no",
+      "no-display",
+      "no-extension",
+      "no-gap",
+      "no-gaps",
+      "no-grouping",
+      "no-heading",
+      "no-scrolling",
+      "no-sign",
+      "no-title",
+      "no-topofpage",
+      "no-zero",
+      "node",
+      "nodes",
+      "non-unicode",
+      "non-unique",
+      "not",
+      // also an operator
+      "null",
+      "number",
+      "object",
+      // also a data type
+      "objects",
+      "obligatory",
+      "occurrence",
+      "occurrences",
+      "occurs",
+      "of",
+      "off",
+      "offset",
+      "ole",
+      "on",
+      "only",
+      "open",
+      "option",
+      "optional",
+      "options",
+      "or",
+      // also an operator
+      "order",
+      "other",
+      "others",
+      "out",
+      "outer",
+      "output",
+      "output-length",
+      "overflow",
+      "overlay",
+      "pack",
+      "package",
+      "pad",
+      "padding",
+      "page",
+      "pages",
+      "parameter",
+      "parameters",
+      "parameter-table",
+      "part",
+      "partially",
+      "pattern",
+      "percentage",
+      "perform",
+      "performing",
+      "person",
+      "pf1",
+      "pf10",
+      "pf11",
+      "pf12",
+      "pf13",
+      "pf14",
+      "pf15",
+      "pf2",
+      "pf3",
+      "pf4",
+      "pf5",
+      "pf6",
+      "pf7",
+      "pf8",
+      "pf9",
+      "pf-status",
+      "pink",
+      "places",
+      "pool",
+      "pos_high",
+      "pos_low",
+      "position",
+      "pragmas",
+      "precompiled",
+      "preferred",
+      "preserving",
+      "primary",
+      "print",
+      "print-control",
+      "priority",
+      "private",
+      "procedure",
+      "process",
+      "program",
+      "property",
+      "protected",
+      "provide",
+      "public",
+      "push",
+      "pushbutton",
+      "put",
+      "queue-only",
+      "quickinfo",
+      "radiobutton",
+      "raise",
+      "raising",
+      "range",
+      "ranges",
+      "read",
+      "reader",
+      "read-only",
+      "receive",
+      "received",
+      "receiver",
+      "receiving",
+      "red",
+      "redefinition",
+      "reduce",
+      "reduced",
+      "ref",
+      "reference",
+      "refresh",
+      "regex",
+      "reject",
+      "remote",
+      "renaming",
+      "replace",
+      // also a built-in
+      "replacement",
+      "replacing",
+      "report",
+      "request",
+      "requested",
+      "reserve",
+      "reset",
+      "resolution",
+      "respecting",
+      "responsible",
+      "result",
+      "results",
+      "resumable",
+      "resume",
+      "retry",
+      "return",
+      "returncode",
+      "returning",
+      "returns",
+      "right",
+      "right-justified",
+      "rightplus",
+      "rightspace",
+      "risk",
+      "rmc_communication_failure",
+      "rmc_invalid_status",
+      "rmc_system_failure",
+      "role",
+      "rollback",
+      "rows",
+      "rpad",
+      "rtrim",
+      "run",
+      "sap",
+      "sap-spool",
+      "saving",
+      "scale_preserving",
+      "scale_preserving_scientific",
+      "scan",
+      "scientific",
+      "scientific_with_leading_zero",
+      "scroll",
+      "scroll-boundary",
+      "scrolling",
+      "search",
+      "secondary",
+      "seconds",
+      "section",
+      "select",
+      "selection",
+      "selections",
+      "selection-screen",
+      "selection-set",
+      "selection-sets",
+      "selection-table",
+      "select-options",
+      "send",
+      "separate",
+      "separated",
+      "set",
+      "shared",
+      "shift",
+      "short",
+      "shortdump-id",
+      "sign_as_postfix",
+      "single",
+      "size",
+      "skip",
+      "skipping",
+      "smart",
+      "some",
+      "sort",
+      "sortable",
+      "sorted",
+      // also a table type
+      "source",
+      "specified",
+      "split",
+      "spool",
+      "spots",
+      "sql",
+      "sqlscript",
+      "stable",
+      "stamp",
+      "standard",
+      // also a table type
+      "starting",
+      "start-of-editing",
+      "start-of-selection",
+      "state",
+      "statement",
+      "statements",
+      "static",
+      "statics",
+      "statusinfo",
+      "step-loop",
+      "stop",
+      "structure",
+      "structures",
+      "style",
+      "subkey",
+      "submatches",
+      "submit",
+      "subroutine",
+      "subscreen",
+      "subtract",
+      "subtract-corresponding",
+      "suffix",
+      "sum",
+      "summary",
+      "summing",
+      "supplied",
+      "supply",
+      "suppress",
+      "switch",
+      "switchstates",
+      "symbol",
+      "syncpoints",
+      "syntax",
+      "syntax-check",
+      "syntax-trace",
+      "system-call",
+      "system-exceptions",
+      "system-exit",
+      "tab",
+      "tabbed",
+      "table",
+      "tables",
+      "tableview",
+      "tabstrip",
+      "target",
+      "task",
+      "tasks",
+      "test",
+      "testing",
+      "test-injection",
+      "test-seam",
+      "text",
+      "textpool",
+      "then",
+      "throw",
+      "time",
+      "times",
+      "timestamp",
+      "timezone",
+      "tims_is_valid",
+      "title",
+      "titlebar",
+      "title-lines",
+      "to",
+      "tokenization",
+      "tokens",
+      "top-lines",
+      "top-of-page",
+      "trace-file",
+      "trace-table",
+      "trailing",
+      "transaction",
+      "transfer",
+      "transformation",
+      "translate",
+      // also a built-in
+      "transporting",
+      "trmac",
+      "truncate",
+      "truncation",
+      "try",
+      "tstmp_add_seconds",
+      "tstmp_current_utctimestamp",
+      "tstmp_is_valid",
+      "tstmp_seconds_between",
+      "type",
+      "type-pool",
+      "type-pools",
+      "types",
+      "uline",
+      "unassign",
+      "under",
+      "unicode",
+      "union",
+      "unique",
+      "unit_conversion",
+      "unix",
+      "unpack",
+      "until",
+      "unwind",
+      "up",
+      "update",
+      "upper",
+      "user",
+      "user-command",
+      "using",
+      "utf-8",
+      "valid",
+      "value",
+      "value-request",
+      "values",
+      "vary",
+      "varying",
+      "verification-message",
+      "version",
+      "via",
+      "view",
+      "visible",
+      "wait",
+      "warning",
+      "when",
+      "whenever",
+      "where",
+      "while",
+      "width",
+      "window",
+      "windows",
+      "with",
+      "with-heading",
+      "without",
+      "with-title",
+      "word",
+      "work",
+      "write",
+      "writer",
+      "xml",
+      "xsd",
+      "yellow",
+      "yes",
+      "yymmdd",
+      "zero",
+      "zone",
+      // since 7.55:
+      "abap_system_timezone",
+      "abap_user_timezone",
+      "access",
+      "action",
+      "adabas",
+      "adjust_numbers",
+      "allow_precision_loss",
+      "allowed",
+      "amdp",
+      "applicationuser",
+      "as_geo_json",
+      "as400",
+      "associations",
+      "balance",
+      "behavior",
+      "breakup",
+      "bulk",
+      "cds",
+      "cds_client",
+      "check_before_save",
+      "child",
+      "clients",
+      "corr",
+      "corr_spearman",
+      "cross",
+      "cycles",
+      "datn_add_days",
+      "datn_add_months",
+      "datn_days_between",
+      "dats_from_datn",
+      "dats_tims_to_tstmp",
+      "dats_to_datn",
+      "db2",
+      "db6",
+      "ddl",
+      "dense_rank",
+      "depth",
+      "deterministic",
+      "discarding",
+      "entities",
+      "entity",
+      "error",
+      "failed",
+      "finalize",
+      "first_value",
+      "fltp_to_dec",
+      "following",
+      "fractional",
+      "full",
+      "graph",
+      "grouping",
+      "hierarchy",
+      "hierarchy_ancestors",
+      "hierarchy_ancestors_aggregate",
+      "hierarchy_descendants",
+      "hierarchy_descendants_aggregate",
+      "hierarchy_siblings",
+      "incremental",
+      "indicators",
+      "lag",
+      "last_value",
+      "lead",
+      "leaves",
+      "like_regexpr",
+      "link",
+      "locale_sap",
+      "lock",
+      "locks",
+      "many",
+      "mapped",
+      "matched",
+      "measures",
+      "median",
+      "mssqlnt",
+      "multiple",
+      "nodetype",
+      "ntile",
+      "nulls",
+      "occurrences_regexpr",
+      "one",
+      "operations",
+      "oracle",
+      "orphans",
+      "over",
+      "parent",
+      "parents",
+      "partition",
+      "pcre",
+      "period",
+      "pfcg_mapping",
+      "preceding",
+      "privileged",
+      "product",
+      "projection",
+      "rank",
+      "redirected",
+      "replace_regexpr",
+      "reported",
+      "response",
+      "responses",
+      "root",
+      "row",
+      "row_number",
+      "sap_system_date",
+      "save",
+      "schema",
+      "session",
+      "sets",
+      "shortdump",
+      "siblings",
+      "spantree",
+      "start",
+      "stddev",
+      "string_agg",
+      "subtotal",
+      "sybase",
+      "tims_from_timn",
+      "tims_to_timn",
+      "to_blob",
+      "to_clob",
+      "total",
+      "trace-entry",
+      "tstmp_to_dats",
+      "tstmp_to_dst",
+      "tstmp_to_tims",
+      "tstmpl_from_utcl",
+      "tstmpl_to_utcl",
+      "unbounded",
+      "utcl_add_seconds",
+      "utcl_current",
+      "utcl_seconds_between",
+      "uuid",
+      "var",
+      "verbatim"
+    ],
+    //
+    // Built-in Functions
+    //
+    // Functions that are also statements have been moved to keywords
+    //
+    builtinFunctions: [
+      "abs",
+      "acos",
+      "asin",
+      "atan",
+      "bit-set",
+      "boolc",
+      "boolx",
+      "ceil",
+      "char_off",
+      "charlen",
+      "cmax",
+      "cmin",
+      "concat_lines_of",
+      // 'condense', // moved to keywords
+      "contains",
+      "contains_any_not_of",
+      "contains_any_of",
+      "cos",
+      "cosh",
+      "count",
+      "count_any_not_of",
+      "count_any_of",
+      "dbmaxlen",
+      "distance",
+      "escape",
+      "exp",
+      // 'find', // moved to keywords
+      "find_any_not_of",
+      "find_any_of",
+      "find_end",
+      "floor",
+      "frac",
+      "from_mixed",
+      // 'insert', // moved to keywords
+      "ipow",
+      "line_exists",
+      "line_index",
+      // 'lines', // moved to keywords
+      "log",
+      "log10",
+      // 'match', // moved to keywords
+      "matches",
+      "nmax",
+      "nmin",
+      "numofchar",
+      "repeat",
+      // 'replace', // moved to keywords
+      "rescale",
+      "reverse",
+      "round",
+      "segment",
+      "shift_left",
+      "shift_right",
+      "sign",
+      "sin",
+      "sinh",
+      "sqrt",
+      "strlen",
+      "substring",
+      "substring_after",
+      "substring_before",
+      "substring_from",
+      "substring_to",
+      "tan",
+      "tanh",
+      "to_lower",
+      "to_mixed",
+      "to_upper",
+      // 'translate', // moved to keywords
+      "trunc",
+      "utclong_add",
+      // since 7.54
+      "utclong_current",
+      // since 7.54
+      "utclong_diff",
+      // since 7.54
+      "xsdbool",
+      "xstrlen"
+    ],
+    //
+    // Data Types
+    //
+    // Data types that are also part of statements have been moved to keywords
+    //
+    typeKeywords: [
+      // built-in abap types
+      "b",
+      "c",
+      "d",
+      "decfloat16",
+      "decfloat34",
+      "f",
+      "i",
+      "int8",
+      // since 7.54
+      "n",
+      "p",
+      "s",
+      "string",
+      "t",
+      "utclong",
+      // since 7.54
+      "x",
+      "xstring",
+      // generic data types
+      "any",
+      "clike",
+      "csequence",
+      "decfloat",
+      // 'object', // moved to keywords
+      "numeric",
+      "simple",
+      "xsequence",
+      // ddic/sql data types
+      "accp",
+      "char",
+      "clnt",
+      "cuky",
+      "curr",
+      "datn",
+      // since 7.55
+      "dats",
+      "d16d",
+      // since 7.55
+      "d16n",
+      // since 7.55
+      "d16r",
+      // since 7.55
+      "d34d",
+      // since 7.55
+      "d34n",
+      // since 7.55
+      "d34r",
+      // since 7.55
+      "dec",
+      "df16_dec",
+      "df16_raw",
+      "df34_dec",
+      "df34_raw",
+      "fltp",
+      "geom_ewkb",
+      // since 7.55
+      "int1",
+      "int2",
+      "int4",
+      "lang",
+      "lchr",
+      "lraw",
+      "numc",
+      "quan",
+      "raw",
+      "rawstring",
+      "sstring",
+      "timn",
+      // since 7.55
+      "tims",
+      "unit",
+      "utcl",
+      // since 7.55
+      // ddic data types (obsolete)
+      "df16_scl",
+      "df34_scl",
+      "prec",
+      "varc",
+      // special data types and constants
+      "abap_bool",
+      "abap_false",
+      "abap_true",
+      "abap_undefined",
+      "me",
+      "screen",
+      "space",
+      "super",
+      "sy",
+      "syst",
+      "table_line",
+      // obsolete data object
+      "*sys*"
+    ],
+    builtinMethods: ["class_constructor", "constructor"],
+    derivedTypes: [
+      "%CID",
+      "%CID_REF",
+      "%CONTROL",
+      "%DATA",
+      "%ELEMENT",
+      "%FAIL",
+      "%KEY",
+      "%MSG",
+      "%PARAM",
+      "%PID",
+      "%PID_ASSOC",
+      "%PID_PARENT",
+      "%_HINTS"
+    ],
+    cdsLanguage: [
+      "@AbapAnnotation",
+      "@AbapCatalog",
+      "@AccessControl",
+      "@API",
+      "@ClientDependent",
+      "@ClientHandling",
+      "@CompatibilityContract",
+      "@DataAging",
+      "@EndUserText",
+      "@Environment",
+      "@LanguageDependency",
+      "@MappingRole",
+      "@Metadata",
+      "@MetadataExtension",
+      "@ObjectModel",
+      "@Scope",
+      "@Semantics",
+      "$EXTENSION",
+      "$SELF"
+    ],
+    selectors: ["->", "->*", "=>", "~", "~*"],
+    //
+    // Operators
+    //
+    // Operators that can be part of statements have been moved to keywords
+    //
+    operators: [
+      // arithmetic operators
+      " +",
+      " -",
+      "/",
+      "*",
+      "**",
+      "div",
+      "mod",
+      // assignment operators
+      "=",
+      "#",
+      "@",
+      "+=",
+      "-=",
+      "*=",
+      "/=",
+      "**=",
+      "&&=",
+      // casting operator
+      "?=",
+      // concat operators
+      "&",
+      "&&",
+      // bit operators
+      "bit-and",
+      "bit-not",
+      "bit-or",
+      "bit-xor",
+      "m",
+      "o",
+      "z",
+      // boolean operators
+      // 'and', // moved to keywords
+      // 'equiv', // moved to keywords
+      // 'not', // moved to keywords
+      // 'or', // moved to keywords
+      // comparison operators
+      "<",
+      " >",
+      // todo: separate from -> and =>
+      "<=",
+      ">=",
+      "<>",
+      "><",
+      // obsolete
+      "=<",
+      // obsolete
+      "=>",
+      // obsolete
+      // 'between', // moved to keywords
+      "bt",
+      "byte-ca",
+      "byte-cn",
+      "byte-co",
+      "byte-cs",
+      "byte-na",
+      "byte-ns",
+      "ca",
+      "cn",
+      "co",
+      "cp",
+      "cs",
+      "eq",
+      // obsolete
+      "ge",
+      // obsolete
+      "gt",
+      // obsolete
+      // 'in', // moved to keywords
+      "le",
+      // obsolete
+      "lt",
+      // obsolete
+      "na",
+      "nb",
+      "ne",
+      // obsolete
+      "np",
+      "ns",
+      // cds
+      "*/",
+      "*:",
+      "--",
+      "/*",
+      "//"
+    ],
+    symbols: /[=><!~?&+\-*\/\^%#@]+/,
+    tokenizer: {
+      root: [
+        [
+          /[a-z_\/$%@]([\w\/$%]|-(?!>))*/,
+          // exclude '->' selector
+          {
+            cases: {
+              "@typeKeywords": "type",
+              "@keywords": "keyword",
+              "@cdsLanguage": "annotation",
+              "@derivedTypes": "type",
+              "@builtinFunctions": "type",
+              "@builtinMethods": "type",
+              "@operators": "key",
+              "@default": "identifier"
+            }
+          }
+        ],
+        [/<[\w]+>/, "identifier"],
+        // field symbols
+        [/##[\w|_]+/, "comment"],
+        // pragmas
+        { include: "@whitespace" },
+        [/[:,.]/, "delimiter"],
+        [/[{}()\[\]]/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@selectors": "tag",
+              "@operators": "key",
+              "@default": ""
+            }
+          }
+        ],
+        [/'/, { token: "string", bracket: "@open", next: "@stringquote" }],
+        [/`/, { token: "string", bracket: "@open", next: "@stringping" }],
+        [/\|/, { token: "string", bracket: "@open", next: "@stringtemplate" }],
+        [/\d+/, "number"]
+      ],
+      stringtemplate: [
+        [/[^\\\|]+/, "string"],
+        [/\\\|/, "string"],
+        [/\|/, { token: "string", bracket: "@close", next: "@pop" }]
+      ],
+      stringping: [
+        [/[^\\`]+/, "string"],
+        [/`/, { token: "string", bracket: "@close", next: "@pop" }]
+      ],
+      stringquote: [
+        [/[^\\']+/, "string"],
+        [/'/, { token: "string", bracket: "@close", next: "@pop" }]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/^\*.*$/, "comment"],
+        [/\".*$/, "comment"]
+      ]
+    }
+  };
+  return __toCommonJS(abap_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/apex/apex.js

@@ -0,0 +1,364 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/apex/apex", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/apex/apex.ts
+  var apex_exports = {};
+  __export(apex_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    // the default separators except `@$`
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "<", close: ">" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),
+        end: new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")
+      }
+    }
+  };
+  var keywords = [
+    "abstract",
+    "activate",
+    "and",
+    "any",
+    "array",
+    "as",
+    "asc",
+    "assert",
+    "autonomous",
+    "begin",
+    "bigdecimal",
+    "blob",
+    "boolean",
+    "break",
+    "bulk",
+    "by",
+    "case",
+    "cast",
+    "catch",
+    "char",
+    "class",
+    "collect",
+    "commit",
+    "const",
+    "continue",
+    "convertcurrency",
+    "decimal",
+    "default",
+    "delete",
+    "desc",
+    "do",
+    "double",
+    "else",
+    "end",
+    "enum",
+    "exception",
+    "exit",
+    "export",
+    "extends",
+    "false",
+    "final",
+    "finally",
+    "float",
+    "for",
+    "from",
+    "future",
+    "get",
+    "global",
+    "goto",
+    "group",
+    "having",
+    "hint",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "inner",
+    "insert",
+    "instanceof",
+    "int",
+    "interface",
+    "into",
+    "join",
+    "last_90_days",
+    "last_month",
+    "last_n_days",
+    "last_week",
+    "like",
+    "limit",
+    "list",
+    "long",
+    "loop",
+    "map",
+    "merge",
+    "native",
+    "new",
+    "next_90_days",
+    "next_month",
+    "next_n_days",
+    "next_week",
+    "not",
+    "null",
+    "nulls",
+    "number",
+    "object",
+    "of",
+    "on",
+    "or",
+    "outer",
+    "override",
+    "package",
+    "parallel",
+    "pragma",
+    "private",
+    "protected",
+    "public",
+    "retrieve",
+    "return",
+    "returning",
+    "rollback",
+    "savepoint",
+    "search",
+    "select",
+    "set",
+    "short",
+    "sort",
+    "stat",
+    "static",
+    "strictfp",
+    "super",
+    "switch",
+    "synchronized",
+    "system",
+    "testmethod",
+    "then",
+    "this",
+    "this_month",
+    "this_week",
+    "throw",
+    "throws",
+    "today",
+    "tolabel",
+    "tomorrow",
+    "transaction",
+    "transient",
+    "trigger",
+    "true",
+    "try",
+    "type",
+    "undelete",
+    "update",
+    "upsert",
+    "using",
+    "virtual",
+    "void",
+    "volatile",
+    "webservice",
+    "when",
+    "where",
+    "while",
+    "yesterday"
+  ];
+  var uppercaseFirstLetter = (lowercase) => lowercase.charAt(0).toUpperCase() + lowercase.substr(1);
+  var keywordsWithCaseVariations = [];
+  keywords.forEach((lowercase) => {
+    keywordsWithCaseVariations.push(lowercase);
+    keywordsWithCaseVariations.push(lowercase.toUpperCase());
+    keywordsWithCaseVariations.push(uppercaseFirstLetter(lowercase));
+  });
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".apex",
+    keywords: keywordsWithCaseVariations,
+    operators: [
+      "=",
+      ">",
+      "<",
+      "!",
+      "~",
+      "?",
+      ":",
+      "==",
+      "<=",
+      ">=",
+      "!=",
+      "&&",
+      "||",
+      "++",
+      "--",
+      "+",
+      "-",
+      "*",
+      "/",
+      "&",
+      "|",
+      "^",
+      "%",
+      "<<",
+      ">>",
+      ">>>",
+      "+=",
+      "-=",
+      "*=",
+      "/=",
+      "&=",
+      "|=",
+      "^=",
+      "%=",
+      "<<=",
+      ">>=",
+      ">>>="
+    ],
+    // we include these common regular expressions
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    digits: /\d+(_+\d+)*/,
+    octaldigits: /[0-7]+(_+[0-7]+)*/,
+    binarydigits: /[0-1]+(_+[0-1]+)*/,
+    hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // identifiers and keywords
+        [
+          /[a-z_$][\w$]*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        // assume that identifiers starting with an uppercase letter are types
+        [
+          /[A-Z][\w\$]*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "type.identifier"
+            }
+          }
+        ],
+        // whitespace
+        { include: "@whitespace" },
+        // delimiters and operators
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        // @ annotations.
+        [/@\s*[a-zA-Z_\$][\w\$]*/, "annotation"],
+        // numbers
+        [/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/, "number.float"],
+        [/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/, "number.float"],
+        [/(@digits)[fFdD]/, "number.float"],
+        [/(@digits)[lL]?/, "number"],
+        // delimiter: after number because of .\d floats
+        [/[;,.]/, "delimiter"],
+        // strings
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/'([^'\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/"/, "string", '@string."'],
+        [/'/, "string", "@string.'"],
+        // characters
+        [/'[^\\']'/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*\*(?!\/)/, "comment.doc", "@apexdoc"],
+        [/\/\*/, "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
+      apexdoc: [
+        [/[^\/*]+/, "comment.doc"],
+        [/\*\//, "comment.doc", "@pop"],
+        [/[\/*]/, "comment.doc"]
+      ],
+      string: [
+        [/[^\\"']+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [
+          /["']/,
+          {
+            cases: {
+              "$#==$S2": { token: "string", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ]
+      ]
+    }
+  };
+  return __toCommonJS(apex_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/azcli/azcli.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
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/azcli/azcli", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/azcli/azcli.ts
+  var azcli_exports = {};
+  __export(azcli_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "#"
+    }
+  };
+  var language = {
+    defaultToken: "keyword",
+    ignoreCase: true,
+    tokenPostfix: ".azcli",
+    str: /[^#\s]/,
+    tokenizer: {
+      root: [
+        { include: "@comment" },
+        [
+          /\s-+@str*\s*/,
+          {
+            cases: {
+              "@eos": { token: "key.identifier", next: "@popall" },
+              "@default": { token: "key.identifier", next: "@type" }
+            }
+          }
+        ],
+        [
+          /^-+@str*\s*/,
+          {
+            cases: {
+              "@eos": { token: "key.identifier", next: "@popall" },
+              "@default": { token: "key.identifier", next: "@type" }
+            }
+          }
+        ]
+      ],
+      type: [
+        { include: "@comment" },
+        [
+          /-+@str*\s*/,
+          {
+            cases: {
+              "@eos": { token: "key.identifier", next: "@popall" },
+              "@default": "key.identifier"
+            }
+          }
+        ],
+        [
+          /@str+\s*/,
+          {
+            cases: {
+              "@eos": { token: "string", next: "@popall" },
+              "@default": "string"
+            }
+          }
+        ]
+      ],
+      comment: [
+        [
+          /#.*$/,
+          {
+            cases: {
+              "@eos": { token: "comment", next: "@popall" }
+            }
+          }
+        ]
+      ]
+    }
+  };
+  return __toCommonJS(azcli_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/bat/bat.js

@@ -0,0 +1,134 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/bat/bat", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/bat/bat.ts
+  var bat_exports = {};
+  __export(bat_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "REM"
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' }
+    ],
+    surroundingPairs: [
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*(::\\s*|REM\\s+)#region"),
+        end: new RegExp("^\\s*(::\\s*|REM\\s+)#endregion")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    ignoreCase: true,
+    tokenPostfix: ".bat",
+    brackets: [
+      { token: "delimiter.bracket", open: "{", close: "}" },
+      { token: "delimiter.parenthesis", open: "(", close: ")" },
+      { token: "delimiter.square", open: "[", close: "]" }
+    ],
+    keywords: /call|defined|echo|errorlevel|exist|for|goto|if|pause|set|shift|start|title|not|pushd|popd/,
+    // we include these common regular expressions
+    symbols: /[=><!~?&|+\-*\/\^;\.,]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        [/^(\s*)(rem(?:\s.*|))$/, ["", "comment"]],
+        [/(\@?)(@keywords)(?!\w)/, [{ token: "keyword" }, { token: "keyword.$2" }]],
+        // whitespace
+        [/[ \t\r\n]+/, ""],
+        // blocks
+        [/setlocal(?!\w)/, "keyword.tag-setlocal"],
+        [/endlocal(?!\w)/, "keyword.tag-setlocal"],
+        // words
+        [/[a-zA-Z_]\w*/, ""],
+        // labels
+        [/:\w*/, "metatag"],
+        // variables
+        [/%[^%]+%/, "variable"],
+        [/%%[\w]+(?!\w)/, "variable"],
+        // punctuations
+        [/[{}()\[\]]/, "@brackets"],
+        [/@symbols/, "delimiter"],
+        // numbers
+        [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+        [/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, "number.hex"],
+        [/\d+/, "number"],
+        // punctuation: after number because of .\d floats
+        [/[;,.]/, "delimiter"],
+        // strings:
+        [/"/, "string", '@string."'],
+        [/'/, "string", "@string.'"]
+      ],
+      string: [
+        [
+          /[^\\"'%]+/,
+          {
+            cases: {
+              "@eos": { token: "string", next: "@popall" },
+              "@default": "string"
+            }
+          }
+        ],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/%[\w ]+%/, "variable"],
+        [/%%[\w]+(?!\w)/, "variable"],
+        [
+          /["']/,
+          {
+            cases: {
+              "$#==$S2": { token: "string", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ],
+        [/$/, "string", "@popall"]
+      ]
+    }
+  };
+  return __toCommonJS(bat_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/bicep/bicep.js

@@ -0,0 +1,143 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/bicep/bicep", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/bicep/bicep.ts
+  var bicep_exports = {};
+  __export(bicep_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var bounded = (text) => `\\b${text}\\b`;
+  var identifierStart = "[_a-zA-Z]";
+  var identifierContinue = "[_a-zA-Z0-9]";
+  var identifier = bounded(`${identifierStart}${identifierContinue}*`);
+  var keywords = [
+    "targetScope",
+    "resource",
+    "module",
+    "param",
+    "var",
+    "output",
+    "for",
+    "in",
+    "if",
+    "existing"
+  ];
+  var namedLiterals = ["true", "false", "null"];
+  var nonCommentWs = `[ \\t\\r\\n]`;
+  var numericLiteral = `[0-9]+`;
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "'", close: "'" },
+      { open: "'''", close: "'''" }
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "'", close: "'", notIn: ["string", "comment"] },
+      { open: "'''", close: "'''", notIn: ["string", "comment"] }
+    ],
+    autoCloseBefore: ":.,=}])' \n	",
+    indentationRules: {
+      increaseIndentPattern: new RegExp("^((?!\\/\\/).)*(\\{[^}\"'`]*|\\([^)\"'`]*|\\[[^\\]\"'`]*)$"),
+      decreaseIndentPattern: new RegExp("^((?!.*?\\/\\*).*\\*/)?\\s*[\\}\\]].*$")
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".bicep",
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" }
+    ],
+    symbols: /[=><!~?:&|+\-*/^%]+/,
+    keywords,
+    namedLiterals,
+    escapes: `\\\\(u{[0-9A-Fa-f]+}|n|r|t|\\\\|'|\\\${)`,
+    tokenizer: {
+      root: [{ include: "@expression" }, { include: "@whitespace" }],
+      stringVerbatim: [
+        { regex: `(|'|'')[^']`, action: { token: "string" } },
+        { regex: `'''`, action: { token: "string.quote", next: "@pop" } }
+      ],
+      stringLiteral: [
+        { regex: `\\\${`, action: { token: "delimiter.bracket", next: "@bracketCounting" } },
+        { regex: `[^\\\\'$]+`, action: { token: "string" } },
+        { regex: "@escapes", action: { token: "string.escape" } },
+        { regex: `\\\\.`, action: { token: "string.escape.invalid" } },
+        { regex: `'`, action: { token: "string", next: "@pop" } }
+      ],
+      bracketCounting: [
+        { regex: `{`, action: { token: "delimiter.bracket", next: "@bracketCounting" } },
+        { regex: `}`, action: { token: "delimiter.bracket", next: "@pop" } },
+        { include: "expression" }
+      ],
+      comment: [
+        { regex: `[^\\*]+`, action: { token: "comment" } },
+        { regex: `\\*\\/`, action: { token: "comment", next: "@pop" } },
+        { regex: `[\\/*]`, action: { token: "comment" } }
+      ],
+      whitespace: [
+        { regex: nonCommentWs },
+        { regex: `\\/\\*`, action: { token: "comment", next: "@comment" } },
+        { regex: `\\/\\/.*$`, action: { token: "comment" } }
+      ],
+      expression: [
+        { regex: `'''`, action: { token: "string.quote", next: "@stringVerbatim" } },
+        { regex: `'`, action: { token: "string.quote", next: "@stringLiteral" } },
+        { regex: numericLiteral, action: { token: "number" } },
+        {
+          regex: identifier,
+          action: {
+            cases: {
+              "@keywords": { token: "keyword" },
+              "@namedLiterals": { token: "keyword" },
+              "@default": { token: "identifier" }
+            }
+          }
+        }
+      ]
+    }
+  };
+  return __toCommonJS(bicep_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/cameligo/cameligo.js

@@ -0,0 +1,208 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/cameligo/cameligo", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/cameligo/cameligo.ts
+  var cameligo_exports = {};
+  __export(cameligo_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  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"]
+      ]
+    }
+  };
+  return __toCommonJS(cameligo_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/clojure/clojure.js

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

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/coffee/coffee.js

@@ -0,0 +1,266 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/coffee/coffee", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/coffee/coffee.ts
+  var coffee_exports = {};
+  __export(coffee_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\$\-\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+    comments: {
+      blockComment: ["###", "###"],
+      lineComment: "#"
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*#region\\b"),
+        end: new RegExp("^\\s*#endregion\\b")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    ignoreCase: true,
+    tokenPostfix: ".coffee",
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" }
+    ],
+    regEx: /\/(?!\/\/)(?:[^\/\\]|\\.)*\/[igm]*/,
+    keywords: [
+      "and",
+      "or",
+      "is",
+      "isnt",
+      "not",
+      "on",
+      "yes",
+      "@",
+      "no",
+      "off",
+      "true",
+      "false",
+      "null",
+      "this",
+      "new",
+      "delete",
+      "typeof",
+      "in",
+      "instanceof",
+      "return",
+      "throw",
+      "break",
+      "continue",
+      "debugger",
+      "if",
+      "else",
+      "switch",
+      "for",
+      "while",
+      "do",
+      "try",
+      "catch",
+      "finally",
+      "class",
+      "extends",
+      "super",
+      "undefined",
+      "then",
+      "unless",
+      "until",
+      "loop",
+      "of",
+      "by",
+      "when"
+    ],
+    // we include these common regular expressions
+    symbols: /[=><!~?&%|+\-*\/\^\.,\:]+/,
+    escapes: /\\(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // identifiers and keywords
+        [/\@[a-zA-Z_]\w*/, "variable.predefined"],
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              this: "variable.predefined",
+              "@keywords": { token: "keyword.$0" },
+              "@default": ""
+            }
+          }
+        ],
+        // whitespace
+        [/[ \t\r\n]+/, ""],
+        // Comments
+        [/###/, "comment", "@comment"],
+        [/#.*$/, "comment"],
+        // regular expressions
+        ["///", { token: "regexp", next: "@hereregexp" }],
+        [/^(\s*)(@regEx)/, ["", "regexp"]],
+        [/(\()(\s*)(@regEx)/, ["@brackets", "", "regexp"]],
+        [/(\,)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+        [/(\=)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+        [/(\:)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+        [/(\[)(\s*)(@regEx)/, ["@brackets", "", "regexp"]],
+        [/(\!)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+        [/(\&)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+        [/(\|)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+        [/(\?)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+        [/(\{)(\s*)(@regEx)/, ["@brackets", "", "regexp"]],
+        [/(\;)(\s*)(@regEx)/, ["", "", "regexp"]],
+        // delimiters
+        [
+          /}/,
+          {
+            cases: {
+              "$S2==interpolatedstring": {
+                token: "string",
+                next: "@pop"
+              },
+              "@default": "@brackets"
+            }
+          }
+        ],
+        [/[{}()\[\]]/, "@brackets"],
+        [/@symbols/, "delimiter"],
+        // numbers
+        [/\d+[eE]([\-+]?\d+)?/, "number.float"],
+        [/\d+\.\d+([eE][\-+]?\d+)?/, "number.float"],
+        [/0[xX][0-9a-fA-F]+/, "number.hex"],
+        [/0[0-7]+(?!\d)/, "number.octal"],
+        [/\d+/, "number"],
+        // delimiter: after number because of .\d floats
+        [/[,.]/, "delimiter"],
+        // strings:
+        [/"""/, "string", '@herestring."""'],
+        [/'''/, "string", "@herestring.'''"],
+        [
+          /"/,
+          {
+            cases: {
+              "@eos": "string",
+              "@default": { token: "string", next: '@string."' }
+            }
+          }
+        ],
+        [
+          /'/,
+          {
+            cases: {
+              "@eos": "string",
+              "@default": { token: "string", next: "@string.'" }
+            }
+          }
+        ]
+      ],
+      string: [
+        [/[^"'\#\\]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\./, "string.escape.invalid"],
+        [/\./, "string.escape.invalid"],
+        [
+          /#{/,
+          {
+            cases: {
+              '$S2=="': {
+                token: "string",
+                next: "root.interpolatedstring"
+              },
+              "@default": "string"
+            }
+          }
+        ],
+        [
+          /["']/,
+          {
+            cases: {
+              "$#==$S2": { token: "string", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ],
+        [/#/, "string"]
+      ],
+      herestring: [
+        [
+          /("""|''')/,
+          {
+            cases: {
+              "$1==$S2": { token: "string", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ],
+        [/[^#\\'"]+/, "string"],
+        [/['"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\./, "string.escape.invalid"],
+        [/#{/, { token: "string.quote", next: "root.interpolatedstring" }],
+        [/#/, "string"]
+      ],
+      comment: [
+        [/[^#]+/, "comment"],
+        [/###/, "comment", "@pop"],
+        [/#/, "comment"]
+      ],
+      hereregexp: [
+        [/[^\\\/#]+/, "regexp"],
+        [/\\./, "regexp"],
+        [/#.*$/, "comment"],
+        ["///[igm]*", { token: "regexp", next: "@pop" }],
+        [/\//, "regexp"]
+      ]
+    }
+  };
+  return __toCommonJS(coffee_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/cpp/cpp.js

@@ -0,0 +1,423 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/cpp/cpp", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/cpp/cpp.ts
+  var cpp_exports = {};
+  __export(cpp_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "[", close: "]" },
+      { open: "{", close: "}" },
+      { open: "(", close: ")" },
+      { open: "'", close: "'", notIn: ["string", "comment"] },
+      { open: '"', close: '"', notIn: ["string"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*#pragma\\s+region\\b"),
+        end: new RegExp("^\\s*#pragma\\s+endregion\\b")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".cpp",
+    brackets: [
+      { token: "delimiter.curly", open: "{", close: "}" },
+      { token: "delimiter.parenthesis", open: "(", close: ")" },
+      { token: "delimiter.square", open: "[", close: "]" },
+      { token: "delimiter.angle", open: "<", close: ">" }
+    ],
+    keywords: [
+      "abstract",
+      "amp",
+      "array",
+      "auto",
+      "bool",
+      "break",
+      "case",
+      "catch",
+      "char",
+      "class",
+      "const",
+      "constexpr",
+      "const_cast",
+      "continue",
+      "cpu",
+      "decltype",
+      "default",
+      "delegate",
+      "delete",
+      "do",
+      "double",
+      "dynamic_cast",
+      "each",
+      "else",
+      "enum",
+      "event",
+      "explicit",
+      "export",
+      "extern",
+      "false",
+      "final",
+      "finally",
+      "float",
+      "for",
+      "friend",
+      "gcnew",
+      "generic",
+      "goto",
+      "if",
+      "in",
+      "initonly",
+      "inline",
+      "int",
+      "interface",
+      "interior_ptr",
+      "internal",
+      "literal",
+      "long",
+      "mutable",
+      "namespace",
+      "new",
+      "noexcept",
+      "nullptr",
+      "__nullptr",
+      "operator",
+      "override",
+      "partial",
+      "pascal",
+      "pin_ptr",
+      "private",
+      "property",
+      "protected",
+      "public",
+      "ref",
+      "register",
+      "reinterpret_cast",
+      "restrict",
+      "return",
+      "safe_cast",
+      "sealed",
+      "short",
+      "signed",
+      "sizeof",
+      "static",
+      "static_assert",
+      "static_cast",
+      "struct",
+      "switch",
+      "template",
+      "this",
+      "thread_local",
+      "throw",
+      "tile_static",
+      "true",
+      "try",
+      "typedef",
+      "typeid",
+      "typename",
+      "union",
+      "unsigned",
+      "using",
+      "virtual",
+      "void",
+      "volatile",
+      "wchar_t",
+      "where",
+      "while",
+      "_asm",
+      // reserved word with one underscores
+      "_based",
+      "_cdecl",
+      "_declspec",
+      "_fastcall",
+      "_if_exists",
+      "_if_not_exists",
+      "_inline",
+      "_multiple_inheritance",
+      "_pascal",
+      "_single_inheritance",
+      "_stdcall",
+      "_virtual_inheritance",
+      "_w64",
+      "__abstract",
+      // reserved word with two underscores
+      "__alignof",
+      "__asm",
+      "__assume",
+      "__based",
+      "__box",
+      "__builtin_alignof",
+      "__cdecl",
+      "__clrcall",
+      "__declspec",
+      "__delegate",
+      "__event",
+      "__except",
+      "__fastcall",
+      "__finally",
+      "__forceinline",
+      "__gc",
+      "__hook",
+      "__identifier",
+      "__if_exists",
+      "__if_not_exists",
+      "__inline",
+      "__int128",
+      "__int16",
+      "__int32",
+      "__int64",
+      "__int8",
+      "__interface",
+      "__leave",
+      "__m128",
+      "__m128d",
+      "__m128i",
+      "__m256",
+      "__m256d",
+      "__m256i",
+      "__m512",
+      "__m512d",
+      "__m512i",
+      "__m64",
+      "__multiple_inheritance",
+      "__newslot",
+      "__nogc",
+      "__noop",
+      "__nounwind",
+      "__novtordisp",
+      "__pascal",
+      "__pin",
+      "__pragma",
+      "__property",
+      "__ptr32",
+      "__ptr64",
+      "__raise",
+      "__restrict",
+      "__resume",
+      "__sealed",
+      "__single_inheritance",
+      "__stdcall",
+      "__super",
+      "__thiscall",
+      "__try",
+      "__try_cast",
+      "__typeof",
+      "__unaligned",
+      "__unhook",
+      "__uuidof",
+      "__value",
+      "__virtual_inheritance",
+      "__w64",
+      "__wchar_t"
+    ],
+    operators: [
+      "=",
+      ">",
+      "<",
+      "!",
+      "~",
+      "?",
+      ":",
+      "==",
+      "<=",
+      ">=",
+      "!=",
+      "&&",
+      "||",
+      "++",
+      "--",
+      "+",
+      "-",
+      "*",
+      "/",
+      "&",
+      "|",
+      "^",
+      "%",
+      "<<",
+      ">>",
+      "+=",
+      "-=",
+      "*=",
+      "/=",
+      "&=",
+      "|=",
+      "^=",
+      "%=",
+      "<<=",
+      ">>="
+    ],
+    // we include these common regular expressions
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[0abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    integersuffix: /([uU](ll|LL|l|L)|(ll|LL|l|L)?[uU]?)/,
+    floatsuffix: /[fFlL]?/,
+    encoding: /u|u8|U|L/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // C++ 11 Raw String
+        [/@encoding?R\"(?:([^ ()\\\t]*))\(/, { token: "string.raw.begin", next: "@raw.$1" }],
+        // identifiers and keywords
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        // The preprocessor checks must be before whitespace as they check /^\s*#/ which
+        // otherwise fails to match later after other whitespace has been removed.
+        // Inclusion
+        [/^\s*#\s*include/, { token: "keyword.directive.include", next: "@include" }],
+        // Preprocessor directive
+        [/^\s*#\s*\w+/, "keyword.directive"],
+        // whitespace
+        { include: "@whitespace" },
+        // [[ attributes ]].
+        [/\[\s*\[/, { token: "annotation", next: "@annotation" }],
+        // delimiters and operators
+        [/[{}()<>\[\]]/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        // numbers
+        [/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/, "number.float"],
+        [/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/, "number.float"],
+        [/0[xX][0-9a-fA-F']*[0-9a-fA-F](@integersuffix)/, "number.hex"],
+        [/0[0-7']*[0-7](@integersuffix)/, "number.octal"],
+        [/0[bB][0-1']*[0-1](@integersuffix)/, "number.binary"],
+        [/\d[\d']*\d(@integersuffix)/, "number"],
+        [/\d(@integersuffix)/, "number"],
+        // delimiter: after number because of .\d floats
+        [/[;,.]/, "delimiter"],
+        // strings
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/"/, "string", "@string"],
+        // characters
+        [/'[^\\']'/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*\*(?!\/)/, "comment.doc", "@doccomment"],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*\\$/, "comment", "@linecomment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      //For use with continuous line comments
+      linecomment: [
+        [/.*[^\\]$/, "comment", "@pop"],
+        [/[^]+/, "comment"]
+      ],
+      //Identical copy of comment above, except for the addition of .doc
+      doccomment: [
+        [/[^\/*]+/, "comment.doc"],
+        [/\*\//, "comment.doc", "@pop"],
+        [/[\/*]/, "comment.doc"]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"]
+      ],
+      raw: [
+        [/[^)]+/, "string.raw"],
+        [/\)$S2\"/, { token: "string.raw.end", next: "@pop" }],
+        [/\)/, "string.raw"]
+      ],
+      annotation: [
+        { include: "@whitespace" },
+        [/using|alignas/, "keyword"],
+        [/[a-zA-Z0-9_]+/, "annotation"],
+        [/[,:]/, "delimiter"],
+        [/[()]/, "@brackets"],
+        [/\]\s*\]/, { token: "annotation", next: "@pop" }]
+      ],
+      include: [
+        [
+          /(\s*)(<)([^<>]*)(>)/,
+          [
+            "",
+            "keyword.directive.include.begin",
+            "string.include.identifier",
+            { token: "keyword.directive.include.end", next: "@pop" }
+          ]
+        ],
+        [
+          /(\s*)(")([^"]*)(")/,
+          [
+            "",
+            "keyword.directive.include.begin",
+            "string.include.identifier",
+            { token: "keyword.directive.include.end", next: "@pop" }
+          ]
+        ]
+      ]
+    }
+  };
+  return __toCommonJS(cpp_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/csharp/csharp.js

@@ -0,0 +1,360 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/csharp/csharp", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/csharp/csharp.ts
+  var csharp_exports = {};
+  __export(csharp_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\$\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "'", close: "'", notIn: ["string", "comment"] },
+      { open: '"', close: '"', notIn: ["string", "comment"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">" },
+      { open: "'", close: "'" },
+      { open: '"', close: '"' }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*#region\\b"),
+        end: new RegExp("^\\s*#endregion\\b")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".cs",
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "<", close: ">", token: "delimiter.angle" }
+    ],
+    keywords: [
+      "extern",
+      "alias",
+      "using",
+      "bool",
+      "decimal",
+      "sbyte",
+      "byte",
+      "short",
+      "ushort",
+      "int",
+      "uint",
+      "long",
+      "ulong",
+      "char",
+      "float",
+      "double",
+      "object",
+      "dynamic",
+      "string",
+      "assembly",
+      "is",
+      "as",
+      "ref",
+      "out",
+      "this",
+      "base",
+      "new",
+      "typeof",
+      "void",
+      "checked",
+      "unchecked",
+      "default",
+      "delegate",
+      "var",
+      "const",
+      "if",
+      "else",
+      "switch",
+      "case",
+      "while",
+      "do",
+      "for",
+      "foreach",
+      "in",
+      "break",
+      "continue",
+      "goto",
+      "return",
+      "throw",
+      "try",
+      "catch",
+      "finally",
+      "lock",
+      "yield",
+      "from",
+      "let",
+      "where",
+      "join",
+      "on",
+      "equals",
+      "into",
+      "orderby",
+      "ascending",
+      "descending",
+      "select",
+      "group",
+      "by",
+      "namespace",
+      "partial",
+      "class",
+      "field",
+      "event",
+      "method",
+      "param",
+      "public",
+      "protected",
+      "internal",
+      "private",
+      "abstract",
+      "sealed",
+      "static",
+      "struct",
+      "readonly",
+      "volatile",
+      "virtual",
+      "override",
+      "params",
+      "get",
+      "set",
+      "add",
+      "remove",
+      "operator",
+      "true",
+      "false",
+      "implicit",
+      "explicit",
+      "interface",
+      "enum",
+      "null",
+      "async",
+      "await",
+      "fixed",
+      "sizeof",
+      "stackalloc",
+      "unsafe",
+      "nameof",
+      "when"
+    ],
+    namespaceFollows: ["namespace", "using"],
+    parenFollows: ["if", "for", "while", "switch", "foreach", "using", "catch", "when"],
+    operators: [
+      "=",
+      "??",
+      "||",
+      "&&",
+      "|",
+      "^",
+      "&",
+      "==",
+      "!=",
+      "<=",
+      ">=",
+      "<<",
+      "+",
+      "-",
+      "*",
+      "/",
+      "%",
+      "!",
+      "~",
+      "++",
+      "--",
+      "+=",
+      "-=",
+      "*=",
+      "/=",
+      "%=",
+      "&=",
+      "|=",
+      "^=",
+      "<<=",
+      ">>=",
+      ">>",
+      "=>"
+    ],
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    // escape sequences
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // identifiers and keywords
+        [
+          /\@?[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@namespaceFollows": {
+                token: "keyword.$0",
+                next: "@namespace"
+              },
+              "@keywords": {
+                token: "keyword.$0",
+                next: "@qualified"
+              },
+              "@default": { token: "identifier", next: "@qualified" }
+            }
+          }
+        ],
+        // whitespace
+        { include: "@whitespace" },
+        // delimiters and operators
+        [
+          /}/,
+          {
+            cases: {
+              "$S2==interpolatedstring": {
+                token: "string.quote",
+                next: "@pop"
+              },
+              "$S2==litinterpstring": {
+                token: "string.quote",
+                next: "@pop"
+              },
+              "@default": "@brackets"
+            }
+          }
+        ],
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        // numbers
+        [/[0-9_]*\.[0-9_]+([eE][\-+]?\d+)?[fFdD]?/, "number.float"],
+        [/0[xX][0-9a-fA-F_]+/, "number.hex"],
+        [/0[bB][01_]+/, "number.hex"],
+        // binary: use same theme style as hex
+        [/[0-9_]+/, "number"],
+        // delimiter: after number because of .\d floats
+        [/[;,.]/, "delimiter"],
+        // strings
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/"/, { token: "string.quote", next: "@string" }],
+        [/\$\@"/, { token: "string.quote", next: "@litinterpstring" }],
+        [/\@"/, { token: "string.quote", next: "@litstring" }],
+        [/\$"/, { token: "string.quote", next: "@interpolatedstring" }],
+        // characters
+        [/'[^\\']'/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      qualified: [
+        [
+          /[a-zA-Z_][\w]*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        [/\./, "delimiter"],
+        ["", "", "@pop"]
+      ],
+      namespace: [
+        { include: "@whitespace" },
+        [/[A-Z]\w*/, "namespace"],
+        [/[\.=]/, "delimiter"],
+        ["", "", "@pop"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        // [/\/\*/,    'comment', '@push' ],    // no nested comments :-(
+        ["\\*/", "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, { token: "string.quote", next: "@pop" }]
+      ],
+      litstring: [
+        [/[^"]+/, "string"],
+        [/""/, "string.escape"],
+        [/"/, { token: "string.quote", next: "@pop" }]
+      ],
+      litinterpstring: [
+        [/[^"{]+/, "string"],
+        [/""/, "string.escape"],
+        [/{{/, "string.escape"],
+        [/}}/, "string.escape"],
+        [/{/, { token: "string.quote", next: "root.litinterpstring" }],
+        [/"/, { token: "string.quote", next: "@pop" }]
+      ],
+      interpolatedstring: [
+        [/[^\\"{]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/{{/, "string.escape"],
+        [/}}/, "string.escape"],
+        [/{/, { token: "string.quote", next: "root.interpolatedstring" }],
+        [/"/, { token: "string.quote", next: "@pop" }]
+      ],
+      whitespace: [
+        [/^[ \t\v\f]*#((r)|(load))(?=\s)/, "directive.csx"],
+        [/^[ \t\v\f]*#\w.*$/, "namespace.cpp"],
+        [/[ \t\v\f\r\n]+/, ""],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ]
+    }
+  };
+  return __toCommonJS(csharp_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/csp/csp.js

@@ -0,0 +1,87 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/csp/csp", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/csp/csp.ts
+  var csp_exports = {};
+  __export(csp_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    brackets: [],
+    autoClosingPairs: [],
+    surroundingPairs: []
+  };
+  var language = {
+    // Set defaultToken to invalid to see what you do not tokenize yet
+    // defaultToken: 'invalid',
+    keywords: [],
+    typeKeywords: [],
+    tokenPostfix: ".csp",
+    operators: [],
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    tokenizer: {
+      root: [
+        [/child-src/, "string.quote"],
+        [/connect-src/, "string.quote"],
+        [/default-src/, "string.quote"],
+        [/font-src/, "string.quote"],
+        [/frame-src/, "string.quote"],
+        [/img-src/, "string.quote"],
+        [/manifest-src/, "string.quote"],
+        [/media-src/, "string.quote"],
+        [/object-src/, "string.quote"],
+        [/script-src/, "string.quote"],
+        [/style-src/, "string.quote"],
+        [/worker-src/, "string.quote"],
+        [/base-uri/, "string.quote"],
+        [/plugin-types/, "string.quote"],
+        [/sandbox/, "string.quote"],
+        [/disown-opener/, "string.quote"],
+        [/form-action/, "string.quote"],
+        [/frame-ancestors/, "string.quote"],
+        [/report-uri/, "string.quote"],
+        [/report-to/, "string.quote"],
+        [/upgrade-insecure-requests/, "string.quote"],
+        [/block-all-mixed-content/, "string.quote"],
+        [/require-sri-for/, "string.quote"],
+        [/reflected-xss/, "string.quote"],
+        [/referrer/, "string.quote"],
+        [/policy-uri/, "string.quote"],
+        [/'self'/, "string.quote"],
+        [/'unsafe-inline'/, "string.quote"],
+        [/'unsafe-eval'/, "string.quote"],
+        [/'strict-dynamic'/, "string.quote"],
+        [/'unsafe-hashed-attributes'/, "string.quote"]
+      ]
+    }
+  };
+  return __toCommonJS(csp_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/css/css.js

@@ -0,0 +1,219 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/css/css", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/css/css.ts
+  var css_exports = {};
+  __export(css_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  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"]
+      ]
+    }
+  };
+  return __toCommonJS(css_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/cypher/cypher.js

@@ -0,0 +1,297 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/cypher/cypher", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/cypher/cypher.ts
+  var cypher_exports = {};
+  __export(cypher_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "`", close: "`" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "`", close: "`" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: `.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"]
+      ]
+    }
+  };
+  return __toCommonJS(cypher_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/dart/dart.js

@@ -0,0 +1,315 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/dart/dart", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/dart/dart.ts
+  var dart_exports = {};
+  __export(dart_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "'", close: "'", notIn: ["string", "comment"] },
+      { open: '"', close: '"', notIn: ["string"] },
+      { open: "`", close: "`", notIn: ["string", "comment"] },
+      { open: "/**", close: " */", notIn: ["string"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">" },
+      { open: "'", close: "'" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "`", close: "`" }
+    ],
+    folding: {
+      markers: {
+        start: /^\s*\s*#?region\b/,
+        end: /^\s*\s*#?endregion\b/
+      }
+    }
+  };
+  var language = {
+    defaultToken: "invalid",
+    tokenPostfix: ".dart",
+    keywords: [
+      "abstract",
+      "dynamic",
+      "implements",
+      "show",
+      "as",
+      "else",
+      "import",
+      "static",
+      "assert",
+      "enum",
+      "in",
+      "super",
+      "async",
+      "export",
+      "interface",
+      "switch",
+      "await",
+      "extends",
+      "is",
+      "sync",
+      "break",
+      "external",
+      "library",
+      "this",
+      "case",
+      "factory",
+      "mixin",
+      "throw",
+      "catch",
+      "false",
+      "new",
+      "true",
+      "class",
+      "final",
+      "null",
+      "try",
+      "const",
+      "finally",
+      "on",
+      "typedef",
+      "continue",
+      "for",
+      "operator",
+      "var",
+      "covariant",
+      "Function",
+      "part",
+      "void",
+      "default",
+      "get",
+      "rethrow",
+      "while",
+      "deferred",
+      "hide",
+      "return",
+      "with",
+      "do",
+      "if",
+      "set",
+      "yield"
+    ],
+    typeKeywords: ["int", "double", "String", "bool"],
+    operators: [
+      "+",
+      "-",
+      "*",
+      "/",
+      "~/",
+      "%",
+      "++",
+      "--",
+      "==",
+      "!=",
+      ">",
+      "<",
+      ">=",
+      "<=",
+      "=",
+      "-=",
+      "/=",
+      "%=",
+      ">>=",
+      "^=",
+      "+=",
+      "*=",
+      "~/=",
+      "<<=",
+      "&=",
+      "!=",
+      "||",
+      "&&",
+      "&",
+      "|",
+      "^",
+      "~",
+      "<<",
+      ">>",
+      "!",
+      ">>>",
+      "??",
+      "?",
+      ":",
+      "|="
+    ],
+    // we include these common regular expressions
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    digits: /\d+(_+\d+)*/,
+    octaldigits: /[0-7]+(_+[0-7]+)*/,
+    binarydigits: /[0-1]+(_+[0-1]+)*/,
+    hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+    regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
+    regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [[/[{}]/, "delimiter.bracket"], { include: "common" }],
+      common: [
+        // identifiers and keywords
+        [
+          /[a-z_$][\w$]*/,
+          {
+            cases: {
+              "@typeKeywords": "type.identifier",
+              "@keywords": "keyword",
+              "@default": "identifier"
+            }
+          }
+        ],
+        [/[A-Z_$][\w\$]*/, "type.identifier"],
+        // show class names
+        // [/[A-Z][\w\$]*/, 'identifier'],
+        // whitespace
+        { include: "@whitespace" },
+        // regular expression: ensure it is terminated before beginning (otherwise it is an opeator)
+        [
+          /\/(?=([^\\\/]|\\.)+\/([gimsuy]*)(\s*)(\.|;|,|\)|\]|\}|$))/,
+          { token: "regexp", bracket: "@open", next: "@regexp" }
+        ],
+        // @ annotations.
+        [/@[a-zA-Z]+/, "annotation"],
+        // variable
+        // delimiters and operators
+        [/[()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [/!(?=([^=]|$))/, "delimiter"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        // numbers
+        [/(@digits)[eE]([\-+]?(@digits))?/, "number.float"],
+        [/(@digits)\.(@digits)([eE][\-+]?(@digits))?/, "number.float"],
+        [/0[xX](@hexdigits)n?/, "number.hex"],
+        [/0[oO]?(@octaldigits)n?/, "number.octal"],
+        [/0[bB](@binarydigits)n?/, "number.binary"],
+        [/(@digits)n?/, "number"],
+        // delimiter: after number because of .\d floats
+        [/[;,.]/, "delimiter"],
+        // strings
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/'([^'\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/"/, "string", "@string_double"],
+        [/'/, "string", "@string_single"]
+        //   [/[a-zA-Z]+/, "variable"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*\*(?!\/)/, "comment.doc", "@jsdoc"],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/\/.*$/, "comment.doc"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      jsdoc: [
+        [/[^\/*]+/, "comment.doc"],
+        [/\*\//, "comment.doc", "@pop"],
+        [/[\/*]/, "comment.doc"]
+      ],
+      // We match regular expression quite precisely
+      regexp: [
+        [
+          /(\{)(\d+(?:,\d*)?)(\})/,
+          ["regexp.escape.control", "regexp.escape.control", "regexp.escape.control"]
+        ],
+        [
+          /(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/,
+          ["regexp.escape.control", { token: "regexp.escape.control", next: "@regexrange" }]
+        ],
+        [/(\()(\?:|\?=|\?!)/, ["regexp.escape.control", "regexp.escape.control"]],
+        [/[()]/, "regexp.escape.control"],
+        [/@regexpctl/, "regexp.escape.control"],
+        [/[^\\\/]/, "regexp"],
+        [/@regexpesc/, "regexp.escape"],
+        [/\\\./, "regexp.invalid"],
+        [/(\/)([gimsuy]*)/, [{ token: "regexp", bracket: "@close", next: "@pop" }, "keyword.other"]]
+      ],
+      regexrange: [
+        [/-/, "regexp.escape.control"],
+        [/\^/, "regexp.invalid"],
+        [/@regexpesc/, "regexp.escape"],
+        [/[^\]]/, "regexp"],
+        [
+          /\]/,
+          {
+            token: "regexp.escape.control",
+            next: "@pop",
+            bracket: "@close"
+          }
+        ]
+      ],
+      string_double: [
+        [/[^\\"\$]+/, "string"],
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"],
+        [/\$\w+/, "identifier"]
+      ],
+      string_single: [
+        [/[^\\'\$]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/'/, "string", "@pop"],
+        [/\$\w+/, "identifier"]
+      ]
+    }
+  };
+  return __toCommonJS(dart_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/dockerfile/dockerfile.js

@@ -0,0 +1,164 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/dockerfile/dockerfile", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/dockerfile/dockerfile.ts
+  var dockerfile_exports = {};
+  __export(dockerfile_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ]
+  };
+  var language = {
+    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"]
+      ]
+    }
+  };
+  return __toCommonJS(dockerfile_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/ecl/ecl.js

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

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/elixir/elixir.js

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

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/flow9/flow9.js

@@ -0,0 +1,176 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/flow9/flow9", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/flow9/flow9.ts
+  var flow9_exports = {};
+  __export(flow9_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      blockComment: ["/*", "*/"],
+      lineComment: "//"
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}", notIn: ["string"] },
+      { open: "[", close: "]", notIn: ["string"] },
+      { open: "(", close: ")", notIn: ["string"] },
+      { open: '"', close: '"', notIn: ["string"] },
+      { open: "'", close: "'", notIn: ["string"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "<", close: ">" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".flow",
+    keywords: [
+      "import",
+      "require",
+      "export",
+      "forbid",
+      "native",
+      "if",
+      "else",
+      "cast",
+      "unsafe",
+      "switch",
+      "default"
+    ],
+    types: [
+      "io",
+      "mutable",
+      "bool",
+      "int",
+      "double",
+      "string",
+      "flow",
+      "void",
+      "ref",
+      "true",
+      "false",
+      "with"
+    ],
+    operators: [
+      "=",
+      ">",
+      "<",
+      "<=",
+      ">=",
+      "==",
+      "!",
+      "!=",
+      ":=",
+      "::=",
+      "&&",
+      "||",
+      "+",
+      "-",
+      "*",
+      "/",
+      "@",
+      "&",
+      "%",
+      ":",
+      "->",
+      "\\",
+      "$",
+      "??",
+      "^"
+    ],
+    symbols: /[@$=><!~?:&|+\-*\\\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // identifiers and keywords
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@keywords": "keyword",
+              "@types": "type",
+              "@default": "identifier"
+            }
+          }
+        ],
+        // whitespace
+        { include: "@whitespace" },
+        // delimiters and operators
+        [/[{}()\[\]]/, "delimiter"],
+        [/[<>](?!@symbols)/, "delimiter"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        // numbers
+        [/((0(x|X)[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)/, "number"],
+        // delimiter: after number because of .\d floats
+        [/[;,.]/, "delimiter"],
+        // strings
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        [/"/, "string", "@string"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"]
+      ]
+    }
+  };
+  return __toCommonJS(flow9_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/freemarker2/freemarker2.js

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

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/fsharp/fsharp.js

@@ -0,0 +1,251 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/fsharp/fsharp", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/fsharp/fsharp.ts
+  var fsharp_exports = {};
+  __export(fsharp_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["(*", "*)"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*//\\s*#region\\b|^\\s*\\(\\*\\s*#region(.*)\\*\\)"),
+        end: new RegExp("^\\s*//\\s*#endregion\\b|^\\s*\\(\\*\\s*#endregion\\s*\\*\\)")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".fs",
+    keywords: [
+      "abstract",
+      "and",
+      "atomic",
+      "as",
+      "assert",
+      "asr",
+      "base",
+      "begin",
+      "break",
+      "checked",
+      "component",
+      "const",
+      "constraint",
+      "constructor",
+      "continue",
+      "class",
+      "default",
+      "delegate",
+      "do",
+      "done",
+      "downcast",
+      "downto",
+      "elif",
+      "else",
+      "end",
+      "exception",
+      "eager",
+      "event",
+      "external",
+      "extern",
+      "false",
+      "finally",
+      "for",
+      "fun",
+      "function",
+      "fixed",
+      "functor",
+      "global",
+      "if",
+      "in",
+      "include",
+      "inherit",
+      "inline",
+      "interface",
+      "internal",
+      "land",
+      "lor",
+      "lsl",
+      "lsr",
+      "lxor",
+      "lazy",
+      "let",
+      "match",
+      "member",
+      "mod",
+      "module",
+      "mutable",
+      "namespace",
+      "method",
+      "mixin",
+      "new",
+      "not",
+      "null",
+      "of",
+      "open",
+      "or",
+      "object",
+      "override",
+      "private",
+      "parallel",
+      "process",
+      "protected",
+      "pure",
+      "public",
+      "rec",
+      "return",
+      "static",
+      "sealed",
+      "struct",
+      "sig",
+      "then",
+      "to",
+      "true",
+      "tailcall",
+      "trait",
+      "try",
+      "type",
+      "upcast",
+      "use",
+      "val",
+      "void",
+      "virtual",
+      "volatile",
+      "when",
+      "while",
+      "with",
+      "yield"
+    ],
+    // we include these common regular expressions
+    symbols: /[=><!~?:&|+\-*\^%;\.,\/]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    integersuffix: /[uU]?[yslnLI]?/,
+    floatsuffix: /[fFmM]?/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // identifiers and keywords
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        // whitespace
+        { include: "@whitespace" },
+        // [< attributes >].
+        [/\[<.*>\]/, "annotation"],
+        // Preprocessor directive
+        [/^#(if|else|endif)/, "keyword"],
+        // delimiters and operators
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [/@symbols/, "delimiter"],
+        // numbers
+        [/\d*\d+[eE]([\-+]?\d+)?(@floatsuffix)/, "number.float"],
+        [/\d*\.\d+([eE][\-+]?\d+)?(@floatsuffix)/, "number.float"],
+        [/0x[0-9a-fA-F]+LF/, "number.float"],
+        [/0x[0-9a-fA-F]+(@integersuffix)/, "number.hex"],
+        [/0b[0-1]+(@integersuffix)/, "number.bin"],
+        [/\d+(@integersuffix)/, "number"],
+        // delimiter: after number because of .\d floats
+        [/[;,.]/, "delimiter"],
+        // strings
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/"""/, "string", '@string."""'],
+        [/"/, "string", '@string."'],
+        // literal string
+        [/\@"/, { token: "string.quote", next: "@litstring" }],
+        // characters
+        [/'[^\\']'B?/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\(\*(?!\))/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^*(]+/, "comment"],
+        [/\*\)/, "comment", "@pop"],
+        [/\*/, "comment"],
+        [/\(\*\)/, "comment"],
+        [/\(/, "comment"]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [
+          /("""|"B?)/,
+          {
+            cases: {
+              "$#==$S2": { token: "string", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ]
+      ],
+      litstring: [
+        [/[^"]+/, "string"],
+        [/""/, "string.escape"],
+        [/"/, { token: "string.quote", next: "@pop" }]
+      ]
+    }
+  };
+  return __toCommonJS(fsharp_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/go/go.js

@@ -0,0 +1,252 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/go/go", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/go/go.ts
+  var go_exports = {};
+  __export(go_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "`", close: "`", notIn: ["string"] },
+      { open: '"', close: '"', notIn: ["string"] },
+      { open: "'", close: "'", notIn: ["string", "comment"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "`", close: "`" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".go",
+    keywords: [
+      "break",
+      "case",
+      "chan",
+      "const",
+      "continue",
+      "default",
+      "defer",
+      "else",
+      "fallthrough",
+      "for",
+      "func",
+      "go",
+      "goto",
+      "if",
+      "import",
+      "interface",
+      "map",
+      "package",
+      "range",
+      "return",
+      "select",
+      "struct",
+      "switch",
+      "type",
+      "var",
+      "bool",
+      "true",
+      "false",
+      "uint8",
+      "uint16",
+      "uint32",
+      "uint64",
+      "int8",
+      "int16",
+      "int32",
+      "int64",
+      "float32",
+      "float64",
+      "complex64",
+      "complex128",
+      "byte",
+      "rune",
+      "uint",
+      "int",
+      "uintptr",
+      "string",
+      "nil"
+    ],
+    operators: [
+      "+",
+      "-",
+      "*",
+      "/",
+      "%",
+      "&",
+      "|",
+      "^",
+      "<<",
+      ">>",
+      "&^",
+      "+=",
+      "-=",
+      "*=",
+      "/=",
+      "%=",
+      "&=",
+      "|=",
+      "^=",
+      "<<=",
+      ">>=",
+      "&^=",
+      "&&",
+      "||",
+      "<-",
+      "++",
+      "--",
+      "==",
+      "<",
+      ">",
+      "=",
+      "!",
+      "!=",
+      "<=",
+      ">=",
+      ":=",
+      "...",
+      "(",
+      ")",
+      "",
+      "]",
+      "{",
+      "}",
+      ",",
+      ";",
+      ".",
+      ":"
+    ],
+    // we include these common regular expressions
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // identifiers and keywords
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        // whitespace
+        { include: "@whitespace" },
+        // [[ attributes ]].
+        [/\[\[.*\]\]/, "annotation"],
+        // Preprocessor directive
+        [/^\s*#\w+/, "keyword"],
+        // delimiters and operators
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        // numbers
+        [/\d*\d+[eE]([\-+]?\d+)?/, "number.float"],
+        [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+        [/0[xX][0-9a-fA-F']*[0-9a-fA-F]/, "number.hex"],
+        [/0[0-7']*[0-7]/, "number.octal"],
+        [/0[bB][0-1']*[0-1]/, "number.binary"],
+        [/\d[\d']*/, "number"],
+        [/\d/, "number"],
+        // delimiter: after number because of .\d floats
+        [/[;,.]/, "delimiter"],
+        // strings
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/"/, "string", "@string"],
+        [/`/, "string", "@rawstring"],
+        // characters
+        [/'[^\\']'/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*\*(?!\/)/, "comment.doc", "@doccomment"],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        // [/\/\*/, 'comment', '@push' ],    // nested comment not allowed :-(
+        // [/\/\*/,    'comment.invalid' ],    // this breaks block comments in the shape of /* //*/
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      //Identical copy of comment above, except for the addition of .doc
+      doccomment: [
+        [/[^\/*]+/, "comment.doc"],
+        // [/\/\*/, 'comment.doc', '@push' ],    // nested comment not allowed :-(
+        [/\/\*/, "comment.doc.invalid"],
+        [/\*\//, "comment.doc", "@pop"],
+        [/[\/*]/, "comment.doc"]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"]
+      ],
+      rawstring: [
+        [/[^\`]/, "string"],
+        [/`/, "string", "@pop"]
+      ]
+    }
+  };
+  return __toCommonJS(go_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/graphql/graphql.js

@@ -0,0 +1,185 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/graphql/graphql", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/graphql/graphql.ts
+  var graphql_exports = {};
+  __export(graphql_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  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"]
+      ]
+    }
+  };
+  return __toCommonJS(graphql_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/handlebars/handlebars.js

@@ -0,0 +1,481 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/handlebars/handlebars", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __commonJS = (cb, mod) => function __require2() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/fillers/monaco-editor-core-amd.ts
+  var require_monaco_editor_core_amd = __commonJS({
+    "src/fillers/monaco-editor-core-amd.ts"(exports, module) {
+      var api = __toESM(__require("vs/editor/editor.api"));
+      module.exports = api;
+    }
+  });
+
+  // src/basic-languages/handlebars/handlebars.ts
+  var handlebars_exports = {};
+  __export(handlebars_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+
+  // src/fillers/monaco-editor-core.ts
+  var monaco_editor_core_exports = {};
+  __reExport(monaco_editor_core_exports, __toESM(require_monaco_editor_core_amd()));
+
+  // src/basic-languages/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" }],
+        [/<!DOCTYPE/, "metatag.html", "@doctype"],
+        [/<!--/, "comment.html", "@commentHtml"],
+        [/(<)(\w+)(\/>)/, ["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" }]],
+        [/</, "delimiter.html"],
+        [/\{/, "delimiter.html"],
+        [/[^<{]+/]
+        // text
+      ],
+      doctype: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.comment"
+          }
+        ],
+        [/[^>]+/, "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 <script> tags handling
+      // After <script
+      script: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.script"
+          }
+        ],
+        [/type/, "attribute.name", "@scriptAfterType"],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@scriptEmbedded.text/javascript",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        // whitespace
+        [
+          /(<\/)(script\s*)(>)/,
+          ["delimiter.html", "tag.html", { token: "delimiter.html", next: "@pop" }]
+        ]
+      ],
+      // After <script ... type
+      scriptAfterType: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.scriptAfterType"
+          }
+        ],
+        [/=/, "delimiter", "@scriptAfterTypeEquals"],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@scriptEmbedded.text/javascript",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        // cover invalid e.g. <script type>
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      // After <script ... type =
+      scriptAfterTypeEquals: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.scriptAfterTypeEquals"
+          }
+        ],
+        [
+          /"([^"]*)"/,
+          {
+            token: "attribute.value",
+            switchTo: "@scriptWithCustomType.$1"
+          }
+        ],
+        [
+          /'([^']*)'/,
+          {
+            token: "attribute.value",
+            switchTo: "@scriptWithCustomType.$1"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@scriptEmbedded.text/javascript",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        // cover invalid e.g. <script type=>
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      // After <script ... type = $S2
+      scriptWithCustomType: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.scriptWithCustomType.$S2"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@scriptEmbedded.$S2",
+            nextEmbedded: "$S2"
+          }
+        ],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      scriptEmbedded: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInEmbeddedState.scriptEmbedded.$S2",
+            nextEmbedded: "@pop"
+          }
+        ],
+        [/<\/script/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }]
+      ],
+      // -- END <script> tags handling
+      // -- BEGIN <style> tags handling
+      // After <style
+      style: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.style"
+          }
+        ],
+        [/type/, "attribute.name", "@styleAfterType"],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@styleEmbedded.text/css",
+            nextEmbedded: "text/css"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        // whitespace
+        [
+          /(<\/)(style\s*)(>)/,
+          ["delimiter.html", "tag.html", { token: "delimiter.html", next: "@pop" }]
+        ]
+      ],
+      // After <style ... type
+      styleAfterType: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.styleAfterType"
+          }
+        ],
+        [/=/, "delimiter", "@styleAfterTypeEquals"],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@styleEmbedded.text/css",
+            nextEmbedded: "text/css"
+          }
+        ],
+        // cover invalid e.g. <style type>
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      // After <style ... type =
+      styleAfterTypeEquals: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.styleAfterTypeEquals"
+          }
+        ],
+        [
+          /"([^"]*)"/,
+          {
+            token: "attribute.value",
+            switchTo: "@styleWithCustomType.$1"
+          }
+        ],
+        [
+          /'([^']*)'/,
+          {
+            token: "attribute.value",
+            switchTo: "@styleWithCustomType.$1"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@styleEmbedded.text/css",
+            nextEmbedded: "text/css"
+          }
+        ],
+        // cover invalid e.g. <style type=>
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      // After <style ... type = $S2
+      styleWithCustomType: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInSimpleState.styleWithCustomType.$S2"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@styleEmbedded.$S2",
+            nextEmbedded: "$S2"
+          }
+        ],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      styleEmbedded: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@handlebarsInEmbeddedState.styleEmbedded.$S2",
+            nextEmbedded: "@pop"
+          }
+        ],
+        [/<\/style/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }]
+      ],
+      // -- END <style> tags handling
+      handlebarsInSimpleState: [
+        [/\{\{\{?/, "delimiter.handlebars"],
+        [/\}\}\}?/, { token: "delimiter.handlebars", switchTo: "@$S2.$S3" }],
+        { include: "handlebarsRoot" }
+      ],
+      handlebarsInEmbeddedState: [
+        [/\{\{\{?/, "delimiter.handlebars"],
+        [
+          /\}\}\}?/,
+          {
+            token: "delimiter.handlebars",
+            switchTo: "@$S2.$S3",
+            nextEmbedded: "$S3"
+          }
+        ],
+        { include: "handlebarsRoot" }
+      ],
+      handlebarsRoot: [
+        [/"[^"]*"/, "string.handlebars"],
+        [/[#/][^\s}]+/, "keyword.helper.handlebars"],
+        [/else\b/, "keyword.helper.handlebars"],
+        [/[\s]+/],
+        [/[^}]/, "variable.parameter.handlebars"]
+      ]
+    }
+  };
+  return __toCommonJS(handlebars_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/hcl/hcl.js

@@ -0,0 +1,217 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/hcl/hcl", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/hcl/hcl.ts
+  var hcl_exports = {};
+  __export(hcl_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "#",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"', notIn: ["string"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".hcl",
+    keywords: [
+      "var",
+      "local",
+      "path",
+      "for_each",
+      "any",
+      "string",
+      "number",
+      "bool",
+      "true",
+      "false",
+      "null",
+      "if ",
+      "else ",
+      "endif ",
+      "for ",
+      "in",
+      "endfor"
+    ],
+    operators: [
+      "=",
+      ">=",
+      "<=",
+      "==",
+      "!=",
+      "+",
+      "-",
+      "*",
+      "/",
+      "%",
+      "&&",
+      "||",
+      "!",
+      "<",
+      ">",
+      "?",
+      "...",
+      ":"
+    ],
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    terraformFunctions: /(abs|ceil|floor|log|max|min|pow|signum|chomp|format|formatlist|indent|join|lower|regex|regexall|replace|split|strrev|substr|title|trimspace|upper|chunklist|coalesce|coalescelist|compact|concat|contains|distinct|element|flatten|index|keys|length|list|lookup|map|matchkeys|merge|range|reverse|setintersection|setproduct|setunion|slice|sort|transpose|values|zipmap|base64decode|base64encode|base64gzip|csvdecode|jsondecode|jsonencode|urlencode|yamldecode|yamlencode|abspath|dirname|pathexpand|basename|file|fileexists|fileset|filebase64|templatefile|formatdate|timeadd|timestamp|base64sha256|base64sha512|bcrypt|filebase64sha256|filebase64sha512|filemd5|filemd1|filesha256|filesha512|md5|rsadecrypt|sha1|sha256|sha512|uuid|uuidv5|cidrhost|cidrnetmask|cidrsubnet|tobool|tolist|tomap|tonumber|toset|tostring)/,
+    terraformMainBlocks: /(module|data|terraform|resource|provider|variable|output|locals)/,
+    tokenizer: {
+      root: [
+        // highlight main blocks
+        [
+          /^@terraformMainBlocks([ \t]*)([\w-]+|"[\w-]+"|)([ \t]*)([\w-]+|"[\w-]+"|)([ \t]*)(\{)/,
+          ["type", "", "string", "", "string", "", "@brackets"]
+        ],
+        // highlight all the remaining blocks
+        [
+          /(\w+[ \t]+)([ \t]*)([\w-]+|"[\w-]+"|)([ \t]*)([\w-]+|"[\w-]+"|)([ \t]*)(\{)/,
+          ["identifier", "", "string", "", "string", "", "@brackets"]
+        ],
+        // highlight block
+        [
+          /(\w+[ \t]+)([ \t]*)([\w-]+|"[\w-]+"|)([ \t]*)([\w-]+|"[\w-]+"|)(=)(\{)/,
+          ["identifier", "", "string", "", "operator", "", "@brackets"]
+        ],
+        // terraform general highlight - shared with expressions
+        { include: "@terraform" }
+      ],
+      terraform: [
+        // highlight terraform functions
+        [/@terraformFunctions(\()/, ["type", "@brackets"]],
+        // all other words are variables or keywords
+        [
+          /[a-zA-Z_]\w*-*/,
+          // must work with variables such as foo-bar and also with negative numbers
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "variable"
+            }
+          }
+        ],
+        { include: "@whitespace" },
+        { include: "@heredoc" },
+        // delimiters and operators
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "operator",
+              "@default": ""
+            }
+          }
+        ],
+        // numbers
+        [/\d*\d+[eE]([\-+]?\d+)?/, "number.float"],
+        [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+        [/\d[\d']*/, "number"],
+        [/\d/, "number"],
+        [/[;,.]/, "delimiter"],
+        // delimiter: after number because of .\d floats
+        // strings
+        [/"/, "string", "@string"],
+        // this will include expressions
+        [/'/, "invalid"]
+      ],
+      heredoc: [
+        [/<<[-]*\s*["]?([\w\-]+)["]?/, { token: "string.heredoc.delimiter", next: "@heredocBody.$1" }]
+      ],
+      heredocBody: [
+        [
+          /([\w\-]+)$/,
+          {
+            cases: {
+              "$1==$S2": [
+                {
+                  token: "string.heredoc.delimiter",
+                  next: "@popall"
+                }
+              ],
+              "@default": "string.heredoc"
+            }
+          }
+        ],
+        [/./, "string.heredoc"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"],
+        [/#.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      string: [
+        [/\$\{/, { token: "delimiter", next: "@stringExpression" }],
+        [/[^\\"\$]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@popall"]
+      ],
+      stringInsideExpression: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"]
+      ],
+      stringExpression: [
+        [/\}/, { token: "delimiter", next: "@pop" }],
+        [/"/, "string", "@stringInsideExpression"],
+        { include: "@terraform" }
+      ]
+    }
+  };
+  return __toCommonJS(hcl_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/html/html.js

@@ -0,0 +1,370 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/html/html", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __commonJS = (cb, mod) => function __require2() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/fillers/monaco-editor-core-amd.ts
+  var require_monaco_editor_core_amd = __commonJS({
+    "src/fillers/monaco-editor-core-amd.ts"(exports, module) {
+      var api = __toESM(__require("vs/editor/editor.api"));
+      module.exports = api;
+    }
+  });
+
+  // src/basic-languages/html/html.ts
+  var html_exports = {};
+  __export(html_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+
+  // src/fillers/monaco-editor-core.ts
+  var monaco_editor_core_exports = {};
+  __reExport(monaco_editor_core_exports, __toESM(require_monaco_editor_core_amd()));
+
+  // src/basic-languages/html/html.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: "}" },
+      { 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 }
+      }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*<!--\\s*#region\\b.*-->"),
+        end: new RegExp("^\\s*<!--\\s*#endregion\\b.*-->")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".html",
+    ignoreCase: true,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        [/<!DOCTYPE/, "metatag", "@doctype"],
+        [/<!--/, "comment", "@comment"],
+        [/(<)((?:[\w\-]+:)?[\w\-]+)(\s*)(\/>)/, ["delimiter", "tag", "", "delimiter"]],
+        [/(<)(script)/, ["delimiter", { token: "tag", next: "@script" }]],
+        [/(<)(style)/, ["delimiter", { token: "tag", next: "@style" }]],
+        [/(<)((?:[\w\-]+:)?[\w\-]+)/, ["delimiter", { token: "tag", next: "@otherTag" }]],
+        [/(<\/)((?:[\w\-]+:)?[\w\-]+)/, ["delimiter", { token: "tag", next: "@otherTag" }]],
+        [/</, "delimiter"],
+        [/[^<]+/]
+        // text
+      ],
+      doctype: [
+        [/[^>]+/, "metatag.content"],
+        [/>/, "metatag", "@pop"]
+      ],
+      comment: [
+        [/-->/, "comment", "@pop"],
+        [/[^-]+/, "comment.content"],
+        [/./, "comment.content"]
+      ],
+      otherTag: [
+        [/\/?>/, "delimiter", "@pop"],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [/[ \t\r\n]+/]
+        // whitespace
+      ],
+      // -- BEGIN <script> tags handling
+      // After <script
+      script: [
+        [/type/, "attribute.name", "@scriptAfterType"],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [
+          />/,
+          {
+            token: "delimiter",
+            next: "@scriptEmbedded",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/(<\/)(script\s*)(>)/, ["delimiter", "tag", { token: "delimiter", next: "@pop" }]]
+      ],
+      // After <script ... type
+      scriptAfterType: [
+        [/=/, "delimiter", "@scriptAfterTypeEquals"],
+        [
+          />/,
+          {
+            token: "delimiter",
+            next: "@scriptEmbedded",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        // cover invalid e.g. <script type>
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      // After <script ... type =
+      scriptAfterTypeEquals: [
+        [
+          /"module"/,
+          {
+            token: "attribute.value",
+            switchTo: "@scriptWithCustomType.text/javascript"
+          }
+        ],
+        [
+          /'module'/,
+          {
+            token: "attribute.value",
+            switchTo: "@scriptWithCustomType.text/javascript"
+          }
+        ],
+        [
+          /"([^"]*)"/,
+          {
+            token: "attribute.value",
+            switchTo: "@scriptWithCustomType.$1"
+          }
+        ],
+        [
+          /'([^']*)'/,
+          {
+            token: "attribute.value",
+            switchTo: "@scriptWithCustomType.$1"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter",
+            next: "@scriptEmbedded",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        // cover invalid e.g. <script type=>
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      // After <script ... type = $S2
+      scriptWithCustomType: [
+        [
+          />/,
+          {
+            token: "delimiter",
+            next: "@scriptEmbedded.$S2",
+            nextEmbedded: "$S2"
+          }
+        ],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      scriptEmbedded: [
+        [/<\/script/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }],
+        [/[^<]+/, ""]
+      ],
+      // -- END <script> tags handling
+      // -- BEGIN <style> tags handling
+      // After <style
+      style: [
+        [/type/, "attribute.name", "@styleAfterType"],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [
+          />/,
+          {
+            token: "delimiter",
+            next: "@styleEmbedded",
+            nextEmbedded: "text/css"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/(<\/)(style\s*)(>)/, ["delimiter", "tag", { token: "delimiter", next: "@pop" }]]
+      ],
+      // After <style ... type
+      styleAfterType: [
+        [/=/, "delimiter", "@styleAfterTypeEquals"],
+        [
+          />/,
+          {
+            token: "delimiter",
+            next: "@styleEmbedded",
+            nextEmbedded: "text/css"
+          }
+        ],
+        // cover invalid e.g. <style type>
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      // After <style ... type =
+      styleAfterTypeEquals: [
+        [
+          /"([^"]*)"/,
+          {
+            token: "attribute.value",
+            switchTo: "@styleWithCustomType.$1"
+          }
+        ],
+        [
+          /'([^']*)'/,
+          {
+            token: "attribute.value",
+            switchTo: "@styleWithCustomType.$1"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter",
+            next: "@styleEmbedded",
+            nextEmbedded: "text/css"
+          }
+        ],
+        // cover invalid e.g. <style type=>
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      // After <style ... type = $S2
+      styleWithCustomType: [
+        [
+          />/,
+          {
+            token: "delimiter",
+            next: "@styleEmbedded.$S2",
+            nextEmbedded: "$S2"
+          }
+        ],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      styleEmbedded: [
+        [/<\/style/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }],
+        [/[^<]+/, ""]
+      ]
+      // -- END <style> tags handling
+    }
+  };
+  return __toCommonJS(html_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/ini/ini.js

@@ -0,0 +1,105 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/ini/ini", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/ini/ini.ts
+  var ini_exports = {};
+  __export(ini_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "#"
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".ini",
+    // we include these common regular expressions
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // sections
+        [/^\[[^\]]*\]/, "metatag"],
+        // keys
+        [/(^\w+)(\s*)(\=)/, ["key", "", "delimiter"]],
+        // whitespace
+        { include: "@whitespace" },
+        // numbers
+        [/\d+/, "number"],
+        // strings: recover on non-terminated strings
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/'([^'\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/"/, "string", '@string."'],
+        [/'/, "string", "@string.'"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/^\s*[#;].*$/, "comment"]
+      ],
+      string: [
+        [/[^\\"']+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [
+          /["']/,
+          {
+            cases: {
+              "$#==$S2": { token: "string", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ]
+      ]
+    }
+  };
+  return __toCommonJS(ini_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/java/java.js

@@ -0,0 +1,266 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/java/java", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/java/java.ts
+  var java_exports = {};
+  __export(java_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    // the default separators except `@$`
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "<", close: ">" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),
+        end: new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".java",
+    keywords: [
+      "abstract",
+      "continue",
+      "for",
+      "new",
+      "switch",
+      "assert",
+      "default",
+      "goto",
+      "package",
+      "synchronized",
+      "boolean",
+      "do",
+      "if",
+      "private",
+      "this",
+      "break",
+      "double",
+      "implements",
+      "protected",
+      "throw",
+      "byte",
+      "else",
+      "import",
+      "public",
+      "throws",
+      "case",
+      "enum",
+      "instanceof",
+      "return",
+      "transient",
+      "catch",
+      "extends",
+      "int",
+      "short",
+      "try",
+      "char",
+      "final",
+      "interface",
+      "static",
+      "void",
+      "class",
+      "finally",
+      "long",
+      "strictfp",
+      "volatile",
+      "const",
+      "float",
+      "native",
+      "super",
+      "while",
+      "true",
+      "false",
+      "yield",
+      "record",
+      "sealed",
+      "non-sealed",
+      "permits"
+    ],
+    operators: [
+      "=",
+      ">",
+      "<",
+      "!",
+      "~",
+      "?",
+      ":",
+      "==",
+      "<=",
+      ">=",
+      "!=",
+      "&&",
+      "||",
+      "++",
+      "--",
+      "+",
+      "-",
+      "*",
+      "/",
+      "&",
+      "|",
+      "^",
+      "%",
+      "<<",
+      ">>",
+      ">>>",
+      "+=",
+      "-=",
+      "*=",
+      "/=",
+      "&=",
+      "|=",
+      "^=",
+      "%=",
+      "<<=",
+      ">>=",
+      ">>>="
+    ],
+    // we include these common regular expressions
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    digits: /\d+(_+\d+)*/,
+    octaldigits: /[0-7]+(_+[0-7]+)*/,
+    binarydigits: /[0-1]+(_+[0-1]+)*/,
+    hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // Special keyword with a dash
+        ["non-sealed", "keyword.non-sealed"],
+        // 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": ""
+            }
+          }
+        ],
+        // @ annotations.
+        [/@\s*[a-zA-Z_\$][\w\$]*/, "annotation"],
+        // numbers
+        [/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/, "number.float"],
+        [/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/, "number.float"],
+        [/0[xX](@hexdigits)[Ll]?/, "number.hex"],
+        [/0(@octaldigits)[Ll]?/, "number.octal"],
+        [/0[bB](@binarydigits)[Ll]?/, "number.binary"],
+        [/(@digits)[fFdD]/, "number.float"],
+        [/(@digits)[lL]?/, "number"],
+        // delimiter: after number because of .\d floats
+        [/[;,.]/, "delimiter"],
+        // strings
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/"""/, "string", "@multistring"],
+        [/"/, "string", "@string"],
+        // characters
+        [/'[^\\']'/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*\*(?!\/)/, "comment.doc", "@javadoc"],
+        [/\/\*/, "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
+      javadoc: [
+        [/[^\/*]+/, "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"]
+      ],
+      multistring: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"""/, "string", "@pop"],
+        [/./, "string"]
+      ]
+    }
+  };
+  return __toCommonJS(java_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/javascript/javascript.js

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

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/julia/julia.js

@@ -0,0 +1,545 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/julia/julia", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/julia/julia.ts
+  var julia_exports = {};
+  __export(julia_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ]
+  };
+  var language = {
+    tokenPostfix: ".julia",
+    keywords: [
+      "begin",
+      "while",
+      "if",
+      "for",
+      "try",
+      "return",
+      "break",
+      "continue",
+      "function",
+      "macro",
+      "quote",
+      "let",
+      "local",
+      "global",
+      "const",
+      "do",
+      "struct",
+      "module",
+      "baremodule",
+      "using",
+      "import",
+      "export",
+      "end",
+      "else",
+      "elseif",
+      "catch",
+      "finally",
+      "mutable",
+      "primitive",
+      "abstract",
+      "type",
+      "in",
+      "isa",
+      "where",
+      "new"
+    ],
+    types: [
+      "LinRange",
+      "LineNumberNode",
+      "LinearIndices",
+      "LoadError",
+      "MIME",
+      "Matrix",
+      "Method",
+      "MethodError",
+      "Missing",
+      "MissingException",
+      "Module",
+      "NTuple",
+      "NamedTuple",
+      "Nothing",
+      "Number",
+      "OrdinalRange",
+      "OutOfMemoryError",
+      "OverflowError",
+      "Pair",
+      "PartialQuickSort",
+      "PermutedDimsArray",
+      "Pipe",
+      "Ptr",
+      "QuoteNode",
+      "Rational",
+      "RawFD",
+      "ReadOnlyMemoryError",
+      "Real",
+      "ReentrantLock",
+      "Ref",
+      "Regex",
+      "RegexMatch",
+      "RoundingMode",
+      "SegmentationFault",
+      "Set",
+      "Signed",
+      "Some",
+      "StackOverflowError",
+      "StepRange",
+      "StepRangeLen",
+      "StridedArray",
+      "StridedMatrix",
+      "StridedVecOrMat",
+      "StridedVector",
+      "String",
+      "StringIndexError",
+      "SubArray",
+      "SubString",
+      "SubstitutionString",
+      "Symbol",
+      "SystemError",
+      "Task",
+      "Text",
+      "TextDisplay",
+      "Timer",
+      "Tuple",
+      "Type",
+      "TypeError",
+      "TypeVar",
+      "UInt",
+      "UInt128",
+      "UInt16",
+      "UInt32",
+      "UInt64",
+      "UInt8",
+      "UndefInitializer",
+      "AbstractArray",
+      "UndefKeywordError",
+      "AbstractChannel",
+      "UndefRefError",
+      "AbstractChar",
+      "UndefVarError",
+      "AbstractDict",
+      "Union",
+      "AbstractDisplay",
+      "UnionAll",
+      "AbstractFloat",
+      "UnitRange",
+      "AbstractIrrational",
+      "Unsigned",
+      "AbstractMatrix",
+      "AbstractRange",
+      "Val",
+      "AbstractSet",
+      "Vararg",
+      "AbstractString",
+      "VecElement",
+      "AbstractUnitRange",
+      "VecOrMat",
+      "AbstractVecOrMat",
+      "Vector",
+      "AbstractVector",
+      "VersionNumber",
+      "Any",
+      "WeakKeyDict",
+      "ArgumentError",
+      "WeakRef",
+      "Array",
+      "AssertionError",
+      "BigFloat",
+      "BigInt",
+      "BitArray",
+      "BitMatrix",
+      "BitSet",
+      "BitVector",
+      "Bool",
+      "BoundsError",
+      "CapturedException",
+      "CartesianIndex",
+      "CartesianIndices",
+      "Cchar",
+      "Cdouble",
+      "Cfloat",
+      "Channel",
+      "Char",
+      "Cint",
+      "Cintmax_t",
+      "Clong",
+      "Clonglong",
+      "Cmd",
+      "Colon",
+      "Complex",
+      "ComplexF16",
+      "ComplexF32",
+      "ComplexF64",
+      "CompositeException",
+      "Condition",
+      "Cptrdiff_t",
+      "Cshort",
+      "Csize_t",
+      "Cssize_t",
+      "Cstring",
+      "Cuchar",
+      "Cuint",
+      "Cuintmax_t",
+      "Culong",
+      "Culonglong",
+      "Cushort",
+      "Cvoid",
+      "Cwchar_t",
+      "Cwstring",
+      "DataType",
+      "DenseArray",
+      "DenseMatrix",
+      "DenseVecOrMat",
+      "DenseVector",
+      "Dict",
+      "DimensionMismatch",
+      "Dims",
+      "DivideError",
+      "DomainError",
+      "EOFError",
+      "Enum",
+      "ErrorException",
+      "Exception",
+      "ExponentialBackOff",
+      "Expr",
+      "Float16",
+      "Float32",
+      "Float64",
+      "Function",
+      "GlobalRef",
+      "HTML",
+      "IO",
+      "IOBuffer",
+      "IOContext",
+      "IOStream",
+      "IdDict",
+      "IndexCartesian",
+      "IndexLinear",
+      "IndexStyle",
+      "InexactError",
+      "InitError",
+      "Int",
+      "Int128",
+      "Int16",
+      "Int32",
+      "Int64",
+      "Int8",
+      "Integer",
+      "InterruptException",
+      "InvalidStateException",
+      "Irrational",
+      "KeyError"
+    ],
+    keywordops: ["<:", ">:", ":", "=>", "...", ".", "->", "?"],
+    allops: /[^\w\d\s()\[\]{}"'#]+/,
+    constants: [
+      "true",
+      "false",
+      "nothing",
+      "missing",
+      "undef",
+      "Inf",
+      "pi",
+      "NaN",
+      "\u03C0",
+      "\u212F",
+      "ans",
+      "PROGRAM_FILE",
+      "ARGS",
+      "C_NULL",
+      "VERSION",
+      "DEPOT_PATH",
+      "LOAD_PATH"
+    ],
+    operators: [
+      "!",
+      "!=",
+      "!==",
+      "%",
+      "&",
+      "*",
+      "+",
+      "-",
+      "/",
+      "//",
+      "<",
+      "<<",
+      "<=",
+      "==",
+      "===",
+      "=>",
+      ">",
+      ">=",
+      ">>",
+      ">>>",
+      "\\",
+      "^",
+      "|",
+      "|>",
+      "~",
+      "\xF7",
+      "\u2208",
+      "\u2209",
+      "\u220B",
+      "\u220C",
+      "\u2218",
+      "\u221A",
+      "\u221B",
+      "\u2229",
+      "\u222A",
+      "\u2248",
+      "\u2249",
+      "\u2260",
+      "\u2261",
+      "\u2262",
+      "\u2264",
+      "\u2265",
+      "\u2286",
+      "\u2287",
+      "\u2288",
+      "\u2289",
+      "\u228A",
+      "\u228B",
+      "\u22BB"
+    ],
+    brackets: [
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.square" }
+    ],
+    ident: /π|ℯ|\b(?!\d)\w+\b/,
+    // escape sequences
+    escape: /(?:[abefnrstv\\"'\n\r]|[0-7]{1,3}|x[0-9A-Fa-f]{1,2}|u[0-9A-Fa-f]{4})/,
+    escapes: /\\(?:C\-(@escape|.)|c(@escape|.)|@escape)/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        [/(::)\s*|\b(isa)\s+/, "keyword", "@typeanno"],
+        [/\b(isa)(\s*\(@ident\s*,\s*)/, ["keyword", { token: "", next: "@typeanno" }]],
+        [/\b(type|struct)[ \t]+/, "keyword", "@typeanno"],
+        // symbols
+        [/^\s*:@ident[!?]?/, "metatag"],
+        [/(return)(\s*:@ident[!?]?)/, ["keyword", "metatag"]],
+        [/(\(|\[|\{|@allops)(\s*:@ident[!?]?)/, ["", "metatag"]],
+        [/:\(/, "metatag", "@quote"],
+        // regular expressions
+        [/r"""/, "regexp.delim", "@tregexp"],
+        [/r"/, "regexp.delim", "@sregexp"],
+        // strings
+        [/raw"""/, "string.delim", "@rtstring"],
+        [/[bv]?"""/, "string.delim", "@dtstring"],
+        [/raw"/, "string.delim", "@rsstring"],
+        [/[bv]?"/, "string.delim", "@dsstring"],
+        [
+          /(@ident)\{/,
+          {
+            cases: {
+              "$1@types": { token: "type", next: "@gen" },
+              "@default": { token: "type", next: "@gen" }
+            }
+          }
+        ],
+        [
+          /@ident[!?'']?(?=\.?\()/,
+          {
+            cases: {
+              "@types": "type",
+              "@keywords": "keyword",
+              "@constants": "variable",
+              "@default": "keyword.flow"
+            }
+          }
+        ],
+        [
+          /@ident[!?']?/,
+          {
+            cases: {
+              "@types": "type",
+              "@keywords": "keyword",
+              "@constants": "variable",
+              "@default": "identifier"
+            }
+          }
+        ],
+        [/\$\w+/, "key"],
+        [/\$\(/, "key", "@paste"],
+        [/@@@ident/, "annotation"],
+        // whitespace
+        { include: "@whitespace" },
+        // characters
+        [/'(?:@escapes|.)'/, "string.character"],
+        // delimiters and operators
+        [/[()\[\]{}]/, "@brackets"],
+        [
+          /@allops/,
+          {
+            cases: {
+              "@keywordops": "keyword",
+              "@operators": "operator"
+            }
+          }
+        ],
+        [/[;,]/, "delimiter"],
+        // numbers
+        [/0[xX][0-9a-fA-F](_?[0-9a-fA-F])*/, "number.hex"],
+        [/0[_oO][0-7](_?[0-7])*/, "number.octal"],
+        [/0[bB][01](_?[01])*/, "number.binary"],
+        [/[+\-]?\d+(\.\d+)?(im?|[eE][+\-]?\d+(\.\d+)?)?/, "number"]
+      ],
+      // type
+      typeanno: [
+        [/[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*\{/, "type", "@gen"],
+        [/([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(\s*<:\s*)/, ["type", "keyword"]],
+        [/[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*/, "type", "@pop"],
+        ["", "", "@pop"]
+      ],
+      // generic type
+      gen: [
+        [/[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*\{/, "type", "@push"],
+        [/[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*/, "type"],
+        [/<:/, "keyword"],
+        [/(\})(\s*<:\s*)/, ["type", { token: "keyword", next: "@pop" }]],
+        [/\}/, "type", "@pop"],
+        { include: "@root" }
+      ],
+      // $(...)
+      quote: [
+        [/\$\(/, "key", "@paste"],
+        [/\(/, "@brackets", "@paren"],
+        [/\)/, "metatag", "@pop"],
+        { include: "@root" }
+      ],
+      // :(...)
+      paste: [
+        [/:\(/, "metatag", "@quote"],
+        [/\(/, "@brackets", "@paren"],
+        [/\)/, "key", "@pop"],
+        { include: "@root" }
+      ],
+      // (...)
+      paren: [
+        [/\$\(/, "key", "@paste"],
+        [/:\(/, "metatag", "@quote"],
+        [/\(/, "@brackets", "@push"],
+        [/\)/, "@brackets", "@pop"],
+        { include: "@root" }
+      ],
+      // r"egex string"
+      sregexp: [
+        [/^.*/, "invalid"],
+        [/[^\\"()\[\]{}]/, "regexp"],
+        [/[()\[\]{}]/, "@brackets"],
+        [/\\./, "operator.scss"],
+        [/"[imsx]*/, "regexp.delim", "@pop"]
+      ],
+      tregexp: [
+        [/[^\\"()\[\]{}]/, "regexp"],
+        [/[()\[\]{}]/, "@brackets"],
+        [/\\./, "operator.scss"],
+        [/"(?!"")/, "string"],
+        [/"""[imsx]*/, "regexp.delim", "@pop"]
+      ],
+      // raw"string"
+      rsstring: [
+        [/^.*/, "invalid"],
+        [/[^\\"]/, "string"],
+        [/\\./, "string.escape"],
+        [/"/, "string.delim", "@pop"]
+      ],
+      rtstring: [
+        [/[^\\"]/, "string"],
+        [/\\./, "string.escape"],
+        [/"(?!"")/, "string"],
+        [/"""/, "string.delim", "@pop"]
+      ],
+      // "string".
+      dsstring: [
+        [/^.*/, "invalid"],
+        [/[^\\"\$]/, "string"],
+        [/\$/, "", "@interpolated"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string.delim", "@pop"]
+      ],
+      dtstring: [
+        [/[^\\"\$]/, "string"],
+        [/\$/, "", "@interpolated"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"(?!"")/, "string"],
+        [/"""/, "string.delim", "@pop"]
+      ],
+      // interpolated sequence
+      interpolated: [
+        [/\(/, { token: "", switchTo: "@interpolated_compound" }],
+        [/[a-zA-Z_]\w*/, "identifier"],
+        ["", "", "@pop"]
+        // just a $ is interpreted as a $
+      ],
+      // any code
+      interpolated_compound: [[/\)/, "", "@pop"], { include: "@root" }],
+      // whitespace & comments
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/#=/, "comment", "@multi_comment"],
+        [/#.*$/, "comment"]
+      ],
+      multi_comment: [
+        [/#=/, "comment", "@push"],
+        [/=#/, "comment", "@pop"],
+        [/=(?!#)|#(?!=)/, "comment"],
+        [/[^#=]+/, "comment"]
+      ]
+    }
+  };
+  return __toCommonJS(julia_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/kotlin/kotlin.js

@@ -0,0 +1,287 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/kotlin/kotlin", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/kotlin/kotlin.ts
+  var kotlin_exports = {};
+  __export(kotlin_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    // the default separators except `@$`
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "<", close: ">" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),
+        end: new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".kt",
+    keywords: [
+      "as",
+      "as?",
+      "break",
+      "class",
+      "continue",
+      "do",
+      "else",
+      "false",
+      "for",
+      "fun",
+      "if",
+      "in",
+      "!in",
+      "interface",
+      "is",
+      "!is",
+      "null",
+      "object",
+      "package",
+      "return",
+      "super",
+      "this",
+      "throw",
+      "true",
+      "try",
+      "typealias",
+      "val",
+      "var",
+      "when",
+      "while",
+      "by",
+      "catch",
+      "constructor",
+      "delegate",
+      "dynamic",
+      "field",
+      "file",
+      "finally",
+      "get",
+      "import",
+      "init",
+      "param",
+      "property",
+      "receiver",
+      "set",
+      "setparam",
+      "where",
+      "actual",
+      "abstract",
+      "annotation",
+      "companion",
+      "const",
+      "crossinline",
+      "data",
+      "enum",
+      "expect",
+      "external",
+      "final",
+      "infix",
+      "inline",
+      "inner",
+      "internal",
+      "lateinit",
+      "noinline",
+      "open",
+      "operator",
+      "out",
+      "override",
+      "private",
+      "protected",
+      "public",
+      "reified",
+      "sealed",
+      "suspend",
+      "tailrec",
+      "vararg",
+      "field",
+      "it"
+    ],
+    operators: [
+      "+",
+      "-",
+      "*",
+      "/",
+      "%",
+      "=",
+      "+=",
+      "-=",
+      "*=",
+      "/=",
+      "%=",
+      "++",
+      "--",
+      "&&",
+      "||",
+      "!",
+      "==",
+      "!=",
+      "===",
+      "!==",
+      ">",
+      "<",
+      "<=",
+      ">=",
+      "[",
+      "]",
+      "!!",
+      "?.",
+      "?:",
+      "::",
+      "..",
+      ":",
+      "?",
+      "->",
+      "@",
+      ";",
+      "$",
+      "_"
+    ],
+    // we include these common regular expressions
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    digits: /\d+(_+\d+)*/,
+    octaldigits: /[0-7]+(_+[0-7]+)*/,
+    binarydigits: /[0-1]+(_+[0-1]+)*/,
+    hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // class name highlighting
+        [/[A-Z][\w\$]*/, "type.identifier"],
+        // 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": ""
+            }
+          }
+        ],
+        // @ annotations.
+        [/@\s*[a-zA-Z_\$][\w\$]*/, "annotation"],
+        // numbers
+        [/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/, "number.float"],
+        [/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/, "number.float"],
+        [/0[xX](@hexdigits)[Ll]?/, "number.hex"],
+        [/0(@octaldigits)[Ll]?/, "number.octal"],
+        [/0[bB](@binarydigits)[Ll]?/, "number.binary"],
+        [/(@digits)[fFdD]/, "number.float"],
+        [/(@digits)[lL]?/, "number"],
+        // delimiter: after number because of .\d floats
+        [/[;,.]/, "delimiter"],
+        // strings
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/"""/, "string", "@multistring"],
+        [/"/, "string", "@string"],
+        // characters
+        [/'[^\\']'/, "string"],
+        [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+        [/'/, "string.invalid"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/\/\*\*(?!\/)/, "comment.doc", "@javadoc"],
+        [/\/\*/, "comment", "@comment"],
+        [/\/\/.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\/*]+/, "comment"],
+        [/\/\*/, "comment", "@comment"],
+        [/\*\//, "comment", "@pop"],
+        [/[\/*]/, "comment"]
+      ],
+      //Identical copy of comment above, except for the addition of .doc
+      javadoc: [
+        [/[^\/*]+/, "comment.doc"],
+        [/\/\*/, "comment.doc", "@push"],
+        [/\/\*/, "comment.doc.invalid"],
+        [/\*\//, "comment.doc", "@pop"],
+        [/[\/*]/, "comment.doc"]
+      ],
+      string: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"/, "string", "@pop"]
+      ],
+      multistring: [
+        [/[^\\"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [/"""/, "string", "@pop"],
+        [/./, "string"]
+      ]
+    }
+  };
+  return __toCommonJS(kotlin_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/less/less.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
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/less/less", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/less/less.ts
+  var less_exports = {};
+  __export(less_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    wordPattern: /(#?-?\d*\.\d\w*%?)|([@#!.:]?[\w-?]+%?)|[@#!.]/g,
+    comments: {
+      blockComment: ["/*", "*/"],
+      lineComment: "//"
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}", notIn: ["string", "comment"] },
+      { open: "[", close: "]", notIn: ["string", "comment"] },
+      { open: "(", close: ")", notIn: ["string", "comment"] },
+      { open: '"', close: '"', notIn: ["string", "comment"] },
+      { open: "'", close: "'", notIn: ["string", "comment"] }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*\\/\\*\\s*#region\\b\\s*(.*?)\\s*\\*\\/"),
+        end: new RegExp("^\\s*\\/\\*\\s*#endregion\\b.*\\*\\/")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".less",
+    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])))*",
+    identifierPlus: "-?-?([a-zA-Z:.]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-:.]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*",
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.bracket" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "<", close: ">", token: "delimiter.angle" }
+    ],
+    tokenizer: {
+      root: [
+        { include: "@nestedJSBegin" },
+        ["[ \\t\\r\\n]+", ""],
+        { include: "@comments" },
+        { include: "@keyword" },
+        { include: "@strings" },
+        { include: "@numbers" },
+        ["[*_]?[a-zA-Z\\-\\s]+(?=:.*(;|(\\\\$)))", "attribute.name", "@attribute"],
+        ["url(\\-prefix)?\\(", { token: "tag", next: "@urldeclaration" }],
+        ["[{}()\\[\\]]", "@brackets"],
+        ["[,:;]", "delimiter"],
+        ["#@identifierPlus", "tag.id"],
+        ["&", "tag"],
+        ["\\.@identifierPlus(?=\\()", "tag.class", "@attribute"],
+        ["\\.@identifierPlus", "tag.class"],
+        ["@identifierPlus", "tag"],
+        { include: "@operators" },
+        ["@(@identifier(?=[:,\\)]))", "variable", "@attribute"],
+        ["@(@identifier)", "variable"],
+        ["@", "key", "@atRules"]
+      ],
+      nestedJSBegin: [
+        ["``", "delimiter.backtick"],
+        [
+          "`",
+          {
+            token: "delimiter.backtick",
+            next: "@nestedJSEnd",
+            nextEmbedded: "text/javascript"
+          }
+        ]
+      ],
+      nestedJSEnd: [
+        [
+          "`",
+          {
+            token: "delimiter.backtick",
+            next: "@pop",
+            nextEmbedded: "@pop"
+          }
+        ]
+      ],
+      operators: [["[<>=\\+\\-\\*\\/\\^\\|\\~]", "operator"]],
+      keyword: [
+        [
+          "(@[\\s]*import|![\\s]*important|true|false|when|iscolor|isnumber|isstring|iskeyword|isurl|ispixel|ispercentage|isem|hue|saturation|lightness|alpha|lighten|darken|saturate|desaturate|fadein|fadeout|fade|spin|mix|round|ceil|floor|percentage)\\b",
+          "keyword"
+        ]
+      ],
+      urldeclaration: [
+        { include: "@strings" },
+        ["[^)\r\n]+", "string"],
+        ["\\)", { token: "tag", next: "@pop" }]
+      ],
+      attribute: [
+        { include: "@nestedJSBegin" },
+        { include: "@comments" },
+        { include: "@strings" },
+        { include: "@numbers" },
+        { include: "@keyword" },
+        ["[a-zA-Z\\-]+(?=\\()", "attribute.value", "@attribute"],
+        [">", "operator", "@pop"],
+        ["@identifier", "attribute.value"],
+        { include: "@operators" },
+        ["@(@identifier)", "variable"],
+        ["[)\\}]", "@brackets", "@pop"],
+        ["[{}()\\[\\]>]", "@brackets"],
+        ["[;]", "delimiter", "@pop"],
+        ["[,=:]", "delimiter"],
+        ["\\s", ""],
+        [".", "attribute.value"]
+      ],
+      comments: [
+        ["\\/\\*", "comment", "@comment"],
+        ["\\/\\/+.*", "comment"]
+      ],
+      comment: [
+        ["\\*\\/", "comment", "@pop"],
+        [".", "comment"]
+      ],
+      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"
+        ]
+      ],
+      strings: [
+        ['~?"', { token: "string.delimiter", next: "@stringsEndDoubleQuote" }],
+        ["~?'", { token: "string.delimiter", next: "@stringsEndQuote" }]
+      ],
+      stringsEndDoubleQuote: [
+        ['\\\\"', "string"],
+        ['"', { token: "string.delimiter", next: "@popall" }],
+        [".", "string"]
+      ],
+      stringsEndQuote: [
+        ["\\\\'", "string"],
+        ["'", { token: "string.delimiter", next: "@popall" }],
+        [".", "string"]
+      ],
+      atRules: [
+        { include: "@comments" },
+        { include: "@strings" },
+        ["[()]", "delimiter"],
+        ["[\\{;]", "delimiter", "@pop"],
+        [".", "key"]
+      ]
+    }
+  };
+  return __toCommonJS(less_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/lexon/lexon.js

@@ -0,0 +1,191 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/lexon/lexon", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/lexon/lexon.ts
+  var lexon_exports = {};
+  __export(lexon_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "COMMENT"
+      // blockComment: ['COMMENT', '.'],
+    },
+    brackets: [["(", ")"]],
+    autoClosingPairs: [
+      { 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: "." }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*(::\\s*|COMMENT\\s+)#region"),
+        end: new RegExp("^\\s*(::\\s*|COMMENT\\s+)#endregion")
+      }
+    }
+  };
+  var language = {
+    // Set defaultToken to invalid to see what you do not tokenize yet
+    // defaultToken: 'invalid',
+    tokenPostfix: ".lexon",
+    ignoreCase: true,
+    keywords: [
+      "lexon",
+      "lex",
+      "clause",
+      "terms",
+      "contracts",
+      "may",
+      "pay",
+      "pays",
+      "appoints",
+      "into",
+      "to"
+    ],
+    typeKeywords: ["amount", "person", "key", "time", "date", "asset", "text"],
+    operators: [
+      "less",
+      "greater",
+      "equal",
+      "le",
+      "gt",
+      "or",
+      "and",
+      "add",
+      "added",
+      "subtract",
+      "subtracted",
+      "multiply",
+      "multiplied",
+      "times",
+      "divide",
+      "divided",
+      "is",
+      "be",
+      "certified"
+    ],
+    // we include these common regular expressions
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // comment
+        [/^(\s*)(comment:?(?:\s.*|))$/, ["", "comment"]],
+        // special identifier cases
+        [
+          /"/,
+          {
+            token: "identifier.quote",
+            bracket: "@open",
+            next: "@quoted_identifier"
+          }
+        ],
+        [
+          "LEX$",
+          {
+            token: "keyword",
+            bracket: "@open",
+            next: "@identifier_until_period"
+          }
+        ],
+        ["LEXON", { token: "keyword", bracket: "@open", next: "@semver" }],
+        [
+          ":",
+          {
+            token: "delimiter",
+            bracket: "@open",
+            next: "@identifier_until_period"
+          }
+        ],
+        // identifiers and keywords
+        [
+          /[a-z_$][\w$]*/,
+          {
+            cases: {
+              "@operators": "operator",
+              "@typeKeywords": "keyword.type",
+              "@keywords": "keyword",
+              "@default": "identifier"
+            }
+          }
+        ],
+        // whitespace
+        { include: "@whitespace" },
+        // delimiters and operators
+        [/[{}()\[\]]/, "@brackets"],
+        [/[<>](?!@symbols)/, "@brackets"],
+        [/@symbols/, "delimiter"],
+        // numbers
+        [/\d*\.\d*\.\d*/, "number.semver"],
+        [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+        [/0[xX][0-9a-fA-F]+/, "number.hex"],
+        [/\d+/, "number"],
+        // delimiter: after number because of .\d floats
+        [/[;,.]/, "delimiter"]
+      ],
+      quoted_identifier: [
+        [/[^\\"]+/, "identifier"],
+        [/"/, { token: "identifier.quote", bracket: "@close", next: "@pop" }]
+      ],
+      space_identifier_until_period: [
+        [":", "delimiter"],
+        [" ", { token: "white", next: "@identifier_rest" }]
+      ],
+      identifier_until_period: [
+        { include: "@whitespace" },
+        [":", { token: "delimiter", next: "@identifier_rest" }],
+        [/[^\\.]+/, "identifier"],
+        [/\./, { token: "delimiter", bracket: "@close", next: "@pop" }]
+      ],
+      identifier_rest: [
+        [/[^\\.]+/, "identifier"],
+        [/\./, { token: "delimiter", bracket: "@close", next: "@pop" }]
+      ],
+      semver: [
+        { include: "@whitespace" },
+        [":", "delimiter"],
+        [/\d*\.\d*\.\d*/, { token: "number.semver", bracket: "@close", next: "@pop" }]
+      ],
+      whitespace: [[/[ \t\r\n]+/, "white"]]
+    }
+  };
+  return __toCommonJS(lexon_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/liquid/liquid.js

@@ -0,0 +1,302 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/liquid/liquid", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __commonJS = (cb, mod) => function __require2() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/fillers/monaco-editor-core-amd.ts
+  var require_monaco_editor_core_amd = __commonJS({
+    "src/fillers/monaco-editor-core-amd.ts"(exports, module) {
+      var api = __toESM(__require("vs/editor/editor.api"));
+      module.exports = api;
+    }
+  });
+
+  // src/basic-languages/liquid/liquid.ts
+  var liquid_exports = {};
+  __export(liquid_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+
+  // src/fillers/monaco-editor-core.ts
+  var monaco_editor_core_exports = {};
+  __reExport(monaco_editor_core_exports, __toESM(require_monaco_editor_core_amd()));
+
+  // src/basic-languages/liquid/liquid.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,
+    brackets: [
+      ["<!--", "-->"],
+      ["<", ">"],
+      ["{{", "}}"],
+      ["{%", "%}"],
+      ["{", "}"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { 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: "",
+    builtinTags: [
+      "if",
+      "else",
+      "elseif",
+      "endif",
+      "render",
+      "assign",
+      "capture",
+      "endcapture",
+      "case",
+      "endcase",
+      "comment",
+      "endcomment",
+      "cycle",
+      "decrement",
+      "for",
+      "endfor",
+      "include",
+      "increment",
+      "layout",
+      "raw",
+      "endraw",
+      "render",
+      "tablerow",
+      "endtablerow",
+      "unless",
+      "endunless"
+    ],
+    builtinFilters: [
+      "abs",
+      "append",
+      "at_least",
+      "at_most",
+      "capitalize",
+      "ceil",
+      "compact",
+      "date",
+      "default",
+      "divided_by",
+      "downcase",
+      "escape",
+      "escape_once",
+      "first",
+      "floor",
+      "join",
+      "json",
+      "last",
+      "lstrip",
+      "map",
+      "minus",
+      "modulo",
+      "newline_to_br",
+      "plus",
+      "prepend",
+      "remove",
+      "remove_first",
+      "replace",
+      "replace_first",
+      "reverse",
+      "round",
+      "rstrip",
+      "size",
+      "slice",
+      "sort",
+      "sort_natural",
+      "split",
+      "strip",
+      "strip_html",
+      "strip_newlines",
+      "times",
+      "truncate",
+      "truncatewords",
+      "uniq",
+      "upcase",
+      "url_decode",
+      "url_encode",
+      "where"
+    ],
+    constants: ["true", "false"],
+    operators: ["==", "!=", ">", "<", ">=", "<="],
+    symbol: /[=><!]+/,
+    identifier: /[a-zA-Z_][\w]*/,
+    tokenizer: {
+      root: [
+        [/\{\%\s*comment\s*\%\}/, "comment.start.liquid", "@comment"],
+        [/\{\{/, { token: "@rematch", switchTo: "@liquidState.root" }],
+        [/\{\%/, { token: "@rematch", switchTo: "@liquidState.root" }],
+        [/(<)([\w\-]+)(\/>)/, ["delimiter.html", "tag.html", "delimiter.html"]],
+        [/(<)([:\w]+)/, ["delimiter.html", { token: "tag.html", next: "@otherTag" }]],
+        [/(<\/)([\w\-]+)/, ["delimiter.html", { token: "tag.html", next: "@otherTag" }]],
+        [/</, "delimiter.html"],
+        [/\{/, "delimiter.html"],
+        [/[^<{]+/]
+        // text
+      ],
+      comment: [
+        [/\{\%\s*endcomment\s*\%\}/, "comment.end.liquid", "@pop"],
+        [/./, "comment.content.liquid"]
+      ],
+      otherTag: [
+        [
+          /\{\{/,
+          {
+            token: "@rematch",
+            switchTo: "@liquidState.otherTag"
+          }
+        ],
+        [
+          /\{\%/,
+          {
+            token: "@rematch",
+            switchTo: "@liquidState.otherTag"
+          }
+        ],
+        [/\/?>/, "delimiter.html", "@pop"],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [/[ \t\r\n]+/]
+        // whitespace
+      ],
+      liquidState: [
+        [/\{\{/, "delimiter.output.liquid"],
+        [/\}\}/, { token: "delimiter.output.liquid", switchTo: "@$S2.$S3" }],
+        [/\{\%/, "delimiter.tag.liquid"],
+        [/raw\s*\%\}/, "delimiter.tag.liquid", "@liquidRaw"],
+        [/\%\}/, { token: "delimiter.tag.liquid", switchTo: "@$S2.$S3" }],
+        { include: "liquidRoot" }
+      ],
+      liquidRaw: [
+        [/^(?!\{\%\s*endraw\s*\%\}).+/],
+        [/\{\%/, "delimiter.tag.liquid"],
+        [/@identifier/],
+        [/\%\}/, { token: "delimiter.tag.liquid", next: "@root" }]
+      ],
+      liquidRoot: [
+        [/\d+(\.\d+)?/, "number.liquid"],
+        [/"[^"]*"/, "string.liquid"],
+        [/'[^']*'/, "string.liquid"],
+        [/\s+/],
+        [
+          /@symbol/,
+          {
+            cases: {
+              "@operators": "operator.liquid",
+              "@default": ""
+            }
+          }
+        ],
+        [/\./],
+        [
+          /@identifier/,
+          {
+            cases: {
+              "@constants": "keyword.liquid",
+              "@builtinFilters": "predefined.liquid",
+              "@builtinTags": "predefined.liquid",
+              "@default": "variable.liquid"
+            }
+          }
+        ],
+        [/[^}|%]/, "variable.liquid"]
+      ]
+    }
+  };
+  return __toCommonJS(liquid_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/lua/lua.js

@@ -0,0 +1,196 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/lua/lua", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/lua/lua.ts
+  var lua_exports = {};
+  __export(lua_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "--",
+      blockComment: ["--[[", "]]"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".lua",
+    keywords: [
+      "and",
+      "break",
+      "do",
+      "else",
+      "elseif",
+      "end",
+      "false",
+      "for",
+      "function",
+      "goto",
+      "if",
+      "in",
+      "local",
+      "nil",
+      "not",
+      "or",
+      "repeat",
+      "return",
+      "then",
+      "true",
+      "until",
+      "while"
+    ],
+    brackets: [
+      { token: "delimiter.bracket", open: "{", close: "}" },
+      { token: "delimiter.array", open: "[", close: "]" },
+      { token: "delimiter.parenthesis", open: "(", close: ")" }
+    ],
+    operators: [
+      "+",
+      "-",
+      "*",
+      "/",
+      "%",
+      "^",
+      "#",
+      "==",
+      "~=",
+      "<=",
+      ">=",
+      "<",
+      ">",
+      "=",
+      ";",
+      ":",
+      ",",
+      ".",
+      "..",
+      "..."
+    ],
+    // we include these common regular expressions
+    symbols: /[=><!~?:&|+\-*\/\^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // identifiers and keywords
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        // whitespace
+        { include: "@whitespace" },
+        // keys
+        [/(,)(\s*)([a-zA-Z_]\w*)(\s*)(:)(?!:)/, ["delimiter", "", "key", "", "delimiter"]],
+        [/({)(\s*)([a-zA-Z_]\w*)(\s*)(:)(?!:)/, ["@brackets", "", "key", "", "delimiter"]],
+        // delimiters and operators
+        [/[{}()\[\]]/, "@brackets"],
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "delimiter",
+              "@default": ""
+            }
+          }
+        ],
+        // numbers
+        [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+        [/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, "number.hex"],
+        [/\d+?/, "number"],
+        // delimiter: after number because of .\d floats
+        [/[;,.]/, "delimiter"],
+        // strings: recover on non-terminated strings
+        [/"([^"\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/'([^'\\]|\\.)*$/, "string.invalid"],
+        // non-teminated string
+        [/"/, "string", '@string."'],
+        [/'/, "string", "@string.'"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, ""],
+        [/--\[([=]*)\[/, "comment", "@comment.$1"],
+        [/--.*$/, "comment"]
+      ],
+      comment: [
+        [/[^\]]+/, "comment"],
+        [
+          /\]([=]*)\]/,
+          {
+            cases: {
+              "$1==$S2": { token: "comment", next: "@pop" },
+              "@default": "comment"
+            }
+          }
+        ],
+        [/./, "comment"]
+      ],
+      string: [
+        [/[^\\"']+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        [
+          /["']/,
+          {
+            cases: {
+              "$#==$S2": { token: "string", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ]
+      ]
+    }
+  };
+  return __toCommonJS(lua_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/m3/m3.js

@@ -0,0 +1,244 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/m3/m3", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/m3/m3.ts
+  var m3_exports = {};
+  __export(m3_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      blockComment: ["(*", "*)"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "[", close: "]" },
+      { open: "{", close: "}" },
+      { open: "(", close: ")" },
+      { open: "(*", close: "*)" },
+      { open: "<*", close: "*>" },
+      { open: "'", close: "'", notIn: ["string", "comment"] },
+      { open: '"', close: '"', notIn: ["string", "comment"] }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".m3",
+    brackets: [
+      { token: "delimiter.curly", open: "{", close: "}" },
+      { token: "delimiter.parenthesis", open: "(", close: ")" },
+      { token: "delimiter.square", open: "[", close: "]" }
+    ],
+    keywords: [
+      "AND",
+      "ANY",
+      "ARRAY",
+      "AS",
+      "BEGIN",
+      "BITS",
+      "BRANDED",
+      "BY",
+      "CASE",
+      "CONST",
+      "DIV",
+      "DO",
+      "ELSE",
+      "ELSIF",
+      "END",
+      "EVAL",
+      "EXCEPT",
+      "EXCEPTION",
+      "EXIT",
+      "EXPORTS",
+      "FINALLY",
+      "FOR",
+      "FROM",
+      "GENERIC",
+      "IF",
+      "IMPORT",
+      "IN",
+      "INTERFACE",
+      "LOCK",
+      "LOOP",
+      "METHODS",
+      "MOD",
+      "MODULE",
+      "NOT",
+      "OBJECT",
+      "OF",
+      "OR",
+      "OVERRIDES",
+      "PROCEDURE",
+      "RAISE",
+      "RAISES",
+      "READONLY",
+      "RECORD",
+      "REF",
+      "REPEAT",
+      "RETURN",
+      "REVEAL",
+      "SET",
+      "THEN",
+      "TO",
+      "TRY",
+      "TYPE",
+      "TYPECASE",
+      "UNSAFE",
+      "UNTIL",
+      "UNTRACED",
+      "VALUE",
+      "VAR",
+      "WHILE",
+      "WITH"
+    ],
+    reservedConstNames: [
+      "ABS",
+      "ADR",
+      "ADRSIZE",
+      "BITSIZE",
+      "BYTESIZE",
+      "CEILING",
+      "DEC",
+      "DISPOSE",
+      "FALSE",
+      "FIRST",
+      "FLOAT",
+      "FLOOR",
+      "INC",
+      "ISTYPE",
+      "LAST",
+      "LOOPHOLE",
+      "MAX",
+      "MIN",
+      "NARROW",
+      "NEW",
+      "NIL",
+      "NUMBER",
+      "ORD",
+      "ROUND",
+      "SUBARRAY",
+      "TRUE",
+      "TRUNC",
+      "TYPECODE",
+      "VAL"
+    ],
+    reservedTypeNames: [
+      "ADDRESS",
+      "ANY",
+      "BOOLEAN",
+      "CARDINAL",
+      "CHAR",
+      "EXTENDED",
+      "INTEGER",
+      "LONGCARD",
+      "LONGINT",
+      "LONGREAL",
+      "MUTEX",
+      "NULL",
+      "REAL",
+      "REFANY",
+      "ROOT",
+      "TEXT"
+    ],
+    operators: ["+", "-", "*", "/", "&", "^", "."],
+    relations: ["=", "#", "<", "<=", ">", ">=", "<:", ":"],
+    delimiters: ["|", "..", "=>", ",", ";", ":="],
+    symbols: /[>=<#.,:;+\-*/&^]+/,
+    escapes: /\\(?:[\\fnrt"']|[0-7]{3})/,
+    tokenizer: {
+      root: [
+        // Identifiers and keywords
+        [/_\w*/, "invalid"],
+        [
+          /[a-zA-Z][a-zA-Z0-9_]*/,
+          {
+            cases: {
+              "@keywords": { token: "keyword.$0" },
+              "@reservedConstNames": { token: "constant.reserved.$0" },
+              "@reservedTypeNames": { token: "type.reserved.$0" },
+              "@default": "identifier"
+            }
+          }
+        ],
+        // Whitespace
+        { include: "@whitespace" },
+        [/[{}()\[\]]/, "@brackets"],
+        // Integer- and real literals
+        [/[0-9]+\.[0-9]+(?:[DdEeXx][\+\-]?[0-9]+)?/, "number.float"],
+        [/[0-9]+(?:\_[0-9a-fA-F]+)?L?/, "number"],
+        // Operators, relations, and delimiters
+        [
+          /@symbols/,
+          {
+            cases: {
+              "@operators": "operators",
+              "@relations": "operators",
+              "@delimiters": "delimiter",
+              "@default": "invalid"
+            }
+          }
+        ],
+        // Character literals
+        [/'[^\\']'/, "string.char"],
+        [/(')(@escapes)(')/, ["string.char", "string.escape", "string.char"]],
+        [/'/, "invalid"],
+        // Text literals
+        [/"([^"\\]|\\.)*$/, "invalid"],
+        [/"/, "string.text", "@text"]
+      ],
+      text: [
+        [/[^\\"]+/, "string.text"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "invalid"],
+        [/"/, "string.text", "@pop"]
+      ],
+      comment: [
+        [/\(\*/, "comment", "@push"],
+        [/\*\)/, "comment", "@pop"],
+        [/./, "comment"]
+      ],
+      pragma: [
+        [/<\*/, "keyword.pragma", "@push"],
+        [/\*>/, "keyword.pragma", "@pop"],
+        [/./, "keyword.pragma"]
+      ],
+      whitespace: [
+        [/[ \t\r\n]+/, "white"],
+        [/\(\*/, "comment", "@comment"],
+        [/<\*/, "keyword.pragma", "@pragma"]
+      ]
+    }
+  };
+  return __toCommonJS(m3_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/markdown/markdown.js

@@ -0,0 +1,263 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/markdown/markdown", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/markdown/markdown.ts
+  var markdown_exports = {};
+  __export(markdown_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      blockComment: ["<!--", "-->"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">", notIn: ["string"] }
+    ],
+    surroundingPairs: [
+      { open: "(", close: ")" },
+      { open: "[", close: "]" },
+      { open: "`", close: "`" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*<!--\\s*#?region\\b.*-->"),
+        end: new RegExp("^\\s*<!--\\s*#?endregion\\b.*-->")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".md",
+    // escape codes
+    control: /[\\`*_\[\]{}()#+\-\.!]/,
+    noncontrol: /[^\\`*_\[\]{}()#+\-\.!]/,
+    escapes: /\\(?:@control)/,
+    // escape codes for javascript/CSS strings
+    jsescapes: /\\(?:[btnfr\\"']|[0-7][0-7]?|[0-3][0-7]{2})/,
+    // non matched elements
+    empty: [
+      "area",
+      "base",
+      "basefont",
+      "br",
+      "col",
+      "frame",
+      "hr",
+      "img",
+      "input",
+      "isindex",
+      "link",
+      "meta",
+      "param"
+    ],
+    tokenizer: {
+      root: [
+        // markdown tables
+        [/^\s*\|/, "@rematch", "@table_header"],
+        // headers (with #)
+        [/^(\s{0,3})(#+)((?:[^\\#]|@escapes)+)((?:#+)?)/, ["white", "keyword", "keyword", "keyword"]],
+        // headers (with =)
+        [/^\s*(=+|\-+)\s*$/, "keyword"],
+        // headers (with ***)
+        [/^\s*((\*[ ]?)+)\s*$/, "meta.separator"],
+        // quote
+        [/^\s*>+/, "comment"],
+        // list (starting with * or number)
+        [/^\s*([\*\-+:]|\d+\.)\s/, "keyword"],
+        // code block (4 spaces indent)
+        [/^(\t|[ ]{4})[^ ].*$/, "string"],
+        // code block (3 tilde)
+        [/^\s*~~~\s*((?:\w|[\/\-#])+)?\s*$/, { token: "string", next: "@codeblock" }],
+        // github style code blocks (with backticks and language)
+        [
+          /^\s*```\s*((?:\w|[\/\-#])+).*$/,
+          { token: "string", next: "@codeblockgh", nextEmbedded: "$1" }
+        ],
+        // github style code blocks (with backticks but no language)
+        [/^\s*```\s*$/, { token: "string", next: "@codeblock" }],
+        // markup within lines
+        { include: "@linecontent" }
+      ],
+      table_header: [
+        { include: "@table_common" },
+        [/[^\|]+/, "keyword.table.header"]
+        // table header
+      ],
+      table_body: [{ include: "@table_common" }, { include: "@linecontent" }],
+      table_common: [
+        [/\s*[\-:]+\s*/, { token: "keyword", switchTo: "table_body" }],
+        // header-divider
+        [/^\s*\|/, "keyword.table.left"],
+        // opening |
+        [/^\s*[^\|]/, "@rematch", "@pop"],
+        // exiting
+        [/^\s*$/, "@rematch", "@pop"],
+        // exiting
+        [
+          /\|/,
+          {
+            cases: {
+              "@eos": "keyword.table.right",
+              // closing |
+              "@default": "keyword.table.middle"
+              // inner |
+            }
+          }
+        ]
+      ],
+      codeblock: [
+        [/^\s*~~~\s*$/, { token: "string", next: "@pop" }],
+        [/^\s*```\s*$/, { token: "string", next: "@pop" }],
+        [/.*$/, "variable.source"]
+      ],
+      // github style code blocks
+      codeblockgh: [
+        [/```\s*$/, { token: "string", next: "@pop", nextEmbedded: "@pop" }],
+        [/[^`]+/, "variable.source"]
+      ],
+      linecontent: [
+        // escapes
+        [/&\w+;/, "string.escape"],
+        [/@escapes/, "escape"],
+        // various markup
+        [/\b__([^\\_]|@escapes|_(?!_))+__\b/, "strong"],
+        [/\*\*([^\\*]|@escapes|\*(?!\*))+\*\*/, "strong"],
+        [/\b_[^_]+_\b/, "emphasis"],
+        [/\*([^\\*]|@escapes)+\*/, "emphasis"],
+        [/`([^\\`]|@escapes)+`/, "variable"],
+        // links
+        [/\{+[^}]+\}+/, "string.target"],
+        [/(!?\[)((?:[^\]\\]|@escapes)*)(\]\([^\)]+\))/, ["string.link", "", "string.link"]],
+        [/(!?\[)((?:[^\]\\]|@escapes)*)(\])/, "string.link"],
+        // or html
+        { include: "html" }
+      ],
+      // Note: it is tempting to rather switch to the real HTML mode instead of building our own here
+      // but currently there is a limitation in Monarch that prevents us from doing it: The opening
+      // '<' would start the HTML mode, however there is no way to jump 1 character back to let the
+      // HTML mode also tokenize the opening angle bracket. Thus, even though we could jump to HTML,
+      // we cannot correctly tokenize it in that mode yet.
+      html: [
+        // html tags
+        [/<(\w+)\/>/, "tag"],
+        [
+          /<(\w+)(\-|\w)*/,
+          {
+            cases: {
+              "@empty": { token: "tag", next: "@tag.$1" },
+              "@default": { token: "tag", next: "@tag.$1" }
+            }
+          }
+        ],
+        [/<\/(\w+)(\-|\w)*\s*>/, { token: "tag" }],
+        [/<!--/, "comment", "@comment"]
+      ],
+      comment: [
+        [/[^<\-]+/, "comment.content"],
+        [/-->/, "comment", "@pop"],
+        [/<!--/, "comment.content.invalid"],
+        [/[<\-]/, "comment.content"]
+      ],
+      // Almost full HTML tag matching, complete with embedded scripts & styles
+      tag: [
+        [/[ \t\r\n]+/, "white"],
+        [
+          /(type)(\s*=\s*)(")([^"]+)(")/,
+          [
+            "attribute.name.html",
+            "delimiter.html",
+            "string.html",
+            { token: "string.html", switchTo: "@tag.$S2.$4" },
+            "string.html"
+          ]
+        ],
+        [
+          /(type)(\s*=\s*)(')([^']+)(')/,
+          [
+            "attribute.name.html",
+            "delimiter.html",
+            "string.html",
+            { token: "string.html", switchTo: "@tag.$S2.$4" },
+            "string.html"
+          ]
+        ],
+        [/(\w+)(\s*=\s*)("[^"]*"|'[^']*')/, ["attribute.name.html", "delimiter.html", "string.html"]],
+        [/\w+/, "attribute.name.html"],
+        [/\/>/, "tag", "@pop"],
+        [
+          />/,
+          {
+            cases: {
+              "$S2==style": {
+                token: "tag",
+                switchTo: "embeddedStyle",
+                nextEmbedded: "text/css"
+              },
+              "$S2==script": {
+                cases: {
+                  $S3: {
+                    token: "tag",
+                    switchTo: "embeddedScript",
+                    nextEmbedded: "$S3"
+                  },
+                  "@default": {
+                    token: "tag",
+                    switchTo: "embeddedScript",
+                    nextEmbedded: "text/javascript"
+                  }
+                }
+              },
+              "@default": { token: "tag", next: "@pop" }
+            }
+          }
+        ]
+      ],
+      embeddedStyle: [
+        [/[^<]+/, ""],
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }],
+        [/</, ""]
+      ],
+      embeddedScript: [
+        [/[^<]+/, ""],
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }],
+        [/</, ""]
+      ]
+    }
+  };
+  return __toCommonJS(markdown_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/mdx/mdx.js

@@ -0,0 +1,226 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/mdx/mdx", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __commonJS = (cb, mod) => function __require2() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/fillers/monaco-editor-core-amd.ts
+  var require_monaco_editor_core_amd = __commonJS({
+    "src/fillers/monaco-editor-core-amd.ts"(exports, module) {
+      var api = __toESM(__require("vs/editor/editor.api"));
+      module.exports = api;
+    }
+  });
+
+  // src/basic-languages/mdx/mdx.ts
+  var mdx_exports = {};
+  __export(mdx_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+
+  // src/fillers/monaco-editor-core.ts
+  var monaco_editor_core_exports = {};
+  __reExport(monaco_editor_core_exports, __toESM(require_monaco_editor_core_amd()));
+
+  // src/basic-languages/mdx/mdx.ts
+  var conf = {
+    comments: {
+      blockComment: ["{/*", "*/}"]
+    },
+    brackets: [["{", "}"]],
+    autoClosingPairs: [
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "\u201C", close: "\u201D" },
+      { open: "\u2018", close: "\u2019" },
+      { open: "`", close: "`" },
+      { open: "{", close: "}" },
+      { open: "(", close: ")" },
+      { open: "_", close: "_" },
+      { open: "**", close: "**" },
+      { open: "<", close: ">" }
+    ],
+    onEnterRules: [
+      {
+        beforeText: /^\s*- .+/,
+        action: { indentAction: monaco_editor_core_exports.languages.IndentAction.None, appendText: "- " }
+      },
+      {
+        beforeText: /^\s*\+ .+/,
+        action: { indentAction: monaco_editor_core_exports.languages.IndentAction.None, appendText: "+ " }
+      },
+      {
+        beforeText: /^\s*\* .+/,
+        action: { indentAction: monaco_editor_core_exports.languages.IndentAction.None, appendText: "* " }
+      },
+      {
+        beforeText: /^> /,
+        action: { indentAction: monaco_editor_core_exports.languages.IndentAction.None, appendText: "> " }
+      },
+      {
+        beforeText: /<\w+/,
+        action: { indentAction: monaco_editor_core_exports.languages.IndentAction.Indent }
+      },
+      {
+        beforeText: /\s+>\s*$/,
+        action: { indentAction: monaco_editor_core_exports.languages.IndentAction.Indent }
+      },
+      {
+        beforeText: /<\/\w+>/,
+        action: { indentAction: monaco_editor_core_exports.languages.IndentAction.Outdent }
+      },
+      ...Array.from({ length: 100 }, (_, index) => ({
+        beforeText: new RegExp(`^${index}\\. .+`),
+        action: { indentAction: monaco_editor_core_exports.languages.IndentAction.None, appendText: `${index + 1}. ` }
+      }))
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".mdx",
+    control: /[!#()*+.[\\\]_`{}\-]/,
+    escapes: /\\@control/,
+    tokenizer: {
+      root: [
+        [/^---$/, { token: "meta.content", next: "@frontmatter", nextEmbedded: "yaml" }],
+        [/^\s*import/, { token: "keyword", next: "@import", nextEmbedded: "js" }],
+        [/^\s*export/, { token: "keyword", next: "@export", nextEmbedded: "js" }],
+        [/<\w+/, { token: "type.identifier", next: "@jsx" }],
+        [/<\/?\w+>/, "type.identifier"],
+        [
+          /^(\s*)(>*\s*)(#{1,6}\s)/,
+          [{ token: "white" }, { token: "comment" }, { token: "keyword", next: "@header" }]
+        ],
+        [/^(\s*)(>*\s*)([*+-])(\s+)/, ["white", "comment", "keyword", "white"]],
+        [/^(\s*)(>*\s*)(\d{1,9}\.)(\s+)/, ["white", "comment", "number", "white"]],
+        [/^(\s*)(>*\s*)(\d{1,9}\.)(\s+)/, ["white", "comment", "number", "white"]],
+        [/^(\s*)(>*\s*)(-{3,}|\*{3,}|_{3,})$/, ["white", "comment", "keyword"]],
+        [/`{3,}(\s.*)?$/, { token: "string", next: "@codeblock_backtick" }],
+        [/~{3,}(\s.*)?$/, { token: "string", next: "@codeblock_tilde" }],
+        [
+          /`{3,}(\S+).*$/,
+          { token: "string", next: "@codeblock_highlight_backtick", nextEmbedded: "$1" }
+        ],
+        [
+          /~{3,}(\S+).*$/,
+          { token: "string", next: "@codeblock_highlight_tilde", nextEmbedded: "$1" }
+        ],
+        [/^(\s*)(-{4,})$/, ["white", "comment"]],
+        [/^(\s*)(>+)/, ["white", "comment"]],
+        { include: "content" }
+      ],
+      content: [
+        [
+          /(\[)(.+)(]\()(.+)(\s+".*")(\))/,
+          ["", "string.link", "", "type.identifier", "string.link", ""]
+        ],
+        [/(\[)(.+)(]\()(.+)(\))/, ["", "type.identifier", "", "string.link", ""]],
+        [/(\[)(.+)(]\[)(.+)(])/, ["", "type.identifier", "", "type.identifier", ""]],
+        [/(\[)(.+)(]:\s+)(\S*)/, ["", "type.identifier", "", "string.link"]],
+        [/(\[)(.+)(])/, ["", "type.identifier", ""]],
+        [/`.*`/, "variable.source"],
+        [/_/, { token: "emphasis", next: "@emphasis_underscore" }],
+        [/\*(?!\*)/, { token: "emphasis", next: "@emphasis_asterisk" }],
+        [/\*\*/, { token: "strong", next: "@strong" }],
+        [/{/, { token: "delimiter.bracket", next: "@expression", nextEmbedded: "js" }]
+      ],
+      import: [[/'\s*(;|$)/, { token: "string", next: "@pop", nextEmbedded: "@pop" }]],
+      expression: [
+        [/{/, { token: "delimiter.bracket", next: "@expression" }],
+        [/}/, { token: "delimiter.bracket", next: "@pop", nextEmbedded: "@pop" }]
+      ],
+      export: [[/^\s*$/, { token: "delimiter.bracket", next: "@pop", nextEmbedded: "@pop" }]],
+      jsx: [
+        [/\s+/, ""],
+        [/(\w+)(=)("(?:[^"\\]|\\.)*")/, ["attribute.name", "operator", "string"]],
+        [/(\w+)(=)('(?:[^'\\]|\\.)*')/, ["attribute.name", "operator", "string"]],
+        [/(\w+(?=\s|>|={|$))/, ["attribute.name"]],
+        [/={/, { token: "delimiter.bracket", next: "@expression", nextEmbedded: "js" }],
+        [/>/, { token: "type.identifier", next: "@pop" }]
+      ],
+      header: [
+        [/.$/, { token: "keyword", next: "@pop" }],
+        { include: "content" },
+        [/./, { token: "keyword" }]
+      ],
+      strong: [
+        [/\*\*/, { token: "strong", next: "@pop" }],
+        { include: "content" },
+        [/./, { token: "strong" }]
+      ],
+      emphasis_underscore: [
+        [/_/, { token: "emphasis", next: "@pop" }],
+        { include: "content" },
+        [/./, { token: "emphasis" }]
+      ],
+      emphasis_asterisk: [
+        [/\*(?!\*)/, { token: "emphasis", next: "@pop" }],
+        { include: "content" },
+        [/./, { token: "emphasis" }]
+      ],
+      frontmatter: [[/^---$/, { token: "meta.content", nextEmbedded: "@pop", next: "@pop" }]],
+      codeblock_highlight_backtick: [
+        [/\s*`{3,}\s*$/, { token: "string", next: "@pop", nextEmbedded: "@pop" }],
+        [/.*$/, "variable.source"]
+      ],
+      codeblock_highlight_tilde: [
+        [/\s*~{3,}\s*$/, { token: "string", next: "@pop", nextEmbedded: "@pop" }],
+        [/.*$/, "variable.source"]
+      ],
+      codeblock_backtick: [
+        [/\s*`{3,}\s*$/, { token: "string", next: "@pop" }],
+        [/.*$/, "variable.source"]
+      ],
+      codeblock_tilde: [
+        [/\s*~{3,}\s*$/, { token: "string", next: "@pop" }],
+        [/.*$/, "variable.source"]
+      ]
+    }
+  };
+  return __toCommonJS(mdx_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/mips/mips.js

@@ -0,0 +1,232 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/mips/mips", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/mips/mips.ts
+  var mips_exports = {};
+  __export(mips_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\$\-\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+    comments: {
+      blockComment: ["###", "###"],
+      lineComment: "#"
+    },
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*#region\\b"),
+        end: new RegExp("^\\s*#endregion\\b")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    ignoreCase: false,
+    tokenPostfix: ".mips",
+    regEx: /\/(?!\/\/)(?:[^\/\\]|\\.)*\/[igm]*/,
+    keywords: [
+      ".data",
+      ".text",
+      "syscall",
+      "trap",
+      "add",
+      "addu",
+      "addi",
+      "addiu",
+      "and",
+      "andi",
+      "div",
+      "divu",
+      "mult",
+      "multu",
+      "nor",
+      "or",
+      "ori",
+      "sll",
+      "slv",
+      "sra",
+      "srav",
+      "srl",
+      "srlv",
+      "sub",
+      "subu",
+      "xor",
+      "xori",
+      "lhi",
+      "lho",
+      "lhi",
+      "llo",
+      "slt",
+      "slti",
+      "sltu",
+      "sltiu",
+      "beq",
+      "bgtz",
+      "blez",
+      "bne",
+      "j",
+      "jal",
+      "jalr",
+      "jr",
+      "lb",
+      "lbu",
+      "lh",
+      "lhu",
+      "lw",
+      "li",
+      "la",
+      "sb",
+      "sh",
+      "sw",
+      "mfhi",
+      "mflo",
+      "mthi",
+      "mtlo",
+      "move"
+    ],
+    // we include these common regular expressions
+    symbols: /[\.,\:]+/,
+    escapes: /\\(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        // identifiers and keywords
+        [/\$[a-zA-Z_]\w*/, "variable.predefined"],
+        [
+          /[.a-zA-Z_]\w*/,
+          {
+            cases: {
+              this: "variable.predefined",
+              "@keywords": { token: "keyword.$0" },
+              "@default": ""
+            }
+          }
+        ],
+        // whitespace
+        [/[ \t\r\n]+/, ""],
+        // Comments
+        [/#.*$/, "comment"],
+        // regular expressions
+        ["///", { token: "regexp", next: "@hereregexp" }],
+        [/^(\s*)(@regEx)/, ["", "regexp"]],
+        [/(\,)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+        [/(\:)(\s*)(@regEx)/, ["delimiter", "", "regexp"]],
+        // delimiters
+        [/@symbols/, "delimiter"],
+        // numbers
+        [/\d+[eE]([\-+]?\d+)?/, "number.float"],
+        [/\d+\.\d+([eE][\-+]?\d+)?/, "number.float"],
+        [/0[xX][0-9a-fA-F]+/, "number.hex"],
+        [/0[0-7]+(?!\d)/, "number.octal"],
+        [/\d+/, "number"],
+        // delimiter: after number because of .\d floats
+        [/[,.]/, "delimiter"],
+        // strings:
+        [/"""/, "string", '@herestring."""'],
+        [/'''/, "string", "@herestring.'''"],
+        [
+          /"/,
+          {
+            cases: {
+              "@eos": "string",
+              "@default": { token: "string", next: '@string."' }
+            }
+          }
+        ],
+        [
+          /'/,
+          {
+            cases: {
+              "@eos": "string",
+              "@default": { token: "string", next: "@string.'" }
+            }
+          }
+        ]
+      ],
+      string: [
+        [/[^"'\#\\]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\./, "string.escape.invalid"],
+        [/\./, "string.escape.invalid"],
+        [
+          /#{/,
+          {
+            cases: {
+              '$S2=="': {
+                token: "string",
+                next: "root.interpolatedstring"
+              },
+              "@default": "string"
+            }
+          }
+        ],
+        [
+          /["']/,
+          {
+            cases: {
+              "$#==$S2": { token: "string", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ],
+        [/#/, "string"]
+      ],
+      herestring: [
+        [
+          /("""|''')/,
+          {
+            cases: {
+              "$1==$S2": { token: "string", next: "@pop" },
+              "@default": "string"
+            }
+          }
+        ],
+        [/[^#\\'"]+/, "string"],
+        [/['"]+/, "string"],
+        [/@escapes/, "string.escape"],
+        [/\./, "string.escape.invalid"],
+        [/#{/, { token: "string.quote", next: "root.interpolatedstring" }],
+        [/#/, "string"]
+      ],
+      comment: [
+        [/[^#]+/, "comment"],
+        [/#/, "comment"]
+      ],
+      hereregexp: [
+        [/[^\\\/#]+/, "regexp"],
+        [/\\./, "regexp"],
+        [/#.*$/, "comment"],
+        ["///[igm]*", { token: "regexp", next: "@pop" }],
+        [/\//, "regexp"]
+      ]
+    }
+  };
+  return __toCommonJS(mips_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/msdax/msdax.js

@@ -0,0 +1,409 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/msdax/msdax", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/msdax/msdax.ts
+  var msdax_exports = {};
+  __export(msdax_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["[", "]"],
+      ["(", ")"],
+      ["{", "}"]
+    ],
+    autoClosingPairs: [
+      { open: '"', close: '"', notIn: ["string", "comment"] },
+      { open: "'", close: "'", notIn: ["string", "comment"] },
+      { open: "[", close: "]", notIn: ["string", "comment"] },
+      { open: "(", close: ")", notIn: ["string", "comment"] },
+      { open: "{", close: "}", notIn: ["string", "comment"] }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".msdax",
+    ignoreCase: true,
+    brackets: [
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "{", close: "}", token: "delimiter.brackets" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" }
+    ],
+    keywords: [
+      // Query keywords
+      "VAR",
+      "RETURN",
+      "NOT",
+      "EVALUATE",
+      "DATATABLE",
+      "ORDER",
+      "BY",
+      "START",
+      "AT",
+      "DEFINE",
+      "MEASURE",
+      "ASC",
+      "DESC",
+      "IN",
+      // Datatable types
+      "BOOLEAN",
+      "DOUBLE",
+      "INTEGER",
+      "DATETIME",
+      "CURRENCY",
+      "STRING"
+    ],
+    functions: [
+      // Relational
+      "CLOSINGBALANCEMONTH",
+      "CLOSINGBALANCEQUARTER",
+      "CLOSINGBALANCEYEAR",
+      "DATEADD",
+      "DATESBETWEEN",
+      "DATESINPERIOD",
+      "DATESMTD",
+      "DATESQTD",
+      "DATESYTD",
+      "ENDOFMONTH",
+      "ENDOFQUARTER",
+      "ENDOFYEAR",
+      "FIRSTDATE",
+      "FIRSTNONBLANK",
+      "LASTDATE",
+      "LASTNONBLANK",
+      "NEXTDAY",
+      "NEXTMONTH",
+      "NEXTQUARTER",
+      "NEXTYEAR",
+      "OPENINGBALANCEMONTH",
+      "OPENINGBALANCEQUARTER",
+      "OPENINGBALANCEYEAR",
+      "PARALLELPERIOD",
+      "PREVIOUSDAY",
+      "PREVIOUSMONTH",
+      "PREVIOUSQUARTER",
+      "PREVIOUSYEAR",
+      "SAMEPERIODLASTYEAR",
+      "STARTOFMONTH",
+      "STARTOFQUARTER",
+      "STARTOFYEAR",
+      "TOTALMTD",
+      "TOTALQTD",
+      "TOTALYTD",
+      "ADDCOLUMNS",
+      "ADDMISSINGITEMS",
+      "ALL",
+      "ALLEXCEPT",
+      "ALLNOBLANKROW",
+      "ALLSELECTED",
+      "CALCULATE",
+      "CALCULATETABLE",
+      "CALENDAR",
+      "CALENDARAUTO",
+      "CROSSFILTER",
+      "CROSSJOIN",
+      "CURRENTGROUP",
+      "DATATABLE",
+      "DETAILROWS",
+      "DISTINCT",
+      "EARLIER",
+      "EARLIEST",
+      "EXCEPT",
+      "FILTER",
+      "FILTERS",
+      "GENERATE",
+      "GENERATEALL",
+      "GROUPBY",
+      "IGNORE",
+      "INTERSECT",
+      "ISONORAFTER",
+      "KEEPFILTERS",
+      "LOOKUPVALUE",
+      "NATURALINNERJOIN",
+      "NATURALLEFTOUTERJOIN",
+      "RELATED",
+      "RELATEDTABLE",
+      "ROLLUP",
+      "ROLLUPADDISSUBTOTAL",
+      "ROLLUPGROUP",
+      "ROLLUPISSUBTOTAL",
+      "ROW",
+      "SAMPLE",
+      "SELECTCOLUMNS",
+      "SUBSTITUTEWITHINDEX",
+      "SUMMARIZE",
+      "SUMMARIZECOLUMNS",
+      "TOPN",
+      "TREATAS",
+      "UNION",
+      "USERELATIONSHIP",
+      "VALUES",
+      "SUM",
+      "SUMX",
+      "PATH",
+      "PATHCONTAINS",
+      "PATHITEM",
+      "PATHITEMREVERSE",
+      "PATHLENGTH",
+      "AVERAGE",
+      "AVERAGEA",
+      "AVERAGEX",
+      "COUNT",
+      "COUNTA",
+      "COUNTAX",
+      "COUNTBLANK",
+      "COUNTROWS",
+      "COUNTX",
+      "DISTINCTCOUNT",
+      "DIVIDE",
+      "GEOMEAN",
+      "GEOMEANX",
+      "MAX",
+      "MAXA",
+      "MAXX",
+      "MEDIAN",
+      "MEDIANX",
+      "MIN",
+      "MINA",
+      "MINX",
+      "PERCENTILE.EXC",
+      "PERCENTILE.INC",
+      "PERCENTILEX.EXC",
+      "PERCENTILEX.INC",
+      "PRODUCT",
+      "PRODUCTX",
+      "RANK.EQ",
+      "RANKX",
+      "STDEV.P",
+      "STDEV.S",
+      "STDEVX.P",
+      "STDEVX.S",
+      "VAR.P",
+      "VAR.S",
+      "VARX.P",
+      "VARX.S",
+      "XIRR",
+      "XNPV",
+      // Scalar
+      "DATE",
+      "DATEDIFF",
+      "DATEVALUE",
+      "DAY",
+      "EDATE",
+      "EOMONTH",
+      "HOUR",
+      "MINUTE",
+      "MONTH",
+      "NOW",
+      "SECOND",
+      "TIME",
+      "TIMEVALUE",
+      "TODAY",
+      "WEEKDAY",
+      "WEEKNUM",
+      "YEAR",
+      "YEARFRAC",
+      "CONTAINS",
+      "CONTAINSROW",
+      "CUSTOMDATA",
+      "ERROR",
+      "HASONEFILTER",
+      "HASONEVALUE",
+      "ISBLANK",
+      "ISCROSSFILTERED",
+      "ISEMPTY",
+      "ISERROR",
+      "ISEVEN",
+      "ISFILTERED",
+      "ISLOGICAL",
+      "ISNONTEXT",
+      "ISNUMBER",
+      "ISODD",
+      "ISSUBTOTAL",
+      "ISTEXT",
+      "USERNAME",
+      "USERPRINCIPALNAME",
+      "AND",
+      "FALSE",
+      "IF",
+      "IFERROR",
+      "NOT",
+      "OR",
+      "SWITCH",
+      "TRUE",
+      "ABS",
+      "ACOS",
+      "ACOSH",
+      "ACOT",
+      "ACOTH",
+      "ASIN",
+      "ASINH",
+      "ATAN",
+      "ATANH",
+      "BETA.DIST",
+      "BETA.INV",
+      "CEILING",
+      "CHISQ.DIST",
+      "CHISQ.DIST.RT",
+      "CHISQ.INV",
+      "CHISQ.INV.RT",
+      "COMBIN",
+      "COMBINA",
+      "CONFIDENCE.NORM",
+      "CONFIDENCE.T",
+      "COS",
+      "COSH",
+      "COT",
+      "COTH",
+      "CURRENCY",
+      "DEGREES",
+      "EVEN",
+      "EXP",
+      "EXPON.DIST",
+      "FACT",
+      "FLOOR",
+      "GCD",
+      "INT",
+      "ISO.CEILING",
+      "LCM",
+      "LN",
+      "LOG",
+      "LOG10",
+      "MOD",
+      "MROUND",
+      "ODD",
+      "PERMUT",
+      "PI",
+      "POISSON.DIST",
+      "POWER",
+      "QUOTIENT",
+      "RADIANS",
+      "RAND",
+      "RANDBETWEEN",
+      "ROUND",
+      "ROUNDDOWN",
+      "ROUNDUP",
+      "SIGN",
+      "SIN",
+      "SINH",
+      "SQRT",
+      "SQRTPI",
+      "TAN",
+      "TANH",
+      "TRUNC",
+      "BLANK",
+      "CONCATENATE",
+      "CONCATENATEX",
+      "EXACT",
+      "FIND",
+      "FIXED",
+      "FORMAT",
+      "LEFT",
+      "LEN",
+      "LOWER",
+      "MID",
+      "REPLACE",
+      "REPT",
+      "RIGHT",
+      "SEARCH",
+      "SUBSTITUTE",
+      "TRIM",
+      "UNICHAR",
+      "UNICODE",
+      "UPPER",
+      "VALUE"
+    ],
+    tokenizer: {
+      root: [
+        { include: "@comments" },
+        { include: "@whitespace" },
+        { include: "@numbers" },
+        { include: "@strings" },
+        { include: "@complexIdentifiers" },
+        [/[;,.]/, "delimiter"],
+        [/[({})]/, "@brackets"],
+        [
+          /[a-z_][a-zA-Z0-9_]*/,
+          {
+            cases: {
+              "@keywords": "keyword",
+              "@functions": "keyword",
+              "@default": "identifier"
+            }
+          }
+        ],
+        [/[<>=!%&+\-*/|~^]/, "operator"]
+      ],
+      whitespace: [[/\s+/, "white"]],
+      comments: [
+        [/\/\/+.*/, "comment"],
+        [/\/\*/, { token: "comment.quote", next: "@comment" }]
+      ],
+      comment: [
+        [/[^*/]+/, "comment"],
+        [/\*\//, { token: "comment.quote", next: "@pop" }],
+        [/./, "comment"]
+      ],
+      numbers: [
+        [/0[xX][0-9a-fA-F]*/, "number"],
+        [/[$][+-]*\d*(\.\d*)?/, "number"],
+        [/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, "number"]
+      ],
+      strings: [
+        [/N"/, { token: "string", next: "@string" }],
+        [/"/, { token: "string", next: "@string" }]
+      ],
+      string: [
+        [/[^"]+/, "string"],
+        [/""/, "string"],
+        [/"/, { token: "string", next: "@pop" }]
+      ],
+      complexIdentifiers: [
+        [/\[/, { token: "identifier.quote", next: "@bracketedIdentifier" }],
+        [/'/, { token: "identifier.quote", next: "@quotedIdentifier" }]
+      ],
+      bracketedIdentifier: [
+        [/[^\]]+/, "identifier"],
+        [/]]/, "identifier"],
+        [/]/, { token: "identifier.quote", next: "@pop" }]
+      ],
+      quotedIdentifier: [
+        [/[^']+/, "identifier"],
+        [/''/, "identifier"],
+        [/'/, { token: "identifier.quote", next: "@pop" }]
+      ]
+    }
+  };
+  return __toCommonJS(msdax_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/mysql/mysql.js

@@ -0,0 +1,912 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/mysql/mysql", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/mysql/mysql.ts
+  var mysql_exports = {};
+  __export(mysql_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "--",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".sql",
+    ignoreCase: true,
+    brackets: [
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" }
+    ],
+    keywords: [
+      // This list is generated using `keywords.js`
+      "ACCESSIBLE",
+      "ADD",
+      "ALL",
+      "ALTER",
+      "ANALYZE",
+      "AND",
+      "AS",
+      "ASC",
+      "ASENSITIVE",
+      "BEFORE",
+      "BETWEEN",
+      "BIGINT",
+      "BINARY",
+      "BLOB",
+      "BOTH",
+      "BY",
+      "CALL",
+      "CASCADE",
+      "CASE",
+      "CHANGE",
+      "CHAR",
+      "CHARACTER",
+      "CHECK",
+      "COLLATE",
+      "COLUMN",
+      "CONDITION",
+      "CONSTRAINT",
+      "CONTINUE",
+      "CONVERT",
+      "CREATE",
+      "CROSS",
+      "CUBE",
+      "CUME_DIST",
+      "CURRENT_DATE",
+      "CURRENT_TIME",
+      "CURRENT_TIMESTAMP",
+      "CURRENT_USER",
+      "CURSOR",
+      "DATABASE",
+      "DATABASES",
+      "DAY_HOUR",
+      "DAY_MICROSECOND",
+      "DAY_MINUTE",
+      "DAY_SECOND",
+      "DEC",
+      "DECIMAL",
+      "DECLARE",
+      "DEFAULT",
+      "DELAYED",
+      "DELETE",
+      "DENSE_RANK",
+      "DESC",
+      "DESCRIBE",
+      "DETERMINISTIC",
+      "DISTINCT",
+      "DISTINCTROW",
+      "DIV",
+      "DOUBLE",
+      "DROP",
+      "DUAL",
+      "EACH",
+      "ELSE",
+      "ELSEIF",
+      "EMPTY",
+      "ENCLOSED",
+      "ESCAPED",
+      "EXCEPT",
+      "EXISTS",
+      "EXIT",
+      "EXPLAIN",
+      "FALSE",
+      "FETCH",
+      "FIRST_VALUE",
+      "FLOAT",
+      "FLOAT4",
+      "FLOAT8",
+      "FOR",
+      "FORCE",
+      "FOREIGN",
+      "FROM",
+      "FULLTEXT",
+      "FUNCTION",
+      "GENERATED",
+      "GET",
+      "GRANT",
+      "GROUP",
+      "GROUPING",
+      "GROUPS",
+      "HAVING",
+      "HIGH_PRIORITY",
+      "HOUR_MICROSECOND",
+      "HOUR_MINUTE",
+      "HOUR_SECOND",
+      "IF",
+      "IGNORE",
+      "IN",
+      "INDEX",
+      "INFILE",
+      "INNER",
+      "INOUT",
+      "INSENSITIVE",
+      "INSERT",
+      "INT",
+      "INT1",
+      "INT2",
+      "INT3",
+      "INT4",
+      "INT8",
+      "INTEGER",
+      "INTERVAL",
+      "INTO",
+      "IO_AFTER_GTIDS",
+      "IO_BEFORE_GTIDS",
+      "IS",
+      "ITERATE",
+      "JOIN",
+      "JSON_TABLE",
+      "KEY",
+      "KEYS",
+      "KILL",
+      "LAG",
+      "LAST_VALUE",
+      "LATERAL",
+      "LEAD",
+      "LEADING",
+      "LEAVE",
+      "LEFT",
+      "LIKE",
+      "LIMIT",
+      "LINEAR",
+      "LINES",
+      "LOAD",
+      "LOCALTIME",
+      "LOCALTIMESTAMP",
+      "LOCK",
+      "LONG",
+      "LONGBLOB",
+      "LONGTEXT",
+      "LOOP",
+      "LOW_PRIORITY",
+      "MASTER_BIND",
+      "MASTER_SSL_VERIFY_SERVER_CERT",
+      "MATCH",
+      "MAXVALUE",
+      "MEDIUMBLOB",
+      "MEDIUMINT",
+      "MEDIUMTEXT",
+      "MIDDLEINT",
+      "MINUTE_MICROSECOND",
+      "MINUTE_SECOND",
+      "MOD",
+      "MODIFIES",
+      "NATURAL",
+      "NOT",
+      "NO_WRITE_TO_BINLOG",
+      "NTH_VALUE",
+      "NTILE",
+      "NULL",
+      "NUMERIC",
+      "OF",
+      "ON",
+      "OPTIMIZE",
+      "OPTIMIZER_COSTS",
+      "OPTION",
+      "OPTIONALLY",
+      "OR",
+      "ORDER",
+      "OUT",
+      "OUTER",
+      "OUTFILE",
+      "OVER",
+      "PARTITION",
+      "PERCENT_RANK",
+      "PRECISION",
+      "PRIMARY",
+      "PROCEDURE",
+      "PURGE",
+      "RANGE",
+      "RANK",
+      "READ",
+      "READS",
+      "READ_WRITE",
+      "REAL",
+      "RECURSIVE",
+      "REFERENCES",
+      "REGEXP",
+      "RELEASE",
+      "RENAME",
+      "REPEAT",
+      "REPLACE",
+      "REQUIRE",
+      "RESIGNAL",
+      "RESTRICT",
+      "RETURN",
+      "REVOKE",
+      "RIGHT",
+      "RLIKE",
+      "ROW",
+      "ROWS",
+      "ROW_NUMBER",
+      "SCHEMA",
+      "SCHEMAS",
+      "SECOND_MICROSECOND",
+      "SELECT",
+      "SENSITIVE",
+      "SEPARATOR",
+      "SET",
+      "SHOW",
+      "SIGNAL",
+      "SMALLINT",
+      "SPATIAL",
+      "SPECIFIC",
+      "SQL",
+      "SQLEXCEPTION",
+      "SQLSTATE",
+      "SQLWARNING",
+      "SQL_BIG_RESULT",
+      "SQL_CALC_FOUND_ROWS",
+      "SQL_SMALL_RESULT",
+      "SSL",
+      "STARTING",
+      "STORED",
+      "STRAIGHT_JOIN",
+      "SYSTEM",
+      "TABLE",
+      "TERMINATED",
+      "THEN",
+      "TINYBLOB",
+      "TINYINT",
+      "TINYTEXT",
+      "TO",
+      "TRAILING",
+      "TRIGGER",
+      "TRUE",
+      "UNDO",
+      "UNION",
+      "UNIQUE",
+      "UNLOCK",
+      "UNSIGNED",
+      "UPDATE",
+      "USAGE",
+      "USE",
+      "USING",
+      "UTC_DATE",
+      "UTC_TIME",
+      "UTC_TIMESTAMP",
+      "VALUES",
+      "VARBINARY",
+      "VARCHAR",
+      "VARCHARACTER",
+      "VARYING",
+      "VIRTUAL",
+      "WHEN",
+      "WHERE",
+      "WHILE",
+      "WINDOW",
+      "WITH",
+      "WRITE",
+      "XOR",
+      "YEAR_MONTH",
+      "ZEROFILL"
+    ],
+    operators: [
+      "AND",
+      "BETWEEN",
+      "IN",
+      "LIKE",
+      "NOT",
+      "OR",
+      "IS",
+      "NULL",
+      "INTERSECT",
+      "UNION",
+      "INNER",
+      "JOIN",
+      "LEFT",
+      "OUTER",
+      "RIGHT"
+    ],
+    builtinFunctions: [
+      "ABS",
+      "ACOS",
+      "ADDDATE",
+      "ADDTIME",
+      "AES_DECRYPT",
+      "AES_ENCRYPT",
+      "ANY_VALUE",
+      "Area",
+      "AsBinary",
+      "AsWKB",
+      "ASCII",
+      "ASIN",
+      "AsText",
+      "AsWKT",
+      "ASYMMETRIC_DECRYPT",
+      "ASYMMETRIC_DERIVE",
+      "ASYMMETRIC_ENCRYPT",
+      "ASYMMETRIC_SIGN",
+      "ASYMMETRIC_VERIFY",
+      "ATAN",
+      "ATAN2",
+      "ATAN",
+      "AVG",
+      "BENCHMARK",
+      "BIN",
+      "BIT_AND",
+      "BIT_COUNT",
+      "BIT_LENGTH",
+      "BIT_OR",
+      "BIT_XOR",
+      "Buffer",
+      "CAST",
+      "CEIL",
+      "CEILING",
+      "Centroid",
+      "CHAR",
+      "CHAR_LENGTH",
+      "CHARACTER_LENGTH",
+      "CHARSET",
+      "COALESCE",
+      "COERCIBILITY",
+      "COLLATION",
+      "COMPRESS",
+      "CONCAT",
+      "CONCAT_WS",
+      "CONNECTION_ID",
+      "Contains",
+      "CONV",
+      "CONVERT",
+      "CONVERT_TZ",
+      "ConvexHull",
+      "COS",
+      "COT",
+      "COUNT",
+      "CRC32",
+      "CREATE_ASYMMETRIC_PRIV_KEY",
+      "CREATE_ASYMMETRIC_PUB_KEY",
+      "CREATE_DH_PARAMETERS",
+      "CREATE_DIGEST",
+      "Crosses",
+      "CUME_DIST",
+      "CURDATE",
+      "CURRENT_DATE",
+      "CURRENT_ROLE",
+      "CURRENT_TIME",
+      "CURRENT_TIMESTAMP",
+      "CURRENT_USER",
+      "CURTIME",
+      "DATABASE",
+      "DATE",
+      "DATE_ADD",
+      "DATE_FORMAT",
+      "DATE_SUB",
+      "DATEDIFF",
+      "DAY",
+      "DAYNAME",
+      "DAYOFMONTH",
+      "DAYOFWEEK",
+      "DAYOFYEAR",
+      "DECODE",
+      "DEFAULT",
+      "DEGREES",
+      "DES_DECRYPT",
+      "DES_ENCRYPT",
+      "DENSE_RANK",
+      "Dimension",
+      "Disjoint",
+      "Distance",
+      "ELT",
+      "ENCODE",
+      "ENCRYPT",
+      "EndPoint",
+      "Envelope",
+      "Equals",
+      "EXP",
+      "EXPORT_SET",
+      "ExteriorRing",
+      "EXTRACT",
+      "ExtractValue",
+      "FIELD",
+      "FIND_IN_SET",
+      "FIRST_VALUE",
+      "FLOOR",
+      "FORMAT",
+      "FORMAT_BYTES",
+      "FORMAT_PICO_TIME",
+      "FOUND_ROWS",
+      "FROM_BASE64",
+      "FROM_DAYS",
+      "FROM_UNIXTIME",
+      "GEN_RANGE",
+      "GEN_RND_EMAIL",
+      "GEN_RND_PAN",
+      "GEN_RND_SSN",
+      "GEN_RND_US_PHONE",
+      "GeomCollection",
+      "GeomCollFromText",
+      "GeometryCollectionFromText",
+      "GeomCollFromWKB",
+      "GeometryCollectionFromWKB",
+      "GeometryCollection",
+      "GeometryN",
+      "GeometryType",
+      "GeomFromText",
+      "GeometryFromText",
+      "GeomFromWKB",
+      "GeometryFromWKB",
+      "GET_FORMAT",
+      "GET_LOCK",
+      "GLength",
+      "GREATEST",
+      "GROUP_CONCAT",
+      "GROUPING",
+      "GTID_SUBSET",
+      "GTID_SUBTRACT",
+      "HEX",
+      "HOUR",
+      "ICU_VERSION",
+      "IF",
+      "IFNULL",
+      "INET_ATON",
+      "INET_NTOA",
+      "INET6_ATON",
+      "INET6_NTOA",
+      "INSERT",
+      "INSTR",
+      "InteriorRingN",
+      "Intersects",
+      "INTERVAL",
+      "IS_FREE_LOCK",
+      "IS_IPV4",
+      "IS_IPV4_COMPAT",
+      "IS_IPV4_MAPPED",
+      "IS_IPV6",
+      "IS_USED_LOCK",
+      "IS_UUID",
+      "IsClosed",
+      "IsEmpty",
+      "ISNULL",
+      "IsSimple",
+      "JSON_APPEND",
+      "JSON_ARRAY",
+      "JSON_ARRAY_APPEND",
+      "JSON_ARRAY_INSERT",
+      "JSON_ARRAYAGG",
+      "JSON_CONTAINS",
+      "JSON_CONTAINS_PATH",
+      "JSON_DEPTH",
+      "JSON_EXTRACT",
+      "JSON_INSERT",
+      "JSON_KEYS",
+      "JSON_LENGTH",
+      "JSON_MERGE",
+      "JSON_MERGE_PATCH",
+      "JSON_MERGE_PRESERVE",
+      "JSON_OBJECT",
+      "JSON_OBJECTAGG",
+      "JSON_OVERLAPS",
+      "JSON_PRETTY",
+      "JSON_QUOTE",
+      "JSON_REMOVE",
+      "JSON_REPLACE",
+      "JSON_SCHEMA_VALID",
+      "JSON_SCHEMA_VALIDATION_REPORT",
+      "JSON_SEARCH",
+      "JSON_SET",
+      "JSON_STORAGE_FREE",
+      "JSON_STORAGE_SIZE",
+      "JSON_TABLE",
+      "JSON_TYPE",
+      "JSON_UNQUOTE",
+      "JSON_VALID",
+      "LAG",
+      "LAST_DAY",
+      "LAST_INSERT_ID",
+      "LAST_VALUE",
+      "LCASE",
+      "LEAD",
+      "LEAST",
+      "LEFT",
+      "LENGTH",
+      "LineFromText",
+      "LineStringFromText",
+      "LineFromWKB",
+      "LineStringFromWKB",
+      "LineString",
+      "LN",
+      "LOAD_FILE",
+      "LOCALTIME",
+      "LOCALTIMESTAMP",
+      "LOCATE",
+      "LOG",
+      "LOG10",
+      "LOG2",
+      "LOWER",
+      "LPAD",
+      "LTRIM",
+      "MAKE_SET",
+      "MAKEDATE",
+      "MAKETIME",
+      "MASK_INNER",
+      "MASK_OUTER",
+      "MASK_PAN",
+      "MASK_PAN_RELAXED",
+      "MASK_SSN",
+      "MASTER_POS_WAIT",
+      "MAX",
+      "MBRContains",
+      "MBRCoveredBy",
+      "MBRCovers",
+      "MBRDisjoint",
+      "MBREqual",
+      "MBREquals",
+      "MBRIntersects",
+      "MBROverlaps",
+      "MBRTouches",
+      "MBRWithin",
+      "MD5",
+      "MEMBER OF",
+      "MICROSECOND",
+      "MID",
+      "MIN",
+      "MINUTE",
+      "MLineFromText",
+      "MultiLineStringFromText",
+      "MLineFromWKB",
+      "MultiLineStringFromWKB",
+      "MOD",
+      "MONTH",
+      "MONTHNAME",
+      "MPointFromText",
+      "MultiPointFromText",
+      "MPointFromWKB",
+      "MultiPointFromWKB",
+      "MPolyFromText",
+      "MultiPolygonFromText",
+      "MPolyFromWKB",
+      "MultiPolygonFromWKB",
+      "MultiLineString",
+      "MultiPoint",
+      "MultiPolygon",
+      "NAME_CONST",
+      "NOT IN",
+      "NOW",
+      "NTH_VALUE",
+      "NTILE",
+      "NULLIF",
+      "NumGeometries",
+      "NumInteriorRings",
+      "NumPoints",
+      "OCT",
+      "OCTET_LENGTH",
+      "OLD_PASSWORD",
+      "ORD",
+      "Overlaps",
+      "PASSWORD",
+      "PERCENT_RANK",
+      "PERIOD_ADD",
+      "PERIOD_DIFF",
+      "PI",
+      "Point",
+      "PointFromText",
+      "PointFromWKB",
+      "PointN",
+      "PolyFromText",
+      "PolygonFromText",
+      "PolyFromWKB",
+      "PolygonFromWKB",
+      "Polygon",
+      "POSITION",
+      "POW",
+      "POWER",
+      "PS_CURRENT_THREAD_ID",
+      "PS_THREAD_ID",
+      "PROCEDURE ANALYSE",
+      "QUARTER",
+      "QUOTE",
+      "RADIANS",
+      "RAND",
+      "RANDOM_BYTES",
+      "RANK",
+      "REGEXP_INSTR",
+      "REGEXP_LIKE",
+      "REGEXP_REPLACE",
+      "REGEXP_REPLACE",
+      "RELEASE_ALL_LOCKS",
+      "RELEASE_LOCK",
+      "REPEAT",
+      "REPLACE",
+      "REVERSE",
+      "RIGHT",
+      "ROLES_GRAPHML",
+      "ROUND",
+      "ROW_COUNT",
+      "ROW_NUMBER",
+      "RPAD",
+      "RTRIM",
+      "SCHEMA",
+      "SEC_TO_TIME",
+      "SECOND",
+      "SESSION_USER",
+      "SHA1",
+      "SHA",
+      "SHA2",
+      "SIGN",
+      "SIN",
+      "SLEEP",
+      "SOUNDEX",
+      "SOURCE_POS_WAIT",
+      "SPACE",
+      "SQRT",
+      "SRID",
+      "ST_Area",
+      "ST_AsBinary",
+      "ST_AsWKB",
+      "ST_AsGeoJSON",
+      "ST_AsText",
+      "ST_AsWKT",
+      "ST_Buffer",
+      "ST_Buffer_Strategy",
+      "ST_Centroid",
+      "ST_Collect",
+      "ST_Contains",
+      "ST_ConvexHull",
+      "ST_Crosses",
+      "ST_Difference",
+      "ST_Dimension",
+      "ST_Disjoint",
+      "ST_Distance",
+      "ST_Distance_Sphere",
+      "ST_EndPoint",
+      "ST_Envelope",
+      "ST_Equals",
+      "ST_ExteriorRing",
+      "ST_FrechetDistance",
+      "ST_GeoHash",
+      "ST_GeomCollFromText",
+      "ST_GeometryCollectionFromText",
+      "ST_GeomCollFromTxt",
+      "ST_GeomCollFromWKB",
+      "ST_GeometryCollectionFromWKB",
+      "ST_GeometryN",
+      "ST_GeometryType",
+      "ST_GeomFromGeoJSON",
+      "ST_GeomFromText",
+      "ST_GeometryFromText",
+      "ST_GeomFromWKB",
+      "ST_GeometryFromWKB",
+      "ST_HausdorffDistance",
+      "ST_InteriorRingN",
+      "ST_Intersection",
+      "ST_Intersects",
+      "ST_IsClosed",
+      "ST_IsEmpty",
+      "ST_IsSimple",
+      "ST_IsValid",
+      "ST_LatFromGeoHash",
+      "ST_Length",
+      "ST_LineFromText",
+      "ST_LineStringFromText",
+      "ST_LineFromWKB",
+      "ST_LineStringFromWKB",
+      "ST_LineInterpolatePoint",
+      "ST_LineInterpolatePoints",
+      "ST_LongFromGeoHash",
+      "ST_Longitude",
+      "ST_MakeEnvelope",
+      "ST_MLineFromText",
+      "ST_MultiLineStringFromText",
+      "ST_MLineFromWKB",
+      "ST_MultiLineStringFromWKB",
+      "ST_MPointFromText",
+      "ST_MultiPointFromText",
+      "ST_MPointFromWKB",
+      "ST_MultiPointFromWKB",
+      "ST_MPolyFromText",
+      "ST_MultiPolygonFromText",
+      "ST_MPolyFromWKB",
+      "ST_MultiPolygonFromWKB",
+      "ST_NumGeometries",
+      "ST_NumInteriorRing",
+      "ST_NumInteriorRings",
+      "ST_NumPoints",
+      "ST_Overlaps",
+      "ST_PointAtDistance",
+      "ST_PointFromGeoHash",
+      "ST_PointFromText",
+      "ST_PointFromWKB",
+      "ST_PointN",
+      "ST_PolyFromText",
+      "ST_PolygonFromText",
+      "ST_PolyFromWKB",
+      "ST_PolygonFromWKB",
+      "ST_Simplify",
+      "ST_SRID",
+      "ST_StartPoint",
+      "ST_SwapXY",
+      "ST_SymDifference",
+      "ST_Touches",
+      "ST_Transform",
+      "ST_Union",
+      "ST_Validate",
+      "ST_Within",
+      "ST_X",
+      "ST_Y",
+      "StartPoint",
+      "STATEMENT_DIGEST",
+      "STATEMENT_DIGEST_TEXT",
+      "STD",
+      "STDDEV",
+      "STDDEV_POP",
+      "STDDEV_SAMP",
+      "STR_TO_DATE",
+      "STRCMP",
+      "SUBDATE",
+      "SUBSTR",
+      "SUBSTRING",
+      "SUBSTRING_INDEX",
+      "SUBTIME",
+      "SUM",
+      "SYSDATE",
+      "SYSTEM_USER",
+      "TAN",
+      "TIME",
+      "TIME_FORMAT",
+      "TIME_TO_SEC",
+      "TIMEDIFF",
+      "TIMESTAMP",
+      "TIMESTAMPADD",
+      "TIMESTAMPDIFF",
+      "TO_BASE64",
+      "TO_DAYS",
+      "TO_SECONDS",
+      "Touches",
+      "TRIM",
+      "TRUNCATE",
+      "UCASE",
+      "UNCOMPRESS",
+      "UNCOMPRESSED_LENGTH",
+      "UNHEX",
+      "UNIX_TIMESTAMP",
+      "UpdateXML",
+      "UPPER",
+      "USER",
+      "UTC_DATE",
+      "UTC_TIME",
+      "UTC_TIMESTAMP",
+      "UUID",
+      "UUID_SHORT",
+      "UUID_TO_BIN",
+      "VALIDATE_PASSWORD_STRENGTH",
+      "VALUES",
+      "VAR_POP",
+      "VAR_SAMP",
+      "VARIANCE",
+      "VERSION",
+      "WAIT_FOR_EXECUTED_GTID_SET",
+      "WAIT_UNTIL_SQL_THREAD_AFTER_GTIDS",
+      "WEEK",
+      "WEEKDAY",
+      "WEEKOFYEAR",
+      "WEIGHT_STRING",
+      "Within",
+      "X",
+      "Y",
+      "YEAR",
+      "YEARWEEK"
+    ],
+    builtinVariables: [
+      // NOT SUPPORTED
+    ],
+    tokenizer: {
+      root: [
+        { include: "@comments" },
+        { include: "@whitespace" },
+        { include: "@numbers" },
+        { include: "@strings" },
+        { include: "@complexIdentifiers" },
+        { include: "@scopes" },
+        [/[;,.]/, "delimiter"],
+        [/[()]/, "@brackets"],
+        [
+          /[\w@]+/,
+          {
+            cases: {
+              "@operators": "operator",
+              "@builtinVariables": "predefined",
+              "@builtinFunctions": "predefined",
+              "@keywords": "keyword",
+              "@default": "identifier"
+            }
+          }
+        ],
+        [/[<>=!%&+\-*/|~^]/, "operator"]
+      ],
+      whitespace: [[/\s+/, "white"]],
+      comments: [
+        [/--+.*/, "comment"],
+        [/#+.*/, "comment"],
+        [/\/\*/, { token: "comment.quote", next: "@comment" }]
+      ],
+      comment: [
+        [/[^*/]+/, "comment"],
+        // Not supporting nested comments, as nested comments seem to not be standard?
+        // i.e. http://stackoverflow.com/questions/728172/are-there-multiline-comment-delimiters-in-sql-that-are-vendor-agnostic
+        // [/\/\*/, { token: 'comment.quote', next: '@push' }],    // nested comment not allowed :-(
+        [/\*\//, { token: "comment.quote", next: "@pop" }],
+        [/./, "comment"]
+      ],
+      numbers: [
+        [/0[xX][0-9a-fA-F]*/, "number"],
+        [/[$][+-]*\d*(\.\d*)?/, "number"],
+        [/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, "number"]
+      ],
+      strings: [
+        [/'/, { token: "string", next: "@string" }],
+        [/"/, { token: "string.double", next: "@stringDouble" }]
+      ],
+      string: [
+        [/\\'/, "string"],
+        [/[^']+/, "string"],
+        [/''/, "string"],
+        [/'/, { token: "string", next: "@pop" }]
+      ],
+      stringDouble: [
+        [/[^"]+/, "string.double"],
+        [/""/, "string.double"],
+        [/"/, { token: "string.double", next: "@pop" }]
+      ],
+      complexIdentifiers: [[/`/, { token: "identifier.quote", next: "@quotedIdentifier" }]],
+      quotedIdentifier: [
+        [/[^`]+/, "identifier"],
+        [/``/, "identifier"],
+        [/`/, { token: "identifier.quote", next: "@pop" }]
+      ],
+      scopes: [
+        // NOT SUPPORTED
+      ]
+    }
+  };
+  return __toCommonJS(mysql_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/objective-c/objective-c.js

@@ -0,0 +1,217 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/objective-c/objective-c", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/objective-c/objective-c.ts
+  var objective_c_exports = {};
+  __export(objective_c_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".objective-c",
+    keywords: [
+      "#import",
+      "#include",
+      "#define",
+      "#else",
+      "#endif",
+      "#if",
+      "#ifdef",
+      "#ifndef",
+      "#ident",
+      "#undef",
+      "@class",
+      "@defs",
+      "@dynamic",
+      "@encode",
+      "@end",
+      "@implementation",
+      "@interface",
+      "@package",
+      "@private",
+      "@protected",
+      "@property",
+      "@protocol",
+      "@public",
+      "@selector",
+      "@synthesize",
+      "__declspec",
+      "assign",
+      "auto",
+      "BOOL",
+      "break",
+      "bycopy",
+      "byref",
+      "case",
+      "char",
+      "Class",
+      "const",
+      "copy",
+      "continue",
+      "default",
+      "do",
+      "double",
+      "else",
+      "enum",
+      "extern",
+      "FALSE",
+      "false",
+      "float",
+      "for",
+      "goto",
+      "if",
+      "in",
+      "int",
+      "id",
+      "inout",
+      "IMP",
+      "long",
+      "nil",
+      "nonatomic",
+      "NULL",
+      "oneway",
+      "out",
+      "private",
+      "public",
+      "protected",
+      "readwrite",
+      "readonly",
+      "register",
+      "return",
+      "SEL",
+      "self",
+      "short",
+      "signed",
+      "sizeof",
+      "static",
+      "struct",
+      "super",
+      "switch",
+      "typedef",
+      "TRUE",
+      "true",
+      "union",
+      "unsigned",
+      "volatile",
+      "void",
+      "while"
+    ],
+    decpart: /\d(_?\d)*/,
+    decimal: /0|@decpart/,
+    tokenizer: {
+      root: [
+        { include: "@comments" },
+        { include: "@whitespace" },
+        { include: "@numbers" },
+        { include: "@strings" },
+        [/[,:;]/, "delimiter"],
+        [/[{}\[\]()<>]/, "@brackets"],
+        [
+          /[a-zA-Z@#]\w*/,
+          {
+            cases: {
+              "@keywords": "keyword",
+              "@default": "identifier"
+            }
+          }
+        ],
+        [/[<>=\\+\\-\\*\\/\\^\\|\\~,]|and\\b|or\\b|not\\b]/, "operator"]
+      ],
+      whitespace: [[/\s+/, "white"]],
+      comments: [
+        ["\\/\\*", "comment", "@comment"],
+        ["\\/\\/+.*", "comment"]
+      ],
+      comment: [
+        ["\\*\\/", "comment", "@pop"],
+        [".", "comment"]
+      ],
+      numbers: [
+        [/0[xX][0-9a-fA-F]*(_?[0-9a-fA-F])*/, "number.hex"],
+        [
+          /@decimal((\.@decpart)?([eE][\-+]?@decpart)?)[fF]*/,
+          {
+            cases: {
+              "(\\d)*": "number",
+              $0: "number.float"
+            }
+          }
+        ]
+      ],
+      // Recognize strings, including those broken across lines with \ (but not without)
+      strings: [
+        [/'$/, "string.escape", "@popall"],
+        [/'/, "string.escape", "@stringBody"],
+        [/"$/, "string.escape", "@popall"],
+        [/"/, "string.escape", "@dblStringBody"]
+      ],
+      stringBody: [
+        [/[^\\']+$/, "string", "@popall"],
+        [/[^\\']+/, "string"],
+        [/\\./, "string"],
+        [/'/, "string.escape", "@popall"],
+        [/\\$/, "string"]
+      ],
+      dblStringBody: [
+        [/[^\\"]+$/, "string", "@popall"],
+        [/[^\\"]+/, "string"],
+        [/\\./, "string"],
+        [/"/, "string.escape", "@popall"],
+        [/\\$/, "string"]
+      ]
+    }
+  };
+  return __toCommonJS(objective_c_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/pascal/pascal.js

@@ -0,0 +1,285 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/pascal/pascal", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/pascal/pascal.ts
+  var pascal_exports = {};
+  __export(pascal_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    // the default separators except `@$`
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+    comments: {
+      lineComment: "//",
+      blockComment: ["{", "}"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"],
+      ["<", ">"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">" },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">" },
+      { open: "'", close: "'" }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*\\{\\$REGION(\\s\\'.*\\')?\\}"),
+        end: new RegExp("^\\s*\\{\\$ENDREGION\\}")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".pascal",
+    ignoreCase: true,
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "<", close: ">", token: "delimiter.angle" }
+    ],
+    keywords: [
+      "absolute",
+      "abstract",
+      "all",
+      "and_then",
+      "array",
+      "as",
+      "asm",
+      "attribute",
+      "begin",
+      "bindable",
+      "case",
+      "class",
+      "const",
+      "contains",
+      "default",
+      "div",
+      "else",
+      "end",
+      "except",
+      "exports",
+      "external",
+      "far",
+      "file",
+      "finalization",
+      "finally",
+      "forward",
+      "generic",
+      "goto",
+      "if",
+      "implements",
+      "import",
+      "in",
+      "index",
+      "inherited",
+      "initialization",
+      "interrupt",
+      "is",
+      "label",
+      "library",
+      "mod",
+      "module",
+      "name",
+      "near",
+      "not",
+      "object",
+      "of",
+      "on",
+      "only",
+      "operator",
+      "or_else",
+      "otherwise",
+      "override",
+      "package",
+      "packed",
+      "pow",
+      "private",
+      "program",
+      "protected",
+      "public",
+      "published",
+      "interface",
+      "implementation",
+      "qualified",
+      "read",
+      "record",
+      "resident",
+      "requires",
+      "resourcestring",
+      "restricted",
+      "segment",
+      "set",
+      "shl",
+      "shr",
+      "specialize",
+      "stored",
+      "strict",
+      "then",
+      "threadvar",
+      "to",
+      "try",
+      "type",
+      "unit",
+      "uses",
+      "var",
+      "view",
+      "virtual",
+      "dynamic",
+      "overload",
+      "reintroduce",
+      "with",
+      "write",
+      "xor",
+      "true",
+      "false",
+      "procedure",
+      "function",
+      "constructor",
+      "destructor",
+      "property",
+      "break",
+      "continue",
+      "exit",
+      "abort",
+      "while",
+      "do",
+      "for",
+      "raise",
+      "repeat",
+      "until"
+    ],
+    typeKeywords: [
+      "boolean",
+      "double",
+      "byte",
+      "integer",
+      "shortint",
+      "char",
+      "longint",
+      "float",
+      "string"
+    ],
+    operators: [
+      "=",
+      ">",
+      "<",
+      "<=",
+      ">=",
+      "<>",
+      ":",
+      ":=",
+      "and",
+      "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"]
+      ]
+    }
+  };
+  return __toCommonJS(pascal_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/pascaligo/pascaligo.js

@@ -0,0 +1,198 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/pascaligo/pascaligo", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/pascaligo/pascaligo.ts
+  var pascaligo_exports = {};
+  __export(pascaligo_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "//",
+      blockComment: ["(*", "*)"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"],
+      ["<", ">"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">" },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: "<", close: ">" },
+      { open: "'", close: "'" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".pascaligo",
+    ignoreCase: true,
+    brackets: [
+      { open: "{", close: "}", token: "delimiter.curly" },
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" },
+      { open: "<", close: ">", token: "delimiter.angle" }
+    ],
+    keywords: [
+      "begin",
+      "block",
+      "case",
+      "const",
+      "else",
+      "end",
+      "fail",
+      "for",
+      "from",
+      "function",
+      "if",
+      "is",
+      "nil",
+      "of",
+      "remove",
+      "return",
+      "skip",
+      "then",
+      "type",
+      "var",
+      "while",
+      "with",
+      "option",
+      "None",
+      "transaction"
+    ],
+    typeKeywords: [
+      "bool",
+      "int",
+      "list",
+      "map",
+      "nat",
+      "record",
+      "string",
+      "unit",
+      "address",
+      "map",
+      "mtz",
+      "xtz"
+    ],
+    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"]
+      ]
+    }
+  };
+  return __toCommonJS(pascaligo_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/perl/perl.js

@@ -0,0 +1,660 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/perl/perl", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/perl/perl.ts
+  var perl_exports = {};
+  __export(perl_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "#"
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "`", close: "`" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: "`", close: "`" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".perl",
+    brackets: [
+      { token: "delimiter.bracket", open: "{", close: "}" },
+      { token: "delimiter.parenthesis", open: "(", close: ")" },
+      { token: "delimiter.square", open: "[", close: "]" }
+    ],
+    // https://learn.perl.org/docs/keywords.html
+    // Perl syntax
+    keywords: [
+      "__DATA__",
+      "else",
+      "lock",
+      "__END__",
+      "elsif",
+      "lt",
+      "__FILE__",
+      "eq",
+      "__LINE__",
+      "exp",
+      "ne",
+      "sub",
+      "__PACKAGE__",
+      "for",
+      "no",
+      "and",
+      "foreach",
+      "or",
+      "unless",
+      "cmp",
+      "ge",
+      "package",
+      "until",
+      "continue",
+      "gt",
+      "while",
+      "CORE",
+      "if",
+      "xor",
+      "do",
+      "le",
+      "__DIE__",
+      "__WARN__"
+    ],
+    // Perl functions
+    builtinFunctions: [
+      "-A",
+      "END",
+      "length",
+      "setpgrp",
+      "-B",
+      "endgrent",
+      "link",
+      "setpriority",
+      "-b",
+      "endhostent",
+      "listen",
+      "setprotoent",
+      "-C",
+      "endnetent",
+      "local",
+      "setpwent",
+      "-c",
+      "endprotoent",
+      "localtime",
+      "setservent",
+      "-d",
+      "endpwent",
+      "log",
+      "setsockopt",
+      "-e",
+      "endservent",
+      "lstat",
+      "shift",
+      "-f",
+      "eof",
+      "map",
+      "shmctl",
+      "-g",
+      "eval",
+      "mkdir",
+      "shmget",
+      "-k",
+      "exec",
+      "msgctl",
+      "shmread",
+      "-l",
+      "exists",
+      "msgget",
+      "shmwrite",
+      "-M",
+      "exit",
+      "msgrcv",
+      "shutdown",
+      "-O",
+      "fcntl",
+      "msgsnd",
+      "sin",
+      "-o",
+      "fileno",
+      "my",
+      "sleep",
+      "-p",
+      "flock",
+      "next",
+      "socket",
+      "-r",
+      "fork",
+      "not",
+      "socketpair",
+      "-R",
+      "format",
+      "oct",
+      "sort",
+      "-S",
+      "formline",
+      "open",
+      "splice",
+      "-s",
+      "getc",
+      "opendir",
+      "split",
+      "-T",
+      "getgrent",
+      "ord",
+      "sprintf",
+      "-t",
+      "getgrgid",
+      "our",
+      "sqrt",
+      "-u",
+      "getgrnam",
+      "pack",
+      "srand",
+      "-w",
+      "gethostbyaddr",
+      "pipe",
+      "stat",
+      "-W",
+      "gethostbyname",
+      "pop",
+      "state",
+      "-X",
+      "gethostent",
+      "pos",
+      "study",
+      "-x",
+      "getlogin",
+      "print",
+      "substr",
+      "-z",
+      "getnetbyaddr",
+      "printf",
+      "symlink",
+      "abs",
+      "getnetbyname",
+      "prototype",
+      "syscall",
+      "accept",
+      "getnetent",
+      "push",
+      "sysopen",
+      "alarm",
+      "getpeername",
+      "quotemeta",
+      "sysread",
+      "atan2",
+      "getpgrp",
+      "rand",
+      "sysseek",
+      "AUTOLOAD",
+      "getppid",
+      "read",
+      "system",
+      "BEGIN",
+      "getpriority",
+      "readdir",
+      "syswrite",
+      "bind",
+      "getprotobyname",
+      "readline",
+      "tell",
+      "binmode",
+      "getprotobynumber",
+      "readlink",
+      "telldir",
+      "bless",
+      "getprotoent",
+      "readpipe",
+      "tie",
+      "break",
+      "getpwent",
+      "recv",
+      "tied",
+      "caller",
+      "getpwnam",
+      "redo",
+      "time",
+      "chdir",
+      "getpwuid",
+      "ref",
+      "times",
+      "CHECK",
+      "getservbyname",
+      "rename",
+      "truncate",
+      "chmod",
+      "getservbyport",
+      "require",
+      "uc",
+      "chomp",
+      "getservent",
+      "reset",
+      "ucfirst",
+      "chop",
+      "getsockname",
+      "return",
+      "umask",
+      "chown",
+      "getsockopt",
+      "reverse",
+      "undef",
+      "chr",
+      "glob",
+      "rewinddir",
+      "UNITCHECK",
+      "chroot",
+      "gmtime",
+      "rindex",
+      "unlink",
+      "close",
+      "goto",
+      "rmdir",
+      "unpack",
+      "closedir",
+      "grep",
+      "say",
+      "unshift",
+      "connect",
+      "hex",
+      "scalar",
+      "untie",
+      "cos",
+      "index",
+      "seek",
+      "use",
+      "crypt",
+      "INIT",
+      "seekdir",
+      "utime",
+      "dbmclose",
+      "int",
+      "select",
+      "values",
+      "dbmopen",
+      "ioctl",
+      "semctl",
+      "vec",
+      "defined",
+      "join",
+      "semget",
+      "wait",
+      "delete",
+      "keys",
+      "semop",
+      "waitpid",
+      "DESTROY",
+      "kill",
+      "send",
+      "wantarray",
+      "die",
+      "last",
+      "setgrent",
+      "warn",
+      "dump",
+      "lc",
+      "sethostent",
+      "write",
+      "each",
+      "lcfirst",
+      "setnetent"
+    ],
+    // File handlers
+    builtinFileHandlers: ["ARGV", "STDERR", "STDOUT", "ARGVOUT", "STDIN", "ENV"],
+    // Perl variables
+    builtinVariables: [
+      "$!",
+      "$^RE_TRIE_MAXBUF",
+      "$LAST_REGEXP_CODE_RESULT",
+      '$"',
+      "$^S",
+      "$LIST_SEPARATOR",
+      "$#",
+      "$^T",
+      "$MATCH",
+      "$$",
+      "$^TAINT",
+      "$MULTILINE_MATCHING",
+      "$%",
+      "$^UNICODE",
+      "$NR",
+      "$&",
+      "$^UTF8LOCALE",
+      "$OFMT",
+      "$'",
+      "$^V",
+      "$OFS",
+      "$(",
+      "$^W",
+      "$ORS",
+      "$)",
+      "$^WARNING_BITS",
+      "$OS_ERROR",
+      "$*",
+      "$^WIDE_SYSTEM_CALLS",
+      "$OSNAME",
+      "$+",
+      "$^X",
+      "$OUTPUT_AUTO_FLUSH",
+      "$,",
+      "$_",
+      "$OUTPUT_FIELD_SEPARATOR",
+      "$-",
+      "$`",
+      "$OUTPUT_RECORD_SEPARATOR",
+      "$.",
+      "$a",
+      "$PERL_VERSION",
+      "$/",
+      "$ACCUMULATOR",
+      "$PERLDB",
+      "$0",
+      "$ARG",
+      "$PID",
+      "$:",
+      "$ARGV",
+      "$POSTMATCH",
+      "$;",
+      "$b",
+      "$PREMATCH",
+      "$<",
+      "$BASETIME",
+      "$PROCESS_ID",
+      "$=",
+      "$CHILD_ERROR",
+      "$PROGRAM_NAME",
+      "$>",
+      "$COMPILING",
+      "$REAL_GROUP_ID",
+      "$?",
+      "$DEBUGGING",
+      "$REAL_USER_ID",
+      "$@",
+      "$EFFECTIVE_GROUP_ID",
+      "$RS",
+      "$[",
+      "$EFFECTIVE_USER_ID",
+      "$SUBSCRIPT_SEPARATOR",
+      "$\\",
+      "$EGID",
+      "$SUBSEP",
+      "$]",
+      "$ERRNO",
+      "$SYSTEM_FD_MAX",
+      "$^",
+      "$EUID",
+      "$UID",
+      "$^A",
+      "$EVAL_ERROR",
+      "$WARNING",
+      "$^C",
+      "$EXCEPTIONS_BEING_CAUGHT",
+      "$|",
+      "$^CHILD_ERROR_NATIVE",
+      "$EXECUTABLE_NAME",
+      "$~",
+      "$^D",
+      "$EXTENDED_OS_ERROR",
+      "%!",
+      "$^E",
+      "$FORMAT_FORMFEED",
+      "%^H",
+      "$^ENCODING",
+      "$FORMAT_LINE_BREAK_CHARACTERS",
+      "%ENV",
+      "$^F",
+      "$FORMAT_LINES_LEFT",
+      "%INC",
+      "$^H",
+      "$FORMAT_LINES_PER_PAGE",
+      "%OVERLOAD",
+      "$^I",
+      "$FORMAT_NAME",
+      "%SIG",
+      "$^L",
+      "$FORMAT_PAGE_NUMBER",
+      "@+",
+      "$^M",
+      "$FORMAT_TOP_NAME",
+      "@-",
+      "$^N",
+      "$GID",
+      "@_",
+      "$^O",
+      "$INPLACE_EDIT",
+      "@ARGV",
+      "$^OPEN",
+      "$INPUT_LINE_NUMBER",
+      "@INC",
+      "$^P",
+      "$INPUT_RECORD_SEPARATOR",
+      "@LAST_MATCH_START",
+      "$^R",
+      "$LAST_MATCH_END",
+      "$^RE_DEBUG_FLAGS",
+      "$LAST_PAREN_MATCH"
+    ],
+    // operators
+    symbols: /[:+\-\^*$&%@=<>!?|\/~\.]/,
+    quoteLikeOps: ["qr", "m", "s", "q", "qq", "qx", "qw", "tr", "y"],
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        { include: "@whitespace" },
+        [
+          /[a-zA-Z\-_][\w\-_]*/,
+          {
+            cases: {
+              "@keywords": "keyword",
+              "@builtinFunctions": "type.identifier",
+              "@builtinFileHandlers": "variable.predefined",
+              "@quoteLikeOps": {
+                token: "@rematch",
+                next: "quotedConstructs"
+              },
+              "@default": ""
+            }
+          }
+        ],
+        // Perl variables
+        [
+          /[\$@%][*@#?\+\-\$!\w\\\^><~:;\.]+/,
+          {
+            cases: {
+              "@builtinVariables": "variable.predefined",
+              "@default": "variable"
+            }
+          }
+        ],
+        { include: "@strings" },
+        { include: "@dblStrings" },
+        // Perl Doc
+        { include: "@perldoc" },
+        // Here Doc
+        { include: "@heredoc" },
+        [/[{}\[\]()]/, "@brackets"],
+        // RegExp
+        [/[\/](?:(?:\[(?:\\]|[^\]])+\])|(?:\\\/|[^\]\/]))*[\/]\w*\s*(?=[).,;]|$)/, "regexp"],
+        [/@symbols/, "operators"],
+        { include: "@numbers" },
+        [/[,;]/, "delimiter"]
+      ],
+      whitespace: [
+        [/\s+/, "white"],
+        [/(^#!.*$)/, "metatag"],
+        [/(^#.*$)/, "comment"]
+      ],
+      numbers: [
+        [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+        [/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, "number.hex"],
+        [/\d+/, "number"]
+      ],
+      // Single quote string
+      strings: [[/'/, "string", "@stringBody"]],
+      stringBody: [
+        [/'/, "string", "@popall"],
+        [/\\'/, "string.escape"],
+        [/./, "string"]
+      ],
+      // Double quote string
+      dblStrings: [[/"/, "string", "@dblStringBody"]],
+      dblStringBody: [
+        [/"/, "string", "@popall"],
+        [/@escapes/, "string.escape"],
+        [/\\./, "string.escape.invalid"],
+        { include: "@variables" },
+        [/./, "string"]
+      ],
+      // Quoted constructs
+      // Percent strings in Ruby are similar to quote-like operators in Perl.
+      // This is adapted from pstrings in ../ruby/ruby.ts.
+      quotedConstructs: [
+        [/(q|qw|tr|y)\s*\(/, { token: "string.delim", switchTo: "@qstring.(.)" }],
+        [/(q|qw|tr|y)\s*\[/, { token: "string.delim", switchTo: "@qstring.[.]" }],
+        [/(q|qw|tr|y)\s*\{/, { token: "string.delim", switchTo: "@qstring.{.}" }],
+        [/(q|qw|tr|y)\s*</, { token: "string.delim", switchTo: "@qstring.<.>" }],
+        [/(q|qw|tr|y)#/, { token: "string.delim", switchTo: "@qstring.#.#" }],
+        [/(q|qw|tr|y)\s*([^A-Za-z0-9#\s])/, { token: "string.delim", switchTo: "@qstring.$2.$2" }],
+        [/(q|qw|tr|y)\s+(\w)/, { token: "string.delim", switchTo: "@qstring.$2.$2" }],
+        [/(qr|m|s)\s*\(/, { token: "regexp.delim", switchTo: "@qregexp.(.)" }],
+        [/(qr|m|s)\s*\[/, { token: "regexp.delim", switchTo: "@qregexp.[.]" }],
+        [/(qr|m|s)\s*\{/, { token: "regexp.delim", switchTo: "@qregexp.{.}" }],
+        [/(qr|m|s)\s*</, { token: "regexp.delim", switchTo: "@qregexp.<.>" }],
+        [/(qr|m|s)#/, { token: "regexp.delim", switchTo: "@qregexp.#.#" }],
+        [/(qr|m|s)\s*([^A-Za-z0-9_#\s])/, { token: "regexp.delim", switchTo: "@qregexp.$2.$2" }],
+        [/(qr|m|s)\s+(\w)/, { token: "regexp.delim", switchTo: "@qregexp.$2.$2" }],
+        [/(qq|qx)\s*\(/, { token: "string.delim", switchTo: "@qqstring.(.)" }],
+        [/(qq|qx)\s*\[/, { token: "string.delim", switchTo: "@qqstring.[.]" }],
+        [/(qq|qx)\s*\{/, { token: "string.delim", switchTo: "@qqstring.{.}" }],
+        [/(qq|qx)\s*</, { token: "string.delim", switchTo: "@qqstring.<.>" }],
+        [/(qq|qx)#/, { token: "string.delim", switchTo: "@qqstring.#.#" }],
+        [/(qq|qx)\s*([^A-Za-z0-9#\s])/, { token: "string.delim", switchTo: "@qqstring.$2.$2" }],
+        [/(qq|qx)\s+(\w)/, { token: "string.delim", switchTo: "@qqstring.$2.$2" }]
+      ],
+      // Non-expanded quoted string
+      // qstring<open>.<close>
+      //  open = open delimiter
+      //  close = close delimiter
+      qstring: [
+        [/\\./, "string.escape"],
+        [
+          /./,
+          {
+            cases: {
+              "$#==$S3": { token: "string.delim", next: "@pop" },
+              "$#==$S2": { token: "string.delim", next: "@push" },
+              // nested delimiters
+              "@default": "string"
+            }
+          }
+        ]
+      ],
+      // Quoted regexp
+      // qregexp.<open>.<close>
+      //  open = open delimiter
+      //  close = close delimiter
+      qregexp: [
+        { include: "@variables" },
+        [/\\./, "regexp.escape"],
+        [
+          /./,
+          {
+            cases: {
+              "$#==$S3": {
+                token: "regexp.delim",
+                next: "@regexpModifiers"
+              },
+              "$#==$S2": { token: "regexp.delim", next: "@push" },
+              // nested delimiters
+              "@default": "regexp"
+            }
+          }
+        ]
+      ],
+      regexpModifiers: [[/[msixpodualngcer]+/, { token: "regexp.modifier", next: "@popall" }]],
+      // Expanded quoted string
+      // qqstring.<open>.<close>
+      //  open = open delimiter
+      //  close = close delimiter
+      qqstring: [{ include: "@variables" }, { include: "@qstring" }],
+      heredoc: [
+        [/<<\s*['"`]?([\w\-]+)['"`]?/, { token: "string.heredoc.delimiter", next: "@heredocBody.$1" }]
+      ],
+      heredocBody: [
+        [
+          /^([\w\-]+)$/,
+          {
+            cases: {
+              "$1==$S2": [
+                {
+                  token: "string.heredoc.delimiter",
+                  next: "@popall"
+                }
+              ],
+              "@default": "string.heredoc"
+            }
+          }
+        ],
+        [/./, "string.heredoc"]
+      ],
+      perldoc: [[/^=\w/, "comment.doc", "@perldocBody"]],
+      perldocBody: [
+        [/^=cut\b/, "type.identifier", "@popall"],
+        [/./, "comment.doc"]
+      ],
+      variables: [
+        [/\$\w+/, "variable"],
+        // scalar
+        [/@\w+/, "variable"],
+        // array
+        [/%\w+/, "variable"]
+        // key/value
+      ]
+    }
+  };
+  return __toCommonJS(perl_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/pgsql/pgsql.js

@@ -0,0 +1,885 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/pgsql/pgsql", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/pgsql/pgsql.ts
+  var pgsql_exports = {};
+  __export(pgsql_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    comments: {
+      lineComment: "--",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ],
+    surroundingPairs: [
+      { open: "{", close: "}" },
+      { open: "[", close: "]" },
+      { open: "(", close: ")" },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" }
+    ]
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: ".sql",
+    ignoreCase: true,
+    brackets: [
+      { open: "[", close: "]", token: "delimiter.square" },
+      { open: "(", close: ")", token: "delimiter.parenthesis" }
+    ],
+    keywords: [
+      // This list is generated using `keywords.js`
+      "ALL",
+      "ANALYSE",
+      "ANALYZE",
+      "AND",
+      "ANY",
+      "ARRAY",
+      "AS",
+      "ASC",
+      "ASYMMETRIC",
+      "AUTHORIZATION",
+      "BINARY",
+      "BOTH",
+      "CASE",
+      "CAST",
+      "CHECK",
+      "COLLATE",
+      "COLLATION",
+      "COLUMN",
+      "CONCURRENTLY",
+      "CONSTRAINT",
+      "CREATE",
+      "CROSS",
+      "CURRENT_CATALOG",
+      "CURRENT_DATE",
+      "CURRENT_ROLE",
+      "CURRENT_SCHEMA",
+      "CURRENT_TIME",
+      "CURRENT_TIMESTAMP",
+      "CURRENT_USER",
+      "DEFAULT",
+      "DEFERRABLE",
+      "DESC",
+      "DISTINCT",
+      "DO",
+      "ELSE",
+      "END",
+      "EXCEPT",
+      "FALSE",
+      "FETCH",
+      "FOR",
+      "FOREIGN",
+      "FREEZE",
+      "FROM",
+      "FULL",
+      "GRANT",
+      "GROUP",
+      "HAVING",
+      "ILIKE",
+      "IN",
+      "INITIALLY",
+      "INNER",
+      "INTERSECT",
+      "INTO",
+      "IS",
+      "ISNULL",
+      "JOIN",
+      "LATERAL",
+      "LEADING",
+      "LEFT",
+      "LIKE",
+      "LIMIT",
+      "LOCALTIME",
+      "LOCALTIMESTAMP",
+      "NATURAL",
+      "NOT",
+      "NOTNULL",
+      "NULL",
+      "OFFSET",
+      "ON",
+      "ONLY",
+      "OR",
+      "ORDER",
+      "OUTER",
+      "OVERLAPS",
+      "PLACING",
+      "PRIMARY",
+      "REFERENCES",
+      "RETURNING",
+      "RIGHT",
+      "SELECT",
+      "SESSION_USER",
+      "SIMILAR",
+      "SOME",
+      "SYMMETRIC",
+      "TABLE",
+      "TABLESAMPLE",
+      "THEN",
+      "TO",
+      "TRAILING",
+      "TRUE",
+      "UNION",
+      "UNIQUE",
+      "USER",
+      "USING",
+      "VARIADIC",
+      "VERBOSE",
+      "WHEN",
+      "WHERE",
+      "WINDOW",
+      "WITH"
+    ],
+    operators: [
+      "AND",
+      "BETWEEN",
+      "IN",
+      "LIKE",
+      "NOT",
+      "OR",
+      "IS",
+      "NULL",
+      "INTERSECT",
+      "UNION",
+      "INNER",
+      "JOIN",
+      "LEFT",
+      "OUTER",
+      "RIGHT"
+    ],
+    builtinFunctions: [
+      "abbrev",
+      "abs",
+      "acldefault",
+      "aclexplode",
+      "acos",
+      "acosd",
+      "acosh",
+      "age",
+      "any",
+      "area",
+      "array_agg",
+      "array_append",
+      "array_cat",
+      "array_dims",
+      "array_fill",
+      "array_length",
+      "array_lower",
+      "array_ndims",
+      "array_position",
+      "array_positions",
+      "array_prepend",
+      "array_remove",
+      "array_replace",
+      "array_to_json",
+      "array_to_string",
+      "array_to_tsvector",
+      "array_upper",
+      "ascii",
+      "asin",
+      "asind",
+      "asinh",
+      "atan",
+      "atan2",
+      "atan2d",
+      "atand",
+      "atanh",
+      "avg",
+      "bit",
+      "bit_and",
+      "bit_count",
+      "bit_length",
+      "bit_or",
+      "bit_xor",
+      "bool_and",
+      "bool_or",
+      "bound_box",
+      "box",
+      "brin_desummarize_range",
+      "brin_summarize_new_values",
+      "brin_summarize_range",
+      "broadcast",
+      "btrim",
+      "cardinality",
+      "cbrt",
+      "ceil",
+      "ceiling",
+      "center",
+      "char_length",
+      "character_length",
+      "chr",
+      "circle",
+      "clock_timestamp",
+      "coalesce",
+      "col_description",
+      "concat",
+      "concat_ws",
+      "convert",
+      "convert_from",
+      "convert_to",
+      "corr",
+      "cos",
+      "cosd",
+      "cosh",
+      "cot",
+      "cotd",
+      "count",
+      "covar_pop",
+      "covar_samp",
+      "cume_dist",
+      "current_catalog",
+      "current_database",
+      "current_date",
+      "current_query",
+      "current_role",
+      "current_schema",
+      "current_schemas",
+      "current_setting",
+      "current_time",
+      "current_timestamp",
+      "current_user",
+      "currval",
+      "cursor_to_xml",
+      "cursor_to_xmlschema",
+      "date_bin",
+      "date_part",
+      "date_trunc",
+      "database_to_xml",
+      "database_to_xml_and_xmlschema",
+      "database_to_xmlschema",
+      "decode",
+      "degrees",
+      "dense_rank",
+      "diagonal",
+      "diameter",
+      "div",
+      "encode",
+      "enum_first",
+      "enum_last",
+      "enum_range",
+      "every",
+      "exp",
+      "extract",
+      "factorial",
+      "family",
+      "first_value",
+      "floor",
+      "format",
+      "format_type",
+      "gcd",
+      "gen_random_uuid",
+      "generate_series",
+      "generate_subscripts",
+      "get_bit",
+      "get_byte",
+      "get_current_ts_config",
+      "gin_clean_pending_list",
+      "greatest",
+      "grouping",
+      "has_any_column_privilege",
+      "has_column_privilege",
+      "has_database_privilege",
+      "has_foreign_data_wrapper_privilege",
+      "has_function_privilege",
+      "has_language_privilege",
+      "has_schema_privilege",
+      "has_sequence_privilege",
+      "has_server_privilege",
+      "has_table_privilege",
+      "has_tablespace_privilege",
+      "has_type_privilege",
+      "height",
+      "host",
+      "hostmask",
+      "inet_client_addr",
+      "inet_client_port",
+      "inet_merge",
+      "inet_same_family",
+      "inet_server_addr",
+      "inet_server_port",
+      "initcap",
+      "isclosed",
+      "isempty",
+      "isfinite",
+      "isopen",
+      "json_agg",
+      "json_array_elements",
+      "json_array_elements_text",
+      "json_array_length",
+      "json_build_array",
+      "json_build_object",
+      "json_each",
+      "json_each_text",
+      "json_extract_path",
+      "json_extract_path_text",
+      "json_object",
+      "json_object_agg",
+      "json_object_keys",
+      "json_populate_record",
+      "json_populate_recordset",
+      "json_strip_nulls",
+      "json_to_record",
+      "json_to_recordset",
+      "json_to_tsvector",
+      "json_typeof",
+      "jsonb_agg",
+      "jsonb_array_elements",
+      "jsonb_array_elements_text",
+      "jsonb_array_length",
+      "jsonb_build_array",
+      "jsonb_build_object",
+      "jsonb_each",
+      "jsonb_each_text",
+      "jsonb_extract_path",
+      "jsonb_extract_path_text",
+      "jsonb_insert",
+      "jsonb_object",
+      "jsonb_object_agg",
+      "jsonb_object_keys",
+      "jsonb_path_exists",
+      "jsonb_path_match",
+      "jsonb_path_query",
+      "jsonb_path_query_array",
+      "jsonb_path_exists_tz",
+      "jsonb_path_query_first",
+      "jsonb_path_query_array_tz",
+      "jsonb_path_query_first_tz",
+      "jsonb_path_query_tz",
+      "jsonb_path_match_tz",
+      "jsonb_populate_record",
+      "jsonb_populate_recordset",
+      "jsonb_pretty",
+      "jsonb_set",
+      "jsonb_set_lax",
+      "jsonb_strip_nulls",
+      "jsonb_to_record",
+      "jsonb_to_recordset",
+      "jsonb_to_tsvector",
+      "jsonb_typeof",
+      "justify_days",
+      "justify_hours",
+      "justify_interval",
+      "lag",
+      "last_value",
+      "lastval",
+      "lcm",
+      "lead",
+      "least",
+      "left",
+      "length",
+      "line",
+      "ln",
+      "localtime",
+      "localtimestamp",
+      "log",
+      "log10",
+      "lower",
+      "lower_inc",
+      "lower_inf",
+      "lpad",
+      "lseg",
+      "ltrim",
+      "macaddr8_set7bit",
+      "make_date",
+      "make_interval",
+      "make_time",
+      "make_timestamp",
+      "make_timestamptz",
+      "makeaclitem",
+      "masklen",
+      "max",
+      "md5",
+      "min",
+      "min_scale",
+      "mod",
+      "mode",
+      "multirange",
+      "netmask",
+      "network",
+      "nextval",
+      "normalize",
+      "now",
+      "npoints",
+      "nth_value",
+      "ntile",
+      "nullif",
+      "num_nonnulls",
+      "num_nulls",
+      "numnode",
+      "obj_description",
+      "octet_length",
+      "overlay",
+      "parse_ident",
+      "path",
+      "pclose",
+      "percent_rank",
+      "percentile_cont",
+      "percentile_disc",
+      "pg_advisory_lock",
+      "pg_advisory_lock_shared",
+      "pg_advisory_unlock",
+      "pg_advisory_unlock_all",
+      "pg_advisory_unlock_shared",
+      "pg_advisory_xact_lock",
+      "pg_advisory_xact_lock_shared",
+      "pg_backend_pid",
+      "pg_backup_start_time",
+      "pg_blocking_pids",
+      "pg_cancel_backend",
+      "pg_client_encoding",
+      "pg_collation_actual_version",
+      "pg_collation_is_visible",
+      "pg_column_compression",
+      "pg_column_size",
+      "pg_conf_load_time",
+      "pg_control_checkpoint",
+      "pg_control_init",
+      "pg_control_recovery",
+      "pg_control_system",
+      "pg_conversion_is_visible",
+      "pg_copy_logical_replication_slot",
+      "pg_copy_physical_replication_slot",
+      "pg_create_logical_replication_slot",
+      "pg_create_physical_replication_slot",
+      "pg_create_restore_point",
+      "pg_current_logfile",
+      "pg_current_snapshot",
+      "pg_current_wal_flush_lsn",
+      "pg_current_wal_insert_lsn",
+      "pg_current_wal_lsn",
+      "pg_current_xact_id",
+      "pg_current_xact_id_if_assigned",
+      "pg_current_xlog_flush_location",
+      "pg_current_xlog_insert_location",
+      "pg_current_xlog_location",
+      "pg_database_size",
+      "pg_describe_object",
+      "pg_drop_replication_slot",
+      "pg_event_trigger_ddl_commands",
+      "pg_event_trigger_dropped_objects",
+      "pg_event_trigger_table_rewrite_oid",
+      "pg_event_trigger_table_rewrite_reason",
+      "pg_export_snapshot",
+      "pg_filenode_relation",
+      "pg_function_is_visible",
+      "pg_get_catalog_foreign_keys",
+      "pg_get_constraintdef",
+      "pg_get_expr",
+      "pg_get_function_arguments",
+      "pg_get_function_identity_arguments",
+      "pg_get_function_result",
+      "pg_get_functiondef",
+      "pg_get_indexdef",
+      "pg_get_keywords",
+      "pg_get_object_address",
+      "pg_get_owned_sequence",
+      "pg_get_ruledef",
+      "pg_get_serial_sequence",
+      "pg_get_statisticsobjdef",
+      "pg_get_triggerdef",
+      "pg_get_userbyid",
+      "pg_get_viewdef",
+      "pg_get_wal_replay_pause_state",
+      "pg_has_role",
+      "pg_identify_object",
+      "pg_identify_object_as_address",
+      "pg_import_system_collations",
+      "pg_index_column_has_property",
+      "pg_index_has_property",
+      "pg_indexam_has_property",
+      "pg_indexes_size",
+      "pg_is_in_backup",
+      "pg_is_in_recovery",
+      "pg_is_other_temp_schema",
+      "pg_is_wal_replay_paused",
+      "pg_is_xlog_replay_paused",
+      "pg_jit_available",
+      "pg_last_committed_xact",
+      "pg_last_wal_receive_lsn",
+      "pg_last_wal_replay_lsn",
+      "pg_last_xact_replay_timestamp",
+      "pg_last_xlog_receive_location",
+      "pg_last_xlog_replay_location",
+      "pg_listening_channels",
+      "pg_log_backend_memory_contexts",
+      "pg_logical_emit_message",
+      "pg_logical_slot_get_binary_changes",
+      "pg_logical_slot_get_changes",
+      "pg_logical_slot_peek_binary_changes",
+      "pg_logical_slot_peek_changes",
+      "pg_ls_archive_statusdir",
+      "pg_ls_dir",
+      "pg_ls_logdir",
+      "pg_ls_tmpdir",
+      "pg_ls_waldir",
+      "pg_mcv_list_items",
+      "pg_my_temp_schema",
+      "pg_notification_queue_usage",
+      "pg_opclass_is_visible",
+      "pg_operator_is_visible",
+      "pg_opfamily_is_visible",
+      "pg_options_to_table",
+      "pg_partition_ancestors",
+      "pg_partition_root",
+      "pg_partition_tree",
+      "pg_postmaster_start_time",
+      "pg_promote",
+      "pg_read_binary_file",
+      "pg_read_file",
+      "pg_relation_filenode",
+      "pg_relation_filepath",
+      "pg_relation_size",
+      "pg_reload_conf",
+      "pg_replication_origin_advance",
+      "pg_replication_origin_create",
+      "pg_replication_origin_drop",
+      "pg_replication_origin_oid",
+      "pg_replication_origin_progress",
+      "pg_replication_origin_session_is_setup",
+      "pg_replication_origin_session_progress",
+      "pg_replication_origin_session_reset",
+      "pg_replication_origin_session_setup",
+      "pg_replication_origin_xact_reset",
+      "pg_replication_origin_xact_setup",
+      "pg_replication_slot_advance",
+      "pg_rotate_logfile",
+      "pg_safe_snapshot_blocking_pids",
+      "pg_size_bytes",
+      "pg_size_pretty",
+      "pg_sleep",
+      "pg_sleep_for",
+      "pg_sleep_until",
+      "pg_snapshot_xip",
+      "pg_snapshot_xmax",
+      "pg_snapshot_xmin",
+      "pg_start_backup",
+      "pg_stat_file",
+      "pg_statistics_obj_is_visible",
+      "pg_stop_backup",
+      "pg_switch_wal",
+      "pg_switch_xlog",
+      "pg_table_is_visible",
+      "pg_table_size",
+      "pg_tablespace_databases",
+      "pg_tablespace_location",
+      "pg_tablespace_size",
+      "pg_terminate_backend",
+      "pg_total_relation_size",
+      "pg_trigger_depth",
+      "pg_try_advisory_lock",
+      "pg_try_advisory_lock_shared",
+      "pg_try_advisory_xact_lock",
+      "pg_try_advisory_xact_lock_shared",
+      "pg_ts_config_is_visible",
+      "pg_ts_dict_is_visible",
+      "pg_ts_parser_is_visible",
+      "pg_ts_template_is_visible",
+      "pg_type_is_visible",
+      "pg_typeof",
+      "pg_visible_in_snapshot",
+      "pg_wal_lsn_diff",
+      "pg_wal_replay_pause",
+      "pg_wal_replay_resume",
+      "pg_walfile_name",
+      "pg_walfile_name_offset",
+      "pg_xact_commit_timestamp",
+      "pg_xact_commit_timestamp_origin",
+      "pg_xact_status",
+      "pg_xlog_location_diff",
+      "pg_xlog_replay_pause",
+      "pg_xlog_replay_resume",
+      "pg_xlogfile_name",
+      "pg_xlogfile_name_offset",
+      "phraseto_tsquery",
+      "pi",
+      "plainto_tsquery",
+      "point",
+      "polygon",
+      "popen",
+      "position",
+      "power",
+      "pqserverversion",
+      "query_to_xml",
+      "query_to_xml_and_xmlschema",
+      "query_to_xmlschema",
+      "querytree",
+      "quote_ident",
+      "quote_literal",
+      "quote_nullable",
+      "radians",
+      "radius",
+      "random",
+      "range_agg",
+      "range_intersect_agg",
+      "range_merge",
+      "rank",
+      "regexp_count",
+      "regexp_instr",
+      "regexp_like",
+      "regexp_match",
+      "regexp_matches",
+      "regexp_replace",
+      "regexp_split_to_array",
+      "regexp_split_to_table",
+      "regexp_substr",
+      "regr_avgx",
+      "regr_avgy",
+      "regr_count",
+      "regr_intercept",
+      "regr_r2",
+      "regr_slope",
+      "regr_sxx",
+      "regr_sxy",
+      "regr_syy",
+      "repeat",
+      "replace",
+      "reverse",
+      "right",
+      "round",
+      "row_number",
+      "row_security_active",
+      "row_to_json",
+      "rpad",
+      "rtrim",
+      "scale",
+      "schema_to_xml",
+      "schema_to_xml_and_xmlschema",
+      "schema_to_xmlschema",
+      "session_user",
+      "set_bit",
+      "set_byte",
+      "set_config",
+      "set_masklen",
+      "setseed",
+      "setval",
+      "setweight",
+      "sha224",
+      "sha256",
+      "sha384",
+      "sha512",
+      "shobj_description",
+      "sign",
+      "sin",
+      "sind",
+      "sinh",
+      "slope",
+      "split_part",
+      "sprintf",
+      "sqrt",
+      "starts_with",
+      "statement_timestamp",
+      "stddev",
+      "stddev_pop",
+      "stddev_samp",
+      "string_agg",
+      "string_to_array",
+      "string_to_table",
+      "strip",
+      "strpos",
+      "substr",
+      "substring",
+      "sum",
+      "suppress_redundant_updates_trigger",
+      "table_to_xml",
+      "table_to_xml_and_xmlschema",
+      "table_to_xmlschema",
+      "tan",
+      "tand",
+      "tanh",
+      "text",
+      "timeofday",
+      "timezone",
+      "to_ascii",
+      "to_char",
+      "to_date",
+      "to_hex",
+      "to_json",
+      "to_number",
+      "to_regclass",
+      "to_regcollation",
+      "to_regnamespace",
+      "to_regoper",
+      "to_regoperator",
+      "to_regproc",
+      "to_regprocedure",
+      "to_regrole",
+      "to_regtype",
+      "to_timestamp",
+      "to_tsquery",
+      "to_tsvector",
+      "transaction_timestamp",
+      "translate",
+      "trim",
+      "trim_array",
+      "trim_scale",
+      "trunc",
+      "ts_debug",
+      "ts_delete",
+      "ts_filter",
+      "ts_headline",
+      "ts_lexize",
+      "ts_parse",
+      "ts_rank",
+      "ts_rank_cd",
+      "ts_rewrite",
+      "ts_stat",
+      "ts_token_type",
+      "tsquery_phrase",
+      "tsvector_to_array",
+      "tsvector_update_trigger",
+      "tsvector_update_trigger_column",
+      "txid_current",
+      "txid_current_if_assigned",
+      "txid_current_snapshot",
+      "txid_snapshot_xip",
+      "txid_snapshot_xmax",
+      "txid_snapshot_xmin",
+      "txid_status",
+      "txid_visible_in_snapshot",
+      "unistr",
+      "unnest",
+      "upper",
+      "upper_inc",
+      "upper_inf",
+      "user",
+      "var_pop",
+      "var_samp",
+      "variance",
+      "version",
+      "websearch_to_tsquery",
+      "width",
+      "width_bucket",
+      "xml_is_well_formed",
+      "xml_is_well_formed_content",
+      "xml_is_well_formed_document",
+      "xmlagg",
+      "xmlcomment",
+      "xmlconcat",
+      "xmlelement",
+      "xmlexists",
+      "xmlforest",
+      "xmlparse",
+      "xmlpi",
+      "xmlroot",
+      "xmlserialize",
+      "xpath",
+      "xpath_exists"
+    ],
+    builtinVariables: [
+      // NOT SUPPORTED
+    ],
+    pseudoColumns: [
+      // NOT SUPPORTED
+    ],
+    tokenizer: {
+      root: [
+        { include: "@comments" },
+        { include: "@whitespace" },
+        { include: "@pseudoColumns" },
+        { include: "@numbers" },
+        { include: "@strings" },
+        { include: "@complexIdentifiers" },
+        { include: "@scopes" },
+        [/[;,.]/, "delimiter"],
+        [/[()]/, "@brackets"],
+        [
+          /[\w@#$]+/,
+          {
+            cases: {
+              "@operators": "operator",
+              "@builtinVariables": "predefined",
+              "@builtinFunctions": "predefined",
+              "@keywords": "keyword",
+              "@default": "identifier"
+            }
+          }
+        ],
+        [/[<>=!%&+\-*/|~^]/, "operator"]
+      ],
+      whitespace: [[/\s+/, "white"]],
+      comments: [
+        [/--+.*/, "comment"],
+        [/\/\*/, { token: "comment.quote", next: "@comment" }]
+      ],
+      comment: [
+        [/[^*/]+/, "comment"],
+        // Not supporting nested comments, as nested comments seem to not be standard?
+        // i.e. http://stackoverflow.com/questions/728172/are-there-multiline-comment-delimiters-in-sql-that-are-vendor-agnostic
+        // [/\/\*/, { token: 'comment.quote', next: '@push' }],    // nested comment not allowed :-(
+        [/\*\//, { token: "comment.quote", next: "@pop" }],
+        [/./, "comment"]
+      ],
+      pseudoColumns: [
+        [
+          /[$][A-Za-z_][\w@#$]*/,
+          {
+            cases: {
+              "@pseudoColumns": "predefined",
+              "@default": "identifier"
+            }
+          }
+        ]
+      ],
+      numbers: [
+        [/0[xX][0-9a-fA-F]*/, "number"],
+        [/[$][+-]*\d*(\.\d*)?/, "number"],
+        [/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, "number"]
+      ],
+      strings: [[/'/, { token: "string", next: "@string" }]],
+      string: [
+        [/[^']+/, "string"],
+        [/''/, "string"],
+        [/'/, { token: "string", next: "@pop" }]
+      ],
+      complexIdentifiers: [[/"/, { token: "identifier.quote", next: "@quotedIdentifier" }]],
+      quotedIdentifier: [
+        [/[^"]+/, "identifier"],
+        [/""/, "identifier"],
+        [/"/, { token: "identifier.quote", next: "@pop" }]
+      ],
+      scopes: [
+        // NOT SUPPORTED
+      ]
+    }
+  };
+  return __toCommonJS(pgsql_exports);
+})();
+return moduleExports;
+});

novas/novacore-zephyr/claude-code-router/ui/node_modules/monaco-editor/dev/vs/basic-languages/php/php.js

@@ -0,0 +1,534 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+define("vs/basic-languages/php/php", ["require"],(require)=>{
+"use strict";
+var moduleExports = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/basic-languages/php/php.ts
+  var php_exports = {};
+  __export(php_exports, {
+    conf: () => conf,
+    language: () => language
+  });
+  var conf = {
+    wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+    comments: {
+      lineComment: "//",
+      blockComment: ["/*", "*/"]
+    },
+    brackets: [
+      ["{", "}"],
+      ["[", "]"],
+      ["(", ")"]
+    ],
+    autoClosingPairs: [
+      { open: "{", close: "}", notIn: ["string"] },
+      { open: "[", close: "]", notIn: ["string"] },
+      { open: "(", close: ")", notIn: ["string"] },
+      { open: '"', close: '"', notIn: ["string"] },
+      { open: "'", close: "'", notIn: ["string", "comment"] }
+    ],
+    folding: {
+      markers: {
+        start: new RegExp("^\\s*(#|//)region\\b"),
+        end: new RegExp("^\\s*(#|//)endregion\\b")
+      }
+    }
+  };
+  var language = {
+    defaultToken: "",
+    tokenPostfix: "",
+    // ignoreCase: true,
+    // The main tokenizer for our languages
+    tokenizer: {
+      root: [
+        [/<\?((php)|=)?/, { token: "@rematch", switchTo: "@phpInSimpleState.root" }],
+        [/<!DOCTYPE/, "metatag.html", "@doctype"],
+        [/<!--/, "comment.html", "@comment"],
+        [/(<)(\w+)(\/>)/, ["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" }]],
+        [/</, "delimiter.html"],
+        [/[^<]+/]
+        // text
+      ],
+      doctype: [
+        [/<\?((php)|=)?/, { token: "@rematch", switchTo: "@phpInSimpleState.comment" }],
+        [/[^>]+/, "metatag.content.html"],
+        [/>/, "metatag.html", "@pop"]
+      ],
+      comment: [
+        [/<\?((php)|=)?/, { token: "@rematch", switchTo: "@phpInSimpleState.comment" }],
+        [/-->/, "comment.html", "@pop"],
+        [/[^-]+/, "comment.content.html"],
+        [/./, "comment.content.html"]
+      ],
+      otherTag: [
+        [/<\?((php)|=)?/, { token: "@rematch", switchTo: "@phpInSimpleState.otherTag" }],
+        [/\/?>/, "delimiter.html", "@pop"],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [/[ \t\r\n]+/]
+        // whitespace
+      ],
+      // -- BEGIN <script> tags handling
+      // After <script
+      script: [
+        [/<\?((php)|=)?/, { token: "@rematch", switchTo: "@phpInSimpleState.script" }],
+        [/type/, "attribute.name", "@scriptAfterType"],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@scriptEmbedded.text/javascript",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        // whitespace
+        [
+          /(<\/)(script\s*)(>)/,
+          ["delimiter.html", "tag.html", { token: "delimiter.html", next: "@pop" }]
+        ]
+      ],
+      // After <script ... type
+      scriptAfterType: [
+        [
+          /<\?((php)|=)?/,
+          {
+            token: "@rematch",
+            switchTo: "@phpInSimpleState.scriptAfterType"
+          }
+        ],
+        [/=/, "delimiter", "@scriptAfterTypeEquals"],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@scriptEmbedded.text/javascript",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        // cover invalid e.g. <script type>
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      // After <script ... type =
+      scriptAfterTypeEquals: [
+        [
+          /<\?((php)|=)?/,
+          {
+            token: "@rematch",
+            switchTo: "@phpInSimpleState.scriptAfterTypeEquals"
+          }
+        ],
+        [
+          /"([^"]*)"/,
+          {
+            token: "attribute.value",
+            switchTo: "@scriptWithCustomType.$1"
+          }
+        ],
+        [
+          /'([^']*)'/,
+          {
+            token: "attribute.value",
+            switchTo: "@scriptWithCustomType.$1"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@scriptEmbedded.text/javascript",
+            nextEmbedded: "text/javascript"
+          }
+        ],
+        // cover invalid e.g. <script type=>
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      // After <script ... type = $S2
+      scriptWithCustomType: [
+        [
+          /<\?((php)|=)?/,
+          {
+            token: "@rematch",
+            switchTo: "@phpInSimpleState.scriptWithCustomType.$S2"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@scriptEmbedded.$S2",
+            nextEmbedded: "$S2"
+          }
+        ],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/script\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      scriptEmbedded: [
+        [
+          /<\?((php)|=)?/,
+          {
+            token: "@rematch",
+            switchTo: "@phpInEmbeddedState.scriptEmbedded.$S2",
+            nextEmbedded: "@pop"
+          }
+        ],
+        [/<\/script/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }]
+      ],
+      // -- END <script> tags handling
+      // -- BEGIN <style> tags handling
+      // After <style
+      style: [
+        [/<\?((php)|=)?/, { token: "@rematch", switchTo: "@phpInSimpleState.style" }],
+        [/type/, "attribute.name", "@styleAfterType"],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@styleEmbedded.text/css",
+            nextEmbedded: "text/css"
+          }
+        ],
+        [/[ \t\r\n]+/],
+        // whitespace
+        [
+          /(<\/)(style\s*)(>)/,
+          ["delimiter.html", "tag.html", { token: "delimiter.html", next: "@pop" }]
+        ]
+      ],
+      // After <style ... type
+      styleAfterType: [
+        [
+          /<\?((php)|=)?/,
+          {
+            token: "@rematch",
+            switchTo: "@phpInSimpleState.styleAfterType"
+          }
+        ],
+        [/=/, "delimiter", "@styleAfterTypeEquals"],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@styleEmbedded.text/css",
+            nextEmbedded: "text/css"
+          }
+        ],
+        // cover invalid e.g. <style type>
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      // After <style ... type =
+      styleAfterTypeEquals: [
+        [
+          /<\?((php)|=)?/,
+          {
+            token: "@rematch",
+            switchTo: "@phpInSimpleState.styleAfterTypeEquals"
+          }
+        ],
+        [
+          /"([^"]*)"/,
+          {
+            token: "attribute.value",
+            switchTo: "@styleWithCustomType.$1"
+          }
+        ],
+        [
+          /'([^']*)'/,
+          {
+            token: "attribute.value",
+            switchTo: "@styleWithCustomType.$1"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@styleEmbedded.text/css",
+            nextEmbedded: "text/css"
+          }
+        ],
+        // cover invalid e.g. <style type=>
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      // After <style ... type = $S2
+      styleWithCustomType: [
+        [
+          /<\?((php)|=)?/,
+          {
+            token: "@rematch",
+            switchTo: "@phpInSimpleState.styleWithCustomType.$S2"
+          }
+        ],
+        [
+          />/,
+          {
+            token: "delimiter.html",
+            next: "@styleEmbedded.$S2",
+            nextEmbedded: "$S2"
+          }
+        ],
+        [/"([^"]*)"/, "attribute.value"],
+        [/'([^']*)'/, "attribute.value"],
+        [/[\w\-]+/, "attribute.name"],
+        [/=/, "delimiter"],
+        [/[ \t\r\n]+/],
+        // whitespace
+        [/<\/style\s*>/, { token: "@rematch", next: "@pop" }]
+      ],
+      styleEmbedded: [
+        [
+          /<\?((php)|=)?/,
+          {
+            token: "@rematch",
+            switchTo: "@phpInEmbeddedState.styleEmbedded.$S2",
+            nextEmbedded: "@pop"
+          }
+        ],
+        [/<\/style/, { token: "@rematch", next: "@pop", nextEmbedded: "@pop" }]
+      ],
+      // -- END <style> tags handling
+      phpInSimpleState: [
+        [/<\?((php)|=)?/, "metatag.php"],
+        [/\?>/, { token: "metatag.php", switchTo: "@$S2.$S3" }],
+        { include: "phpRoot" }
+      ],
+      phpInEmbeddedState: [
+        [/<\?((php)|=)?/, "metatag.php"],
+        [
+          /\?>/,
+          {
+            token: "metatag.php",
+            switchTo: "@$S2.$S3",
+            nextEmbedded: "$S3"
+          }
+        ],
+        { include: "phpRoot" }
+      ],
+      phpRoot: [
+        [
+          /[a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@phpKeywords": { token: "keyword.php" },
+              "@phpCompileTimeConstants": { token: "constant.php" },
+              "@default": "identifier.php"
+            }
+          }
+        ],
+        [
+          /[$a-zA-Z_]\w*/,
+          {
+            cases: {
+              "@phpPreDefinedVariables": {
+                token: "variable.predefined.php"
+              },
+              "@default": "variable.php"
+            }
+          }
+        ],
+        // brackets
+        [/[{}]/, "delimiter.bracket.php"],
+        [/[\[\]]/, "delimiter.array.php"],
+        [/[()]/, "delimiter.parenthesis.php"],
+        // whitespace
+        [/[ \t\r\n]+/],
+        // comments
+        [/(#|\/\/)$/, "comment.php"],
+        [/(#|\/\/)/, "comment.php", "@phpLineComment"],
+        // block comments
+        [/\/\*/, "comment.php", "@phpComment"],
+        // strings
+        [/"/, "string.php", "@phpDoubleQuoteString"],
+        [/'/, "string.php", "@phpSingleQuoteString"],
+        // delimiters
+        [/[\+\-\*\%\&\|\^\~\!\=\<\>\/\?\;\:\.\,\@]/, "delimiter.php"],
+        // numbers
+        [/\d*\d+[eE]([\-+]?\d+)?/, "number.float.php"],
+        [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float.php"],
+        [/0[xX][0-9a-fA-F']*[0-9a-fA-F]/, "number.hex.php"],
+        [/0[0-7']*[0-7]/, "number.octal.php"],
+        [/0[bB][0-1']*[0-1]/, "number.binary.php"],
+        [/\d[\d']*/, "number.php"],
+        [/\d/, "number.php"]
+      ],
+      phpComment: [
+        [/\*\//, "comment.php", "@pop"],
+        [/[^*]+/, "comment.php"],
+        [/./, "comment.php"]
+      ],
+      phpLineComment: [
+        [/\?>/, { token: "@rematch", next: "@pop" }],
+        [/.$/, "comment.php", "@pop"],
+        [/[^?]+$/, "comment.php", "@pop"],
+        [/[^?]+/, "comment.php"],
+        [/./, "comment.php"]
+      ],
+      phpDoubleQuoteString: [
+        [/[^\\"]+/, "string.php"],
+        [/@escapes/, "string.escape.php"],
+        [/\\./, "string.escape.invalid.php"],
+        [/"/, "string.php", "@pop"]
+      ],
+      phpSingleQuoteString: [
+        [/[^\\']+/, "string.php"],
+        [/@escapes/, "string.escape.php"],
+        [/\\./, "string.escape.invalid.php"],
+        [/'/, "string.php", "@pop"]
+      ]
+    },
+    phpKeywords: [
+      "abstract",
+      "and",
+      "array",
+      "as",
+      "break",
+      "callable",
+      "case",
+      "catch",
+      "cfunction",
+      "class",
+      "clone",
+      "const",
+      "continue",
+      "declare",
+      "default",
+      "do",
+      "else",
+      "elseif",
+      "enddeclare",
+      "endfor",
+      "endforeach",
+      "endif",
+      "endswitch",
+      "endwhile",
+      "extends",
+      "false",
+      "final",
+      "for",
+      "foreach",
+      "function",
+      "global",
+      "goto",
+      "if",
+      "implements",
+      "interface",
+      "instanceof",
+      "insteadof",
+      "namespace",
+      "new",
+      "null",
+      "object",
+      "old_function",
+      "or",
+      "private",
+      "protected",
+      "public",
+      "resource",
+      "static",
+      "switch",
+      "throw",
+      "trait",
+      "try",
+      "true",
+      "use",
+      "var",
+      "while",
+      "xor",
+      "die",
+      "echo",
+      "empty",
+      "exit",
+      "eval",
+      "include",
+      "include_once",
+      "isset",
+      "list",
+      "require",
+      "require_once",
+      "return",
+      "print",
+      "unset",
+      "yield",
+      "__construct"
+    ],
+    phpCompileTimeConstants: [
+      "__CLASS__",
+      "__DIR__",
+      "__FILE__",
+      "__LINE__",
+      "__NAMESPACE__",
+      "__METHOD__",
+      "__FUNCTION__",
+      "__TRAIT__"
+    ],
+    phpPreDefinedVariables: [
+      "$GLOBALS",
+      "$_SERVER",
+      "$_GET",
+      "$_POST",
+      "$_FILES",
+      "$_REQUEST",
+      "$_SESSION",
+      "$_ENV",
+      "$_COOKIE",
+      "$php_errormsg",
+      "$HTTP_RAW_POST_DATA",
+      "$http_response_header",
+      "$argc",
+      "$argv"
+    ],
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/
+  };
+  return __toCommonJS(php_exports);
+})();
+return moduleExports;
+});