github-linguist-grammars 4.6.0

data/grammars/source.glsl.json

@@ -0,0 +1,71 @@
+{
+  "fileTypes": [
+    "vs",
+    "fs",
+    "gs",
+    "vsh",
+    "fsh",
+    "gsh",
+    "vshader",
+    "fshader",
+    "gshader",
+    "vert",
+    "frag",
+    "geom",
+    "glsl",
+    "f.glsl",
+    "v.glsl",
+    "g.glsl"
+  ],
+  "foldingStartMarker": "/\\*\\*|\\{\\s*$",
+  "foldingStopMarker": "\\*\\*/|^\\s*\\}",
+  "keyEquivalent": "^~G",
+  "name": "GLSL",
+  "patterns": [
+    {
+      "match": "^\\s*#\\s*(define|undef|if|ifdef|ifndef|else|elif|endif|error|pragma|extension|version|line)\\b",
+      "name": "keyword.directive.preprocessor.glsl"
+    },
+    {
+      "match": "\\b(__LINE__|__FILE__|__VERSION__|GL_core_profile|GL_es_profile|GL_compatibility_profile)\\b",
+      "name": "constant.macro.predefined.glsl"
+    },
+    {
+      "match": "\\b(precision|highp|mediump|lowp)",
+      "name": "storage.modifier.precision.glsl"
+    },
+    {
+      "match": "\\b(break|case|continue|default|discard|do|else|for|if|return|switch|while)\\b",
+      "name": "keyword.control.glsl"
+    },
+    {
+      "match": "\\b(void|bool|int|uint|float|double|vec[2|3|4]|dvec[2|3|4]|bvec[2|3|4]|ivec[2|3|4]|uvec[2|3|4]|mat[2|3|4]|mat2x2|mat2x3|mat2x4|mat3x2|mat3x3|mat3x4|mat4x2|mat4x3|mat4x4|dmat2|dmat3|dmat4|dmat2x2|dmat2x3|dmat2x4|dmat3x2|dmat3x3|dmat3x4|dmat4x2|dmat4x3|dmat4x4|sampler[1|2|3]D|image[1|2|3]D|samplerCube|imageCube|sampler2DRect|image2DRect|sampler[1|2]DArray|image[1|2]DArray|samplerBuffer|imageBuffer|sampler2DMS|image2DMS|sampler2DMSArray|image2DMSArray|samplerCubeArray|imageCubeArray|sampler[1|2]DShadow|sampler2DRectShadow|sampler[1|2]DArrayShadow|samplerCubeShadow|samplerCubeArrayShadow|isampler[1|2|3]D|iimage[1|2|3]D|isamplerCube|iimageCube|isampler2DRect|iimage2DRect|isampler[1|2]DArray|iimage[1|2]DArray|isamplerBuffer|iimageBuffer|isampler2DMS|iimage2DMS|isampler2DMSArray|iimage2DMSArray|isamplerCubeArray|iimageCubeArray|atomic_uint|usampler[1|2|3]D|uimage[1|2|3]D|usamplerCube|uimageCube|usampler2DRect|uimage2DRect|usampler[1|2]DArray|uimage[1|2]DArray|usamplerBuffer|uimageBuffer|usampler2DMS|uimage2DMS|usampler2DMSArray|uimage2DMSArray|usamplerCubeArray|uimageCubeArray|struct)\\b",
+      "name": "storage.type.glsl"
+    },
+    {
+      "match": "\\b(layout|attribute|centroid|sampler|patch|const|flat|in|inout|invariant|noperspective|out|smooth|uniform|varying|buffer|shared|coherent|readonly|writeonly)\\b",
+      "name": "storage.modifier.glsl"
+    },
+    {
+      "match": "\\b(gl_BackColor|gl_BackLightModelProduct|gl_BackLightProduct|gl_BackMaterial|gl_BackSecondaryColor|gl_ClipDistance|gl_ClipPlane|gl_ClipVertex|gl_Color|gl_DepthRange|gl_DepthRangeParameters|gl_EyePlaneQ|gl_EyePlaneR|gl_EyePlaneS|gl_EyePlaneT|gl_Fog|gl_FogCoord|gl_FogFragCoord|gl_FogParameters|gl_FragColor|gl_FragCoord|gl_FragDat|gl_FragDept|gl_FrontColor|gl_FrontFacing|gl_FrontLightModelProduct|gl_FrontLightProduct|gl_FrontMaterial|gl_FrontSecondaryColor|gl_InstanceID|gl_Layer|gl_LightModel|gl_LightModelParameters|gl_LightModelProducts|gl_LightProducts|gl_LightSource|gl_LightSourceParameters|gl_MaterialParameters|gl_ModelViewMatrix|gl_ModelViewMatrixInverse|gl_ModelViewMatrixInverseTranspose|gl_ModelViewMatrixTranspose|gl_ModelViewProjectionMatrix|gl_ModelViewProjectionMatrixInverse|gl_ModelViewProjectionMatrixInverseTranspose|gl_ModelViewProjectionMatrixTranspose|gl_MultiTexCoord[0-7]|gl_Normal|gl_NormalMatrix|gl_NormalScale|gl_ObjectPlaneQ|gl_ObjectPlaneR|gl_ObjectPlaneS|gl_ObjectPlaneT|gl_Point|gl_PointCoord|gl_PointParameters|gl_PointSize|gl_Position|gl_PrimitiveIDIn|gl_ProjectionMatrix|gl_ProjectionMatrixInverse|gl_ProjectionMatrixInverseTranspose|gl_ProjectionMatrixTranspose|gl_SecondaryColor|gl_TexCoord|gl_TextureEnvColor|gl_TextureMatrix|gl_TextureMatrixInverse|gl_TextureMatrixInverseTranspose|gl_TextureMatrixTranspose|gl_Vertex|gl_VertexID)\\b",
+      "name": "support.variable.glsl"
+    },
+    {
+      "match": "\\b(gl_MaxClipPlanes|gl_MaxCombinedTextureImageUnits|gl_MaxDrawBuffers|gl_MaxFragmentUniformComponents|gl_MaxLights|gl_MaxTextureCoords|gl_MaxTextureImageUnits|gl_MaxTextureUnits|gl_MaxVaryingFloats|gl_MaxVertexAttribs|gl_MaxVertexTextureImageUnits|gl_MaxVertexUniformComponents)\\b",
+      "name": "support.constant.glsl"
+    },
+    {
+      "match": "\\b(abs|acos|all|any|asin|atan|ceil|clamp|cos|cross|degrees|dFdx|dFdy|distance|dot|equal|exp|exp2|faceforward|floor|fract|ftransform|fwidth|greaterThan|greaterThanEqual|inversesqrt|length|lessThan|lessThanEqual|log|log2|matrixCompMult|max|min|mix|mod|noise[1-4]|normalize|not|notEqual|outerProduct|pow|radians|reflect|refract|shadow1D|shadow1DLod|shadow1DProj|shadow1DProjLod|shadow2D|shadow2DLod|shadow2DProj|shadow2DProjLod|sign|sin|smoothstep|sqrt|step|tan|texture1D|texture1DLod|texture1DProj|texture1DProjLod|texture2D|texture2DLod|texture2DProj|texture2DProjLod|texture3D|texture3DLod|texture3DProj|texture3DProjLod|textureCube|textureCubeLod|transpose)\\b",
+      "name": "support.function.glsl"
+    },
+    {
+      "match": "\\b(asm|enum|extern|goto|inline|long|short|sizeof|static|typedef|union|unsigned)\\b",
+      "name": "invalid.illegal.glsl"
+    },
+    {
+      "include": "source.c"
+    }
+  ],
+  "scopeName": "source.glsl",
+  "uuid": "D0FD1B52-F137-4FBA-A148-B8A893CD948C"
+}

