xmlui 0.7.13 → 0.7.15

package/dist/scripts/src/parsers/xmlui-parser/transform.js

@@ -13,6 +13,8 @@ exports.onPrefixRegex = /^on[A-Z]/;
 const propAttrs = ["name", "value"];
 const CDATA_PREFIX_LEN = 9;
 const CDATA_POSTFIX_LEN = 3;
+const NAMESPACE_SCHEME_COMPONENT = "component-ns";
+const THIS_APP_NS = "app-ns";
 function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () => "") {
     const getText = (node) => {
         var _a;
@@ -30,15 +32,16 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
         return null;
     }
     const preppedElement = prepNode(element);
-    const name = getTagName(element);
+    const name = getComponentName(element);
     if (!exports.UCRegex.test(name)) {
         reportError("T002");
         return null;
     }
     const usesStack = [];
+    const namespaceStack = [];
     return transformSingleElement(usesStack, preppedElement);
     function transformSingleElement(usesStack, node) {
-        const name = getTagName(node);
+        const name = getNamespaceResolvedComponentName(node);
         const attrs = getAttributes(node).map(segmentAttr);
         let component;
         if (name === exports.COMPOUND_COMP_ID) {
@@ -54,7 +57,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
             }
             // --- Get "method" attributes
             let api;
-            const apiAttrs = attrs.filter((attr) => refersToApi(attr.startSegment));
+            const apiAttrs = attrs.filter((attr) => attr.startSegment === "method");
             if (apiAttrs.length > 0) {
                 api = {};
                 apiAttrs.forEach((attr) => {
@@ -72,13 +75,13 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
             }
             const children = getChildNodes(node);
             // --- Check for nested component
-            const nestedCompound = children.find((child) => child.kind === syntax_kind_1.SyntaxKind.ElementNode && getTagName(child) === exports.COMPOUND_COMP_ID);
+            const nestedCompound = children.find((child) => child.kind === syntax_kind_1.SyntaxKind.ElementNode && getComponentName(child) === exports.COMPOUND_COMP_ID);
             if (nestedCompound) {
                 reportError("T006");
                 return null;
             }
             // --- Get the single component definition
-            const nestedComponents = children.filter((child) => child.kind === syntax_kind_1.SyntaxKind.ElementNode && exports.UCRegex.test(getTagName(child)));
+            const nestedComponents = children.filter((child) => child.kind === syntax_kind_1.SyntaxKind.ElementNode && exports.UCRegex.test(getComponentName(child)));
             if (nestedComponents.length === 0) {
                 nestedComponents.push(createTextNodeElement(""));
             }
@@ -86,7 +89,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
             const nestedVars = [];
             for (let child of children) {
                 if (child.kind === syntax_kind_1.SyntaxKind.ElementNode) {
-                    const childName = getTagName(child);
+                    const childName = getComponentName(child);
                     if (childName === "var") {
                         nestedVars.push(child);
                     }
@@ -160,6 +163,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
         var _a, _b;
         const isCompound = !isComponent(comp);
         const attributes = getAttributes(element);
+        namespaceStack.push(new Map());
         // --- Process attributes
         attributes.forEach((attr) => {
             // --- Process the attribute
@@ -187,7 +191,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
                 comp.children = mergeValue(comp.children, getText(child));
                 return;
             }
-            const childName = getTagName(child);
+            const childName = getComponentName(child);
             if (isCompound && child.kind === syntax_kind_1.SyntaxKind.ElementNode && exports.UCRegex.test(childName)) {
                 // --- This is the single nested component definition of a compound component,
                 // --- it is already processed
@@ -264,6 +268,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
                     return;
             }
         });
+        namespaceStack.pop();
         if (!comp.script || comp.script.trim().length === 0) {
             // --- No (or whitespace only) script
             return;
@@ -291,11 +296,15 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
     }
     function collectAttribute(comp, attr) {
         var _a, _b, _c, _d, _e;
-        const { startSegment, name, value } = segmentAttr(attr);
+        const { namespace, startSegment, name, value } = segmentAttr(attr);
+        if (namespace === "xmlns") {
+            const nsKey = startSegment === undefined ? name : startSegment + name;
+            return addToNamespaces(namespaceStack, comp, nsKey, value);
+        }
         const isCompound = !isComponent(comp);
         // --- Handle single-word attributes
         if (isCompound) {
-            if (startSegment && !refersToApi(startSegment) && startSegment !== "var") {
+            if (startSegment && startSegment !== "method" && startSegment !== "var") {
                 reportError("T021");
                 return;
             }
@@ -309,11 +318,6 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
             }
             return;
         }
-        // --- Do not allow segmented attribute names
-        if (name.indexOf(".") >= 0) {
-            reportError("T007", name);
-            return;
-        }
         // --- Recognize special attributes by component definition type
         switch (name) {
             case "id":
@@ -330,7 +334,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
                     (_a = comp.vars) !== null && _a !== void 0 ? _a : (comp.vars = {});
                     comp.vars[name] = value;
                 }
-                else if (refersToApi(startSegment)) {
+                else if (startSegment === "method") {
                     (_b = comp.api) !== null && _b !== void 0 ? _b : (comp.api = {});
                     comp.api[name] = value;
                 }
@@ -363,7 +367,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
             }
             if (child.kind !== syntax_kind_1.SyntaxKind.ElementNode)
                 return;
-            const childName = getTagName(child);
+            const childName = getComponentName(child);
             // --- The only element names we accept are "field" or "item"
             if (childName !== "field" && childName !== "item") {
                 reportError("T016");
@@ -407,11 +411,11 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
         return result;
     }
     function collectValue(usesStack, element, allowName = true) {
-        const elementName = getTagName(element);
+        const elementName = getComponentName(element);
         // --- Accept only "name", "value"
         const childNodes = getChildNodes(element);
-        const nestedComponents = childNodes.filter((c) => c.kind === syntax_kind_1.SyntaxKind.ElementNode && exports.UCRegex.test(getTagName(c)));
-        const nestedElements = childNodes.filter((c) => c.kind === syntax_kind_1.SyntaxKind.ElementNode && !exports.UCRegex.test(getTagName(c)));
+        const nestedComponents = childNodes.filter((c) => c.kind === syntax_kind_1.SyntaxKind.ElementNode && exports.UCRegex.test(getComponentName(c)));
+        const nestedElements = childNodes.filter((c) => c.kind === syntax_kind_1.SyntaxKind.ElementNode && !exports.UCRegex.test(getComponentName(c)));
         const attributes = getAttributes(element).map(segmentAttr);
         const attrProps = attributes.filter((attr) => propAttrs.indexOf(attr.name) >= 0);
         if (attributes.length > attrProps.length) {
@@ -552,10 +556,35 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
         // --- Extract the value
         (_a = comp.uses) !== null && _a !== void 0 ? _a : (comp.uses = valueAttr.value.split(",").map((v) => v.trim()));
     }
-    function getTagName(node) {
+    function getComponentName(node) {
         const nameTokens = node.children.find((c) => c.kind === syntax_kind_1.SyntaxKind.TagNameNode).children;
-        const name = nameTokens[nameTokens.length - 1];
-        return getText(name);
+        const name = getText(nameTokens.at(-1));
+        return name;
+    }
+    function getNamespaceResolvedComponentName(node) {
+        const nameTokens = node.children.find((c) => c.kind === syntax_kind_1.SyntaxKind.TagNameNode).children;
+        const name = getText(nameTokens.at(-1));
+        if (nameTokens.length === 1) {
+            return name;
+        }
+        const namespace = getText(nameTokens[0]);
+        if (namespaceStack.length === 0) {
+            reportError("T026");
+        }
+        let resolvedNamespace = undefined;
+        for (let i = namespaceStack.length - 1; i >= 0; --i) {
+            resolvedNamespace = namespaceStack[i].get(namespace);
+            if (resolvedNamespace !== undefined) {
+                break;
+            }
+        }
+        if (resolvedNamespace === undefined) {
+            reportError("T027", namespace);
+        }
+        if (resolvedNamespace === THIS_APP_NS) {
+            return name;
+        }
+        return resolvedNamespace + "." + name;
     }
     function segmentAttr(attr) {
         let key = attr.children[0];
@@ -579,7 +608,7 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
         }
         const valueText = getText(attr.children[2]);
         const value = valueText.substring(1, valueText.length - 1);
-        return { startSegment, name, value };
+        return { namespace, startSegment, name, value };
     }
     function parseEscapeCharactersInAttrValues(attrs) {
         for (let attr of attrs) {
@@ -592,10 +621,10 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
     }
     function prepNode(node) {
         const childNodes = getChildNodes(node);
-        const tagName = getTagName(node);
+        const tagName = getComponentName(node);
         const hasComponentName = exports.UCRegex.test(tagName);
         const shouldUseTextNodeElement = hasComponentName || tagName === "property";
-        const shouldCollapseWhitespace = tagName !== "event" && !refersToApi(tagName);
+        const shouldCollapseWhitespace = tagName !== "event" && tagName !== "method";
         const attrs = getAttributes(node);
         desugarKeyOnlyAttrs(attrs);
         desugarQuotelessAttrs(attrs, getText);
@@ -641,10 +670,10 @@ function nodeToComponentDef(node, originalGetText, fileId, moduleResolver = () =
             }
             childNodes[i] = newChild;
         }
-        const helperNodes = childNodes.filter((c) => c.kind === syntax_kind_1.SyntaxKind.ElementNode && !exports.UCRegex.test(getTagName(c)));
+        const helperNodes = childNodes.filter((c) => c.kind === syntax_kind_1.SyntaxKind.ElementNode && !exports.UCRegex.test(getComponentName(c)));
         const otherNodes = childNodes.filter((c) => c.kind !== syntax_kind_1.SyntaxKind.ElementNode ||
-            (c.kind === syntax_kind_1.SyntaxKind.ElementNode && exports.UCRegex.test(getTagName(c))));
-        const hasComponentChild = otherNodes.some((c) => c.kind === syntax_kind_1.SyntaxKind.ElementNode && exports.UCRegex.test(getTagName(c)));
+            (c.kind === syntax_kind_1.SyntaxKind.ElementNode && exports.UCRegex.test(getComponentName(c))));
+        const hasComponentChild = otherNodes.some((c) => c.kind === syntax_kind_1.SyntaxKind.ElementNode && exports.UCRegex.test(getComponentName(c)));
         if (hasScriptChild && hasComponentChild) {
             const fragment = wrapWithFragment(otherNodes);
             helperNodes.push(fragment);
@@ -985,8 +1014,27 @@ function desugarQuotelessAttrs(attrs, getText) {
         }
     }
 }
-/** Temporarily using 'method' as an alias to 'api'.
- * In the future, 'api' may be completely removed.*/
-function refersToApi(word) {
-    return word === "method";
+function addToNamespaces(namespaceStack, comp, nsKey, value) {
+    var _a;
+    let nsCommaSeparated = value.split(":");
+    if (nsCommaSeparated.length > 2) {
+        return reportError("T028", value);
+    }
+    let nsValue = value;
+    if (nsCommaSeparated.length === 2) {
+        if (nsCommaSeparated[0] != NAMESPACE_SCHEME_COMPONENT) {
+            return reportError("T029", value, NAMESPACE_SCHEME_COMPONENT);
+        }
+        nsValue = nsCommaSeparated[1];
+    }
+    if (!exports.UCRegex.test(nsKey)) {
+        return reportError("T031", nsKey);
+    }
+    const compNamespaces = namespaceStack[namespaceStack.length - 1];
+    if (compNamespaces.has(nsKey)) {
+        return reportError("T025", nsKey);
+    }
+    compNamespaces.set(nsKey, nsValue);
+    (_a = comp.namespaces) !== null && _a !== void 0 ? _a : (comp.namespaces = {});
+    comp.namespaces[nsKey] = nsValue;
 }

package/dist/scripts/src/syntax/grammar.tmLanguage.json

@@ -0,0 +1,328 @@
+{
+    "name": "xmlui",
+    "scopeName": "source.xmlui",
+    "patterns": [{ "include": "#root" }],
+    "repository": {
+        "root": {
+            "patterns": [
+                { "include": "#comments" },
+                { "include": "#helperTag" },
+                { "include": "#componentTag" },
+                { "include": "#escapeCharacter" },
+                { "include": "#textWithBindingExpr" },
+                { "include": "#entity" },
+                {
+                    "begin": "(<!\\[)(CDATA)(\\[)",
+                    "beginCaptures": {
+                        "1": { "name": "punctuation.definition.tag.xmlui" },
+                        "2": { "name": "storage.xmlui" },
+                        "3": { "name": "punctuation.definition.tag.xmlui" }
+                    },
+                    "end": "]]>",
+                    "endCaptures": {
+                        "0": { "name": "punctuation.definition.tag.xmlui" }
+                    },
+                    "contentName": "string.unquoted.cdata.xmlui"
+                }
+            ]
+        },
+        "apiTag": {
+            "begin": "(<)((?:[a-zA-Z_][\\w\\.\\-]*?:)?)(method|api)",
+            "beginCaptures": {
+                "1": { "name": "punctuation.definition.tag.xmlui" },
+                "2": { "name": "keyword.operator.namespace.xmlui" },
+                "3": { "name": "entity.name.tag.localname.xmlui" }
+            },
+            "endCaptures": {
+                "0": { "name": "punctuation.definition.tag.xmlui" }
+            },
+            "applyEndPatternLast": "1",
+            "patterns": [
+                { "include": "#comments" },
+                { "include": "#valueAttributeScriptInside" },
+                { "include": "#attribute" },
+                {
+                    "begin": "(?<!/|(?:/\\s*(?:api|method))\\s*)>",
+                    "beginCaptures": {
+                        "0": {
+                            "name": "punctuation.definition.tag.xmlui"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": { "name": "punctuation.definition.tag.xmlui" },
+                        "2": { "name": "keyword.operator.namespace.xmlui" },
+                        "3": { "name": "entity.name.tag.localname.xmlui" }
+                    },
+                    "contentName": "meta.embedded.block.javascript",
+                    "patterns": [{ "include": "source.js" }],
+                    "end": "(</)((?:[a-zA-Z_][\\w\\.\\-]*?:)?)(method|api)(?=\\s*>)"
+                }
+            ],
+            "end": "/?>"
+        },
+        "eventTag": {
+            "begin": "(<)((?:[a-zA-Z_][\\w\\.\\-]*?:)?)(event)",
+            "beginCaptures": {
+                "1": { "name": "punctuation.definition.tag.xmlui" },
+                "2": { "name": "keyword.operator.namespace.xmlui" },
+                "3": { "name": "entity.name.tag.localname.xmlui" }
+            },
+            "endCaptures": {
+                "0": { "name": "punctuation.definition.tag.xmlui" }
+            },
+            "applyEndPatternLast": "1",
+            "patterns": [
+                { "include": "#comments" },
+                { "include": "#valueAttributeScriptInside" },
+                { "include": "#attribute" },
+                {
+                    "begin": "(?<!/|(?:/\\s*event)\\s*)(>)",
+                    "beginCaptures": {
+                        "0": {
+                            "name": "punctuation.definition.tag.xmlui"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": { "name": "punctuation.definition.tag.xmlui" },
+                        "2": { "name": "keyword.operator.namespace.xmlui" },
+                        "3": { "name": "entity.name.tag.localname.xmlui" }
+                    },
+                    "patterns": [{ "include": "#comments" }, { "include": "#componentTag" }, { "include": "source.js" }],
+                    "end": "(</)((?:[a-zA-Z_][\\w\\.\\-]*?:)?)(event)(?=\\s*>)"
+                }
+            ],
+            "end": ">"
+        },
+        "fieldTag": {
+            "begin": "(<)((?:[a-zA-Z_][\\w\\.\\-]*?:)?)(field)",
+            "beginCaptures": {
+                "1": { "name": "punctuation.definition.tag.xmlui" },
+                "2": { "name": "keyword.operator.namespace.xmlui" },
+                "3": { "name": "entity.name.tag.localname.xmlui" }
+            },
+            "endCaptures": {
+                "0": { "name": "punctuation.definition.tag.xmlui" }
+            },
+            "applyEndPatternLast": "1",
+            "patterns": [
+                { "include": "#comments" },
+                { "include": "#valueAttributeScriptInside" },
+                { "include": "#attribute" },
+                {
+                    "begin": "(?<!/|(?:/\\s*field)\\s*)(>)",
+                    "beginCaptures": {
+                        "0": {
+                            "name": "punctuation.definition.tag.xmlui"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": { "name": "punctuation.definition.tag.xmlui" },
+                        "2": { "name": "keyword.operator.namespace.xmlui" },
+                        "3": { "name": "entity.name.tag.localname.xmlui" }
+                    },
+                    "patterns": [{ "include": "#comments" }, { "include": "#componentTag" }, { "include": "source.js" }],
+                    "end": "(</)((?:[a-zA-Z_][\\w\\.\\-]*?:)?)(field)(?=\\s*>)"
+                }
+            ],
+            "end": ">"
+        },
+        "itemTag": {
+            "begin": "(<)((?:[a-zA-Z_][\\w\\.\\-]*?:)?)(item)",
+            "beginCaptures": {
+                "1": { "name": "punctuation.definition.tag.xmlui" },
+                "2": { "name": "keyword.operator.namespace.xmlui" },
+                "3": { "name": "entity.name.tag.localname.xmlui" }
+            },
+            "endCaptures": {
+                "0": { "name": "punctuation.definition.tag.xmlui" }
+            },
+            "applyEndPatternLast": "1",
+            "patterns": [
+                { "include": "#comments" },
+                { "include": "#valueAttributeScriptInside" },
+                { "include": "#attribute" },
+                {
+                    "begin": "(?<!/|(?:/\\s*item)\\s*)(>)",
+                    "beginCaptures": {
+                        "0": {
+                            "name": "punctuation.definition.tag.xmlui"
+                        }
+                    },
+                    "endCaptures": {
+                        "1": { "name": "punctuation.definition.tag.xmlui" },
+                        "2": { "name": "keyword.operator.namespace.xmlui" },
+                        "3": { "name": "entity.name.tag.localname.xmlui" }
+                    },
+                    "patterns": [{ "include": "#comments" }, { "include": "#componentTag" }, { "include": "source.js" }],
+                    "end": "(</)((?:[a-zA-Z_][\\w\\.\\-]*?:)?)(item)(?=\\s*>)"
+                }
+            ],
+            "end": ">"
+        },
+        "bindingExpr": {
+            "contentName": "meta.embedded.block.javascript",
+            "begin": "\\{",
+            "end": "\\}",
+            "beginCaptures": {
+                "0": { "name": "punctuation.definition.block.xmlui" }
+            },
+            "endCaptures": {
+                "0": { "name": "punctuation.definition.block.xmlui" }
+            },
+            "patterns": [{ "include": "source.js" }]
+        },
+        "helperTag": {
+            "patterns": [
+                { "include": "#scriptTag" },
+                { "include": "#eventTag" },
+                { "include": "#fieldTag" },
+                { "include": "#itemTag" },
+                { "include": "#apiTag" },
+                { "include": "#propOrVarTag" }
+            ]
+        },
+        "valueAttributeScriptInside": {
+            "patterns": [
+                {
+                    "captures": {
+                        "1": { "name": "entity.other.attribute-name.localname.xmlui" },
+                        "2": { "name": "keyword.operator.xmlui" }
+                    },
+                    "match": "(?:^|\\s+)(value)(\\s*=)"
+                },
+                { "include": "#quotedStringJsInside" }
+            ]
+        },
+        "scriptTag": {
+            "begin": "(<)((?:[a-zA-Z_][\\w\\.\\-]*?:)?)(script)(\\s*>)",
+            "end": "(</)(\\2)(\\3)(\\s*>)",
+            "contentName": "meta.embedded.block.javascript",
+            "beginCaptures": {
+                "1": { "name": "punctuation.definition.tag.xmlui" },
+                "2": { "name": "keyword.operator.namespace.xmlui" },
+                "3": { "name": "entity.name.function.xmlui" },
+                "4": { "name": "punctuation.definition.tag.xmlui" }
+            },
+            "endCaptures": {
+                "1": { "name": "punctuation.definition.tag.xmlui" },
+                "2": { "name": "keyword.operator.namespace.xmlui" },
+                "3": { "name": "entity.name.function.xmlui" },
+                "4": { "name": "punctuation.definition.tag.xmlui" }
+            },
+            "patterns": [{ "include": "source.js" }]
+        },
+        "textWithBindingExpr": {
+            "patterns": [{ "include": "#escapeCharacter" }, { "include": "#entity" }, { "include": "#bindingExpr" }]
+        },
+        "propOrVarTag": {
+            "begin": "(</?)([a-zA-Z_][\\w\\.\\-]*?:)?((?:var)|(?:property)|(?:prop))",
+            "beginCaptures": {
+                "1": { "name": "punctuation.definition.tag.xmlui" },
+                "2": { "name": "keyword.operator.namespace.xmlui" },
+                "3": { "name": "entity.name.tag.localname.xmlui" }
+            },
+            "end": "(/?>)",
+            "endCaptures": {
+                "1": { "name": "punctuation.definition.tag.xmlui" }
+            },
+            "patterns": [{ "include": "#attribute" }, { "include": "#comments" }]
+        },
+        "componentTag": {
+            "begin": "(\\s*</?)((?:[a-zA-Z_][\\w\\.\\-]*?:)?)([A-Z][\\w\\.\\-]*)",
+            "beginCaptures": {
+                "1": { "name": "punctuation.definition.tag.xmlui" },
+                "2": { "name": "keyword.operator.namespace.xmlui" },
+                "3": { "name": "support.class.tag.component.xmlui" }
+            },
+            "end": "(/?>)",
+            "endCaptures": {
+                "1": { "name": "punctuation.definition.tag.xmlui" }
+            },
+            "patterns": [{ "include": "#comments" }, { "include": "#eventHandler" }, { "include": "#attribute" }]
+        },
+        "quotedStringJsInside": {
+            "begin": "\"|'|`",
+            "beginCaptures": {
+                "0": { "name": "string.xmlui" }
+            },
+            "end": "\\0",
+            "endCaptures": {
+                "0": { "name": "string.xmlui" }
+            },
+            "contentName": "meta.embedded.block.javascript",
+            "patterns": [{ "include": "source.js" }]
+        },
+        "entity": {
+            "captures": {
+                "1": { "name": "punctuation.definition.constant.xmlui" },
+                "2": { "name": "punctuation.definition.constant.xmlui" },
+                "3": { "name": "punctuation.definition.constant.xmlui" }
+            },
+            "match": "(&)((?:amp)|(?:lt)|(?:gt)|(?:quot)|(?:apos))(;)"
+        },
+        "eventHandler": {
+            "patterns": [
+                {
+                    "captures": {
+                        "1": { "name": "entity.other.attribute-name.localname.xmlui" },
+                        "2": { "name": "keyword.operator.xmlui" }
+                    },
+                    "match": "(?:^|\\s+)(on[A-Z][-\\w.:$]*)(\\s*=)"
+                },
+                { "include": "#quotedStringJsInside" }
+            ]
+        },
+        "attribute": {
+            "patterns": [
+                {
+                    "begin": "(?:^|\\s+)([a-zA-Z$_][-\\w.$]*(?::[a-zA-Z$_][-\\w.$]*)?)(\\s*=)(\\s*['\"`])",
+                    "end": "\\3",
+                    "beginCaptures": {
+                        "1": { "name": "entity.other.attribute-name.localname.xmlui" },
+                        "2": { "name": "keyword.operator.xmlui" },
+                        "3": { "name": "string.xmlui" }
+                    },
+                    "endCaptures": {
+                        "0": { "name": "string.xmlui" }
+                    },
+                    "contentName": "string.xmlui",
+                    "patterns": [{ "include": "#textWithBindingExpr" }]
+                },
+                {
+                    "match": "(?:^|\\s+)([a-zA-Z$_][-\\w.$]*(?::[a-zA-Z$_][-\\w.$]*)?)(\\s*=\\s*)([a-zA-Z$_][-\\w.$]*)",
+                    "captures": {
+                        "1": { "name": "entity.other.attribute-name.localname.xmlui" },
+                        "2": { "name": "keyword.operator.xmlui" },
+                        "3": { "name": "string.xmlui" }
+                    }
+                },
+                {
+                    "match": "([a-zA-Z$_][-\\w.$]*(?::[a-zA-Z$_][-\\w.$]*)?)",
+                    "name": "entity.other.attribute-name.localname.xmlui"
+                }
+            ]
+        },
+        "escapeCharacter": {
+            "patterns": [
+                {
+                    "match": "&(amp|gt|lt|apos|quot|nbsp);",
+                    "name": "constant.character.escape.xmlui"
+                }
+            ]
+        },
+        "comments": {
+            "patterns": [
+                {
+                    "begin": "<!--",
+                    "captures": {
+                        "0": {
+                            "name": "punctuation.definition.comment.xmlui"
+                        }
+                    },
+                    "end": "-->",
+                    "name": "comment.block.xmlui"
+                }
+            ]
+        }
+    }
+}