npm - @salesforcedevs/dx-components - Versions diffs - 1.18.8-layoutfix-alpha → 1.18.9-rnb-scroll - Mend

@salesforcedevs/dx-components 1.18.8-layoutfix-alpha → 1.18.9-rnb-scroll

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/package.json +5 -3
package/src/modules/dx/codeBlock/codeBlock.css +1 -10
package/src/modules/dx/codeBlock/codeBlock.ts +1 -1
package/src/modules/dx/toc/toc.css +17 -1
package/src/modules/dx/toc/toc.html +17 -13
package/src/modules/dx/toc/toc.ts +9 -0
package/src/modules/dxUtils/shiki/shiki.ts +35 -53
package/src/modules/dxUtils/shikiGrammars/shikiGrammars.html +3 -0
package/src/modules/dxUtils/shikiGrammars/shikiGrammars.ts +2165 -0
package/src/modules/dxUtils/shiki/customLanguages/afscript.tmLanguage.json +0 -855
package/src/modules/dxUtils/shiki/customLanguages/ampscript.tmLanguage.json +0 -176
package/src/modules/dxUtils/shiki/customLanguages/dataweave.tmLanguage.json +0 -1130

package/src/modules/dxUtils/shikiGrammars/shikiGrammars.ts ADDED Viewed