data/grammars/source.gnuplot.json

@@ -0,0 +1,276 @@
+{
+  "fileTypes": [
+    "gp",
+    "gnuplot",
+    "gnu",
+    "plot"
+  ],
+  "keyEquivalent": "^~G",
+  "name": "gnuplot",
+  "patterns": [
+    {
+      "include": "#number"
+    },
+    {
+      "include": "#string_single"
+    },
+    {
+      "include": "#string_double"
+    },
+    {
+      "begin": "\\b(for)\\b\\s*(\\[)",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.other.iteration.gnuplot"
+        },
+        "2": {
+          "name": "punctuation.definition.range.begin.gnuplot"
+        }
+      },
+      "comment": "gnuplot iteration statement.\n\t\t\tThere are two forms:\n\t\t\t    numeric [n = 1:2{:inc}]\n\t\t\t    string based [str in \"x y z\"]\n\t\t\t    but both can also iterate over lists etc, so this is kept loose.",
+      "end": "\\]",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.range.end.gnuplot"
+        }
+      },
+      "name": "meta.structure.iteration.gnuplot",
+      "patterns": [
+        {
+          "include": "#number"
+        },
+        {
+          "include": "#operator"
+        },
+        {
+          "include": "#string_double"
+        },
+        {
+          "include": "#string_single"
+        },
+        {
+          "match": ":",
+          "name": "punctuation.separator.range.gnuplot"
+        },
+        {
+          "match": "\\b([a-zA-Z]\\w*)\\b\\s*(=|in)",
+          "name": "variable-assignment.range.gnuplot"
+        },
+        {
+          "match": "(?i:[^\\s(pi|e)\\]])",
+          "name": "invalid.illegal.expected-range-separator.gnuplot"
+        }
+      ]
+    },
+    {
+      "begin": "\\[",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.range.begin.gnuplot"
+        }
+      },
+      "comment": "gnuplot range statement [a:b]. Lots of things are legal, still more make no sense!",
+      "end": "\\]",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.range.end.gnuplot"
+        }
+      },
+      "name": "meta.structure.range.gnuplot",
+      "patterns": [
+        {
+          "include": "#number"
+        },
+        {
+          "include": "#operator"
+        },
+        {
+          "match": ":",
+          "name": "punctuation.separator.range.gnuplot"
+        },
+        {
+          "match": "(?i:[^\\s(pi|e)\\]])",
+          "name": "invalid.illegal.expected-range-separator.gnuplot"
+        }
+      ]
+    },
+    {
+      "match": "\\\\.",
+      "name": "constant.character.escape.gnuplot"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "punctuation.definition.comment.gnuplot"
+        }
+      },
+      "match": "(?<!\\$)(#)(?!\\{).*$\\n?",
+      "name": "comment.line.number-sign.gnuplot"
+    },
+    {
+      "comment": "introduce in gnuplot 4.3.",
+      "match": "for",
+      "name": "keyword.other.iteration.gnuplot"
+    },
+    {
+      "match": "\\b(angles|arrow|autoscale|bars|border|boxwidth|clabel|clip|cntrparam|colorbox|contour|decimalsign|dgrid3d|dummy|encoding|fit|format|grid|hidden3d|historysize|isosamples|key|label|locale|logscale|macros|bmargin|lmargin|rmargin|tmargin|mapping|mouse|multiplot|offsets|origin|output|palette|parametric|pm3d|pointsize|polar|print|rrange|trange|urange|vrange|samples|size|style|surface|tics|ticscale|ticslevel|timestamp|timefmt|title|view|xyplane|x2data|xdata|y2data|ydata|z2data|zdata|x2label|xlabel|y2label|ylabel|z2label|zlabel|x2range|xrange|y2range|yrange|z2range|zrange|mx2tics|mxtics|my2tics|mytics|mz2tics|mztics|nomx2tics|nomxtics|nomy2tics|nomytics|nomz2tics|nomztics|nox2tics|noxtics|noy2tics|noytics|noz2tics|noztics|x2tics|xtics|y2tics|ytics|z2tics|ztics|x2dtics|x2mtics|xdtics|xmtics|y2dtics|y2mtics|ydtics|ymtics|z2dtics|z2mtics|zdtics|zmtics|x2zeroaxis|xzeroaxis|y2zeroaxis|yzeroaxis|z2zeroaxis|zeroaxis|zzeroaxis|zero)\\b",
+      "name": "keyword.other.setting.gnuplot"
+    },
+    {
+      "comment": "missuse of scopes alert! Just for pretty colours",
+      "match": "\\b(cd|call|clear|exit|unset|plot|splot|help|load|pause|quit|fit|replot|ifFIT_LIMIT|FIT_MAXITER|FIT_START_LAMBDA|FIT_LAMBDA_FACTOR|FIT_LOG|FIT_SCRIPT|print|pwd|reread|reset|save|show|test|!|functions|var)\\b",
+      "name": "keyword.other.command.gnuplot"
+    },
+    {
+      "match": "\\b(abs|acos|acosh|arg|asin|asinh|atan|atan2|atanh|besj0|besj1|besy0|besy1|ceil|cos|cosh|erf|erfc|exp|floor|gamma|ibeta|igamma|imag|int|inverf|invnorm|lambertw|lgamma|log|log10|norm|rand|real|sgn|sin|sinh|sqrt|tan|tanh)\\b",
+      "name": "support.function.gnuplot"
+    },
+    {
+      "match": "\\b(gprintf|sprintf|strlen|strstrt|substr|system|word|words)\\b",
+      "name": "support.function.string.gnuplot"
+    },
+    {
+      "match": "\\b(on|off|default|inside|outside|lmargin|rmargin|tmargin|bmargin|at|left|right|center|top|bottom|center|vertical|horizontal|Left|Right|noreverse|noinvert|samplen|spacing|width|height|noautotitle|columnheader|title|noenhanced|nobox|linestyle|ls|linetype|lt|linewidth|lw)\\b",
+      "name": "constant.other.type.gnuplot"
+    },
+    {
+      "comments": "These are the terminal types available on my system -- there are probably a lot more",
+      "match": "\\b(aed512|aed767|aifm|aqua|bitgraph|cgm|corel|dumb|dxf|eepic|emf|emtex|epslatex|epson_180dpi|epson_60dpi|epson_lx800|fig|gif|gpic|hp2623A|hp2648|hp500c|hpdj|hpgl|hpljii|hppj|imagen|jpeg|kc_tek40xx|km_tek40xx|latex|mf|mif|mp|nec_cp6|okidata|pbm|pcl5|pdf|png|postscript|pslatex|pstex|pstricks|qms|regis|selanar|starc|svg|tandy_60dpi|tek40xx|tek410x|texdraw|tgif|tkcanvas|tpic|unknown|vttek)\\b",
+      "name": "constant.other.terminal.gnuplot"
+    },
+    {
+      "match": "\\b(u(sing)?|t(it(le)?)?|notit(le)?|w(i(th)?)?|steps|fs(teps)?|notitle|l(i(nes)?)?|linespoints|via)\\b",
+      "name": "keyword.modifier.gnuplot"
+    },
+    {
+      "comment": "user defined function / variable",
+      "match": "(?x:\n\t\t\t\t\\b # Start with a word boundary\n\t\t\t\t(?=\\b[\\w$]*(\\(|.*=))\t# Look-ahead for a bracket or equals\n\t\t\t\t(?![^(]*\\))\t# negative look ahead for a closing bracket without an opening one. This stops a from matching in f(a)\n\t\t\t\t(\t\t\t\t\t# Group variable name\n\t\t\t\t\t[A-Za-z] \t\t\t# A letter\n\t\t\t\t\t[\\w$]*\t \t\t# Any word chars or $\n\t\t\t\t)\t\t\t\t\t# That is it for the name.\n\t\t\t)",
+      "name": "variable.other.gnuplot"
+    },
+    {
+      "match": "\\b(if)\\b",
+      "name": "keyword.control.gnuplot"
+    },
+    {
+      "begin": "\\b(show)\\b",
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.other.command.gnuplot"
+        }
+      },
+      "contentName": "keyword.line.show.gnuplot",
+      "end": "(?!\\#)($\\n?)",
+      "name": "keyword.line.show.gnuplot",
+      "patterns": [
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    {
+      "begin": "\\b(set)\\b\\s*\\b(terminal)\\b",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.other.command.gnuplot"
+        },
+        "2": {
+          "name": "keyword.other.setting.gnuplot"
+        }
+      },
+      "end": "(?!\\#)($\\n?)",
+      "name": "keyword.line.set.terminal.gnuplot",
+      "patterns": [
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    {
+      "begin": "\\b(set)\\b\\s*\\b(key)\\b",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.other.command.gnuplot"
+        },
+        "2": {
+          "name": "keyword.other.setting.gnuplot"
+        }
+      },
+      "end": "(?!\\#)($\\n?)",
+      "name": "keyword.line.set.key.gnuplot",
+      "patterns": [
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    {
+      "begin": "\\b(set)\\b\\s*(?!\\b(terminal|key|for)\\b)",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.other.command.gnuplot"
+        },
+        "2": {
+          "name": "keyword.other.setting.gnuplot"
+        }
+      },
+      "contentName": "keyword.line.set.gnuplot",
+      "end": "(?!\\#)($\\n?)",
+      "name": "keyword.line.set.gnuplot",
+      "patterns": [
+        {
+          "include": "$self"
+        }
+      ]
+    }
+  ],
+  "repository": {
+    "number": {
+      "comment": "borrowed from textmate book",
+      "match": "(?x:         # turn on extended mode\n                     -?         # an optional minus\n                     (?:\n                       0        # a zero\n                       |        # ...or...\n                       [1-9]    # a 1-9 character\n                       \\d*      # followed by zero or more digits\n                     )\n                     (?:\n                       \\.       # a period\n                       \\d+      # followed by one or more digits\n                       (?:\n                         [eE]   # an e character\n                         [+-]?  # followed by an option +/-\n                         \\d+    # followed by one or more digits\n                       )?       # make exponent optional\n                     )?         # make decimal portion optional\n                 )",
+      "name": "constant.numeric.gnuplot"
+    },
+    "operator": {
+      "comment": "Operator symbols",
+      "match": "\\s*(==|~=|>|>=|<|<=|&|&&|:|\\||\\|\\||\\+|-|\\*|\\.\\*|/|\\./|\\\\|\\.\\\\|\\^|\\.\\^)\\s*",
+      "name": "keyword.operator.symbols.matlab"
+    },
+    "string_double": {
+      "begin": "\"",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.begin.gnuplot"
+        }
+      },
+      "end": "\"",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.end.gnuplot"
+        }
+      },
+      "name": "string.quoted.double.gnuplot",
+      "patterns": [
+        {
+          "match": "\\\\[\\$`\"\\\\\\n]",
+          "name": "constant.character.escape.gnuplot"
+        }
+      ]
+    },
+    "string_single": {
+      "begin": "'",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.begin.gnuplot"
+        }
+      },
+      "end": "'",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.end.gnuplot"
+        }
+      },
+      "name": "string.quoted.single.gnuplot"
+    }
+  },
+  "scopeName": "source.gnuplot",
+  "uuid": "A27F93D4-2AE3-4950-851E-8FA19D3CF999"
+}

