ver 2009.12.14 → 2010.02

data/config/syntax/Doxygen.rb

@@ -0,0 +1,31 @@
+# Encoding: UTF-8
+
+{fileTypes: ["doxygen"],
+ name: "Doxygen",
+ patterns: 
+  [{begin: /\/\*\*\<?/,
+    captures: {0 => {name: "punctuation.definition.comment.doxygen"}},
+    end: "\\*\\/",
+    name: "comment.block.doxygen",
+    patterns: [{include: "#source_doxygen"}]},
+   {begin: /\/\*!\<?/,
+    captures: {0 => {name: "punctuation.definition.comment.doxygen"}},
+    end: "\\*\\/",
+    name: "comment.block.doxygen",
+    patterns: [{include: "#source_doxygen"}]},
+   {begin: /\/\/[\/!]\<?/,
+    beginCaptures: {0 => {name: "punctuation.definition.comment.doxygen"}},
+    end: "$\\n?",
+    name: "comment.line.doxygen",
+    patterns: [{include: "#source_doxygen"}]}],
+ repository: 
+  {keywords: 
+    {patterns: 
+      [{captures: {1 => {name: "punctuation.definition.keyword.doxygen"}},
+        match: 
+         /([\\@])((a|addindex|addtogroup|anchor|arg|attention|author|b|brief|bug|c|callgraph|callergraph|category|class|code|cond|copydoc|date|def|defgroup|deprecated|dir|dontinclude|dot|dotfile|e|else|elseif|em|endcode|endcond|enddot|endhtmlonly|endif|endlatexonly|endlink|endmanonly|endverbatim|endxmlonly|enum|example|exception|file|fn|hideinitializer|htmlinclude|htmlonly|if|ifnot|image|include|includelineno|ingroup|internal|invariant|interface|latexonly|li|line|link|mainpage|manonly|n|name|namespace|nosubgrouping|note|overload|p|package|page|par|paragraph|param|post|pre|private|privatesection|property|protected|protectedsection|protocol|public|publicsection|ref|relates|relatesalso|remarks|return|retval|sa|section|see|showinitializer|since|skip|skipline|struct|subpage|subsection|subsubsection|test|throw|todo|typedef|union|until|var|verbatim|verbinclude|version|warning|weakgroup|xmlonly|xrefitem)\b|(\$|\@|\\|\&|\~|\<|\>|\#|\%|f\$|f\[|f\]))/,
+        name: "keyword.control.doxygen"}]},
+   source_doxygen: 
+    {patterns: [{include: "#keywords"}, {include: "text.html.basic"}]}},
+ scopeName: "text.html.doxygen",
+ uuid: "9725E602-6D7C-4E98-911A-C66802142451"}

data/config/syntax/Dylan.rb

@@ -0,0 +1,53 @@
+# Encoding: UTF-8
+
+{fileTypes: ["dylan"],
+ foldingStartMarker: /\b(define|begin|block)\b/,
+ foldingStopMarker: /\bend\b/,
+ keyEquivalent: "^~D",
+ name: "Dylan",
+ patterns: 
+  [{begin: /\/\*/,
+    captures: {0 => {name: "punctuation.definition.comment.dylan"}},
+    comment: "TODO -- Dylan allows nested comments.",
+    end: "\\*/",
+    name: "comment.block.dylan"},
+   {begin: /\/\//,
+    beginCaptures: {0 => {name: "punctuation.definition.comment.dylan"}},
+    end: "$\\n?",
+    name: "comment.line.double-slash.dylan",
+    patterns: 
+     [{match: /(?>\\\s*\n)/,
+       name: "punctuation.separator.continuation.dylan"}]},
+   {begin: 
+     /\b(define\s+)((?:sealed|inline)\s)?(method|function)\s+([A-Za-z0-9\\-]*[!?]?)\s/,
+    captures: 
+     {1 => {name: "keyword.control.def.dylan"},
+      2 => {name: "storage.modifier.dylan"},
+      3 => {name: "storage.type.function.dylan"},
+      4 => {name: "entity.name.function.dylan"}},
+    end: "\\)",
+    name: "meta.function.dylan"},
+   {match: 
+     /\b(?<!-)(begin|block|case|class|constant|define|domain|else|end|for|function|handler|if|inline|let|library|local|macro|method|module|otherwise|select|unless|until|variable|when|while)(?![:-])\b/,
+    name: "keyword.control.dylan"},
+   {match: /(#t|#f|#next|#rest|#key|#all-keys|#include)/,
+    name: "support.constant.language.dylan"},
+   {match: /\b(sealed|open|abstract|concrete|primary|free)\b/,
+    name: "keyword.control.sealing-directives.dylan"},
+   {match: 
+     /\b((#x[0-9a-fA-F]*)|(([0-9]+\.?[0-9]*)|(\.[0-9]+))((e|E)(\+|-)?[0-9]+)?)\b/,
+    name: "constant.numeric.dylan"},
+   {begin: /"/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.dylan"}},
+    end: "\"",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.dylan"}},
+    name: "string.quoted.double.dylan",
+    patterns: [{match: /\\./, name: "constant.character.escape.dylan"}]},
+   {match: 
+     /<(abort|array|boolean|byte-string|character|class|collection|complex|condition|deque|double-float|empty-list|error|explicit-key-collection|extended-float|float|function|generic-function|integer|list|method|mutable-collection|mutable-explicit-key-collection|mutable-sequence|number|object-table|object|pair|range|rational|real|restart|sealed-object-error|sequence|serious-condition|simple-error|simple-object-vector|simple-restart|simple-vector|simple-warning|single-float|singleton|stretchy-collection|stretchy-vector|string|symbol|table|type-error|type|unicode-string|vector|warning)>/,
+    name: "support.class.dylan"},
+   {match: 
+     /\b(?<!-)(abort|abs|add|add!|add-method|add-new|add-new!|all-superclasses|always|any?|applicable-method?|apply|aref|aref-setter|as|as-lowercase|as-lowercase!|as-uppercase|as-uppercase!|ash|backward-iteration-protocol|break|ceiling|ceiling\/|cerror|check-type|choose|choose-by|complement|compose|concatenate|concatenate-as|condition-format-arguments|condition-format-string|conjoin|copy-sequence|curry|default-handler|dimension|dimensions|direct-subclasses|direct-superclasses|disjoin|do|do-handlers|element|element-setter|empty?|error|even?|every?|fill!|find-key|find-method|first|first-setter|floor|floor\/|forward-iteration-protocol|function-arguments|function-return-values|function-specializers|gcd|generic-function-mandatory-|keywords|generic-function-methods|head|head-setter|identity|initialize|instance?|integral?|intersection|key-sequence|key-test|last|last-setter|lcm|limited|list|logand|logbit?|logior|lognot|logxor|make|map|map-as|map-into|max|member?|merge-hash-codes|min|modulo|negative|negative?|object-class|object-hash|odd?|pair|pop|pop-last|positive?|push|push-last|range|rank|rcurry|reduce|reduce1|remainder|remove|remove!|remove-duplicates|remove-duplicates!|remove-key!|remove-method|replace-elements!|replace-subsequence!|restart-query|return-allowed?|return-description|return-query|reverse|reverse!|round|round\/|row-major-index|second|second-setter|shallow-copy|signal|singleton|size|size-setter|slot-initialized?|sort|sort!|sorted-applicable-methods|subsequence-position|subtype?|table-protocol|tail|tail-setter|third|third-setter|truncate|truncate\/|type-error-expected-type|type-error-value|type-for-copy|type-union|union|values|vector|zero?)(?![:-])\b/,
+    name: "support.function.dylan"}],
+ scopeName: "source.dylan",
+ uuid: "475B8369-3520-4B4C-BBA1-1D1229C6F397"}

data/config/syntax/Eiffel.rb

@@ -0,0 +1,52 @@
+# Encoding: UTF-8
+
+{fileTypes: ["e"],
+ foldingStartMarker: /(class|once|do|external)/,
+ foldingStopMarker: /(ensure|end)/,
+ keyEquivalent: "^~E",
+ name: "Eiffel",
+ patterns: 
+  [{captures: {1 => {name: "punctuation.definition.comment.eiffel"}},
+    match: /(--).*$\n?/,
+    name: "comment.line.double-dash.eiffel"},
+   {match: 
+     /\b(Indexing|indexing|deferred|expanded|class|inherit|rename|as|export|undefine|redefine|select|all|create|creation|feature|prefix|infix|separate|frozen|obsolete|local|is|unique|do|once|external|alias|require|ensure|invariant|variant|rescue|retry|like|check|if|else|elseif|then|inspect|when|from|loop|until|debug|not|or|and|xor|implies|old|end)\b/,
+    name: "keyword.control.eiffel"},
+   {match: /[a-zA-Z_]+/, name: "variable.other.eiffel"},
+   {match: /\b(True|true|False|false|Void|void|Result|result)\b/,
+    name: "constant.language.eiffel"},
+   {begin: /feature/, end: "end", name: "meta.features.eiffel"},
+   {begin: /(do|once)/,
+    end: "(ensure|end)",
+    name: "meta.effective_routine_body.eiffel"},
+   {begin: /rescue/, end: "end", name: "meta.rescue.eiffel"},
+   {begin: /"/,
+    beginCaptures: {0 => {name: "punctuation.definition.string.begin.eiffel"}},
+    end: "\"",
+    endCaptures: {0 => {name: "punctuation.definition.string.end.eiffel"}},
+    name: "string.quoted.double.eiffel",
+    patterns: [{match: /\\./, name: "constant.character.escape.eiffel"}]},
+   {match: /[0-9]+/, name: "constant.numeric.eiffel"},
+   {match: /\b(deferred|expanded)\b/, name: "storage.modifier.eiffel"},
+   {begin: 
+     /^\s*
+	((?:\b(deferred|expanded)\b\s*)*) # modifier
+	(class)\s+
+	(\w+)\s* # identifier/,
+    captures: {1 => {name: "storage.modifier.eiffel"}},
+    end: "(?=end)",
+    name: "meta.definition.class.eiffel",
+    patterns: 
+     [{begin: /\b(extends)\b\s+/,
+       captures: {1 => {name: "storage.modifier.java"}},
+       end: "(?={|implements)",
+       name: "meta.definition.class.extends.java",
+       patterns: [{include: "#all-types"}]},
+      {begin: /\b(implements)\b\s+/,
+       captures: {1 => {name: "storage.modifier.java"}},
+       end: "(?={|extends)",
+       name: "meta.definition.class.implements.java",
+       patterns: [{include: "#all-types"}]}]}],
+ repository: {number: {match: /[0-9]+/}, variable: {match: /[a-zA-Z0-9_]+/}},
+ scopeName: "source.eiffel",
+ uuid: "34672373-DED9-45B8-AF7E-2E4B6C3D6B76"}

data/config/syntax/Erlang.rb

@@ -0,0 +1,632 @@
+# Encoding: UTF-8
+
+{comment: 
+  "The recognition of function definitions and compiler directives (such as module, record and macro definitions) requires that each of the aforementioned constructs must be the first string inside a line (except for whitespace).  Also, the function/module/record/macro names must be given unquoted.  -- desp",
+ fileTypes: ["erl", "hrl"],
+ keyEquivalent: "^~E",
+ name: "Erlang",
+ patterns: 
+  [{include: "#module-directive"},
+   {include: "#import-export-directive"},
+   {include: "#record-directive"},
+   {include: "#define-directive"},
+   {include: "#macro-directive"},
+   {include: "#directive"},
+   {include: "#function"},
+   {include: "#everything-else"}],
+ repository: 
+  {atom: 
+    {patterns: 
+      [{begin: /(')/,
+        beginCaptures: 
+         {1 => {name: "punctuation.definition.symbol.begin.erlang"}},
+        end: "(')",
+        endCaptures: {1 => {name: "punctuation.definition.symbol.end.erlang"}},
+        name: "constant.other.symbol.quoted.single.erlang",
+        patterns: 
+         [{captures: 
+            {1 => {name: "punctuation.definition.escape.erlang"},
+             3 => {name: "punctuation.definition.escape.erlang"}},
+           match: /(\\)([bdefnrstv\\'"]|(\^)[@-_]|[0-7]{1,3})/,
+           name: "constant.other.symbol.escape.erlang"},
+          {match: /\\\^?.?/, name: "invalid.illegal.atom.erlang"}]},
+       {match: /[a-z][a-zA-Z\d@_]*+/,
+        name: "constant.other.symbol.unquoted.erlang"}]},
+   binary: 
+    {begin: /(<<)/,
+     beginCaptures: 
+      {1 => {name: "punctuation.definition.binary.begin.erlang"}},
+     end: "(>>)",
+     endCaptures: {1 => {name: "punctuation.definition.binary.end.erlang"}},
+     name: "meta.structure.binary.erlang",
+     patterns: 
+      [{captures: 
+         {1 => {name: "punctuation.separator.binary.erlang"},
+          2 => {name: "punctuation.separator.value-size.erlang"}},
+        match: /(,)|(:)/},
+       {include: "#internal-type-specifiers"},
+       {include: "#everything-else"}]},
+   character: 
+    {patterns: 
+      [{captures: 
+         {1 => {name: "punctuation.definition.character.erlang"},
+          2 => {name: "constant.character.escape.erlang"},
+          3 => {name: "punctuation.definition.escape.erlang"},
+          5 => {name: "punctuation.definition.escape.erlang"}},
+        match: /(\$)((\\)([bdefnrstv\\'"]|(\^)[@-_]|[0-7]{1,3}))/,
+        name: "constant.character.erlang"},
+       {match: /\$\\\^?.?/, name: "invalid.illegal.character.erlang"},
+       {captures: {1 => {name: "punctuation.definition.character.erlang"}},
+        match: /(\$)\S/,
+        name: "constant.character.erlang"},
+       {match: /\$.?/, name: "invalid.illegal.character.erlang"}]},
+   comment: 
+    {begin: /(%)/,
+     beginCaptures: {1 => {name: "punctuation.definition.comment.erlang"}},
+     end: "$\\n?",
+     name: "comment.line.erlang"},
+   :"define-directive" => 
+    {patterns: 
+      [{begin: /^\s*+(-)\s*+(define)\s*+(\()\s*+([a-zA-Z\d@_]++)\s*+(,)/,
+        beginCaptures: 
+         {1 => {name: "punctuation.section.directive.begin.erlang"},
+          2 => {name: "keyword.control.directive.define.erlang"},
+          3 => {name: "punctuation.definition.parameters.begin.erlang"},
+          4 => {name: "entity.name.function.macro.definition.erlang"},
+          5 => {name: "punctuation.separator.parameters.erlang"}},
+        end: "(\\))\\s*+(\\.)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.parameters.end.erlang"},
+          2 => {name: "punctuation.section.directive.end.erlang"}},
+        name: "meta.directive.define.erlang",
+        patterns: [{include: "#everything-else"}]},
+       {begin: /(?=^\s*+-\s*+define\s*+\(\s*+[a-zA-Z\d@_]++\s*+\()/,
+        end: "(\\))\\s*+(\\.)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.parameters.end.erlang"},
+          2 => {name: "punctuation.section.directive.end.erlang"}},
+        name: "meta.directive.define.erlang",
+        patterns: 
+         [{begin: /^\s*+(-)\s*+(define)\s*+(\()\s*+([a-zA-Z\d@_]++)\s*+(\()/,
+           beginCaptures: 
+            {1 => {name: "punctuation.section.directive.begin.erlang"},
+             2 => {name: "keyword.control.directive.define.erlang"},
+             3 => {name: "punctuation.definition.parameters.begin.erlang"},
+             4 => {name: "entity.name.function.macro.definition.erlang"},
+             5 => {name: "punctuation.definition.parameters.begin.erlang"}},
+           end: "(\\))\\s*(,)",
+           endCaptures: 
+            {1 => {name: "punctuation.definition.parameters.end.erlang"},
+             2 => {name: "punctuation.separator.parameters.erlang"}},
+           patterns: 
+            [{match: /,/, name: "punctuation.separator.parameters.erlang"},
+             {include: "#everything-else"}]},
+          {match: /\|\||\||:|;|,|\.|->/,
+           name: "punctuation.separator.define.erlang"},
+          {include: "#everything-else"}]}]},
+   directive: 
+    {patterns: 
+      [{begin: /^\s*+(-)\s*+([a-z][a-zA-Z\d@_]*+)\s*+(\()/,
+        beginCaptures: 
+         {1 => {name: "punctuation.section.directive.begin.erlang"},
+          2 => {name: "keyword.control.directive.erlang"},
+          3 => {name: "punctuation.definition.parameters.begin.erlang"}},
+        end: "(\\))\\s*+(\\.)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.parameters.end.erlang"},
+          2 => {name: "punctuation.section.directive.end.erlang"}},
+        name: "meta.directive.erlang",
+        patterns: [{include: "#everything-else"}]},
+       {captures: 
+         {1 => {name: "punctuation.section.directive.begin.erlang"},
+          2 => {name: "keyword.control.directive.erlang"},
+          3 => {name: "punctuation.section.directive.end.erlang"}},
+        match: /^\s*+(-)\s*+([a-z][a-zA-Z\d@_]*+)\s*+(\.)/,
+        name: "meta.directive.erlang"}]},
+   :"everything-else" => 
+    {patterns: 
+      [{include: "#comment"},
+       {include: "#record-usage"},
+       {include: "#macro-usage"},
+       {include: "#expression"},
+       {include: "#keyword"},
+       {include: "#textual-operator"},
+       {include: "#function-call"},
+       {include: "#tuple"},
+       {include: "#list"},
+       {include: "#binary"},
+       {include: "#parenthesized-expression"},
+       {include: "#character"},
+       {include: "#number"},
+       {include: "#atom"},
+       {include: "#string"},
+       {include: "#symbolic-operator"},
+       {include: "#variable"}]},
+   expression: 
+    {patterns: 
+      [{begin: /\b(if)\b/,
+        beginCaptures: {1 => {name: "keyword.control.if.erlang"}},
+        end: "\\b(end)\\b",
+        endCaptures: {1 => {name: "keyword.control.end.erlang"}},
+        name: "meta.expression.if.erlang",
+        patterns: 
+         [{include: "#internal-expression-punctuation"},
+          {include: "#everything-else"}]},
+       {begin: /\b(case)\b/,
+        beginCaptures: {1 => {name: "keyword.control.case.erlang"}},
+        end: "\\b(end)\\b",
+        endCaptures: {1 => {name: "keyword.control.end.erlang"}},
+        name: "meta.expression.case.erlang",
+        patterns: 
+         [{include: "#internal-expression-punctuation"},
+          {include: "#everything-else"}]},
+       {begin: /\b(receive)\b/,
+        beginCaptures: {1 => {name: "keyword.control.receive.erlang"}},
+        end: "\\b(end)\\b",
+        endCaptures: {1 => {name: "keyword.control.end.erlang"}},
+        name: "meta.expression.receive.erlang",
+        patterns: 
+         [{include: "#internal-expression-punctuation"},
+          {include: "#everything-else"}]},
+       {captures: 
+         {1 => {name: "keyword.control.fun.erlang"},
+          3 => {name: "entity.name.type.class.module.erlang"},
+          4 => {name: "punctuation.separator.module-function.erlang"},
+          5 => {name: "entity.name.function.erlang"},
+          6 => {name: "punctuation.separator.function-arity.erlang"}},
+        match: 
+         /\b(fun)\s*+(([a-z][a-zA-Z\d@_]*+)\s*+(:)\s*+)?([a-z][a-zA-Z\d@_]*+)\s*(\/)/},
+       {begin: /\b(fun)\b/,
+        beginCaptures: {1 => {name: "keyword.control.fun.erlang"}},
+        end: "\\b(end)\\b",
+        endCaptures: {1 => {name: "keyword.control.end.erlang"}},
+        name: "meta.expression.fun.erlang",
+        patterns: 
+         [{begin: /(?=\()/,
+           end: "(;)|(?=\\bend\\b)",
+           endCaptures: {1 => {name: "punctuation.separator.clauses.erlang"}},
+           patterns: [{include: "#internal-function-parts"}]},
+          {include: "#everything-else"}]},
+       {begin: /\b(try)\b/,
+        beginCaptures: {1 => {name: "keyword.control.try.erlang"}},
+        end: "\\b(end)\\b",
+        endCaptures: {1 => {name: "keyword.control.end.erlang"}},
+        name: "meta.expression.try.erlang",
+        patterns: 
+         [{include: "#internal-expression-punctuation"},
+          {include: "#everything-else"}]},
+       {begin: /\b(begin)\b/,
+        beginCaptures: {1 => {name: "keyword.control.begin.erlang"}},
+        end: "\\b(end)\\b",
+        endCaptures: {1 => {name: "keyword.control.end.erlang"}},
+        name: "meta.expression.begin.erlang",
+        patterns: 
+         [{include: "#internal-expression-punctuation"},
+          {include: "#everything-else"}]},
+       {begin: /\b(query)\b/,
+        beginCaptures: {1 => {name: "keyword.control.query.erlang"}},
+        end: "\\b(end)\\b",
+        endCaptures: {1 => {name: "keyword.control.end.erlang"}},
+        name: "meta.expression.query.erlang",
+        patterns: [{include: "#everything-else"}]}]},
+   function: 
+    {begin: /^\s*+([a-z][a-zA-Z\d@_]*+)\s*+(?=\()/,
+     beginCaptures: {1 => {name: "entity.name.function.definition.erlang"}},
+     end: "(\\.)",
+     endCaptures: {1 => {name: "punctuation.terminator.function.erlang"}},
+     name: "meta.function.erlang",
+     patterns: 
+      [{captures: {1 => {name: "entity.name.function.erlang"}},
+        match: /^\s*+([a-z][a-zA-Z\d@_]*+)\s*+(?=\()/},
+       {begin: /(?=\()/,
+        end: "(;)|(?=\\.)",
+        endCaptures: {1 => {name: "punctuation.separator.clauses.erlang"}},
+        patterns: 
+         [{include: "#parenthesized-expression"},
+          {include: "#internal-function-parts"}]},
+       {include: "#everything-else"}]},
+   :"function-call" => 
+    {begin: /(?=[a-z][a-zA-Z\d@_]*+\s*+(\(|:\s*+[a-z][a-zA-Z\d@_]*+\s*+\())/,
+     end: "(\\))",
+     endCaptures: 
+      {1 => {name: "punctuation.definition.parameters.end.erlang"}},
+     name: "meta.function-call.erlang",
+     patterns: 
+      [{begin: 
+         /((erlang)\s*+(:)\s*+)?(is_atom|is_binary|is_constant|is_float|is_function|is_integer|is_list|is_number|is_pid|is_port|is_reference|is_tuple|is_record|abs|element|hd|length|node|round|self|size|tl|trunc)\s*+(\()/,
+        beginCaptures: 
+         {2 => {name: "entity.name.type.class.module.erlang"},
+          3 => {name: "punctuation.separator.module-function.erlang"},
+          4 => {name: "entity.name.function.guard.erlang"},
+          5 => {name: "punctuation.definition.parameters.begin.erlang"}},
+        end: "(?=\\))",
+        patterns: 
+         [{match: /,/, name: "punctuation.separator.parameters.erlang"},
+          {include: "#everything-else"}]},
+       {begin: 
+         /(([a-z][a-zA-Z\d@_]*+)\s*+(:)\s*+)?([a-z][a-zA-Z\d@_]*+)\s*+(\()/,
+        beginCaptures: 
+         {2 => {name: "entity.name.type.class.module.erlang"},
+          3 => {name: "punctuation.separator.module-function.erlang"},
+          4 => {name: "entity.name.function.erlang"},
+          5 => {name: "punctuation.definition.parameters.begin.erlang"}},
+        end: "(?=\\))",
+        patterns: 
+         [{match: /,/, name: "punctuation.separator.parameters.erlang"},
+          {include: "#everything-else"}]}]},
+   :"import-export-directive" => 
+    {patterns: 
+      [{begin: /^\s*+(-)\s*+(import)\s*+(\()\s*+([a-z][a-zA-Z\d@_]*+)\s*+(,)/,
+        beginCaptures: 
+         {1 => {name: "punctuation.section.directive.begin.erlang"},
+          2 => {name: "keyword.control.directive.import.erlang"},
+          3 => {name: "punctuation.definition.parameters.begin.erlang"},
+          4 => {name: "entity.name.type.class.module.erlang"},
+          5 => {name: "punctuation.separator.parameters.erlang"}},
+        end: "(\\))\\s*+(\\.)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.parameters.end.erlang"},
+          2 => {name: "punctuation.section.directive.end.erlang"}},
+        name: "meta.directive.import.erlang",
+        patterns: [{include: "#internal-function-list"}]},
+       {begin: /^\s*+(-)\s*+(export)\s*+(\()/,
+        beginCaptures: 
+         {1 => {name: "punctuation.section.directive.begin.erlang"},
+          2 => {name: "keyword.control.directive.export.erlang"},
+          3 => {name: "punctuation.definition.parameters.begin.erlang"}},
+        end: "(\\))\\s*+(\\.)",
+        endCaptures: 
+         {1 => {name: "punctuation.definition.parameters.end.erlang"},
+          2 => {name: "punctuation.section.directive.end.erlang"}},
+        name: "meta.directive.export.erlang",
+        patterns: [{include: "#internal-function-list"}]}]},
+   :"internal-expression-punctuation" => 
+    {captures: 
+      {1 => {name: "punctuation.separator.clause-head-body.erlang"},
+       2 => {name: "punctuation.separator.clauses.erlang"},
+       3 => {name: "punctuation.separator.expressions.erlang"}},
+     match: /(->)|(;)|(,)/},
+   :"internal-function-list" => 
+    {begin: /(\[)/,
+     beginCaptures: {1 => {name: "punctuation.definition.list.begin.erlang"}},
+     end: "(\\])",
+     endCaptures: {1 => {name: "punctuation.definition.list.end.erlang"}},
+     name: "meta.structure.list.function.erlang",
+     patterns: 
+      [{begin: /([a-z][a-zA-Z\d@_]*+)\s*+(\/)/,
+        beginCaptures: 
+         {1 => {name: "entity.name.function.erlang"},
+          2 => {name: "punctuation.separator.function-arity.erlang"}},
+        end: "(,)|(?=\\])",
+        endCaptures: {1 => {name: "punctuation.separator.list.erlang"}},
+        patterns: [{include: "#everything-else"}]},
+       {include: "#everything-else"}]},
+   :"internal-function-parts" => 
+    {patterns: 
+      [{begin: /(?=\()/,
+        end: "(->)",
+        endCaptures: 
+         {1 => {name: "punctuation.separator.clause-head-body.erlang"}},
+        patterns: 
+         [{begin: /(\()/,
+           beginCaptures: 
+            {1 => {name: "punctuation.definition.parameters.begin.erlang"}},
+           end: "(\\))",
+           endCaptures: 
+            {1 => {name: "punctuation.definition.parameters.end.erlang"}},
+           patterns: 
+            [{match: /,/, name: "punctuation.separator.parameters.erlang"},
+             {include: "#everything-else"}]},
+          {match: /,|;/, name: "punctuation.separator.guards.erlang"},
+          {include: "#everything-else"}]},
+       {match: /,/, name: "punctuation.separator.expressions.erlang"},
+       {include: "#everything-else"}]},
+   :"internal-record-body" => 
+    {begin: /(\{)/,
+     beginCaptures: 
+      {1 => {name: "punctuation.definition.class.record.begin.erlang"}},
+     end: "(?=\\})",
+     name: "meta.structure.record.erlang",
+     patterns: 
+      [{begin: /(([a-z][a-zA-Z\d@_]*+)|(_))\s*+(=)/,
+        beginCaptures: 
+         {2 => {name: "variable.other.field.erlang"},
+          3 => {name: "variable.language.omitted.field.erlang"},
+          4 => {name: "keyword.operator.assignment.erlang"}},
+        end: "(,)|(?=\\})",
+        endCaptures: 
+         {1 => {name: "punctuation.separator.class.record.erlang"}},
+        patterns: [{include: "#everything-else"}]},
+       {captures: 
+         {1 => {name: "variable.other.field.erlang"},
+          2 => {name: "punctuation.separator.class.record.erlang"}},
+        match: /([a-z][a-zA-Z\d@_]*+)\s*+(,)?/},
+       {include: "#everything-else"}]},
+   :"internal-type-specifiers" => 
+    {begin: /(\/)/,
+     beginCaptures: {1 => {name: "punctuation.separator.value-type.erlang"}},
+     end: "(?=,|:|>>)",
+     patterns: 
+      [{captures: 
+         {1 => {name: "storage.type.erlang"},
+          2 => {name: "storage.modifier.signedness.erlang"},
+          3 => {name: "storage.modifier.endianness.erlang"},
+          4 => {name: "storage.modifier.unit.erlang"},
+          5 => {name: "punctuation.separator.type-specifiers.erlang"}},
+        match: 
+         /(integer|float|binary)|(signed|unsigned)|(big|little|native)|(unit)|(-)/}]},
+   keyword: 
+    {match: 
+      /\b(after|begin|case|catch|cond|end|fun|if|let|of|query|try|receive|when)\b/,
+     name: "keyword.control.erlang"},
+   list: 
+    {begin: /(\[)/,
+     beginCaptures: {1 => {name: "punctuation.definition.list.begin.erlang"}},
+     end: "(\\])",
+     endCaptures: {1 => {name: "punctuation.definition.list.end.erlang"}},
+     name: "meta.structure.list.erlang",
+     patterns: 
+      [{match: /\||\|\||,/, name: "punctuation.separator.list.erlang"},
+       {include: "#everything-else"}]},
+   :"macro-directive" => 
+    {patterns: 
+      [{captures: 
+         {1 => {name: "punctuation.section.directive.begin.erlang"},
+          2 => {name: "keyword.control.directive.ifdef.erlang"},
+          3 => {name: "punctuation.definition.parameters.begin.erlang"},
+          4 => {name: "entity.name.function.macro.erlang"},
+          5 => {name: "punctuation.definition.parameters.end.erlang"},
+          6 => {name: "punctuation.section.directive.end.erlang"}},
+        match: 
+         /^\s*+(-)\s*+(ifdef)\s*+(\()\s*+([a-zA-z\d@_]++)\s*+(\))\s*+(\.)/,
+        name: "meta.directive.ifdef.erlang"},
+       {captures: 
+         {1 => {name: "punctuation.section.directive.begin.erlang"},
+          2 => {name: "keyword.control.directive.ifndef.erlang"},
+          3 => {name: "punctuation.definition.parameters.begin.erlang"},
+          4 => {name: "entity.name.function.macro.erlang"},
+          5 => {name: "punctuation.definition.parameters.end.erlang"},
+          6 => {name: "punctuation.section.directive.end.erlang"}},
+        match: 
+         /^\s*+(-)\s*+(ifndef)\s*+(\()\s*+([a-zA-z\d@_]++)\s*+(\))\s*+(\.)/,
+        name: "meta.directive.ifndef.erlang"},
+       {captures: 
+         {1 => {name: "punctuation.section.directive.begin.erlang"},
+          2 => {name: "keyword.control.directive.undef.erlang"},
+          3 => {name: "punctuation.definition.parameters.begin.erlang"},
+          4 => {name: "entity.name.function.macro.erlang"},
+          5 => {name: "punctuation.definition.parameters.end.erlang"},
+          6 => {name: "punctuation.section.directive.end.erlang"}},
+        match: 
+         /^\s*+(-)\s*+(undef)\s*+(\()\s*+([a-zA-z\d@_]++)\s*+(\))\s*+(\.)/,
+        name: "meta.directive.undef.erlang"}]},
+   :"macro-usage" => 
+    {captures: 
+      {1 => {name: "keyword.operator.macro.erlang"},
+       2 => {name: "entity.name.function.macro.erlang"}},
+     match: /(\?\??)\s*+([a-zA-Z\d@_]++)/,
+     name: "meta.macro-usage.erlang"},
+   :"module-directive" => 
+    {captures: 
+      {1 => {name: "punctuation.section.directive.begin.erlang"},
+       2 => {name: "keyword.control.directive.module.erlang"},
+       3 => {name: "punctuation.definition.parameters.begin.erlang"},
+       4 => {name: "entity.name.type.class.module.definition.erlang"},
+       5 => {name: "punctuation.definition.parameters.end.erlang"},
+       6 => {name: "punctuation.section.directive.end.erlang"}},
+     match: 
+      /^\s*+(-)\s*+(module)\s*+(\()\s*+([a-z][a-zA-Z\d@_]*+)\s*+(\))\s*+(\.)/,
+     name: "meta.directive.module.erlang"},
+   number: 
+    {begin: /(?=\d)/,
+     end: "(?!\\d)",
+     patterns: 
+      [{captures: 
+         {1 => {name: "punctuation.separator.integer-float.erlang"},
+          3 => {name: "punctuation.separator.float-exponent.erlang"}},
+        match: /\d++(\.)\d++(([eE][\+\-])?\d++)?/,
+        name: "constant.numeric.float.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /2(#)[0-1]++/,
+        name: "constant.numeric.integer.binary.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /3(#)[0-2]++/,
+        name: "constant.numeric.integer.base-3.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /4(#)[0-3]++/,
+        name: "constant.numeric.integer.base-4.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /5(#)[0-4]++/,
+        name: "constant.numeric.integer.base-5.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /6(#)[0-5]++/,
+        name: "constant.numeric.integer.base-6.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /7(#)[0-6]++/,
+        name: "constant.numeric.integer.base-7.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /8(#)[0-7]++/,
+        name: "constant.numeric.integer.octal.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /9(#)[0-8]++/,
+        name: "constant.numeric.integer.base-9.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /10(#)\d++/,
+        name: "constant.numeric.integer.decimal.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /11(#)[\daA]++/,
+        name: "constant.numeric.integer.base-11.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /12(#)[\da-bA-B]++/,
+        name: "constant.numeric.integer.base-12.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /13(#)[\da-cA-C]++/,
+        name: "constant.numeric.integer.base-13.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /14(#)[\da-dA-D]++/,
+        name: "constant.numeric.integer.base-14.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /15(#)[\da-eA-E]++/,
+        name: "constant.numeric.integer.base-15.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /16(#)\h++/,
+        name: "constant.numeric.integer.hexadecimal.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /17(#)[\da-gA-G]++/,
+        name: "constant.numeric.integer.base-17.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /18(#)[\da-hA-H]++/,
+        name: "constant.numeric.integer.base-18.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /19(#)[\da-iA-I]++/,
+        name: "constant.numeric.integer.base-19.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /20(#)[\da-jA-J]++/,
+        name: "constant.numeric.integer.base-20.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /21(#)[\da-kA-K]++/,
+        name: "constant.numeric.integer.base-21.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /22(#)[\da-lA-L]++/,
+        name: "constant.numeric.integer.base-22.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /23(#)[\da-mA-M]++/,
+        name: "constant.numeric.integer.base-23.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /24(#)[\da-nA-N]++/,
+        name: "constant.numeric.integer.base-24.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /25(#)[\da-oA-O]++/,
+        name: "constant.numeric.integer.base-25.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /26(#)[\da-pA-P]++/,
+        name: "constant.numeric.integer.base-26.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /27(#)[\da-qA-Q]++/,
+        name: "constant.numeric.integer.base-27.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /28(#)[\da-rA-R]++/,
+        name: "constant.numeric.integer.base-28.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /29(#)[\da-sA-S]++/,
+        name: "constant.numeric.integer.base-29.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /30(#)[\da-tA-T]++/,
+        name: "constant.numeric.integer.base-30.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /31(#)[\da-uA-U]++/,
+        name: "constant.numeric.integer.base-31.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /32(#)[\da-vA-V]++/,
+        name: "constant.numeric.integer.base-32.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /33(#)[\da-wA-W]++/,
+        name: "constant.numeric.integer.base-33.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /34(#)[\da-xA-X]++/,
+        name: "constant.numeric.integer.base-34.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /35(#)[\da-yA-Y]++/,
+        name: "constant.numeric.integer.base-35.erlang"},
+       {captures: {1 => {name: "punctuation.separator.base-integer.erlang"}},
+        match: /36(#)[\da-zA-Z]++/,
+        name: "constant.numeric.integer.base-36.erlang"},
+       {match: /\d++#[\da-zA-Z]++/, name: "invalid.illegal.integer.erlang"},
+       {match: /\d++/, name: "constant.numeric.integer.decimal.erlang"}]},
+   :"parenthesized-expression" => 
+    {begin: /(\()/,
+     beginCaptures: 
+      {1 => {name: "punctuation.section.expression.begin.erlang"}},
+     end: "(\\))",
+     endCaptures: {1 => {name: "punctuation.section.expression.end.erlang"}},
+     name: "meta.expression.parenthesized",
+     patterns: [{include: "#everything-else"}]},
+   :"record-directive" => 
+    {begin: /^\s*+(-)\s*+(record)\s*+(\()\s*+([a-z][a-zA-Z\d@_]*+)\s*+(,)/,
+     beginCaptures: 
+      {1 => {name: "punctuation.section.directive.begin.erlang"},
+       2 => {name: "keyword.control.directive.import.erlang"},
+       3 => {name: "punctuation.definition.parameters.begin.erlang"},
+       4 => {name: "entity.name.type.class.record.definition.erlang"},
+       5 => {name: "punctuation.separator.parameters.erlang"}},
+     end: "((\\}))\\s*+(\\))\\s*+(\\.)",
+     endCaptures: 
+      {1 => {name: "meta.structure.record.erlang"},
+       2 => {name: "punctuation.definition.class.record.end.erlang"},
+       3 => {name: "punctuation.definition.parameters.end.erlang"},
+       4 => {name: "punctuation.section.directive.end.erlang"}},
+     name: "meta.directive.record.erlang",
+     patterns: [{include: "#internal-record-body"}]},
+   :"record-usage" => 
+    {patterns: 
+      [{captures: 
+         {1 => {name: "keyword.operator.record.erlang"},
+          2 => {name: "entity.name.type.class.record.erlang"},
+          3 => {name: "punctuation.separator.record-field.erlang"},
+          4 => {name: "variable.other.field.erlang"}},
+        match: /(#)\s*+([a-z][a-zA-Z\d@_]*+)\s*+(\.)\s*+([a-z][a-zA-Z\d@_]*+)/,
+        name: "meta.record-usage.erlang"},
+       {begin: /(#)\s*+([a-z][a-zA-Z\d@_]*+)/,
+        beginCaptures: 
+         {1 => {name: "keyword.operator.record.erlang"},
+          2 => {name: "entity.name.type.class.record.erlang"}},
+        end: "((\\}))",
+        endCaptures: 
+         {1 => {name: "meta.structure.record.erlang"},
+          2 => {name: "punctuation.definition.class.record.end.erlang"}},
+        name: "meta.record-usage.erlang",
+        patterns: [{include: "#internal-record-body"}]}]},
+   string: 
+    {begin: /(")/,
+     beginCaptures: 
+      {1 => {name: "punctuation.definition.string.begin.erlang"}},
+     end: "(\")",
+     endCaptures: {1 => {name: "punctuation.definition.string.end.erlang"}},
+     name: "string.quoted.double.erlang",
+     patterns: 
+      [{captures: 
+         {1 => {name: "punctuation.definition.escape.erlang"},
+          3 => {name: "punctuation.definition.escape.erlang"}},
+        match: /(\\)([bdefnrstv\\'"]|(\^)[@-_]|[0-7]{1,3})/,
+        name: "constant.character.escape.erlang"},
+       {match: /\\\^?.?/, name: "invalid.illegal.string.erlang"},
+       {captures: 
+         {1 => {name: "punctuation.definition.placeholder.erlang"},
+          10 => {name: "punctuation.separator.placeholder-parts.erlang"},
+          12 => {name: "punctuation.separator.placeholder-parts.erlang"},
+          3 => {name: "punctuation.separator.placeholder-parts.erlang"},
+          4 => {name: "punctuation.separator.placeholder-parts.erlang"},
+          6 => {name: "punctuation.separator.placeholder-parts.erlang"},
+          8 => {name: "punctuation.separator.placeholder-parts.erlang"}},
+        match: 
+         /(~)((\-)?\d++|(\*))?((\.)(\d++|(\*)))?((\.)((\*)|.))?[~cfegswpWPBX#bx\+ni]/,
+        name: "constant.other.placeholder.erlang"},
+       {captures: 
+         {1 => {name: "punctuation.definition.placeholder.erlang"},
+          2 => {name: "punctuation.separator.placeholder-parts.erlang"}},
+        match: /(~)(\*)?(\d++)?[~du\-#fsacl]/,
+        name: "constant.other.placeholder.erlang"},
+       {match: /~.?/, name: "invalid.illegal.string.erlang"}]},
+   :"symbolic-operator" => 
+    {match: /\+\+|\+|--|-|\*|\/=|\/|=\/=|=:=|==|=<|=|<-|<|>=|>|!/,
+     name: "keyword.operator.symbolic.erlang"},
+   :"textual-operator" => 
+    {match: 
+      /\b(andalso|band|and|bxor|xor|bor|orelse|or|bnot|not|bsl|bsr|div|rem)\b/,
+     name: "keyword.operator.textual.erlang"},
+   tuple: 
+    {begin: /(\{)/,
+     beginCaptures: {1 => {name: "punctuation.definition.tuple.begin.erlang"}},
+     end: "(\\})",
+     endCaptures: {1 => {name: "punctuation.definition.tuple.end.erlang"}},
+     name: "meta.structure.tuple.erlang",
+     patterns: 
+      [{match: /,/, name: "punctuation.separator.tuple.erlang"},
+       {include: "#everything-else"}]},
+   variable: 
+    {captures: 
+      {1 => {name: "variable.other.erlang"},
+       2 => {name: "variable.language.omitted.erlang"}},
+     match: /(_[a-zA-Z\d@_]++|[A-Z][a-zA-Z\d@_]*+)|(_)/}},
+ scopeName: "source.erlang",
+ uuid: "58EA597D-5158-4BF7-9FB2-B05135D1E166"}