@@ -0,0 +1,2165 @@
+const dataweaveGrammar = {
+    name: "dataweave",
+    scopeName: "source.data-weave",
+    fileTypes: ["dwl"],
+    uuid: "ba6390ae-c50f-4dce-97f1-951dab8fc607",
+    patterns: [
+        { include: "#comments" },
+        { include: "#directives" },
+        {
+            match: "(---)",
+            name: "keyword.operator.body-marker.dw"
+        },
+        { include: "#expressions" },
+        {
+            match: "([^\\s]+)",
+            name: "invalid"
+        }
+    ],
+    repository: {
+        directives: {
+            patterns: [
+                { include: "#dw-directive" },
+                { include: "#import-directive" },
+                { include: "#type-directive" },
+                { include: "#fun-directive" },
+                { include: "#var-directive" },
+                { include: "#ns-directive" },
+                { include: "#input-directive" },
+                { include: "#output-directive" },
+                { include: "#annotation-usage" },
+                { include: "#annotation-directive" }
+            ]
+        },
+        type_parameters: {
+            begin: "<",
+            end: ">",
+            patterns: [
+                { include: "#types" },
+                { include: "#punctuation-comma" },
+                { include: "#comments" }
+            ]
+        },
+        "variable-reference": {
+            patterns: [
+                {
+                    name: "variable.other.dw",
+                    match: "\\b(?!(fun|input|output|type|var|ns|import|%dw|private|---)\\b)((\\+\\+|\\-\\-|[A-Za-z])[a-zA-Z0-9_]*)"
+                },
+                {
+                    name: "invalid",
+                    match: "\\b(fun|input|output|type|var|ns|import|private)\\b"
+                },
+                {
+                    name: "variable.parameter.dw",
+                    match: "(\\$+)"
+                }
+            ]
+        },
+        cast: {
+            begin: "(?<!\\.|\\$)\\b(as|is)\\s+",
+            beginCaptures: { "1": { name: "keyword.control.as.dw" } },
+            end: "(?=$|^|[;,:})\\]\\s])",
+            patterns: [{ include: "#types" }]
+        },
+        "case-clause": {
+            name: "case-clause.expr.dw",
+            begin: "(?<!\\.|\\$)\\b(case|else(?=\\s*->))\\b(?!\\$|\\.)",
+            beginCaptures: { "1": { name: "keyword.control.switch.dw" } },
+            end: "\\-\\>",
+            endCaptures: { "0": { name: "keyword.control.switch.dw" } },
+            patterns: [
+                {
+                    begin: "(?<!\\.|\\$)\\b(is)\\s+",
+                    beginCaptures: {
+                        "1": { name: "keyword.control.is.dw" }
+                    },
+                    end: "(?=\\-\\>)",
+                    patterns: [{ include: "#types" }]
+                },
+                {
+                    begin: "(?<!\\.|\\$)\\b(matches)\\b",
+                    beginCaptures: {
+                        "1": { name: "keyword.control.matches.dw" }
+                    },
+                    end: "(?=\\-\\>)",
+                    patterns: [{ include: "#expressions" }]
+                },
+                {
+                    begin: "(?<!\\.|\\$)\\b([A-Za-z][a-zA-Z0-9_]*)\\s*:\\s+",
+                    beginCaptures: {
+                        "1": { name: "entity.name.variable.dw" }
+                    },
+                    end: "(?=\\-\\>)",
+                    patterns: [{ include: "#expressions" }]
+                },
+                {
+                    begin: "(?<!\\.|\\$)\\b([A-Za-z][a-zA-Z0-9_]*)\\s*(if|matches)\\s+",
+                    beginCaptures: {
+                        "1": { name: "entity.name.variable.dw" },
+                        "2": { name: "keyword.control.if.dw" }
+                    },
+                    end: "(?=\\-\\>)",
+                    patterns: [{ include: "#expressions" }]
+                },
+                { include: "#expressions" }
+            ]
+        },
+        comments: {
+            patterns: [
+                {
+                    name: "comment.block.dw",
+                    begin: "/\\*",
+                    end: "\\*/",
+                    captures: {
+                        "0": { name: "punctuation.definition.comment.dw" }
+                    }
+                },
+                {
+                    match: "\\s*((//).*$\\n?)",
+                    captures: {
+                        "1": { name: "comment.line.double-slash.dw" },
+                        "2": { name: "punctuation.definition.comment.dw" }
+                    }
+                }
+            ]
+        },
+        constants: {
+            patterns: [
+                {
+                    name: "constant.language.dw",
+                    match: "\\b(true|false|null)\\b"
+                },
+                {
+                    name: "constant.numeric.dw",
+                    match: "\\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\\.?[0-9]*)|(\\.[0-9]+))((e|E)(\\+|-)?[0-9]+)?)([LlFfUuDd]|UL|ul)?\\b"
+                },
+                {
+                    begin: "\\|",
+                    beginCaptures: { "0": { name: "constant.numeric.dw" } },
+                    end: "\\|",
+                    endCaptures: { "0": { name: "constant.numeric.dw" } },
+                    patterns: [
+                        {
+                            name: "constant.numeric.dw",
+                            match: "([0-9]+)"
+                        },
+                        {
+                            name: "constant.character.escape.dw",
+                            match: "([+:\\-WYMDTHSPZ\\.])"
+                        },
+                        {
+                            name: "invalid",
+                            match: "([^\\|])"
+                        }
+                    ]
+                }
+            ]
+        },
+        "dw-directive": {
+            name: "meta.directive.version.dw",
+            begin: "(?<!\\.|\\$)(%dw)\\s+([0-9]\\.[0-9])(?!\\$|\\.)",
+            beginCaptures: {
+                "1": { name: "comment.dw" },
+                "2": { name: "comment.dw" }
+            },
+            end: "(?=\\n)"
+        },
+        infix: {
+            name: "support.function.dw",
+            match: "(?<!^|,|\\[|\\(|=|\\+|>|<|\\-|\\*|:|\\{|case|is|else|not|as|and|or)(?<=[a-zA-Z0-9_$\\}\\])\"'`|/])\\s*(?!(var|match|case|else|fun|input|output|is|as|default|ns|import|null|false|true|using|do|not|and|or)\\s)(\\+\\+|\\-\\-|[a-zA-Z][a-zA-Z_0-9]*)(\\s+|\\s*(?=[\"'/|{]))"
+        },
+        expressions: {
+            name: "expression",
+            patterns: [
+                {
+                    name: "keyword.other.dw",
+                    match: "\\b(not)\\s+"
+                },
+                { include: "#undefined-fun-character" },
+                { include: "#paren-expression" },
+                { include: "#strings" },
+                { include: "#constants" },
+                { include: "#comments" },
+                { include: "#match-statement" },
+                { include: "#using-statement" },
+                { include: "#do-statement" },
+                { include: "#if-statement" },
+                { include: "#regex" },
+                { include: "#type_parameters" },
+                { include: "#keywords" },
+                { include: "#object-literal" },
+                { include: "#array-literal" },
+                { include: "#cast" },
+                { include: "#object-member" },
+                { include: "#variable-reference" },
+                { include: "#selectors" },
+                { include: "#directives" },
+                { include: "#infix" }
+            ]
+        },
+        generics: {
+            patterns: [
+                {
+                    begin: "(:)",
+                    beginCaptures: {
+                        "1": { name: "keyword.operator.declaration.dw" }
+                    },
+                    end: "(?=,|>)",
+                    patterns: [{ include: "#types" }]
+                },
+                {
+                    name: "keyword.operator.extends.dw",
+                    match: "<:"
+                },
+                { include: "#keywords" },
+                {
+                    name: "entity.name.type.parameter.dw",
+                    match: "\\w+"
+                }
+            ]
+        },
+        "input-directive": {
+            name: "meta.directive.ns.dw",
+            begin: "(?<!\\.|\\$)\\b(input)\\s+([[:alpha:]][[:alnum:]]*)\\s*",
+            end: "(?=\\n)",
+            beginCaptures: {
+                "1": { name: "storage.type.dw" },
+                "2": { name: "entity.name.variable.dw" }
+            },
+            patterns: [
+                {
+                    begin: "(\\:\\s*)",
+                    beginCaptures: { "1": { name: "keyword.other.dw" } },
+                    end: "(\\s|\\n)",
+                    patterns: [{ include: "#types" }]
+                },
+                {
+                    match: "([^{\\n\\s])",
+                    name: "string.mime.dw"
+                }
+            ]
+        },
+        keywords: {
+            patterns: [
+                {
+                    name: "keyword.reserved.dw",
+                    match: "\\b(throw|for|yield|enum|private|async)\\b"
+                },
+                {
+                    name: "invalid",
+                    match: "\\b(not)\\b"
+                },
+                {
+                    name: "keyword.control.dw",
+                    match: "\\b(if|else|while|for|do|using|unless|default)\\b"
+                },
+                {
+                    name: "keyword.operator.comparison.dw",
+                    match: "(~=|==|!=|!=|<=|>=|<|>)"
+                },
+                {
+                    name: "keyword.operator.assignment.dw",
+                    match: "(=)"
+                },
+                {
+                    name: "keyword.operator.declaration.dw",
+                    match: "(:)"
+                },
+                {
+                    name: "keyword.operator.arithmetic.dw",
+                    match: "(\\-|\\+|\\*|\\/)"
+                },
+                {
+                    name: "keyword.other.dw",
+                    match: "\\b(and|or)\\b"
+                }
+            ]
+        },
+        "match-block": {
+            name: "match-block.expr.dw",
+            begin: "\\{",
+            beginCaptures: {
+                "0": { name: "punctuation.definition.block.dw" }
+            },
+            end: "(?=\\})",
+            patterns: [{ include: "#case-clause" }, { include: "#expressions" }]
+        },
+        "match-statement": {
+            name: "match-statement.expr.dw",
+            begin: "(?<!\\.|\\$)\\b(match)\\s*(?=\\{)",
+            beginCaptures: { "1": { name: "keyword.control.switch.dw" } },
+            end: "\\}",
+            endCaptures: {
+                "1": { name: "punctuation.definition.block.dw" }
+            },
+            patterns: [{ include: "#match-block" }]
+        },
+        "using-statement": {
+            name: "using-statement.expr.dw",
+            begin: "(?<!\\.|\\$)\\b(using)\\s*(\\()",
+            beginCaptures: {
+                "1": { name: "keyword.control.using.dw" },
+                "2": { name: "punctuation.definitions.begin.dw" }
+            },
+            end: "(\\))",
+            endCaptures: {
+                "1": { name: "punctuation.definitions.end.dw" }
+            },
+            patterns: [
+                {
+                    match: "((?:\\+\\+|\\-\\-|[A-Za-z])(?:[a-zA-Z0-9_]*))(\\s*=)",
+                    captures: {
+                        "1": { name: "entity.name.variable.dw" },
+                        "2": { name: "keyword.operator.dw" }
+                    }
+                },
+                { include: "#expressions" }
+            ]
+        },
+        "do-statement": {
+            name: "do-statement.expr.dw",
+            begin: "(?<!\\.|\\$)\\b(do)\\s*(\\{)",
+            beginCaptures: {
+                "1": { name: "keyword.control.do.dw" },
+                "2": { name: "punctuation.definitions.begin.dw" }
+            },
+            end: "(\\})",
+            endCaptures: {
+                "1": { name: "punctuation.definitions.end.dw" }
+            },
+            patterns: [
+                { include: "#comments" },
+                { include: "#directives" },
+                {
+                    match: "(---)",
+                    name: "keyword.operator.body-marker.dw"
+                },
+                { include: "#expressions" },
+                {
+                    match: "([^\\s]+)",
+                    name: "invalid"
+                }
+            ]
+        },
+        "if-statement": {
+            name: "meta.if.dw",
+            begin: "(?<!\\.|\\$)\\b(if\\s*)\\(",
+            beginCaptures: { "1": { name: "keyword.control.if.dw" } },
+            end: "\\)",
+            patterns: [{ include: "#expressions" }]
+        },
+        "ns-directive": {
+            name: "meta.directive.ns.dw",
+            begin: "(?<!\\.|\\$)\\b(ns)\\s+([A-Za-z][a-zA-Z0-9_]*)\\s+([^\\n]*)(?!\\$|\\.)",
+            beginCaptures: {
+                "1": { name: "storage.type.dw" },
+                "2": { name: "entity.name.namespace.dw" },
+                "3": { name: "meta.definition.ns.dw string.url.dw" }
+            },
+            end: "(?=\\n)"
+        },
+        "object-literal": {
+            name: "meta.objectliteral.dw",
+            begin: "\\{",
+            beginCaptures: {
+                "0": { name: "punctuation.definition.block.dw" }
+            },
+            end: "\\}",
+            endCaptures: {
+                "0": { name: "punctuation.definition.block.dw" }
+            },
+            patterns: [{ include: "#object-member" }]
+        },
+        "attr-literal": {
+            name: "meta.attributes.dw",
+            begin: "\\@\\(",
+            beginCaptures: {
+                "0": { name: "keyword.operator.attributes.dw" }
+            },
+            end: "\\)",
+            endCaptures: {
+                "0": { name: "keyword.operator.attributes.dw" }
+            },
+            patterns: [{ include: "#object-member" }]
+        },
+        selectors: {
+            name: "meta.selector.data-weave",
+            begin: "(?<![\\[\\(:+*/\\-])(\\s*\\.\\.\\*|\\s*\\.\\.|\\s*\\.\\*|\\s*\\.\\@|\\s*\\.#|\\s*\\.&|\\s*\\.|(?=\\[)|\\:\\:)",
+            end: "(?=\\s|,|\\}|\\)|\\n|\\]|\\(|-|$)",
+            patterns: [
+                {
+                    name: "variable.object.member.dw",
+                    match: "\\b([[:alpha:]][_[:alnum:]]+#)",
+                    captures: { "0": { name: "variable.language.dw" } }
+                },
+                {
+                    match: "((?:[A-Za-z])([a-zA-Z0-9_]*)[?!]?|(\\$)+)",
+                    name: "variable.object.member.dw"
+                },
+                { include: "#strings" },
+                {
+                    begin: "(\\[(@|\\^)?)",
+                    end: "(\\])",
+                    patterns: [
+                        { include: "#expressions" },
+                        {
+                            match: "([\\)])",
+                            name: "invalid"
+                        }
+                    ]
+                },
+                { include: "#selectors" }
+            ]
+        },
+        "object-key": {
+            patterns: [
+                {
+                    name: "variable.object.member.dw meta.object-literal.namespace.dw",
+                    match: "\\b([[:alpha:]][_[:alnum:]]+#)",
+                    captures: { "0": { name: "variable.language.dw" } }
+                },
+                {
+                    name: "variable.object.member.dw meta.object-literal.key.dw",
+                    begin: "(?=[\\'\\\"\\`])",
+                    end: "(?=@\\(|:)",
+                    patterns: [{ include: "#strings" }]
+                },
+                {
+                    name: "variable.object.member.dw",
+                    end: "(?=,|\\}|\\))",
+                    match: "(?:[_$[:alpha:]][_$[:alnum:]]*)\\s*(?=:|@\\()",
+                    captures: {
+                        "1": { name: "meta.object-literal.key.dw" }
+                    }
+                }
+            ]
+        },
+        "object-member": {
+            name: "meta.object.member.first.dw",
+            patterns: [
+                { include: "#comments" },
+                { include: "#paren-expression" },
+                { include: "#object-key" },
+                { include: "#attr-literal" },
+                { include: "#object-member-body" },
+                { include: "#punctuation-comma" }
+            ]
+        },
+        "object-member-body": {
+            name: "variable.object.member.dw",
+            begin: ":",
+            beginCaptures: {
+                "0": {
+                    name: "meta.object-literal.key.dw punctuation.separator.key-value.dw"
+                }
+            },
+            end: "(?=,|\\}|\\))",
+            patterns: [{ include: "#expressions" }]
+        },
+        "output-directive": {
+            name: "meta.directive.ns.dw",
+            begin: "(?<!\\.|\\$)\\b(output)\\s+([^\\n{\\s]*)(?!\\$|\\.)",
+            beginCaptures: {
+                "1": { name: "storage.type.dw" },
+                "2": { name: "string.other.dw" }
+            },
+            end: "(?=\\n)"
+        },
+        parameters: {
+            patterns: [
+                {
+                    begin: "(:)",
+                    beginCaptures: {
+                        "1": { name: "keyword.operator.declaration.dw" }
+                    },
+                    end: "(?=,|\\)|=)",
+                    patterns: [{ include: "#types" }]
+                },
+                {
+                    begin: "(=)",
+                    beginCaptures: {
+                        "1": { name: "keyword.operator.declaration.dw" }
+                    },
+                    end: "(?=,|\\))",
+                    patterns: [{ include: "#expressions" }]
+                },
+                {
+                    name: "variable.parameter.dw",
+                    match: "\\w+"
+                }
+            ]
+        },
+        "paren-expression": {
+            begin: "(\\()",
+            beginCaptures: {
+                "1": { name: "punctuation.expression.begin.dw" }
+            },
+            end: "(\\))",
+            endCaptures: { "1": { name: "punctuation.expression.end.dw" } },
+            patterns: [{ include: "#expressions" }]
+        },
+        "punctuation-comma": {
+            name: "punctuation.separator.comma.dw",
+            match: ","
+        },
+        strings: {
+            patterns: [
+                { include: "#qstring-single" },
+                { include: "#qstring-double" },
+                { include: "#qstring-backtick" },
+                { include: "#template" }
+            ]
+        },
+        "qstring-backtick": {
+            begin: "`",
+            beginCaptures: {
+                "0": {
+                    name: "string.quoted.double.dw punctuation.definition.string.begin.dw"
+                }
+            },
+            end: "`",
+            endCaptures: {
+                "0": {
+                    name: "string.quoted.double.dw punctuation.definition.string.end.dw"
+                }
+            },
+            patterns: [
+                { include: "#template-substitution-element" },
+                { include: "#template-dollar" },
+                { include: "#string-character-escape" },
+                {
+                    match: "([^`])",
+                    name: "string.template.dw"
+                }
+            ]
+        },
+        template: {
+            begin: "([$[:alpha:]][_$[:alnum:]]*)\\s*(`)",
+            beginCaptures: {
+                "1": { name: "support.function.dw" },
+                "2": {
+                    name: "string.template.dw punctuation.definition.string.template.begin.dw"
+                }
+            },
+            end: "`",
+            endCaptures: {
+                "0": {
+                    name: "string.template.dw punctuation.definition.string.template.end.dw"
+                }
+            },
+            patterns: [
+                { include: "#template-substitution-element" },
+                { include: "#template-dollar" },
+                { include: "#string-character-escape" },
+                {
+                    match: "([^`])",
+                    name: "string.template.dw"
+                }
+            ]
+        },
+        "string-character-escape": {
+            name: "constant.character.escape.dw",
+            match: "\\\\(u\\h{4}|$|.)"
+        },
+        "undefined-fun-character": {
+            name: "constant.language.undefined.dw",
+            match: "\\?\\?\\?"
+        },
+        "qstring-double": {
+            begin: '"',
+            beginCaptures: {
+                "0": {
+                    name: "string.quoted.double.dw punctuation.definition.string.begin.dw"
+                }
+            },
+            end: '"',
+            endCaptures: {
+                "0": {
+                    name: "string.quoted.double.dw punctuation.definition.string.end.dw"
+                }
+            },
+            patterns: [
+                { include: "#template-substitution-element" },
+                { include: "#template-dollar" },
+                { include: "#string-character-escape" },
+                {
+                    match: '([^"])',
+                    name: "string.quoted.double.dw"
+                }
+            ]
+        },
+        "qstring-single": {
+            begin: "'",
+            beginCaptures: {
+                "0": {
+                    name: "string.quoted.single.dw punctuation.definition.string.begin.dw"
+                }
+            },
+            end: "(\\')|((?:[^\\\\\\n])$)",
+            endCaptures: {
+                "1": {
+                    name: "string.quoted.single.dw punctuation.definition.string.end.dw"
+                },
+                "2": { name: "invalid.illegal.newline.dw" }
+            },
+            patterns: [
+                { include: "#template-substitution-element" },
+                { include: "#template-dollar" },
+                { include: "#string-character-escape" },
+                {
+                    match: "([^'])",
+                    name: "string.quoted.single.dw"
+                }
+            ]
+        },
+        "template-dollar": {
+            patterns: [
+                {
+                    match: "(\\$(\\$)+)",
+                    name: "variable.parameter.dw"
+                },
+                {
+                    match: "(\\$)(?![a-zA-Z(])",
+                    name: "variable.parameter.dw"
+                },
+                {
+                    match: "(\\$)([a-zA-Z][a-zA-Z0-9_]*)",
+                    captures: {
+                        "1": { name: "keyword.other.dw" },
+                        "2": { name: "variable.other.dw" }
+                    },
+                    name: "variable.parameter.dw"
+                }
+            ]
+        },
+        "template-substitution-element": {
+            name: "meta.template.expression.dw",
+            begin: "\\$\\(",
+            beginCaptures: { "0": { name: "keyword.other.dw" } },
+            end: "\\)",
+            endCaptures: { "0": { name: "keyword.other.dw" } },
+            patterns: [{ include: "#expressions" }]
+        },
+        types: {
+            patterns: [
+                { include: "#comments" },
+                {
+                    name: "constant.language.dw",
+                    match: "\\b(true|false|null)\\b"
+                },
+                {
+                    name: "constant.numeric.dw",
+                    match: "\\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\\.?[0-9]*)|(\\.[0-9]+))((e|E)(\\+|-)?[0-9]+)?)([LlFfUuDd]|UL|ul)?\\b"
+                },
+                { include: "#strings" },
+                {
+                    begin: "<",
+                    end: ">",
+                    patterns: [
+                        { include: "#types" },
+                        { include: "#punctuation-comma" },
+                        { include: "#comments" }
+                    ]
+                },
+                {
+                    begin: "\\{\\-\\|",
+                    end: "\\|\\-\\}",
+                    patterns: [
+                        { include: "#punctuation-comma" },
+                        { include: "#object-member-type" }
+                    ]
+                },
+                {
+                    begin: "\\{\\|",
+                    end: "\\|\\}",
+                    patterns: [
+                        { include: "#punctuation-comma" },
+                        { include: "#object-member-type" }
+                    ]
+                },
+                {
+                    begin: "\\{\\-",
+                    end: "\\-\\}",
+                    patterns: [
+                        { include: "#punctuation-comma" },
+                        { include: "#object-member-type" }
+                    ]
+                },
+                {
+                    begin: "\\{",
+                    end: "\\}",
+                    patterns: [
+                        { include: "#punctuation-comma" },
+                        { include: "#object-member-type" }
+                    ]
+                },
+                {
+                    begin: "(\\()",
+                    beginCaptures: {
+                        "0": { name: "keyword.operator.grouping.dw" }
+                    },
+                    end: "(\\)\\s*->|\\))",
+                    endCaptures: {
+                        "0": { name: "keyword.operator.grouping.dw" }
+                    },
+                    patterns: [
+                        { include: "#types" },
+                        { include: "#parameters" }
+                    ]
+                },
+                {
+                    name: "support.class.dw",
+                    match: "(String|Boolean|Number|Range|Namespace|Uri|DateTime|LocalDateTime|Date|LocalTime|TimeZone|Time|Period|Binary|Null|Regex|Nothing|Any|Object|Key)"
+                },
+                {
+                    begin: "(Array|Type)\\s*<",
+                    beginCaptures: { "1": { name: "support.type.dw" } },
+                    end: ">",
+                    patterns: [
+                        {
+                            match: ",",
+                            name: "invalid"
+                        },
+                        { include: "#types" }
+                    ]
+                },
+                {
+                    name: "keyword.operator.declaration.dw",
+                    match: "(&|\\|)"
+                },
+                {
+                    name: "keyword.operator.declaration.dw",
+                    match: "<:"
+                },
+                {
+                    name: "support.class.dw",
+                    match: "\\b([A-Z][a-zA-Z0-9_]*)"
+                },
+                { include: "#undefined-fun-character" },
+                { match: "\\b(var|fun|ns)\\b" },
+                {
+                    name: "invalid",
+                    match: "\\b(input|output|var|ns|import|try|catch|throw|do|for|yield|enum|private|async)\\b"
+                },
+                {
+                    name: "invalid",
+                    match: "\\b(if|else|while|for|do|using|unless|default|match)\\b"
+                },
+                {
+                    name: "invalid",
+                    match: "(~=|==|!=|===|!==|<=|>=|<|>|\\$+)"
+                }
+            ]
+        },
+        "object-member-type": {
+            patterns: [
+                { include: "#comments" },
+                {
+                    match: "_",
+                    name: "variable.language.dw"
+                },
+                {
+                    match: "([a-zA-Z0-9]+#)",
+                    name: "variable.language.dw"
+                },
+                {
+                    match: "\\(\\s*([a-zA-Z][a-zA-Z0-9]*)\\s*\\)",
+                    name: "entity.name.type.dw"
+                },
+                {
+                    match: "([a-zA-Z][a-zA-Z0-9]*)",
+                    name: "variable.object.member.dw"
+                },
+                { include: "#strings" },
+                {
+                    match: "\\?",
+                    name: "keyword.operator.optional.dw"
+                },
+                {
+                    match: "\\*",
+                    name: "keyword.operator.optional.dw"
+                },
+                {
+                    begin: "(\\@\\()",
+                    beginCaptures: {
+                        "1": { name: "keyword.operator.attributes.dw" }
+                    },
+                    end: "(\\))",
+                    endCaptures: {
+                        "1": { name: "keyword.operator.attributes.dw" }
+                    },
+                    patterns: [
+                        { include: "#punctuation-comma" },
+                        { include: "#object-member-type" }
+                    ]
+                },
+                {
+                    begin: "(:)",
+                    beginCaptures: {
+                        "1": { name: "keyword.operator.declaration.dw" }
+                    },
+                    end: "(?=,|}|\\)|\\|}|\\-}|\\|\\-})",
+                    patterns: [{ include: "#types" }]
+                },
+                {
+                    match: "([^\\s])",
+                    name: "invalid"
+                }
+            ]
+        },
+        "type-directive": {
+            name: "meta.directive.type.dw",
+            begin: "(\\s*(type)\\s+([a-zA-Z][a-zA-Z0-9]*))",
+            end: "(?=(fun|input|output|type|var|ns|import|%dw|private|---)\\s|(\\@[a-zA-Z][a-zA-Z0-9]*))",
+            beginCaptures: {
+                "2": { name: "storage.type.dw" },
+                "3": { name: "entity.name.type.dw" }
+            },
+            patterns: [
+                {
+                    begin: "<",
+                    end: ">",
+                    patterns: [{ include: "#generics" }]
+                },
+                {
+                    name: "keyword.other.dw",
+                    match: "\\="
+                },
+                { include: "#types" }
+            ]
+        },
+        "import-directive": {
+            name: "meta.directive.import.dw",
+            begin: "(\\s*(import)\\s+)",
+            end: "(?=(fun|input|output|type|var|ns|import|%dw|private|annotation|\\@|---)\\s|$)",
+            beginCaptures: { "2": { name: "keyword.control.import" } },
+            patterns: [
+                { include: "#comments" },
+                { match: "(,)" },
+                {
+                    match: "(\\*)",
+                    name: "entity.name.type.dw"
+                },
+                {
+                    match: "\\s+(from)\\s+",
+                    captures: { "1": { name: "keyword.control.from" } }
+                },
+                {
+                    match: "(?:[a-zA-Z][a-zA-Z0-9]*(?:::[a-zA-Z][a-zA-Z0-9]*)+)\n",
+                    name: "entity.name.type.dw"
+                },
+                {
+                    match: "(?:[a-zA-Z][a-zA-Z0-9]*)\n",
+                    name: "entity.name.function.dw"
+                },
+                {
+                    match: "\\s+(as)\\s+([a-zA-Z][a-zA-Z0-9]*)",
+                    captures: {
+                        "1": { name: "keyword.control.as" },
+                        "2": { name: "entity.name.function.dw" }
+                    }
+                }
+            ]
+        },
+        "var-directive": {
+            name: "meta.directive.var.dw",
+            begin: "(\\s*(var)\\s+([a-zA-Z][a-zA-Z0-9]*))",
+            end: "(=)",
+            beginCaptures: {
+                "2": { name: "storage.type.dw" },
+                "3": { name: "entity.name.variable.dw" }
+            },
+            endCaptures: {
+                "0": { name: "keyword.operator.assignment.dw" }
+            },
+            patterns: [
+                {
+                    begin: "<",
+                    end: ">",
+                    patterns: [{ include: "#generics" }]
+                },
+                {
+                    begin: "(:)",
+                    beginCaptures: {
+                        "1": { name: "keyword.operator.declaration.dw" }
+                    },
+                    end: "(?==|$)",
+                    patterns: [{ include: "#comments" }, { include: "#types" }]
+                }
+            ]
+        },
+        "fun-directive": {
+            name: "meta.directive.fun.dw",
+            begin: "(\\s*(fun)\\s+([a-zA-Z][a-zA-Z0-9_]*|--|\\+\\+))",
+            end: "(=)",
+            beginCaptures: {
+                "2": { name: "storage.type.dw" },
+                "3": { name: "entity.name.function.dw" }
+            },
+            endCaptures: {
+                "0": { name: "keyword.operator.assignment.dw" }
+            },
+            patterns: [
+                {
+                    begin: "<",
+                    end: ">",
+                    patterns: [{ include: "#generics" }]
+                },
+                {
+                    begin: "\\(",
+                    end: "\\)",
+                    patterns: [{ include: "#parameters" }]
+                },
+                {
+                    begin: "(:)",
+                    beginCaptures: {
+                        "1": { name: "keyword.operator.declaration.dw" }
+                    },
+                    end: "(?==)",
+                    patterns: [{ include: "#types" }]
+                }
+            ]
+        },
+        "annotation-directive": {
+            name: "meta.directive.annot.dw",
+            begin: "(\\s*(annotation)\\s+([a-zA-Z][a-zA-Z0-9]*))",
+            end: "(?=\\n)",
+            beginCaptures: {
+                "2": { name: "storage.type.annotation.dw" },
+                "3": { name: "entity.name.function.dw" }
+            },
+            endCaptures: {
+                "0": { name: "keyword.operator.assignment.dw" }
+            },
+            patterns: [
+                {
+                    begin: "\\(",
+                    end: "\\)",
+                    patterns: [{ include: "#parameters" }]
+                }
+            ]
+        },
+        "annotation-usage": {
+            name: "meta.annot.usage.dw",
+            begin: "(\\s*(\\@)([a-zA-Z][a-zA-Z0-9]*))",
+            end: "(?=\\n)",
+            beginCaptures: {
+                "2": { name: "storage.type.annotation.dw" },
+                "3": { name: "entity.name.function.dw" }
+            },
+            endCaptures: {
+                "0": { name: "keyword.operator.assignment.dw" }
+            },
+            patterns: [
+                {
+                    begin: "\\(",
+                    end: "\\)",
+                    patterns: [{ include: "#parameters" }]
+                }
+            ]
+        },
+        "array-literal": {
+            name: "meta.array.literal.dw",
+            begin: "(?<!\\w|}|])(\\[)",
+            beginCaptures: { "0": { name: "meta.brace.square.dw" } },
+            end: "\\]",
+            endCaptures: { "0": { name: "meta.brace.square.dw" } },
+            patterns: [
+                { include: "#expressions" },
+                { include: "#punctuation-comma" }
+            ]
+        },
+        regex: {
+            patterns: [
+                {
+                    name: "string.regexp.dw",
+                    begin: "(?<=[=(:,\\[?+!]|replace|match|scan|matches|contains|---|case|->|and|or|\\*\\/)\\s*(\\/)(?![\\/*])(?=(?:[^\\/\\\\\\[]|\\\\.|\\[([^\\]\\\\]|\\\\.)+\\])+\\/(?![\\/*])(?!\\s*[a-zA-Z0-9_$]))",
+                    beginCaptures: {
+                        "1": {
+                            name: "punctuation.definition.string.begin.dw"
+                        }
+                    },
+                    end: "(/)",
+                    endCaptures: {
+                        "1": { name: "punctuation.definition.string.end.dw" }
+                    },
+                    patterns: [{ include: "#regexp" }]
+                },
+                {
+                    name: "string.regexp.dw",
+                    begin: "(?<![_$[:alnum:])])\\/(?![\\/*])(?=(?:[^\\/\\\\\\[]|\\\\.|\\[([^\\]\\\\]|\\\\.)+\\])+\\/(?![\\/*])(?!\\s*[a-zA-Z0-9_$]))",
+                    beginCaptures: {
+                        "0": {
+                            name: "punctuation.definition.string.begin.dw"
+                        }
+                    },
+                    end: "(/)",
+                    endCaptures: {
+                        "1": { name: "punctuation.definition.string.end.dw" }
+                    },
+                    patterns: [{ include: "#regexp" }]
+                }
+            ]
+        },
+        regexp: {
+            patterns: [
+                {
+                    name: "keyword.control.anchor.regexp",
+                    match: "\\\\[bB]|\\^|\\$"
+                },
+                {
+                    name: "keyword.other.back-reference.regexp",
+                    match: "\\\\[1-9]\\d*"
+                },
+                {
+                    name: "keyword.operator.quantifier.regexp",
+                    match: "[?+*]|\\{(\\d+,\\d+|\\d+,|,\\d+|\\d+)\\}\\??"
+                },
+                {
+                    name: "keyword.operator.or.regexp",
+                    match: "\\|"
+                },
+                {
+                    name: "meta.group.assertion.regexp",
+                    begin: "(\\()((\\?=)|(\\?!))",
+                    beginCaptures: {
+                        "1": { name: "punctuation.definition.group.regexp" },
+                        "2": {
+                            name: "punctuation.definition.group.assertion.regexp"
+                        },
+                        "3": { name: "meta.assertion.look-ahead.regexp" },
+                        "4": {
+                            name: "meta.assertion.negative-look-ahead.regexp"
+                        }
+                    },
+                    end: "(\\))",
+                    endCaptures: {
+                        "1": { name: "punctuation.definition.group.regexp" }
+                    },
+                    patterns: [{ include: "#regexp" }]
+                },
+                {
+                    name: "meta.group.regexp",
+                    begin: "\\((\\?:)?",
+                    beginCaptures: {
+                        "0": { name: "punctuation.definition.group.regexp" },
+                        "1": {
+                            name: "punctuation.definition.group.capture.regexp"
+                        }
+                    },
+                    end: "\\)",
+                    endCaptures: {
+                        "0": { name: "punctuation.definition.group.regexp" }
+                    },
+                    patterns: [{ include: "#regexp" }]
+                },
+                {
+                    name: "constant.other.character-class.set.regexp",
+                    begin: "(\\[)(\\^)?",
+                    beginCaptures: {
+                        "1": {
+                            name: "punctuation.definition.character-class.regexp"
+                        },
+                        "2": { name: "keyword.operator.negation.regexp" }
+                    },
+                    end: "(\\])",
+                    endCaptures: {
+                        "1": {
+                            name: "punctuation.definition.character-class.regexp"
+                        }
+                    },
+                    patterns: [
+                        {
+                            name: "constant.other.character-class.range.regexp",
+                            match: "(?:.|(\\\\(?:[0-7]{3}|x\\h\\h|u\\h\\h\\h\\h))|(\\\\c[A-Z])|(\\\\.))\\-(?:[^\\]\\\\]|(\\\\(?:[0-7]{3}|x\\h\\h|u\\h\\h\\h\\h))|(\\\\c[A-Z])|(\\\\.))",
+                            captures: {
+                                "1": {
+                                    name: "constant.character.numeric.regexp"
+                                },
+                                "2": {
+                                    name: "constant.character.control.regexp"
+                                },
+                                "3": {
+                                    name: "constant.character.escape.backslash.regexp"
+                                },
+                                "4": {
+                                    name: "constant.character.numeric.regexp"
+                                },
+                                "5": {
+                                    name: "constant.character.control.regexp"
+                                },
+                                "6": {
+                                    name: "constant.character.escape.backslash.regexp"
+                                }
+                            }
+                        },
+                        { include: "#regex-character-class" }
+                    ]
+                },
+                { include: "#regex-character-class" }
+            ]
+        },
+        "regex-character-class": {
+            patterns: [
+                {
+                    name: "constant.other.character-class.regexp",
+                    match: "\\\\[wWsSdDtrnvf]|\\."
+                },
+                {
+                    name: "constant.character.numeric.regexp",
+                    match: "\\\\([0-7]{3}|x\\h\\h|u\\h\\h\\h\\h)"
+                },
+                {
+                    name: "constant.character.control.regexp",
+                    match: "\\\\c[A-Z]"
+                },
+                {
+                    name: "constant.character.escape.backslash.regexp",
+                    match: "\\\\."
+                }
+            ]
+        }
+    }
+};
+const ampscriptGrammar = {
+    version: "2.0",
+    name: "ampscript",
+    scopeName: "text.html.amp",
+    foldingStartMarker: "%%\\[\\s*$",
+    foldingStopMarker: "^\\s*\\]%%$",
+    injections: {
+        "R:comment.block,comment.block.html,meta.attribute": {
+            patterns: [
+                {
+                    include: "#ampscript"
+                },
+                {
+                    include: "#ampscript-substitutions"
+                }
+            ]
+        }
+    },
+    patterns: [
+        {
+            include: "#ampscript"
+        },
+        {
+            include: "text.html.basic"
+        }
+    ],
+    repository: {
+        ampscript: {
+            name: "meta.embedded.amp",
+            begin: "(%%[=\\[])",
+            end: "([\\]=]%%)",
+            beginCaptures: {
+                "1": {
+                    name: "keyword.other.namespace.amp"
+                }
+            },
+            endCaptures: {
+                "1": {
+                    name: "keyword.other.namespace.amp"
+                }
+            },
+            patterns: [
+                {
+                    include: "#ampscript-comments"
+                },
+                {
+                    include: "#ampscript-functions"
+                },
+                {
+                    include: "#ampscript-numeric"
+                },
+                {
+                    include: "#ampscript-contstants"
+                },
+                {
+                    include: "#ampscript-language-elements"
+                },
+                {
+                    include: "#ampscript-strings"
+                }
+            ]
+        },
+        "ampscript-comments": {
+            patterns: [
+                {
+                    name: "comment.block.amp",
+                    begin: "/\\*",
+                    captures: {
+                        "0": {
+                            name: "punctuation.definition.comment.amp"
+                        }
+                    },
+                    end: "\\*/"
+                }
+            ]
+        },
+        "ampscript-functions": {
+            name: "support.function.amp",
+            match: "((?i:beginimpressionregion|endimpressionregion|beginassetblock|endassetblock|contentarea|contentareabyname|contentblockbyname|contentblockbyid|contentblockbykey|treatascontent|treatascontentarea|lookup|lookuprows|lookuprowscs|rowcount|row|field|now|datediff|dateparse|redirectto|random|add|subtract|multiply|divide|mod|concat|indexof|char|empty|propercase|substring|length|lowercase|uppercase|trim|regexmatch|replace|replacelist|format|iif|isnull|output|outputline|v|attributevalue)\\b)(?=\\()"
+        },
+        "ampscript-numeric": {
+            name: "constant.numeric.amp",
+            match: "\\b((0(x|X)[0-9a-fA-F]+)|([0-9]+(\\.[0-9]+)?))\\b"
+        },
+        "ampscript-contstants": {
+            patterns: [
+                {
+                    name: "constant.language.boolean.true.amp",
+                    match: "((?i:true)\\b)"
+                },
+                {
+                    name: "constant.language.boolean.false.amp",
+                    match: "((?i:false)\\b)"
+                },
+                {
+                    name: "constant.language.boolean.null.amp",
+                    match: "((?i:null)\\b)"
+                }
+            ]
+        },
+        "ampscript-language-elements": {
+            patterns: [
+                {
+                    name: "keyword.control.amp",
+                    match: "((?i:do|else|elseif|for|if|endif|next|then|to|downto)\\b)"
+                },
+                {
+                    name: "storage.type.amp",
+                    match: "((?i:var|set)\\b)"
+                },
+                {
+                    name: "variable.parameter.amp",
+                    match: "\\@[a-zA-Z0-9_]+"
+                },
+                {
+                    name: "variable.parameter.amp",
+                    match: "\\[[a-zA-Z0-9_]+\\]"
+                },
+                {
+                    name: "support.class.amp",
+                    match: "((?i:and|or|not)\\b)"
+                },
+                {
+                    name: "variable.operator.amp",
+                    match: "==|!=|>|<|>=|<=|="
+                }
+            ]
+        },
+        "ampscript-strings": {
+            patterns: [
+                {
+                    name: "string.quoted.double.amp",
+                    begin: '"',
+                    end: '"',
+                    beginCaptures: {
+                        "0": {
+                            name: "punctuation.definition.string.begin.amp"
+                        }
+                    },
+                    endCaptures: {
+                        "0": {
+                            name: "punctuation.definition.string.end.amp"
+                        }
+                    },
+                    patterns: [
+                        {
+                            name: "constant.character.escape.amp",
+                            match: '""'
+                        }
+                    ]
+                },
+                {
+                    name: "string.quoted.single.amp",
+                    begin: "'",
+                    end: "'",
+                    beginCaptures: {
+                        "0": {
+                            name: "punctuation.definition.string.begin.amp"
+                        }
+                    },
+                    endCaptures: {
+                        "0": {
+                            name: "punctuation.definition.string.end.amp"
+                        }
+                    },
+                    patterns: [
+                        {
+                            name: "constant.character.escape.amp",
+                            match: "''"
+                        }
+                    ]
+                }
+            ]
+        }
+    }
+};
+const afscriptGrammar = {
+    name: "afscript",
+    scopeName: "source.afscript",
+    fileTypes: ["afscript"],
+    patterns: [
+        {
+            name: "comment.line.afscript",
+            match: "#.*$"
+        },
+        {
+            name: "meta.config.afscript",
+            begin: "^(config):",
+            beginCaptures: {
+                "1": { name: "keyword.control.block.afscript" }
+            },
+            end: "^(?=topic|variables|start_agent|system|$)",
+            patterns: [
+                {
+                    name: "keyword.config.key.afscript",
+                    match: "^\\s+(model_provider|user_locale|locale|agent_id|agent_name|agent_version|agent_type|default_agent_user|language|developer_name|description)(?=:)"
+                },
+                {
+                    name: "entity.name.config.afscript",
+                    match: "^\\s+([a-zA-Z_][a-zA-Z0-9_]*)(?=:)"
+                },
+                { include: "#values" }
+            ]
+        },
+        {
+            name: "meta.variables.afscript",
+            begin: "^(variables):",
+            beginCaptures: {
+                "1": { name: "keyword.control.block.afscript" }
+            },
+            end: "^(?=topic|config|start_agent|system|$)",
+            patterns: [
+                {
+                    name: "keyword.variable.metadata.afscript",
+                    match: "^\\s{8}(description|source)(?=:)"
+                },
+                {
+                    name: "variable.definition.afscript",
+                    match: "^\\s+([a-zA-Z_][a-zA-Z0-9_]*)(?=:)"
+                },
+                {
+                    name: "keyword.variable.source.afscript",
+                    match: "\\b(custom|context)\\b"
+                },
+                {
+                    name: "storage.type.afscript",
+                    match: "\\b(string|number|boolean|object|date|timestamp|currency|id|list)\\b"
+                },
+                { include: "#json-structures" },
+                { include: "#values" }
+            ]
+        },
+        {
+            name: "meta.system.afscript",
+            begin: "^(system):",
+            beginCaptures: {
+                "1": { name: "keyword.control.block.afscript" }
+            },
+            end: "^(?=topic|config|variables|start_agent|$)",
+            patterns: [
+                {
+                    name: "keyword.system.afscript",
+                    match: "\\b(instructions|messages|prompt)(?=:)"
+                },
+                {
+                    name: "keyword.system.message-type.afscript",
+                    match: "\\b(error|welcome)(?=:)"
+                },
+                { include: "#multiline-instructions" },
+                { include: "#values" }
+            ]
+        },
+        {
+            name: "meta.topic.afscript",
+            begin: "^(topic)\\s+([a-zA-Z_][a-zA-Z0-9_]*):",
+            beginCaptures: {
+                "1": { name: "keyword.control.block.afscript" },
+                "2": { name: "entity.name.topic.afscript" }
+            },
+            end: "^(?=topic|config|variables|start_agent|system|$)",
+            patterns: [
+                { include: "#action-definitions" },
+                { include: "#agent-task" },
+                { include: "#task-content" },
+                { include: "#override-instructions" },
+                { include: "#reasoning-instructions" },
+                { include: "#reasoning-actions" },
+                { include: "#directives" },
+                {
+                    name: "keyword.topic.section.afscript",
+                    match: "\\b(actions|action_definitions|before_reasoning|after_reasoning|reasoning_actions|override|variables|instructions)(?=:)"
+                },
+                {
+                    name: "keyword.topic.section.afscript",
+                    match: "^\\s{4}(description)(?=:)"
+                },
+                {
+                    name: "keyword.override.path.afscript",
+                    match: "\\b(system\\.instructions)\\b"
+                },
+                {
+                    name: "storage.type.afscript",
+                    match: "\\b(string|number|boolean|object|date|timestamp|currency|id|list)\\b"
+                },
+                { include: "#operators" },
+                { include: "#punctuation" },
+                { include: "#values" }
+            ]
+        },
+        {
+            name: "meta.start-agent.afscript",
+            begin: "^(start_agent)(?:\\s+([a-zA-Z_][a-zA-Z0-9_]*))?",
+            beginCaptures: {
+                "1": { name: "keyword.control.block.afscript" },
+                "2": { name: "entity.name.agent.afscript" }
+            },
+            end: "^(?=topic|config|variables|start_agent|system|$)",
+            patterns: [
+                { include: "#action-definitions" },
+                { include: "#agent-task" },
+                { include: "#task-content" },
+                { include: "#override-instructions" },
+                { include: "#reasoning-instructions" },
+                { include: "#reasoning-actions" },
+                { include: "#directives" },
+                {
+                    name: "keyword.topic.section.afscript",
+                    match: "\\b(actions|action_definitions|before_reasoning|after_reasoning|reasoning_actions|override|variables|instructions)(?=:)"
+                },
+                {
+                    name: "keyword.topic.section.afscript",
+                    match: "^\\s{4}(description)(?=:)"
+                },
+                {
+                    name: "storage.type.afscript",
+                    match: "\\b(string|number|boolean|object|date|timestamp|currency|id|list)\\b"
+                },
+                { include: "#operators" },
+                { include: "#punctuation" },
+                { include: "#values" }
+            ]
+        },
+        {
+            name: "keyword.control.conditional.available.afscript",
+            match: "\\bavailable when\\b"
+        },
+        {
+            name: "meta.alias.assignment.afscript",
+            match: "\\b(as)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\b",
+            captures: {
+                "1": { name: "keyword.control.afscript" },
+                "2": { name: "entity.name.alias.afscript" }
+            }
+        },
+        {
+            name: "keyword.control.afscript",
+            match: "\\b(if|else|run|set|with|and|or|implementation)\\b|\\btransition to\\b"
+        },
+        {
+            name: "constant.language.afscript",
+            match: "\\b(True|False)\\b"
+        },
+        {
+            name: "constant.other.timestamp.afscript",
+            match: "(?<=\\s|=|,|\\[)\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}(:\\d{2}(\\.\\d+)?)?Z?\\b"
+        },
+        {
+            name: "constant.other.date.afscript",
+            match: "(?<=\\s|=|,|\\[)\\d{4}-\\d{2}-\\d{2}(?!T)\\b"
+        },
+        {
+            name: "constant.numeric.afscript",
+            match: "\\b\\d+(\\.\\d+)?\\b"
+        },
+        {
+            name: "string.quoted.double.afscript",
+            begin: '"',
+            end: '"',
+            patterns: [
+                { include: "#template-expression" },
+                {
+                    name: "constant.character.escape.afscript",
+                    match: "\\\\."
+                }
+            ]
+        },
+        {
+            name: "meta.utils.call.afscript",
+            match: "(@utils)(\\.)([a-zA-Z_][a-zA-Z0-9_]*)\\b",
+            captures: {
+                "1": { name: "support.class.afscript" },
+                "2": { name: "punctuation.accessor.dot.afscript" },
+                "3": { name: "entity.name.function.afscript" }
+            }
+        },
+        {
+            name: "keyword.control.transition.afscript",
+            match: "\\s+to\\s+"
+        },
+        {
+            name: "meta.variable.reference.afscript",
+            match: "(@)(variable|result|input|topic|action)(\\.)([a-zA-Z_][a-zA-Z0-9_]*)",
+            captures: {
+                "1": { name: "support.class.afscript" },
+                "2": { name: "support.class.afscript" },
+                "3": { name: "punctuation.accessor.dot.afscript" },
+                "4": { name: "variable.other.member.afscript" }
+            }
+        },
+        {
+            name: "support.class.afscript",
+            match: "@[a-zA-Z_][a-zA-Z0-9_]*"
+        },
+        {
+            name: "variable.other.member.afscript",
+            match: "(?<=@(?:variable|topic|input|action|result)\\.)\\b[a-zA-Z_][a-zA-Z0-9_]*\\b"
+        },
+        {
+            name: "operator.arithmetic.afscript",
+            match: "[+\\-\\*/%]"
+        },
+        {
+            name: "operator.comparison.afscript",
+            match: "==|!=|<=|>=|<|>"
+        },
+        {
+            name: "operator.assignment.afscript",
+            match: "(?<![=!<>])=(?!=)"
+        },
+        {
+            name: "punctuation.definition.afscript",
+            match: "[{}\\[\\]()]"
+        },
+        { include: "#punctuation" },
+        { include: "#template-expression" }
+    ],
+    repository: {
+        values: {
+            patterns: [
+                { include: "#operators" },
+                { include: "#template-expression" },
+                { include: "#punctuation" },
+                {
+                    name: "string.quoted.double.afscript",
+                    begin: '"',
+                    end: '"',
+                    patterns: [
+                        { include: "#template-expression" },
+                        {
+                            name: "constant.character.escape.afscript",
+                            match: "\\\\."
+                        }
+                    ]
+                },
+                {
+                    name: "constant.language.afscript",
+                    match: "\\b(True|False)\\b"
+                },
+                {
+                    name: "constant.other.timestamp.afscript",
+                    match: "(?<=\\s|=|,|\\[)\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}(:\\d{2}(\\.\\d+)?)?Z?\\b"
+                },
+                {
+                    name: "constant.other.date.afscript",
+                    match: "(?<=\\s|=|,|\\[)\\d{4}-\\d{2}-\\d{2}(?!T)\\b"
+                },
+                {
+                    name: "constant.numeric.afscript",
+                    match: "\\b\\d+(\\.\\d+)?\\b"
+                },
+                {
+                    name: "variable.other.member.afscript",
+                    match: "(?<=@(?:variable|topic|input|action|result)\\.)\\b[a-zA-Z_][a-zA-Z0-9_]*\\b"
+                }
+            ]
+        },
+        "json-structures": {
+            patterns: [
+                {
+                    name: "constant.language.json.afscript",
+                    match: "=\\s*\\{\\}"
+                },
+                {
+                    name: "meta.structure.dictionary.json.afscript",
+                    begin: "=\\s*(\\{)",
+                    beginCaptures: {
+                        "1": {
+                            name: "punctuation.definition.dictionary.begin.json.afscript"
+                        }
+                    },
+                    end: "(\\})",
+                    endCaptures: {
+                        "1": {
+                            name: "punctuation.definition.dictionary.end.json.afscript"
+                        }
+                    },
+                    patterns: [{ include: "#json-value" }]
+                },
+                {
+                    name: "meta.structure.array.json.afscript",
+                    begin: "=\\s*(\\[)",
+                    beginCaptures: {
+                        "1": {
+                            name: "punctuation.definition.array.begin.json.afscript"
+                        }
+                    },
+                    end: "(\\])",
+                    endCaptures: {
+                        "1": {
+                            name: "punctuation.definition.array.end.json.afscript"
+                        }
+                    },
+                    patterns: [{ include: "#json-value" }]
+                }
+            ]
+        },
+        "multiline-instructions": {
+            name: "meta.multiline.instructions.afscript",
+            begin: "^(\\s+)(instructions:)\\s*$",
+            beginCaptures: {
+                "2": { name: "keyword.system.afscript" }
+            },
+            end: "^(?=\\s{4}(messages|prompt)\\b)|^(?=\\S)|^(?=topic\\b|config\\b|variables\\b|start_agent\\b|system\\b)",
+            patterns: [
+                {
+                    name: "string.heredoc.afscript",
+                    begin: "(>>)\\s*$",
+                    beginCaptures: {
+                        "1": { name: "keyword.operator.heredoc.afscript" }
+                    },
+                    end: "^(?=\\s{4}(messages|prompt)\\b)|^(?=\\S)|^(?=topic\\b|config\\b|variables\\b|start_agent\\b|system\\b)",
+                    patterns: [
+                        { include: "#template-expression" },
+                        {
+                            name: "string.unquoted.heredoc.afscript",
+                            match: "."
+                        }
+                    ]
+                },
+                {
+                    name: "string.unquoted.multiline.afscript",
+                    begin: "^\\s+",
+                    end: "^(?=\\s{4}(messages|prompt)\\b)|^(?=\\S)|^(?=topic\\b|config\\b|variables\\b|start_agent\\b|system\\b)",
+                    patterns: [
+                        { include: "#template-expression" },
+                        {
+                            name: "string.unquoted.instructions.afscript",
+                            match: ".*"
+                        }
+                    ]
+                }
+            ]
+        },
+        "agent-task": {
+            patterns: [
+                {
+                    name: "string.heredoc.afscript",
+                    begin: "(>>)\\s*$",
+                    beginCaptures: {
+                        "1": { name: "keyword.operator.heredoc.afscript" }
+                    },
+                    end: "^(?=\\S)",
+                    patterns: [
+                        { include: "#template-expression" },
+                        {
+                            name: "string.unquoted.heredoc.afscript",
+                            match: ".*"
+                        }
+                    ]
+                },
+                {
+                    name: "string.heredoc.quoted.afscript",
+                    begin: '(>>)\\s*"',
+                    beginCaptures: {
+                        "1": { name: "keyword.operator.heredoc.afscript" }
+                    },
+                    end: '"',
+                    patterns: [
+                        { include: "#template-expression" },
+                        {
+                            name: "constant.character.escape.afscript",
+                            match: "\\\\."
+                        }
+                    ]
+                }
+            ]
+        },
+        "task-content": {
+            name: "meta.task.content.afscript",
+            begin: "\\b(task):\\s*$",
+            beginCaptures: {
+                "1": { name: "keyword.topic.section.afscript" }
+            },
+            end: "^(?=\\S)",
+            patterns: [
+                { include: "#template-expression" },
+                {
+                    name: "string.unquoted.task.afscript",
+                    match: ".*"
+                }
+            ]
+        },
+        "override-instructions": {
+            name: "meta.override.instructions.afscript",
+            begin: "^(\\s+)(override system\\.instructions):\\s*$",
+            beginCaptures: {
+                "2": { name: "keyword.override.path.afscript" }
+            },
+            end: "^(?=\\s{4}(reasoning_actions|actions|before_reasoning|after_reasoning|description|variables|instructions|override)\\b)|^(?=\\s*$)|^(?=topic\\b|config\\b|variables\\b|start_agent\\b|system\\b)",
+            patterns: [
+                {
+                    name: "string.heredoc.afscript",
+                    begin: "(>>)\\s*$",
+                    beginCaptures: {
+                        "1": { name: "keyword.operator.heredoc.afscript" }
+                    },
+                    end: "^(?=\\s{4}(reasoning_actions|actions|before_reasoning|after_reasoning|description|variables|instructions|override)\\b)|^(?=\\s*$)|^(?=topic\\b|config\\b|variables\\b|start_agent\\b|system\\b)",
+                    patterns: [
+                        { include: "#template-expression" },
+                        {
+                            name: "string.unquoted.heredoc.afscript",
+                            match: "."
+                        }
+                    ]
+                },
+                {
+                    name: "string.heredoc.quoted.afscript",
+                    begin: '(>>)\\s*"',
+                    beginCaptures: {
+                        "1": { name: "keyword.operator.heredoc.afscript" }
+                    },
+                    end: '"',
+                    patterns: [
+                        { include: "#template-expression" },
+                        {
+                            name: "string.unquoted.heredoc.afscript",
+                            match: "."
+                        }
+                    ]
+                },
+                {
+                    name: "string.unquoted.multiline.afscript",
+                    begin: "^\\s+",
+                    end: "^(?=\\s{4}(reasoning_actions|actions|before_reasoning|after_reasoning|description|variables|instructions|override)\\b)|^(?=\\s*$)|^(?=topic\\b|config\\b|variables\\b|start_agent\\b|system\\b)",
+                    patterns: [
+                        { include: "#template-expression" },
+                        {
+                            name: "string.unquoted.instructions.afscript",
+                            match: ".*"
+                        }
+                    ]
+                }
+            ]
+        },
+        "reasoning-instructions": {
+            name: "meta.reasoning.instructions.afscript",
+            begin: "^(\\s+)(reasoning_instructions):\\s*$",
+            beginCaptures: {
+                "2": { name: "keyword.topic.section.afscript" }
+            },
+            end: "^(?=\\s{4}(reasoning_actions|actions|before_reasoning|after_reasoning|description|variables|instructions|override)\\b)|^(?=\\s*$)|^(?=topic\\b|config\\b|variables\\b|start_agent\\b|system\\b)",
+            patterns: [
+                {
+                    name: "string.heredoc.afscript",
+                    begin: "(>>)\\s*$",
+                    beginCaptures: {
+                        "1": { name: "keyword.operator.heredoc.afscript" }
+                    },
+                    end: "^(?=\\s{4}(reasoning_actions|actions|before_reasoning|after_reasoning|description|variables|instructions|override)\\b)|^(?=\\s*$)|^(?=topic\\b|config\\b|variables\\b|start_agent\\b|system\\b)",
+                    patterns: [
+                        { include: "#template-expression" },
+                        {
+                            name: "string.unquoted.heredoc.afscript",
+                            match: "."
+                        }
+                    ]
+                },
+                {
+                    name: "string.heredoc.quoted.afscript",
+                    begin: '(>>)\\s*"',
+                    beginCaptures: {
+                        "1": { name: "keyword.operator.heredoc.afscript" }
+                    },
+                    end: '"',
+                    patterns: [
+                        { include: "#template-expression" },
+                        {
+                            name: "string.unquoted.heredoc.afscript",
+                            match: "."
+                        }
+                    ]
+                },
+                {
+                    name: "string.heredoc.afscript",
+                    begin: '"',
+                    end: '"',
+                    patterns: [
+                        { include: "#template-expression" },
+                        {
+                            name: "string.unquoted.heredoc.afscript",
+                            match: "."
+                        }
+                    ]
+                }
+            ]
+        },
+        "action-definitions": {
+            name: "meta.actions.afscript",
+            begin: "^(\\s+)(actions|action_definitions):",
+            beginCaptures: {
+                "2": { name: "keyword.topic.section.afscript" }
+            },
+            end: "^(?=\\s{4}(reasoning_instructions|reasoning_actions|before_reasoning|after_reasoning|description|variables|instructions|override)\\b)|^(?=\\s*$)|^(?=topic\\b|config\\b|variables\\b|start_agent\\b|system\\b)",
+            patterns: [
+                {
+                    name: "entity.name.action.afscript",
+                    match: "^\\s{4,8}([a-zA-Z_][a-zA-Z0-9_]*)(?=:)"
+                },
+                {
+                    name: "keyword.action.property.afscript",
+                    match: "^\\s{12}(description|target|inputs|outputs|parameters|returns|implementation|label|require_user_confirmation|include_in_progress_indicator|progress_indicator_message|is_required|is_user_input|developer_name|complex_data_type_name|is_used_by_planner|is_displayable)(?=:)"
+                },
+                {
+                    name: "storage.type.afscript",
+                    match: "\\b(string|number|boolean|object|date|timestamp|currency|id|list)\\b"
+                },
+                { include: "#operators" },
+                { include: "#punctuation" },
+                { include: "#values" }
+            ]
+        },
+        "reasoning-actions": {
+            name: "meta.reasoning-actions.afscript",
+            begin: "^(\\s+)(reasoning_actions):",
+            beginCaptures: {
+                "2": { name: "keyword.topic.section.afscript" }
+            },
+            end: "^(?=\\s{4}(reasoning_instructions|actions|before_reasoning|after_reasoning|description|variables|instructions|override)\\b)|^(?=\\s*$)|^(?=topic\\b|config\\b|variables\\b|start_agent\\b|system\\b)",
+            patterns: [
+                { include: "#directives" },
+                {
+                    name: "meta.utils.call.afscript",
+                    match: "(@utils)(\\.)([a-zA-Z_][a-zA-Z0-9_]*)\\b",
+                    captures: {
+                        "1": { name: "support.class.afscript" },
+                        "2": { name: "punctuation.accessor.dot.afscript" },
+                        "3": { name: "entity.name.function.afscript" }
+                    }
+                },
+                {
+                    name: "meta.variable.reference.afscript",
+                    match: "(@)(action|topic|variable|result|input)(\\.)([a-zA-Z_][a-zA-Z0-9_]*)",
+                    captures: {
+                        "1": { name: "support.class.afscript" },
+                        "2": { name: "support.class.afscript" },
+                        "3": { name: "punctuation.accessor.dot.afscript" },
+                        "4": { name: "variable.other.member.afscript" }
+                    }
+                },
+                {
+                    name: "meta.alias.assignment.afscript",
+                    match: "\\b(as)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\b",
+                    captures: {
+                        "1": { name: "keyword.control.afscript" },
+                        "2": { name: "entity.name.alias.afscript" }
+                    }
+                },
+                {
+                    name: "keyword.control.transition.reasoning.afscript",
+                    match: "\\s+to\\s+"
+                },
+                {
+                    name: "keyword.reasoning.description.afscript",
+                    match: "^\\s{12}(description)(?=:)"
+                },
+                {
+                    name: "keyword.control.afscript",
+                    match: "\\b(setVariables)\\b"
+                },
+                {
+                    name: "entity.name.action.afscript",
+                    match: "\\b[a-zA-Z_][a-zA-Z0-9_]*\\b"
+                },
+                { include: "#values" }
+            ]
+        },
+        directives: {
+            patterns: [
+                {
+                    name: "keyword.control.conditional.available.afscript",
+                    match: "\\bavailable when\\b"
+                },
+                {
+                    name: "meta.alias.assignment.afscript",
+                    match: "\\b(as)\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\b",
+                    captures: {
+                        "1": { name: "keyword.control.afscript" },
+                        "2": { name: "entity.name.alias.afscript" }
+                    }
+                },
+                {
+                    name: "keyword.control.directive.afscript",
+                    match: "\\b(run|set|if|else|after|with|and|or)\\b|\\btransition to\\b"
+                },
+                {
+                    name: "keyword.action-call.afscript",
+                    match: "(@action)(\\.)",
+                    captures: {
+                        "1": { name: "support.class.afscript" },
+                        "2": { name: "punctuation.accessor.dot.afscript" }
+                    }
+                },
+                {
+                    name: "keyword.variable-set.afscript",
+                    match: "(@variable)(\\.)",
+                    captures: {
+                        "1": { name: "support.class.afscript" },
+                        "2": { name: "punctuation.accessor.dot.afscript" }
+                    }
+                },
+                {
+                    name: "keyword.topic-ref.afscript",
+                    match: "(@topic)(\\.)",
+                    captures: {
+                        "1": { name: "support.class.afscript" },
+                        "2": { name: "punctuation.accessor.dot.afscript" }
+                    }
+                },
+                {
+                    name: "keyword.result-ref.afscript",
+                    match: "(@result)(\\.)",
+                    captures: {
+                        "1": { name: "support.class.afscript" },
+                        "2": { name: "punctuation.accessor.dot.afscript" }
+                    }
+                },
+                {
+                    name: "keyword.input-ref.afscript",
+                    match: "(@input)(\\.)",
+                    captures: {
+                        "1": { name: "support.class.afscript" },
+                        "2": { name: "punctuation.accessor.dot.afscript" }
+                    }
+                },
+                {
+                    name: "variable.other.member.afscript",
+                    match: "(?<=@(?:variable|topic|input|action|result)\\.)\\b[a-zA-Z_][a-zA-Z0-9_]*\\b"
+                },
+                { include: "#operators" },
+                { include: "#values" }
+            ]
+        },
+        "template-expression": {
+            name: "meta.template.expression.afscript",
+            begin: "\\{\\{",
+            beginCaptures: {
+                "0": {
+                    name: "punctuation.definition.template.begin.afscript"
+                }
+            },
+            end: "\\}\\}",
+            endCaptures: {
+                "0": { name: "punctuation.definition.template.end.afscript" }
+            },
+            patterns: [
+                {
+                    name: "string.quoted.single.expression.afscript",
+                    begin: "'",
+                    end: "'",
+                    patterns: [
+                        {
+                            name: "constant.character.escape.afscript",
+                            match: "\\\\."
+                        }
+                    ]
+                },
+                {
+                    name: "string.quoted.double.expression.afscript",
+                    begin: '"',
+                    end: '"',
+                    patterns: [
+                        {
+                            name: "constant.character.escape.afscript",
+                            match: "\\\\."
+                        }
+                    ]
+                },
+                {
+                    name: "constant.numeric.expression.afscript",
+                    match: "\\b\\d+(\\.\\d+)?\\b"
+                },
+                {
+                    name: "constant.language.expression.afscript",
+                    match: "\\b(True|False)\\b"
+                },
+                {
+                    name: "keyword.operator.expression.afscript",
+                    match: "\\b(and|or|if|else)\\b"
+                },
+                {
+                    name: "operator.comparison.expression.afscript",
+                    match: "==|!=|<=|>=|<|>"
+                },
+                {
+                    name: "operator.arithmetic.expression.afscript",
+                    match: "[+\\-\\*/%]"
+                },
+                {
+                    name: "meta.variable.reference.expression.afscript",
+                    match: "(@)([a-zA-Z_][a-zA-Z0-9_]*)(\\.)([a-zA-Z_][a-zA-Z0-9_]*)\\b",
+                    captures: {
+                        "1": { name: "support.class.afscript" },
+                        "2": { name: "support.class.afscript" },
+                        "3": { name: "punctuation.accessor.dot.afscript" },
+                        "4": { name: "variable.other.member.afscript" }
+                    }
+                },
+                {
+                    name: "variable.other.expression.afscript",
+                    match: "\\b[a-zA-Z_][a-zA-Z0-9_]*\\b"
+                },
+                {
+                    name: "punctuation.definition.expression.afscript",
+                    match: "[()\\[\\]@.,]"
+                }
+            ]
+        },
+        "json-value": {
+            patterns: [
+                {
+                    name: "constant.language.json.afscript",
+                    match: "\\b(true|false|null)\\b"
+                },
+                {
+                    name: "constant.numeric.json.afscript",
+                    match: "-?\\d+(\\.\\d+)?([eE][+-]?\\d+)?"
+                },
+                {
+                    name: "string.quoted.double.json.afscript",
+                    begin: '"',
+                    end: '"',
+                    patterns: [
+                        {
+                            name: "constant.character.escape.json.afscript",
+                            match: "\\\\."
+                        }
+                    ]
+                },
+                {
+                    name: "meta.structure.dictionary.json.afscript",
+                    begin: "\\{",
+                    beginCaptures: {
+                        "0": {
+                            name: "punctuation.definition.dictionary.begin.json.afscript"
+                        }
+                    },
+                    end: "\\}",
+                    endCaptures: {
+                        "0": {
+                            name: "punctuation.definition.dictionary.end.json.afscript"
+                        }
+                    },
+                    patterns: [
+                        {
+                            name: "meta.structure.dictionary.key.json.afscript",
+                            begin: '"',
+                            end: '"',
+                            patterns: [
+                                {
+                                    name: "constant.character.escape.json.afscript",
+                                    match: "\\\\."
+                                }
+                            ]
+                        },
+                        {
+                            name: "punctuation.separator.dictionary.key-value.json.afscript",
+                            match: ":"
+                        },
+                        {
+                            name: "punctuation.separator.dictionary.pair.json.afscript",
+                            match: ","
+                        },
+                        { include: "#json-value" }
+                    ]
+                },
+                {
+                    name: "meta.structure.array.json.afscript",
+                    begin: "\\[",
+                    beginCaptures: {
+                        "0": {
+                            name: "punctuation.definition.array.begin.json.afscript"
+                        }
+                    },
+                    end: "\\]",
+                    endCaptures: {
+                        "0": {
+                            name: "punctuation.definition.array.end.json.afscript"
+                        }
+                    },
+                    patterns: [
+                        {
+                            name: "punctuation.separator.array.json.afscript",
+                            match: ","
+                        },
+                        { include: "#json-value" }
+                    ]
+                }
+            ]
+        },
+        punctuation: {
+            patterns: [
+                {
+                    name: "punctuation.separator.key-value.afscript",
+                    match: ":"
+                },
+                {
+                    name: "punctuation.separator.list.afscript",
+                    match: ","
+                },
+                {
+                    name: "punctuation.definition.brackets.afscript",
+                    match: "[{}\\[\\]()]"
+                },
+                {
+                    name: "punctuation.accessor.dot.afscript",
+                    match: "\\."
+                }
+            ]
+        },
+        operators: {
+            patterns: [
+                {
+                    name: "operator.comparison.afscript",
+                    match: "==|!=|<=|>=|<|>"
+                },
+                {
+                    name: "operator.assignment.afscript",
+                    match: '\\s=\\s|\\s=(?=[\\{\\["\\d])|(?<=[a-zA-Z_])\\s*=\\s*'
+                },
+                {
+                    name: "operator.arithmetic.afscript",
+                    match: "[+\\-\\*%]"
+                },
+                {
+                    name: "punctuation.separator.path.afscript",
+                    match: "/"
+                }
+            ]
+        }
+    }
+};
+export function getCustomLanguageGrammars() {
+    return {
+        dataweave: dataweaveGrammar,
+        ampscript: ampscriptGrammar,
+        afscript: afscriptGrammar
+    };
+}