data/grammars/source.go.json

@@ -0,0 +1,552 @@
+{
+  "comment": "Go allows any Unicode character to be used in identifiers, so our identifier regex is: \\b([[:alpha:]_]+[[:alnum:]_]*)\\b\n\tcf. The Go Programming Language Specification <http://golang.org/doc/go_spec.html>",
+  "fileTypes": [
+    "go"
+  ],
+  "firstLineMatch": "(?i)-[*]-\\s*(mode:)?\\s*go\\s*-[*]-",
+  "keyEquivalent": "^~G",
+  "name": "Go",
+  "patterns": [
+    {
+      "include": "#receiver_function_declaration"
+    },
+    {
+      "include": "#plain_function_declaration"
+    },
+    {
+      "include": "#basic_things"
+    },
+    {
+      "include": "#exported_variables"
+    },
+    {
+      "begin": "^[[:blank:]]*(import)\\b\\s+",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.control.import.go"
+        }
+      },
+      "end": "(?=(?://|/\\*))|$",
+      "name": "meta.preprocessor.go.import",
+      "patterns": [
+        {
+          "begin": "\"",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.begin.go"
+            }
+          },
+          "end": "\"",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.end.go"
+            }
+          },
+          "name": "string.quoted.double.import.go"
+        }
+      ]
+    },
+    {
+      "include": "#block"
+    },
+    {
+      "include": "#root_parens"
+    },
+    {
+      "include": "#function_calls"
+    }
+  ],
+  "repository": {
+    "access": {
+      "match": "(?<=\\.)[[:alpha:]_][[:alnum:]_]*\\b(?!\\s*\\()",
+      "name": "variable.other.dot-access.go"
+    },
+    "basic_things": {
+      "patterns": [
+        {
+          "include": "#comments"
+        },
+        {
+          "include": "#initializers"
+        },
+        {
+          "include": "#access"
+        },
+        {
+          "include": "#strings"
+        },
+        {
+          "include": "#keywords"
+        }
+      ]
+    },
+    "block": {
+      "begin": "\\{",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.section.block.begin.go"
+        }
+      },
+      "end": "\\}",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.section.block.end.go"
+        }
+      },
+      "name": "meta.block.go",
+      "patterns": [
+        {
+          "include": "#block_innards"
+        }
+      ]
+    },
+    "block_innards": {
+      "patterns": [
+        {
+          "include": "#function_block_innards"
+        },
+        {
+          "include": "#exported_variables"
+        }
+      ]
+    },
+    "comments": {
+      "patterns": [
+        {
+          "captures": {
+            "1": {
+              "name": "meta.toc-list.banner.block.go"
+            }
+          },
+          "match": "^/\\* =(\\s*.*?)\\s*= \\*/$\\n?",
+          "name": "comment.block.go"
+        },
+        {
+          "begin": "/\\*",
+          "captures": {
+            "0": {
+              "name": "punctuation.definition.comment.go"
+            }
+          },
+          "end": "\\*/",
+          "name": "comment.block.go"
+        },
+        {
+          "match": "\\*/.*\\n",
+          "name": "invalid.illegal.stray-comment-end.go"
+        },
+        {
+          "captures": {
+            "1": {
+              "name": "punctuation.definition.comment.go"
+            },
+            "2": {
+              "name": "meta.toc-list.banner.line.go"
+            }
+          },
+          "match": "^(//) =(\\s*.*?)\\s*=\\s*$\\n?",
+          "name": "comment.line.double-slash.banner.go"
+        },
+        {
+          "begin": "(^[ \\t]+)?(?=//)",
+          "beginCaptures": {
+            "1": {
+              "name": "punctuation.whitespace.comment.leading.go"
+            }
+          },
+          "end": "(?!\\G)",
+          "patterns": [
+            {
+              "begin": "//",
+              "beginCaptures": {
+                "0": {
+                  "name": "punctuation.definition.comment.go"
+                }
+              },
+              "end": "\\n",
+              "name": "comment.line.double-slash.go",
+              "patterns": [
+                {
+                  "match": "(?>\\\\\\s*\\n)",
+                  "name": "punctuation.separator.continuation.go"
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    },
+    "exported_variables": {
+      "comment": "This is kinda hacky, in order to get the 'var' scoped the right way again.",
+      "match": "(?<=\\s|\\[\\])([[:upper:]][[:alnum:]_]*)(?=\\W+)",
+      "name": "variable.exported.go"
+    },
+    "fn_parens": {
+      "begin": "\\(",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.section.parens.begin.go"
+        }
+      },
+      "end": "\\)",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.section.parens.end.go"
+        }
+      },
+      "name": "meta.parens.go",
+      "patterns": [
+        {
+          "include": "#basic_things"
+        },
+        {
+          "include": "#function_calls"
+        }
+      ]
+    },
+    "function_block": {
+      "begin": "\\{",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.section.function-block.begin.go"
+        }
+      },
+      "end": "\\}",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.section.function-block.end.go"
+        }
+      },
+      "name": "meta.block.go",
+      "patterns": [
+        {
+          "include": "#function_block_innards"
+        }
+      ]
+    },
+    "function_block_innards": {
+      "patterns": [
+        {
+          "include": "#basic_things"
+        },
+        {
+          "captures": {
+            "1": {
+              "name": "punctuation.whitespace.support.function.leading.go"
+            },
+            "2": {
+              "name": "support.function.builtin.go"
+            }
+          },
+          "match": "(\\s*)\\b(new|c(lose|ap)|p(anic|rint(ln)?)|len|make|append)(?:\\b|\\()"
+        },
+        {
+          "include": "#function_block"
+        },
+        {
+          "include": "#function_calls"
+        },
+        {
+          "include": "#fn_parens"
+        }
+      ]
+    },
+    "function_calls": {
+      "captures": {
+        "1": {
+          "name": "punctuation.whitespace.function-call.leading.go"
+        },
+        "2": {
+          "name": "support.function.any-method.go"
+        },
+        "3": {
+          "name": "punctuation.definition.parameters.go"
+        }
+      },
+      "match": "(?x)\n                (?: (?= \\s ) (?:(?<=else|new|return) | (?<!\\w)) (\\s+) )?\n                (\\b\n                    (?!(for|if|else|switch|return)\\s*\\()\n                    (?:[[:alpha:]_][[:alnum:]_]*+\\b)            # method name\n                )\n                \\s*(\\()\n            ",
+      "name": "meta.function-call.go"
+    },
+    "initializers": {
+      "patterns": [
+        {
+          "captures": {
+            "1": {
+              "name": "keyword.control.go"
+            },
+            "2": {
+              "patterns": [
+                {
+                  "match": "[[:alpha:]_][[:alnum:]_]*",
+                  "name": "variable.other.go"
+                }
+              ]
+            }
+          },
+          "comment": "This matches the 'var x' style of variable declaration.",
+          "match": "^[[:blank:]]*(var)\\s+((?:[[:alpha:]_][[:alnum:]_]*)(?:,\\s+[[:alpha:]_][[:alnum:]_]*)*)",
+          "name": "meta.initialization.explicit.go"
+        },
+        {
+          "captures": {
+            "1": {
+              "patterns": [
+                {
+                  "match": "[[:alpha:]_][[:alnum:]_]*",
+                  "name": "variable.other.go"
+                }
+              ]
+            },
+            "2": {
+              "name": "keyword.operator.go"
+            }
+          },
+          "comment": "This matches the 'x :=' style of variable declaration.",
+          "match": "((?:[[:alpha:]_][[:alnum:]_]*)(?:\\s*,\\s+[[:alpha:]_][[:alnum:]_]*)*)\\s*(:=)",
+          "name": "meta.initialization.short.go"
+        }
+      ]
+    },
+    "keywords": {
+      "patterns": [
+        {
+          "match": "\\b(s(elect|witch)|c(ontinue|ase)|type|i(nterface|f|mport)|def(er|ault)|package|else|var|f(or|unc|allthrough)|r(eturn|ange)|go(to)?|break)\\b",
+          "name": "keyword.control.go"
+        },
+        {
+          "match": "(\\b|(?<=\\]))(int(16|8|32|64)?|uint(16|8|32|64|ptr)?|float(32|64)|complex(64|128)|b(yte|ool)|string|error|struct)\\b",
+          "name": "storage.type.go"
+        },
+        {
+          "match": "\\b(c(onst|han)|map)\\b",
+          "name": "storage.modifier.go"
+        },
+        {
+          "match": "\\b(nil|true|false|iota)\\b",
+          "name": "constant.language.go"
+        },
+        {
+          "match": "\\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\\.?[0-9]*)|(\\.[0-9]+))((e|E)(\\+|-)?[0-9]+)?)\\b",
+          "name": "constant.numeric.go"
+        },
+        {
+          "match": "\\<\\-",
+          "name": "keyword.operator.channel.go"
+        }
+      ]
+    },
+    "plain_function_declaration": {
+      "begin": "(?x)\n    \t            (^[[:blank:]]*(func)\\s*\n    \t             (?: ([[:alpha:]_][[:alnum:]_]*)? )          # name of function is optional\n    \t             (?: \\( ((?:[\\[\\]\\w\\d\\s\\/,._*&<>-]|(?:interface\\{\\}))*)? \\) )             # required braces for parameters (even if empty)\n    \t             \\s*\n    \t             (?: \\(? ((?:[\\[\\]\\w\\d\\s,._*&<>-]|(?:interface\\{\\}))*) \\)? )?             # optional return types, optionally within braces\n                    )\n    \t    ",
+      "beginCaptures": {
+        "1": {
+          "name": "meta.function.declaration.go"
+        },
+        "2": {
+          "name": "keyword.control.go"
+        },
+        "3": {
+          "name": "entity.name.function.go"
+        },
+        "4": {
+          "patterns": [
+            {
+              "match": "[[:alpha:]_][[:alnum:]_]*",
+              "name": "variable.parameters.go"
+            }
+          ]
+        },
+        "5": {
+          "patterns": [
+            {
+              "match": "[[:alpha:]_][[:alnum:]_]*",
+              "name": "variable.return-types.go"
+            }
+          ]
+        }
+      },
+      "comment": "We scope all parenthesized alpha-numeric text as variable.parameters.go and variable.return-types.go, which is a bit lazy, as some of it is storage.type.",
+      "end": "(?<=\\})",
+      "name": "meta.function.plain.go",
+      "patterns": [
+        {
+          "include": "#comments"
+        },
+        {
+          "include": "#storage_type"
+        },
+        {
+          "include": "#storage_modifier"
+        },
+        {
+          "include": "#function_block"
+        }
+      ]
+    },
+    "receiver_function_declaration": {
+      "begin": "(?x)\n    \t            (\n                     (func)\\s*\n    \t             (\n    \t             (?: \\( ((?:[\\[\\]\\w\\d\\s,._*&<>-]|(?:interface\\{\\}))*) \\)\\s+ )                # receiver variable declarations, in brackets\n    \t             (?: ([[:alpha:]_][[:alnum:]_]*)? )          # name of function is optional\n    \t             )\n    \t             (?: \\( ((?:[\\[\\]\\w\\d\\s,._*&<>-]|(?:interface\\{\\}))*)? \\) )               # required braces for parameters (even if empty)\n    \t             \\s*\n    \t             (?: \\(? ((?:[\\[\\]\\w\\d\\s,._*&<>-]|(?:interface\\{\\}))*) \\)? )?             # optional return types, optionally within braces\n                    )\n    \t    ",
+      "beginCaptures": {
+        "1": {
+          "name": "meta.function.receiver.declaration.go"
+        },
+        "2": {
+          "name": "keyword.control.go"
+        },
+        "3": {
+          "name": "entity.name.function.go.full-name"
+        },
+        "4": {
+          "patterns": [
+            {
+              "match": "[[:alpha:]_][[:alnum:]_]*",
+              "name": "variable.receiver.go"
+            }
+          ]
+        },
+        "5": {
+          "name": "entity.name.function.go.name"
+        },
+        "6": {
+          "patterns": [
+            {
+              "match": "[[:alpha:]_][[:alnum:]_]*",
+              "name": "variable.parameters.go"
+            }
+          ]
+        },
+        "7": {
+          "patterns": [
+            {
+              "match": "[[:alpha:]_][[:alnum:]_]*",
+              "name": "variable.return-types.go"
+            }
+          ]
+        }
+      },
+      "comment": "Version of above with support for declaring a receiver variable.",
+      "end": "(?<=\\})",
+      "name": "meta.function.receiver.go",
+      "patterns": [
+        {
+          "include": "#comments"
+        },
+        {
+          "include": "#storage_type"
+        },
+        {
+          "include": "#storage_modifier"
+        },
+        {
+          "include": "#function_block"
+        }
+      ]
+    },
+    "root_parens": {
+      "begin": "\\(",
+      "end": "(?<=\\()(\\))?|(?:\\))",
+      "endCaptures": {
+        "1": {
+          "name": "meta.parens.empty.go"
+        }
+      },
+      "name": "meta.parens.go",
+      "patterns": [
+        {
+          "include": "#basic_things"
+        },
+        {
+          "include": "#exported_variables"
+        },
+        {
+          "include": "#function_calls"
+        }
+      ]
+    },
+    "string_escaped_char": {
+      "patterns": [
+        {
+          "match": "\\\\(\\\\|[abfnrutv'\"]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|[0-7]{3})",
+          "name": "constant.character.escape.go"
+        },
+        {
+          "match": "\\\\.",
+          "name": "invalid.illegal.unknown-escape.go"
+        }
+      ]
+    },
+    "string_placeholder": {
+      "patterns": [
+        {
+          "match": "(?x)%\n                        (\\d+\\$)?                                    # field (argument #)\n                        [#0\\- +']*                                  # flags\n                        [,;:_]?                                     # separator character (AltiVec)\n                        ((-?\\d+)|\\*(-?\\d+\\$)?)?                     # minimum field width\n                        (\\.((-?\\d+)|\\*(-?\\d+\\$)?)?)?                # precision\n                        [diouxXDOUeEfFgGaAcCsSpnvtTbyYhHmMzZq%]      # conversion type\n                    ",
+          "name": "constant.other.placeholder.go"
+        },
+        {
+          "match": "%",
+          "name": "invalid.illegal.placeholder.go"
+        }
+      ]
+    },
+    "strings": {
+      "patterns": [
+        {
+          "begin": "\"",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.begin.go"
+            }
+          },
+          "end": "\"",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.end.go"
+            }
+          },
+          "name": "string.quoted.double.go",
+          "patterns": [
+            {
+              "include": "#string_placeholder"
+            },
+            {
+              "include": "#string_escaped_char"
+            }
+          ]
+        },
+        {
+          "begin": "'",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.begin.go"
+            }
+          },
+          "end": "'",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.end.go"
+            }
+          },
+          "name": "string.quoted.single.go",
+          "patterns": [
+            {
+              "include": "#string_escaped_char"
+            }
+          ]
+        },
+        {
+          "begin": "`",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.begin.go"
+            }
+          },
+          "end": "`",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.end.go"
+            }
+          },
+          "name": "string.quoted.raw.go"
+        }
+      ]
+    }
+  },
+  "scopeName": "source.go",
+  "uuid": "33100200-8916-4F78-8522-4362628C6889"
+}