xmlui 0.9.2 → 0.9.4

package/dist/scripts/src/syntax/monaco/xmluiscript.monacoLanguage.js

@@ -0,0 +1,310 @@
+"use strict";
+/* Based on https://github.com/microsoft/monaco-editor/blob/main/src/basic-languages/javascript/javascript.ts */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XmluiScripGrammar = void 0;
+exports.XmluiScripGrammar = {
+    id: "xmluiscript",
+    config: {
+        wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+        comments: {
+            lineComment: "//",
+            blockComment: ["/*", "*/"],
+        },
+        brackets: [
+            ["{", "}"],
+            ["[", "]"],
+            ["(", ")"],
+        ],
+        onEnterRules: [
+            {
+                // e.g. /** | */
+                beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
+                afterText: /^\s*\*\/$/,
+                action: {
+                    // numeric repr of indentAction: languages.IndentAction.IndentOutdent, but without the "monaco-core" package
+                    indentAction: 2,
+                    appendText: " * ",
+                },
+            },
+            {
+                // e.g. /** ...|
+                beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
+                action: {
+                    // numeric repr of indentAction: languages.IndentAction.None, but without the "monaco-core" package
+                    indentAction: 0,
+                    appendText: " * ",
+                },
+            },
+            {
+                // e.g.  * ...|
+                beforeText: /^(\t|(\ \ ))*\ \*(\ ([^\*]|\*(?!\/))*)?$/,
+                action: {
+                    // numeric repr of indentAction: languages.IndentAction.None, but without the "monaco-core" package
+                    indentAction: 0,
+                    appendText: "* ",
+                },
+            },
+            {
+                // e.g.  */|
+                beforeText: /^(\t|(\ \ ))*\ \*\/\s*$/,
+                action: {
+                    // numeric repr of indentAction: languages.IndentAction.None, but without the "monaco-core" package
+                    indentAction: 0,
+                    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"),
+            },
+        },
+    },
+    language: {
+        // Set defaultToken to invalid to see what you do not tokenize yet
+        defaultToken: "invalid",
+        tokenPostfix: ".xs",
+        typeKeywords: [],
+        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",
+        ],
+        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" },
+            ],
+        },
+    },
+};