github-linguist 7.5.1 → 7.6.0

data/grammars/hint.type.haskell.json

@@ -6,6 +6,14 @@
     }
   ],
   "repository": {
+    "arrow": {
+      "patterns": [
+        {
+          "name": "keyword.other.arrow.haskell",
+          "match": "(?:(?\u003c!(?:[\\p{S}\\p{P}](?\u003c![(),;\\[\\]`{}_\"'])))(?:-\u003e|→)(?!(?:[\\p{S}\\p{P}](?\u003c![(),;\\[\\]`{}_\"']))))"
+        }
+      ]
+    },
     "assignment_op": {
       "patterns": [
         {
@@ -26,6 +34,14 @@
         }
       ]
     },
+    "big_arrow": {
+      "patterns": [
+        {
+          "name": "keyword.other.big-arrow.haskell",
+          "match": "(?:(?\u003c!(?:[\\p{S}\\p{P}](?\u003c![(),;\\[\\]`{}_\"'])))(?:=\u003e|⇒)(?!(?:[\\p{S}\\p{P}](?\u003c![(),;\\[\\]`{}_\"']))))"
+        }
+      ]
+    },
     "block_comment": {
       "patterns": [
         {
@@ -262,24 +278,10 @@
               "include": "#assignment_op"
             },
             {
-              "match": "(?:(?:(?:(?=[\\p{Ll}_\\p{Lu}\\p{Lt}])(?\u003c![\\p{Ll}_\\p{Lu}\\p{Lt}']))([\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*(?:\\.[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)*)\\s*)(?:((?:(?!deriving)(?:[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*(?:\\.[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)*|(?:[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*(?:\\.[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)*\\.)?[\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*|(?:(?!deriving)(?:[\\w()'→⇒\\[\\],]|-\u003e|=\u003e)+\\s*)+))(?:(?:\\s+)(?:(?!deriving)(?:[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*(?:\\.[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)*|(?:[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*(?:\\.[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)*\\.)?[\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*|(?:(?!deriving)(?:[\\w()'→⇒\\[\\],]|-\u003e|=\u003e)+\\s*)+)))*)?))",
-              "captures": {
-                "1": {
-                  "patterns": [
-                    {
-                      "include": "#type_ctor"
-                    }
-                  ]
-                },
-                "2": {
-                  "name": "meta.type-signature.haskell",
-                  "patterns": [
-                    {
-                      "include": "#type_signature"
-                    }
-                  ]
-                }
-              }
+              "include": "#type_ctor_forall"
+            },
+            {
+              "include": "#type_ctor_alt"
             },
             {
               "match": "\\|",
@@ -1408,6 +1410,97 @@
         }
       ]
     },
+    "type_ctor_alt": {
+      "patterns": [
+        {
+          "contentName": "meta.type-signature.haskell",
+          "begin": "(?:(?=[\\p{Ll}_\\p{Lu}\\p{Lt}])(?\u003c![\\p{Ll}_\\p{Lu}\\p{Lt}']))([\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*(?:\\.[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)*)\\s*",
+          "end": "^(?!^[ \\t]|[ \\t]*$)|(?=\\{|\\}|\\||(?:(?=[\\p{Ll}_\\p{Lu}\\p{Lt}])(?\u003c![\\p{Ll}_\\p{Lu}\\p{Lt}']))deriving(?:(?\u003c=[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'])(?![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'])))",
+          "patterns": [
+            {
+              "include": "#comments"
+            },
+            {
+              "include": "#type_signature"
+            }
+          ],
+          "beginCaptures": {
+            "1": {
+              "patterns": [
+                {
+                  "include": "#type_ctor"
+                }
+              ]
+            }
+          }
+        }
+      ]
+    },
+    "type_ctor_forall": {
+      "patterns": [
+        {
+          "contentName": "meta.type-signature.haskell",
+          "begin": "(?:(?=[\\p{Ll}_\\p{Lu}\\p{Lt}])(?\u003c![\\p{Ll}_\\p{Lu}\\p{Lt}']))forall(?:(?\u003c=[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'])(?![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']))",
+          "end": "^(?!^[ \\t]|[ \\t]*$)|(?=\\{|\\}|\\||(?:(?=[\\p{Ll}_\\p{Lu}\\p{Lt}])(?\u003c![\\p{Ll}_\\p{Lu}\\p{Lt}']))deriving(?:(?\u003c=[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'])(?![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'])))",
+          "patterns": [
+            {
+              "include": "#comments"
+            },
+            {
+              "match": "\\G.*?(?:(?\u003c!(?:[\\p{S}\\p{P}](?\u003c![(),;\\[\\]`{}_\"'])))(?:=\u003e|⇒)(?!(?:[\\p{S}\\p{P}](?\u003c![(),;\\[\\]`{}_\"']))))",
+              "captures": {
+                "0": {
+                  "patterns": [
+                    {
+                      "include": "#type_signature"
+                    }
+                  ]
+                }
+              }
+            },
+            {
+              "match": "\\G.*?\\.",
+              "captures": {
+                "0": {
+                  "patterns": [
+                    {
+                      "include": "#type_signature"
+                    }
+                  ]
+                }
+              }
+            },
+            {
+              "include": "#big_arrow"
+            },
+            {
+              "include": "#type_variable"
+            },
+            {
+              "begin": "\\(",
+              "end": "\\)",
+              "patterns": [
+                {
+                  "include": "#type_signature"
+                }
+              ]
+            },
+            {
+              "include": "#type_ctor_alt"
+            }
+          ],
+          "beginCaptures": {
+            "0": {
+              "patterns": [
+                {
+                  "include": "#type_signature"
+                }
+              ]
+            }
+          }
+        }
+      ]
+    },
     "type_name": {
       "patterns": [
         {
@@ -1481,12 +1574,10 @@
           "include": "#string"
         },
         {
-          "name": "keyword.other.arrow.haskell",
-          "match": "(?:(?\u003c!(?:[\\p{S}\\p{P}](?\u003c![(),;\\[\\]`{}_\"'])))(?:-\u003e|→)(?!(?:[\\p{S}\\p{P}](?\u003c![(),;\\[\\]`{}_\"']))))"
+          "include": "#arrow"
         },
         {
-          "name": "keyword.other.big-arrow.haskell",
-          "match": "(?:(?\u003c!(?:[\\p{S}\\p{P}](?\u003c![(),;\\[\\]`{}_\"'])))(?:=\u003e|⇒)(?!(?:[\\p{S}\\p{P}](?\u003c![(),;\\[\\]`{}_\"']))))"
+          "include": "#big_arrow"
         },
         {
           "name": "keyword.operator.promoted.haskell",
@@ -1505,8 +1596,7 @@
           "include": "#operator"
         },
         {
-          "name": "variable.other.generic-type.haskell",
-          "match": "(?:(?=[\\p{Ll}_\\p{Lu}\\p{Lt}])(?\u003c![\\p{Ll}_\\p{Lu}\\p{Lt}']))(?:[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*(?:\\.[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)*\\.)?[\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*(?:(?\u003c=[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'])(?![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']))"
+          "include": "#type_variable"
         },
         {
           "name": "entity.name.type.promoted.haskell",
@@ -1529,6 +1619,14 @@
         }
       ]
     },
+    "type_variable": {
+      "patterns": [
+        {
+          "name": "variable.other.generic-type.haskell",
+          "match": "(?:(?=[\\p{Ll}_\\p{Lu}\\p{Lt}])(?\u003c![\\p{Ll}_\\p{Lu}\\p{Lt}']))(?:[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*(?:\\.[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)*\\.)?[\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*(?:(?\u003c=[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'])(?![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']))"
+        }
+      ]
+    },
     "unit": {
       "patterns": [
         {

data/grammars/injections.etc.json

@@ -2,20 +2,58 @@
   "scopeName": "injections.etc",
   "patterns": [
     {
-      "name": "meta.embedded.source.diff",
-      "begin": "(?\u003c=__END__)(?=\\s|$)",
-      "end": "(?=^(?!diff ))",
+      "name": "storage.type.class.${1:/downcase}",
+      "match": "(?\u003c!\\w)@?(PINHACK)\\b"
+    }
+  ],
+  "repository": {
+    "scopeHack": {
+      "begin": "\\A(?:\\xC2\\xAD|\\xAD){50}",
+      "end": "(?=A)B",
       "patterns": [
         {
-          "begin": "^(?=diff )",
-          "end": "(?=A)B",
-          "patterns": [
-            {
-              "include": "source.diff"
+          "name": "markup.bold",
+          "match": "^ {5}(PRIMER PREVIEW - How grammar scopes look on GitHub):",
+          "captures": {
+            "1": {
+              "name": "constant.other.reference.link"
             }
-          ]
+          }
+        },
+        {
+          "name": "comment.line",
+          "match": "^\\s*Last updated:\\s*(\\d{4}-\\d{2}-\\d{2})$"
+        },
+        {
+          "name": "constant.other.reference.link",
+          "match": "^│ +(TEXTMATE.*) +│$",
+          "captures": {
+            "1": {
+              "name": "markup.heading"
+            }
+          }
+        },
+        {
+          "match": "^│ +│$",
+          "captures": {
+            "0": {
+              "name": "constant.other.reference.link"
+            }
+          }
+        },
+        {
+          "match": "^│\\s+(([a-z][-a-z.]+)\\t\\S+\\s+░▒▓█+)\\s+│$",
+          "captures": {
+            "1": {
+              "name": "$2"
+            }
+          }
+        },
+        {
+          "name": "comment.line",
+          "match": "^#.*$"
         }
       ]
     }
-  ]
+  }
 }

data/grammars/source.abnf.json

@@ -1,445 +1,272 @@
 {
-  "name": "ABNF",
+  "name": "Augmented Backus-Naur Form",
   "scopeName": "source.abnf",
   "patterns": [
     {
-      "include": "#comment"
-    },
-    {
-      "include": "#rule"
+      "include": "#main"
     }
   ],
   "repository": {
-    "comment": {
-      "begin": "(?:(?\u003cwhitespace\u003e^[ \\t]*)|[ \\t]*)(?=;[[:print:]]*$)",
-      "end": "(?!\\G)",
+    "assignment": {
       "patterns": [
         {
-          "include": "#comment-line"
-        }
-      ],
-      "beginCaptures": {
-        "whitespace": {
-          "name": "punctuation.whitespace.comment.leading.abnf"
+          "name": "keyword.operator.assignment.increment.abnf",
+          "match": "=/"
+        },
+        {
+          "name": "keyword.operator.assignment.abnf",
+          "match": "="
         }
-      }
+      ]
     },
-    "comment-line": {
+    "comment": {
       "name": "comment.line.semicolon.abnf",
       "begin": ";",
-      "end": "\\n",
+      "end": "$",
       "beginCaptures": {
         "0": {
           "name": "punctuation.definition.comment.abnf"
         }
       }
     },
-    "constant": {
-      "patterns": [
-        {
-          "include": "#constant-decimal"
-        },
-        {
-          "include": "#constant-hex"
-        },
-        {
-          "include": "#constant-binary"
-        }
-      ]
-    },
-    "constant-binary": {
-      "name": "constant.numeric.binary.abnf",
-      "match": "(?x)%b\n                # First number\n                (?\u003cnumber\u003e[^\\s.-]+)        \n                # Optional \n                #   - dash followed by last number of range, or\n                #   - sequence of additional numbers separated by dot\n                (?:(?:(?=-)(?\u003cdash\u003e-)(?\u003clast\u003e\\w+)) |\n                   (?\u003cnumbers\u003e[\\w.]+))?",
-      "captures": {
-        "dash": {
-          "name": "keyword.operator.range.abnf"
-        },
-        "last": {
-          "patterns": [
-            {
-              "include": "#digit-binary"
-            }
-          ]
-        },
-        "number": {
-          "patterns": [
-            {
-              "include": "#digit-binary"
-            }
-          ]
-        },
-        "numbers": {
-          "patterns": [
-            {
-              "include": "#digits-binary-concatenation"
-            }
-          ]
-        }
-      }
-    },
-    "constant-decimal": {
-      "name": "constant.numeric.decimal.abnf",
-      "match": "(?x)%d\n                (?\u003cnumber\u003e[^\\s.-]+)\n                (?:(?:(?=-)(?\u003cdash\u003e-)(?\u003clast\u003e\\w+)) |\n                   (?\u003cnumbers\u003e[\\w.]+))?",
-      "captures": {
-        "dash": {
-          "name": "keyword.operator.range.abnf"
-        },
-        "last": {
-          "patterns": [
-            {
-              "include": "#digit-decimal"
-            }
-          ]
-        },
-        "number": {
-          "patterns": [
-            {
-              "include": "#digit-decimal"
-            }
-          ]
-        },
-        "numbers": {
-          "patterns": [
-            {
-              "include": "#digits-decimal-concatenation"
-            }
-          ]
-        }
-      }
-    },
-    "constant-hex": {
-      "name": "constant.numeric.hex.abnf",
-      "match": "(?x)%x\n                (?\u003cnumber\u003e[^\\s.-]+)\n                (?:(?:(?=-)(?\u003cdash\u003e-)(?\u003clast\u003e\\w+)) |\n                   (?\u003cnumbers\u003e[\\w.]+))?",
-      "captures": {
-        "dash": {
-          "name": "keyword.operator.range.abnf"
-        },
-        "last": {
-          "patterns": [
-            {
-              "include": "#digit-hex"
-            }
-          ]
-        },
-        "number": {
-          "patterns": [
-            {
-              "include": "#digit-hex"
-            }
-          ]
-        },
-        "numbers": {
-          "patterns": [
-            {
-              "include": "#digits-hex-concatenation"
-            }
-          ]
-        }
-      }
-    },
-    "digit-binary": {
-      "patterns": [
-        {
-          "include": "#digit-binary-valid"
-        },
-        {
-          "include": "#digit-binary-invalid"
-        }
-      ]
-    },
-    "digit-binary-invalid": {
-      "name": "invalid.illegal.digit.binary.abnf",
-      "match": "\\S"
-    },
-    "digit-binary-valid": {
-      "match": "[01]"
-    },
-    "digit-decimal": {
-      "patterns": [
-        {
-          "include": "#digit-decimal-valid"
-        },
-        {
-          "include": "#digit-decimal-invalid"
-        }
-      ]
-    },
-    "digit-decimal-invalid": {
-      "name": "invalid.illegal.digit.decimal.abnf",
-      "match": "\\S"
-    },
-    "digit-decimal-valid": {
-      "match": "\\d"
-    },
-    "digit-hex": {
-      "patterns": [
-        {
-          "include": "#digit-hex-valid"
-        },
-        {
-          "include": "#digit-hex-invalid"
-        }
-      ]
-    },
-    "digit-hex-invalid": {
-      "name": "invalid.illegal.digit.hex.abnf",
-      "match": "\\S"
-    },
-    "digit-hex-valid": {
-      "match": "[0-9A-Fa-f]"
-    },
-    "digits-binary-concatenation": {
-      "match": "(?\u003cdot\u003e\\.)(?\u003cnumber\u003e[^\\s.]+)",
-      "captures": {
-        "dot": {
-          "name": "keyword.operator.concatenation.abnf"
-        },
-        "number": {
-          "patterns": [
-            {
-              "include": "#digit-binary"
-            }
-          ]
-        }
-      }
-    },
-    "digits-decimal-concatenation": {
-      "match": "(?\u003cdot\u003e\\.)(?\u003cnumber\u003e[^\\s.]+)",
-      "captures": {
-        "dot": {
-          "name": "keyword.operator.concatenation.abnf"
-        },
-        "number": {
-          "patterns": [
-            {
-              "include": "#digit-decimal"
-            }
-          ]
-        }
-      }
-    },
-    "digits-hex-concatenation": {
-      "match": "(?\u003cdot\u003e\\.)(?\u003cnumber\u003e[^\\s.]+)",
-      "captures": {
-        "dot": {
-          "name": "keyword.operator.concatenation.abnf"
-        },
-        "number": {
-          "patterns": [
-            {
-              "include": "#digit-hex"
-            }
-          ]
-        }
-      }
-    },
-    "operator-alternative": {
-      "name": "keyword.operator.alternative.abnf",
-      "match": "/"
+    "core-rules": {
+      "name": "support.constant.reference.core-rule.abnf",
+      "match": "(?x)\n\\b\n(ALPHA|BIT|CHAR|CRLF|CR|CTL|DIGIT|DQUOTE\n|HEXDIG|HTAB|LF|LWSP|OCTET|SP|VCHAR|WSP)\n\\b"
     },
-    "operator-definition": {
-      "patterns": [
-        {
-          "include": "#operator-equal-alternative"
-        },
-        {
-          "include": "#operator-equal"
-        }
-      ]
-    },
-    "operator-equal": {
-      "name": "keyword.operator.equal.abnf",
-      "match": "="
-    },
-    "operator-equal-alternative": {
-      "name": "keyword.operator.equal-alternative.abnf",
-      "match": "=/"
-    },
-    "rule": {
-      "name": "meta.rule.abnf",
-      "begin": "(?x)^(\\s*)\n                 # We match the name of the rule and all following whitespace \n                 # characters. We use the additional whitespace to catch a \n                 # missing closing angle bracket.\n                 (?\u003cname\u003e\\S+\\s+)\n                 # The definition operator follows after the rule name.\n                 (?\u003coperator\u003e\\S+)\n                 ",
-      "while": "^(?=\\1\\s)",
-      "patterns": [
-        {
-          "include": "#rule-right-side"
-        }
-      ],
-      "captures": {
-        "name": {
-          "name": "entity.name.function.abnf",
-          "patterns": [
-            {
-              "include": "#rule-name"
-            }
-          ]
-        },
-        "operator": {
-          "patterns": [
-            {
-              "include": "#operator-definition"
-            },
-            {
-              "name": "invalid.illegal.operator.abnf",
-              "match": "\\S+"
-            }
-          ]
-        }
-      }
-    },
-    "rule-group": {
-      "name": "meta.rule.group.abnf",
+    "group": {
+      "name": "meta.group.abnf",
       "begin": "\\(",
       "end": "\\)",
       "patterns": [
         {
-          "include": "#rule-right-side"
+          "include": "#rhs"
         }
       ],
-      "captures": {
+      "beginCaptures": {
         "0": {
-          "name": "keyword.other.group.abnf"
+          "name": "punctuation.definition.round.bracket.begin.abnf"
+        }
+      },
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.round.bracket.end.abnf"
         }
       }
     },
-    "rule-name": {
+    "main": {
       "patterns": [
         {
-          "include": "#rule-name-angle-brackets"
+          "include": "#comment"
         },
         {
-          "include": "#rule-name-plain"
+          "include": "#rule"
         }
       ]
     },
-    "rule-name-angle-brackets": {
-      "name": "variable.other.rule",
-      "begin": "\u003c",
-      "end": "\u003e|(\\s)",
+    "optional": {
+      "name": "meta.optional.abnf",
+      "begin": "\\[",
+      "end": "\\]",
       "patterns": [
         {
-          "include": "#rule-name"
+          "include": "#rhs"
         }
       ],
-      "captures": {
+      "beginCaptures": {
         "0": {
-          "name": "keyword.other.angle-bracket.abnf"
+          "name": "punctuation.definition.square.bracket.begin.abnf"
         }
       },
       "endCaptures": {
         "0": {
-          "name": "keyword.other.angle-bracket.abnf"
-        },
-        "1": {
-          "name": "invalid.illegal.missing.angle-bracket.abnf"
+          "name": "punctuation.definition.square.bracket.end.abnf"
         }
       }
     },
-    "rule-name-core": {
-      "match": "(?x)\\b(?\u003crule\u003e\n                      ALPHA     |\n                      BIT       |\n                      CHAR      |\n                      CR(?:LF)? | \n                      CTL       |\n                      DIGIT     |\n                      DQUOTE    |\n                      HEXDIG    |\n                      HTAB      |\n                      LF        |\n                      LWSP      |\n                      OCTECT    |\n                      SP        |\n                      VCHAR     |\n                      WSP       \n                      )\\b",
+    "quantifier": {
+      "name": "meta.quantifier.abnf",
+      "match": "([0-9]*)(\\*)",
       "captures": {
-        "rule": {
-          "name": "support.constant.core-rule.$1.abnf"
+        "1": {
+          "name": "constant.numeric.decimal.integer.int.abnf"
+        },
+        "2": {
+          "name": "keyword.operator.logical.repetition.asterisk.star.abnf"
         }
       }
     },
-    "rule-name-plain": {
-      "name": "variable.other.rule.abnf",
-      "match": "[a-zA-Z][a-zA-Z0-9\\-]*|(?\u003cinvalid\u003e\\S)",
-      "captures": {
-        "invalid": {
-          "name": "invalid.illegal.character.abnf"
-        }
-      }
+    "reference": {
+      "name": "variable.parameter.argument.identifier.reference.abnf",
+      "match": "[A-Za-z][-A-Za-z0-9]*"
     },
-    "rule-optional": {
-      "name": "meta.rule.optional.abnf",
-      "begin": "\\[",
-      "end": "\\]",
+    "rhs": {
       "patterns": [
         {
-          "include": "#rule-right-side"
-        }
-      ],
-      "captures": {
-        "0": {
-          "name": "keyword.other.optional.abnf"
-        }
-      }
-    },
-    "rule-right-side": {
-      "patterns": [
+          "include": "#assignment"
+        },
         {
-          "include": "#rule-group"
+          "include": "#string"
         },
         {
-          "include": "#rule-optional"
+          "include": "#terminal"
         },
         {
-          "include": "#variable-repetition"
+          "include": "#comment"
         },
         {
-          "include": "#operator-alternative"
+          "include": "#quantifier"
         },
         {
-          "include": "#comment"
+          "include": "#group"
         },
         {
-          "include": "#constant"
+          "include": "#optional"
         },
         {
-          "include": "#string-double-quoted"
+          "include": "#core-rules"
         },
         {
-          "include": "#rule-name-core"
+          "include": "#reference"
         },
         {
-          "include": "#rule-name"
+          "name": "keyword.operator.logical.or.alternation.pipe.abnf",
+          "match": "/"
         }
       ]
     },
-    "string-double-quoted": {
+    "rule": {
+      "name": "meta.ruleset.$2.abnf",
+      "contentName": "meta.rhs.abnf",
+      "begin": "(?:^|\\G)(\\s*)([A-Za-z][-A-Za-z0-9]*)",
+      "end": "^(?!\\1\\s+\\S)|^(?=\\S)",
       "patterns": [
         {
-          "include": "#string-double-quoted-case-insensitive"
-        },
-        {
-          "include": "#string-double-quoted-case-sensitive"
+          "include": "#rhs"
         }
-      ]
-    },
-    "string-double-quoted-case-insensitive": {
-      "name": "string.quoted.double.case-insensitive.abnf",
-      "begin": "(?\u003coperator\u003e%i)?\"",
-      "end": "\"",
-      "captures": {
-        "operator": {
-          "name": "keyword.operator.case-insensitive.abnf"
+      ],
+      "beginCaptures": {
+        "0": {
+          "name": "meta.lhs.abnf"
+        },
+        "1": {
+          "name": "punctuation.whitespace.leading.abnf"
+        },
+        "2": {
+          "name": "entity.name.rule.identifier.abnf"
         }
       }
     },
-    "string-double-quoted-case-sensitive": {
-      "name": "string.quoted.double.case-sensitive.abnf",
-      "begin": "(?\u003coperator\u003e%s)\"",
+    "string": {
+      "name": "string.quoted.double.abnf",
+      "begin": "\"",
       "end": "\"",
-      "captures": {
-        "operator": {
-          "name": "keyword.operator.case-insensitive.abnf"
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.begin.abnf"
+        }
+      },
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.end.abnf"
         }
       }
     },
-    "variable-repetition": {
-      "match": "(?x)\n               # Repetition\n               (?:(?\u003cmin\u003e\\d*)(?\u003crepetition\u003e\\*)(?\u003cmax\u003e\\d*) |\n                  (?\u003cmax\u003e\\d+))\n               # Followed by ABNF element\n               (?=[a-zA-Z(\"])",
-      "captures": {
-        "max": {
-          "name": "constant.numeric.decimal.$max.abnf"
+    "terminal": {
+      "patterns": [
+        {
+          "name": "meta.terminal.numeric.decimal.abnf",
+          "begin": "(%)(d|D)",
+          "end": "(?=$|[;()\\[\\]{}\\s])",
+          "patterns": [
+            {
+              "name": "invalid.illegal.syntax.abnf",
+              "match": "[0-9A-Fa-f]*[^-\\s0-9.;()\\[\\]{}][^-.;()\\[\\]{}]*"
+            },
+            {
+              "name": "constant.numeric.integer.int.decimal.abnf",
+              "match": "[0-9]+"
+            },
+            {
+              "name": "punctuation.separator.range.dash.hyphen.abnf",
+              "match": "-"
+            },
+            {
+              "name": "keyword.operator.concatenation.abnf",
+              "match": "\\."
+            }
+          ],
+          "beginCaptures": {
+            "1": {
+              "name": "punctuation.definition.terminal.percentage-sign.abnf"
+            },
+            "2": {
+              "name": "storage.type.modifier.radix.abnf"
+            }
+          }
         },
-        "min": {
-          "name": "constant.numeric.decimal.$min.abnf"
+        {
+          "name": "meta.terminal.numeric.hexadecimal.hex.abnf",
+          "begin": "(%)(x|X)",
+          "end": "(?=$|[;()\\[\\]{}\\s])",
+          "patterns": [
+            {
+              "name": "invalid.illegal.syntax.abnf",
+              "match": "[0-9A-Fa-f]*[^-\\s0-9A-Fa-f.;()\\[\\]{}][^-.;()\\[\\]{}]*"
+            },
+            {
+              "name": "constant.numeric.integer.int.hexadecimal.hex.abnf",
+              "match": "[0-9A-Fa-f]+"
+            },
+            {
+              "name": "punctuation.separator.range.dash.hyphen.abnf",
+              "match": "-"
+            },
+            {
+              "name": "keyword.operator.concatenation.abnf",
+              "match": "\\."
+            }
+          ],
+          "beginCaptures": {
+            "1": {
+              "name": "punctuation.definition.terminal.percentage-sign.abnf"
+            },
+            "2": {
+              "name": "storage.type.modifier.radix.abnf"
+            }
+          }
         },
-        "repetition": {
-          "name": "keyword.operator.repetition.abnf"
+        {
+          "name": "meta.terminal.numeric.binary.bin.abnf",
+          "begin": "(%)(b|B)",
+          "end": "(?=$|[;()\\[\\]{}\\s])",
+          "patterns": [
+            {
+              "name": "invalid.illegal.syntax.abnf",
+              "match": "[0-1]*[^-\\s0-1.;()\\[\\]{}][^-.;()\\[\\]{}]*"
+            },
+            {
+              "name": "constant.numeric.integer.int.binary.bin.abnf",
+              "match": "[0-1]+"
+            },
+            {
+              "name": "punctuation.separator.range.dash.hyphen.abnf",
+              "match": "-"
+            },
+            {
+              "name": "keyword.operator.concatenation.abnf",
+              "match": "\\."
+            }
+          ],
+          "beginCaptures": {
+            "1": {
+              "name": "punctuation.definition.terminal.percentage-sign.abnf"
+            },
+            "2": {
+              "name": "storage.type.modifier.radix.abnf"
+            }
+          }
         }
-      }
+      ]
     }
   }
 }