tm-grammars 1.22.2 → 1.22.4

package/grammars/abap.json

@@ -35,11 +35,11 @@
       "name": "variable.other.abap"
     },
     {
-      "match": "\\b\\d+(\\b|\\.|,)",
+      "match": "\\b[0-9]+(\\b|\\.|,)",
       "name": "constant.numeric.abap"
     },
     {
-      "match": "(?i)(^|\\s+)((PUBLIC|PRIVATE|PROTECTED)\\sSECTION)(?=\\s+|:|\\.)",
+      "match": "(?ix)(^|\\s+)((PUBLIC|PRIVATE|PROTECTED)\\sSECTION)(?=\\s+|:|\\.)",
       "name": "storage.modifier.class.abap"
     },
     {
@@ -66,11 +66,11 @@
           "name": "constant.character.escape.abap"
         },
         {
-          "match": "(?i)(?<=\\s)(align|alpha|case|country|currency|date|decimals|exponent|number|pad|sign|style|time|timestamp|timezone|width|xsd|zero)(?=\\s=)",
+          "match": "(?ix)(?<=\\s)(align|alpha|case|country|currency|date|decimals|exponent|number|pad|sign|style|time|timestamp|timezone|width|xsd|zero)(?=\\s\\=)",
           "name": "entity.name.property.stringtemplate.abap"
         },
         {
-          "match": "(?i)(?<==\\s)(center|engineering|environment|in|iso|left|leftplus|leftspace|lower|no|out|raw|right|rightplus|rightspace|scale_preserving|scale_preserving_scientific|scientific|scientific_with_leading_zero|sign_as_postfix|simple|space|upper|user|yes)(?=\\s)",
+          "match": "(?ix)(?<=\\=\\s)(center|engineering|environment|in|iso|left|leftplus|leftspace|lower|no|out|raw|right|rightplus|rightspace|scale_preserving|scale_preserving_scientific|scientific|scientific_with_leading_zero|sign_as_postfix|simple|space|upper|user|yes)(?=\\s)",
           "name": "entity.value.property.stringtemplate.abap"
         }
       ]
@@ -111,7 +111,7 @@
       "name": "meta.block.begin.implementation.abap",
       "patterns": [
         {
-          "match": "(?i)(^|\\s+)(definition|implementation|public|inheriting\\s+from|final|deferred|abstract|shared\\s+memory\\s+enabled|(global|local)*\\s*friends|(create\\s+(public|protected|private))|for\\s+behavior\\s+of|for\\s+testing|risk\\s+level\\s+(critical|dangerous|harmless))|duration\\s(short|medium|long)(?=\\s+|\\.)",
+          "match": "(?ix)(^|\\s+)(definition|implementation|public|inheriting\\s+from|final|deferred|abstract|shared\\s+memory\\s+enabled|(global|local)*\\s*friends|(create\\s+(public|protected|private))|for\\s+behavior\\s+of|for\\s+testing|risk\\s+level\\s+(critical|dangerous|harmless))|duration\\s(short|medium|long)(?=\\s+|\\.)",
           "name": "storage.modifier.class.abap"
         },
         {
@@ -127,7 +127,7 @@
       ]
     },
     {
-      "begin": "(?i)^\\s*(method)\\s(?:([a-z_\\/][a-z_0-9\\/]*)~)?([a-z_\\/][a-z_0-9\\/]*)",
+      "begin": "(?ix)^\\s*(method)\\s(?:([a-z_\\/][a-z_0-9\\/]*)~)?([a-z_\\/][a-z_0-9\\/]*)",
       "beginCaptures": {
         "1": {
           "name": "storage.type.block.abap"
@@ -142,19 +142,19 @@
       "end": "\\s*\\.\\s*\\n?",
       "patterns": [
         {
-          "match": "(?i)(?<=^|\\s)(BY\\s+DATABASE(\\s+PROCEDURE|\\s+FUNCTION|\\s+GRAPH\\s+WORKSPACE)|BY\\s+KERNEL\\s+MODULE)(?=\\s+|\\.)",
+          "match": "(?ix)(?<=^|\\s)(BY\\s+DATABASE(\\s+PROCEDURE|\\s+FUNCTION|\\s+GRAPH\\s+WORKSPACE)|BY\\s+KERNEL\\s+MODULE)(?=\\s+|\\.)",
           "name": "storage.modifier.method.abap"
         },
         {
-          "match": "(?i)(?<=^|\\s)(FOR\\s+(HDB|LLANG))(?=\\s+|\\.)",
+          "match": "(?ix)(?<=^|\\s)(FOR\\s+(HDB|LLANG))(?=\\s+|\\.)",
           "name": "storage.modifier.method.abap"
         },
         {
-          "match": "(?i)(?<=\\s)(OPTIONS\\s+(READ-ONLY|DETERMINISTIC|SUPPRESS\\s+SYNTAX\\s+ERRORS))(?=\\s+|\\.)",
+          "match": "(?ix)(?<=\\s)(OPTIONS\\s+(READ-ONLY|DETERMINISTIC|SUPPRESS\\s+SYNTAX\\s+ERRORS))(?=\\s+|\\.)",
           "name": "storage.modifier.method.abap"
         },
         {
-          "match": "(?i)(?<=^|\\s)(LANGUAGE\\s+(SQLSCRIPT|SQL|GRAPH))(?=\\s+|\\.)",
+          "match": "(?ix)(?<=^|\\s)(LANGUAGE\\s+(SQLSCRIPT|SQL|GRAPH))(?=\\s+|\\.)",
           "name": "storage.modifier.method.abap"
         },
         {
@@ -163,7 +163,7 @@
               "name": "storage.modifier.method.abap"
             }
           },
-          "match": "(?i)(?<=\\s)(USING)\\s+([a-z_\\/][a-z_0-9\\/=>]*)+(?=\\s+|\\.)"
+          "match": "(?ix)(?<=\\s)(USING)\\s+([a-z_\\/][a-z_0-9\\/=\\>]*)+(?=\\s+|\\.)"
         },
         {
           "begin": "(?=[A-Za-z_][A-Za-z0-9_]*)",
@@ -177,7 +177,7 @@
       ]
     },
     {
-      "begin": "(?i)^\\s*(INTERFACE)\\s([a-z_\\/][a-z_0-9\\/]*)",
+      "begin": "(?ix)^\\s*(INTERFACE)\\s([a-z_\\/][a-z_0-9\\/]*)",
       "beginCaptures": {
         "1": {
           "name": "storage.type.block.abap"
@@ -189,13 +189,13 @@
       "end": "\\s*\\.\\s*\\n?",
       "patterns": [
         {
-          "match": "(?i)(?<=^|\\s)(DEFERRED|PUBLIC)(?=\\s+|\\.)",
+          "match": "(?ix)(?<=^|\\s)(DEFERRED|PUBLIC)(?=\\s+|\\.)",
           "name": "storage.modifier.method.abap"
         }
       ]
     },
     {
-      "begin": "(?i)^\\s*(FORM)\\s([a-z_\\/][a-z_0-9\\/\\-?]*)",
+      "begin": "(?ix)^\\s*(FORM)\\s([a-z_\\/][a-z_0-9\\/\\-\\?]*)",
       "beginCaptures": {
         "1": {
           "name": "storage.type.block.abap"
@@ -207,7 +207,7 @@
       "end": "\\s*\\.\\s*\\n?",
       "patterns": [
         {
-          "match": "(?i)(?<=^|\\s)(USING|TABLES|CHANGING|RAISING|IMPLEMENTATION|DEFINITION)(?=\\s+|\\.)",
+          "match": "(?ix)(?<=^|\\s)(USING|TABLES|CHANGING|RAISING|IMPLEMENTATION|DEFINITION)(?=\\s+|\\.)",
           "name": "storage.modifier.form.abap"
         },
         {
@@ -256,35 +256,35 @@
   ],
   "repository": {
     "abap_constants": {
-      "match": "(?i)(?<=\\s)(initial|null|@?space|@?abap_true|@?abap_false|@?abap_undefined|table_line|%_final|%_hints|%_predefined|col_background|col_group|col_heading|col_key|col_negative|col_normal|col_positive|col_total|adabas|as400|db2|db6|hdb|oracle|sybase|mssqlnt|pos_low|pos_high)(?=\\s|\\.|,)",
+      "match": "(?ix)(?<=\\s)(initial|null|@?space|@?abap_true|@?abap_false|@?abap_undefined|table_line|\n                                %_final|%_hints|%_predefined|col_background|col_group|col_heading|col_key|col_negative|col_normal|col_positive|col_total|\n\t\t\t\tadabas|as400|db2|db6|hdb|oracle|sybase|mssqlnt|pos_low|pos_high)(?=\\s|\\.|,)",
       "name": "constant.language.abap"
     },
     "abaptypes": {
       "patterns": [
         {
-          "match": "(?i)\\s(abap_bool|string|xstring|any|clike|csequence|numeric|xsequence|decfloat|decfloat16|decfloat34|utclong|simple|int8|c|n|i|p|f|d|t|x)(?=\\s|\\.|,)",
+          "match": "(?ix)\\s(abap_bool|string|xstring|any|clike|csequence|numeric|xsequence|decfloat|decfloat16|decfloat34|utclong|simple|int8|c|n|i|p|f|d|t|x)(?=\\s|\\.|,)",
           "name": "support.type.abap"
         },
         {
-          "match": "(?i)\\s(TYPE|REF|TO|LIKE|LINE|OF|STRUCTURE|STANDARD|SORTED|HASHED|INDEX|TABLE|WITH|UNIQUE|NON-UNIQUE|SECONDARY|DEFAULT|KEY)(?=\\s|\\.|,)",
+          "match": "(?ix)\\s(TYPE|REF|TO|LIKE|LINE|OF|STRUCTURE|STANDARD|SORTED|HASHED|INDEX|TABLE|WITH|UNIQUE|NON-UNIQUE|SECONDARY|DEFAULT|KEY)(?=\\s|\\.|,)",
           "name": "keyword.control.simple.abap"
         }
       ]
     },
     "arithmetic_operator": {
-      "match": "(?i)(?<=\\s)(\\+|-|\\*|\\*\\*|\\/|%|DIV|MOD|BIT-AND|BIT-OR|BIT-XOR|BIT-NOT)(?=\\s)",
+      "match": "(?i)(?<=\\s)(\\+|\\-|\\*|\\*\\*|\\/|%|DIV|MOD|BIT-AND|BIT-OR|BIT-XOR|BIT-NOT)(?=\\s)",
       "name": "keyword.control.simple.abap"
     },
     "builtin_functions": {
-      "match": "(?i)(?<=\\s)(abs|sign|ceil|floor|trunc|frac|acos|asin|atan|cos|sin|tan|cosh|sinh|tanh|exp|log|log10|sqrt|strlen|xstrlen|charlen|lines|numofchar|dbmaxlen|round|rescale|nmax|nmin|cmax|cmin|boolc|boolx|xsdbool|contains|contains_any_of|contains_any_not_of|matches|line_exists|ipow|char_off|count|count_any_of|count_any_not_of|distance|condense|concat_lines_of|escape|find|find_end|find_any_of|find_any_not_of|insert|match|repeat|replace|reverse|segment|shift_left|shift_right|substring|substring_after|substring_from|substring_before|substring_to|to_upper|to_lower|to_mixed|from_mixed|translate|bit-set|line_index)(?=\\()",
+      "match": "(?ix)(?<=\\s)(abs|sign|ceil|floor|trunc|frac|acos|asin|atan|cos|sin|tan|cosh|sinh|tanh|exp|log|log10|sqrt|strlen|xstrlen|charlen|lines|numofchar|dbmaxlen|round|rescale|nmax|nmin|cmax|cmin|boolc|boolx|xsdbool|contains|contains_any_of|contains_any_not_of|matches|line_exists|ipow|char_off|count|count_any_of|count_any_not_of|distance|condense|concat_lines_of|escape|find|find_end|find_any_of|find_any_not_of|insert|match|repeat|replace|reverse|segment|shift_left|shift_right|substring|substring_after|substring_from|substring_before|substring_to|to_upper|to_lower|to_mixed|from_mixed|translate|bit-set|line_index)(?=\\()",
       "name": "entity.name.function.builtin.abap"
     },
     "comparison_operator": {
-      "match": "(?i)(?<=\\s)(<|>|<=|>=|=|<>|eq|ne|lt|le|gt|ge|cs|cp|co|cn|ca|na|ns|np|byte-co|byte-cn|byte-ca|byte-na|byte-cs|byte-ns|o|z|m)(?=\\s)",
+      "match": "(?i)(?<=\\s)(<|>|<\\=|>\\=|\\=|<>|eq|ne|lt|le|gt|ge|cs|cp|co|cn|ca|na|ns|np|byte-co|byte-cn|byte-ca|byte-na|byte-cs|byte-ns|o|z|m)(?=\\s)",
       "name": "keyword.control.simple.abap"
     },
     "control_keywords": {
-      "match": "(?i)(^|\\s)(at|case|catch|continue|do|elseif|else|endat|endcase|endcatch|enddo|endif|endloop|endon|endtry|endwhile|if|loop|on|raise|try|while)(?=\\s|\\.|:)",
+      "match": "(?ix)(^|\\s)(\n\t        at|case|catch|continue|do|elseif|else|endat|endcase|endcatch|enddo|endif|\n\t        endloop|endon|endtry|endwhile|if|loop|on|raise|try|while)(?=\\s|\\.|:)",
       "name": "keyword.control.flow.abap"
     },
     "generic_names": {
@@ -315,14 +315,14 @@
           "name": "variable.other.abap"
         }
       },
-      "match": "(?i)\\b(data|value|field-symbol|final|reference|resumable)\\((<?[a-z_\\/][a-z_0-9\\/]*>?)\\)"
+      "match": "(?ix)\\b(data|value|field-symbol|final|reference|resumable)\\((<?[a-z_\\/][a-z_0-9\\/]*>?)\\)"
     },
     "logical_operator": {
       "match": "(?i)(?<=\\s)(not|or|and)(?=\\s)",
       "name": "keyword.control.simple.abap"
     },
     "main_keywords": {
-      "match": "(?i)(?<=^|\\s)(abap-source|abstract|accept|accepting|access|according|action|activation|actual|add|add-corresponding|adjacent|after|alias|aliases|all|allocate|amdp|analysis|analyzer|append|appending|application|archive|area|arithmetic|as|ascending|assert|assign|assigned|assigning|association|asynchronous|at|attributes|authority|authority-check|authorization|auto|back|background|backward|badi|base|before|begin|behavior|between|binary|bit|blank|blanks|block|blocks|bound|boundaries|bounds|boxed|break|break-point|buffer|by|bypassing|byte|byte-order|call|calling|cast|casting|cds|centered|change|changing|channels|char-to-hex|character|check|checkbox|cid|circular|class|class-data|class-events|class-method|class-methods|class-pool|cleanup|clear|client|clients|clock|clone|close|cnt|code|collect|color|column|comment|comments|commit|common|communication|comparing|component|components|compression|compute|concatenate|cond|condense|condition|connection|constant|constants|context|contexts|control|controls|conv|conversion|convert|copy|corresponding|count|country|cover|create|currency|current|cursor|customer-function|data|database|datainfo|dataset|date|daylight|ddl|deallocate|decimals|declarations|deep|default|deferred|define|delete|deleting|demand|descending|describe|destination|detail|determine|dialog|did|directory|discarding|display|display-mode|distance|distinct|divide|divide-corresponding|dummy|duplicate|duplicates|duration|during|dynpro|edit|editor-call|empty|enabled|enabling|encoding|end|end-enhancement-section|end-of-definition|end-of-page|end-of-selection|end-test-injection|end-test-seam|endenhancement|endexec|endfunction|endian|ending|endmodule|endprovide|endselect|endwith|enhancement|enhancement-point|enhancement-section|enhancements|entities|entity|entries|entry|enum|equiv|errors|escape|escaping|event|events|exact|except|exception|exception-table|exceptions|excluding|exec|execute|exists|exit|exit-command|expanding|explicit|exponent|export|exporting|extended|extension|extract|fail|failed|features|fetch|field|field-groups|field-symbols|fields|file|fill|filter|filters|final|find|first|first-line|fixed-point|flush|following|for|format|forward|found|frame|frames|free|from|full|function|function-pool|generate|get|giving|graph|group|groups|handle|handler|hashed|having|header|headers|heading|help-id|help-request|hide|hint|hold|hotspot|icon|id|identification|identifier|ignore|ignoring|immediately|implemented|implicit|import|importing|in|inactive|incl|include|includes|including|increment|index|index-line|indicators|infotypes|inheriting|init|initial|initialization|inner|input|insert|instance|instances|intensified|interface|interface-pool|interfaces|internal|intervals|into|inverse|inverted-date|is|job|join|keep|keeping|kernel|key|keys|keywords|kind|language|last|late|layout|leading|leave|left|left-justified|legacy|length|let|level|levels|like|line|line-count|line-selection|line-size|linefeed|lines|link|list|list-processing|listbox|load|load-of-program|local|locale|lock|locks|log-point|logical|lower|mapped|mapping|margin|mark|mask|match|matchcode|maximum|members|memory|mesh|message|message-id|messages|messaging|method|methods|mode|modif|modifier|modify|module|move|move-corresponding|multiply|multiply-corresponding|name|nametab|native|nested|nesting|new|new-line|new-page|new-section|next|no-display|no-extension|no-gap|no-gaps|no-grouping|no-heading|no-scrolling|no-sign|no-title|no-zero|nodes|non-unicode|non-unique|number|object|objects|objmgr|obligatory|occurence|occurences|occurrence|occurrences|occurs|of|offset|on|only|open|optional|option|options|order|others|out|outer|output|output-length|overflow|overlay|pack|package|padding|page|parameter|parameter-table|parameters|part|partially|pcre|perform|performing|permissions|pf-status|places|pool|position|pragmas|preceding|precompiled|preferred|preserving|primary|print|print-control|private|privileged|procedure|process|program|property|protected|provide|push|pushbutton|put|query|queue-only|queueonly|quickinfo|radiobutton|raising|range|ranges|read|read-only|receive|received|receiving|redefinition|reduce|ref|reference|refresh|regex|reject|renaming|replace|replacement|replacing|report|reported|request|requested|required|reserve|reset|resolution|respecting|response|restore|result|results|resumable|resume|retry|return|returning|right|right-justified|rollback|rows|rp-provide-from-last|run|sap|sap-spool|save|saving|scan|screen|scroll|scroll-boundary|scrolling|search|seconds|section|select|select-options|selection|selection-screen|selection-set|selection-sets|selection-table|selections|send|separate|separated|session|set|shared|shift|shortdump|shortdump-id|sign|simple|simulation|single|size|skip|skipping|smart|some|sort|sortable|sorted|source|specified|split|spool|spots|sql|stable|stamp|standard|start-of-selection|starting|state|statement|statements|static|statics|statusinfo|step|step-loop|stop|structure|structures|style|subkey|submatches|submit|subroutine|subscreen|substring|subtract|subtract-corresponding|suffix|sum|summary|supplied|supply|suppress|switch|symbol|syntax-check|syntax-trace|system-call|system-exceptions|tab|tabbed|table|tables|tableview|tabstrip|target|task|tasks|test|test-injection|test-seam|testing|text|textpool|then|throw|time|times|title|titlebar|to|tokens|top-lines|top-of-page|trace-file|trace-table|trailing|transaction|transfer|transformation|translate|transporting|trmac|truncate|truncation|type|type-pool|type-pools|types|uline|unassign|unbounded|under|unicode|union|unique|unit|unix|unpack|until|unwind|up|update|upper|user|user-command|using|utf-8|uuid|valid|validate|value|value-request|values|vary|varying|version|via|visible|wait|when|where|window|windows|with|with-heading|with-title|without|word|work|workspace|write|xml|zone)(?=\\s|\\.|:|,)",
+      "match": "(?ix)(?<=^|\\s)(\nabap-source|\nabstract|\naccept|\naccepting|\naccess|\naccording|\naction|\nactivation|\nactual|\nadd|\nadd-corresponding|\nadjacent|\nafter|\nalias|\naliases|\nall|\nallocate|\namdp|\nanalysis|\nanalyzer|\nappend|\nappending|\napplication|\narchive|\narea|\narithmetic|\nas|\nascending|\nassert|\nassign|\nassigned|\nassigning|\nassociation|\nasynchronous|\nat|\nattributes|\nauthority|\nauthority-check|\nauthorization|\nauto|\nback|\nbackground|\nbackward|\nbadi|\nbase|\nbefore|\nbegin|\nbehavior|\nbetween|\nbinary|\nbit|\nblank|\nblanks|\nblock|\nblocks|\nbound|\nboundaries|\nbounds|\nboxed|\nbreak|\nbreak-point|\nbuffer|\nby|\nbypassing|\nbyte|\nbyte-order|\ncall|\ncalling|\ncast|\ncasting|\ncds|\ncentered|\nchange|\nchanging|\nchannels|\nchar-to-hex|\ncharacter|\ncheck|\ncheckbox|\ncid|\ncircular|\nclass|\nclass-data|\nclass-events|\nclass-method|\nclass-methods|\nclass-pool|\ncleanup|\nclear|\nclient|\nclients|\nclock|\nclone|\nclose|\ncnt|\ncode|\ncollect|\ncolor|\ncolumn|\ncomment|\ncomments|\ncommit|\ncommon|\ncommunication|\ncomparing|\ncomponent|\ncomponents|\ncompression|\ncompute|\nconcatenate|\ncond|\ncondense|\ncondition|\nconnection|\nconstant|\nconstants|\ncontext|\ncontexts|\ncontrol|\ncontrols|\nconv|\nconversion|\nconvert|\ncopy|\ncorresponding|\ncount|\ncountry|\ncover|\ncreate|\ncurrency|\ncurrent|\ncursor|\ncustomer-function|\ndata|\ndatabase|\ndatainfo|\ndataset|\ndate|\ndaylight|\nddl|\ndeallocate|\ndecimals|\ndeclarations|\ndeep|\ndefault|\ndeferred|\ndefine|\ndelete|\ndeleting|\ndemand|\ndescending|\ndescribe|\ndestination|\ndetail|\ndetermine|\ndialog|\ndid|\ndirectory|\ndiscarding|\ndisplay|\ndisplay-mode|\ndistance|\ndistinct|\ndivide|\ndivide-corresponding|\ndummy|\nduplicate|\nduplicates|\nduration|\nduring|\ndynpro|\nedit|\neditor-call|\nempty|\nenabled|\nenabling|\nencoding|\nend|\nend-enhancement-section|\nend-of-definition|\nend-of-page|\nend-of-selection|\nend-test-injection|\nend-test-seam|\nendenhancement|\nendexec|\nendfunction|\nendian|\nending|\nendmodule|\nendprovide|\nendselect|\nendwith|\nenhancement|\nenhancement-point|\nenhancement-section|\nenhancements|\nentities|\nentity|\nentries|\nentry|\nenum|\nequiv|\nerrors|\nescape|\nescaping|\nevent|\nevents|\nexact|\nexcept|\nexception|\nexception-table|\nexceptions|\nexcluding|\nexec|\nexecute|\nexists|\nexit|\nexit-command|\nexpanding|\nexplicit|\nexponent|\nexport|\nexporting|\nextended|\nextension|\nextract|\nfail|\nfailed|\nfeatures|\nfetch|\nfield|\nfield-groups|\nfield-symbols|\nfields|\nfile|\nfill|\nfilter|\nfilters|\nfinal|\nfind|\nfirst|\nfirst-line|\nfixed-point|\nflush|\nfollowing|\nfor|\nformat|\nforward|\nfound|\nframe|\nframes|\nfree|\nfrom|\nfull|\nfunction|\nfunction-pool|\ngenerate|\nget|\ngiving|\ngraph|\ngroup|\ngroups|\nhandle|\nhandler|\nhashed|\nhaving|\nheader|\nheaders|\nheading|\nhelp-id|\nhelp-request|\nhide|\nhint|\nhold|\nhotspot|\nicon|\nid|\nidentification|\nidentifier|\nignore|\nignoring|\nimmediately|\nimplemented|\nimplicit|\nimport|\nimporting|\nin|\ninactive|\nincl|\ninclude|\nincludes|\nincluding|\nincrement|\nindex|\nindex-line|\nindicators|\ninfotypes|\ninheriting|\ninit|\ninitial|\ninitialization|\ninner|\ninput|\ninsert|\ninstance|\ninstances|\nintensified|\ninterface|\ninterface-pool|\ninterfaces|\ninternal|\nintervals|\ninto|\ninverse|\ninverted-date|\nis|\njob|\njoin|\nkeep|\nkeeping|\nkernel|\nkey|\nkeys|\nkeywords|\nkind|\nlanguage|\nlast|\nlate|\nlayout|\nleading|\nleave|\nleft|\nleft-justified|\nlegacy|\nlength|\nlet|\nlevel|\nlevels|\nlike|\nline|\nline-count|\nline-selection|\nline-size|\nlinefeed|\nlines|\nlink|\nlist|\nlist-processing|\nlistbox|\nload|\nload-of-program|\nlocal|\nlocale|\nlock|\nlocks|\nlog-point|\nlogical|\nlower|\nmapped|\nmapping|\nmargin|\nmark|\nmask|\nmatch|\nmatchcode|\nmaximum|\nmembers|\nmemory|\nmesh|\nmessage|\nmessage-id|\nmessages|\nmessaging|\nmethod|\nmethods|\nmode|\nmodif|\nmodifier|\nmodify|\nmodule|\nmove|\nmove-corresponding|\nmultiply|\nmultiply-corresponding|\nname|\nnametab|\nnative|\nnested|\nnesting|\nnew|\nnew-line|\nnew-page|\nnew-section|\nnext|\nno-display|\nno-extension|\nno-gap|\nno-gaps|\nno-grouping|\nno-heading|\nno-scrolling|\nno-sign|\nno-title|\nno-zero|\nnodes|\nnon-unicode|\nnon-unique|\nnumber|\nobject|\nobjects|\nobjmgr|\nobligatory|\noccurence|\noccurences|\noccurrence|\noccurrences|\noccurs|\nof|\noffset|\non|\nonly|\nopen|\noptional|\noption|\noptions|\norder|\nothers|\nout|\nouter|\noutput|\noutput-length|\noverflow|\noverlay|\npack|\npackage|\npadding|\npage|\nparameter|\nparameter-table|\nparameters|\npart|\npartially|\npcre|\nperform|\nperforming|\npermissions|\npf-status|\nplaces|\npool|\nposition|\npragmas|\npreceding|\nprecompiled|\npreferred|\npreserving|\nprimary|\nprint|\nprint-control|\nprivate|\nprivileged|\nprocedure|\nprocess|\nprogram|\nproperty|\nprotected|\nprovide|\npush|\npushbutton|\nput|\nquery|\nqueue-only|\nqueueonly|\nquickinfo|\nradiobutton|\nraising|\nrange|\nranges|\nread|\nread-only|\nreceive|\nreceived|\nreceiving|\nredefinition|\nreduce|\nref|\nreference|\nrefresh|\nregex|\nreject|\nrenaming|\nreplace|\nreplacement|\nreplacing|\nreport|\nreported|\nrequest|\nrequested|\nrequired|\nreserve|\nreset|\nresolution|\nrespecting|\nresponse|\nrestore|\nresult|\nresults|\nresumable|\nresume|\nretry|\nreturn|\nreturning|\nright|\nright-justified|\nrollback|\nrows|\nrp-provide-from-last|\nrun|\nsap|\nsap-spool|\nsave|\nsaving|\nscan|\nscreen|\nscroll|\nscroll-boundary|\nscrolling|\nsearch|\nseconds|\nsection|\nselect|\nselect-options|\nselection|\nselection-screen|\nselection-set|\nselection-sets|\nselection-table|\nselections|\nsend|\nseparate|\nseparated|\nsession|\nset|\nshared|\nshift|\nshortdump|\nshortdump-id|\nsign|\nsimple|\nsimulation|\nsingle|\nsize|\nskip|\nskipping|\nsmart|\nsome|\nsort|\nsortable|\nsorted|\nsource|\nspecified|\nsplit|\nspool|\nspots|\nsql|\nstable|\nstamp|\nstandard|\nstart-of-selection|\nstarting|\nstate|\nstatement|\nstatements|\nstatic|\nstatics|\nstatusinfo|\nstep|\nstep-loop|\nstop|\nstructure|\nstructures|\nstyle|\nsubkey|\nsubmatches|\nsubmit|\nsubroutine|\nsubscreen|\nsubstring|\nsubtract|\nsubtract-corresponding|\nsuffix|\nsum|\nsummary|\nsupplied|\nsupply|\nsuppress|\nswitch|\nsymbol|\nsyntax-check|\nsyntax-trace|\nsystem-call|\nsystem-exceptions|\ntab|\ntabbed|\ntable|\ntables|\ntableview|\ntabstrip|\ntarget|\ntask|\ntasks|\ntest|\ntest-injection|\ntest-seam|\ntesting|\ntext|\ntextpool|\nthen|\nthrow|\ntime|\ntimes|\ntitle|\ntitlebar|\nto|\ntokens|\ntop-lines|\ntop-of-page|\ntrace-file|\ntrace-table|\ntrailing|\ntransaction|\ntransfer|\ntransformation|\ntranslate|\ntransporting|\ntrmac|\ntruncate|\ntruncation|\ntype|\ntype-pool|\ntype-pools|\ntypes|\nuline|\nunassign|\nunbounded|\nunder|\nunicode|\nunion|\nunique|\nunit|\nunix|\nunpack|\nuntil|\nunwind|\nup|\nupdate|\nupper|\nuser|\nuser-command|\nusing|\nutf-8|\nuuid|\nvalid|\nvalidate|\nvalue|\nvalue-request|\nvalues|\nvary|\nvarying|\nversion|\nvia|\nvisible|\nwait|\nwhen|\nwhere|\nwindow|\nwindows|\nwith|\nwith-heading|\nwith-title|\nwithout|\nword|\nwork|\nworkspace|\nwrite|\nxml|\nzone\n\t\t        \t)(?=\\s|\\.|:|,)",
       "name": "keyword.control.simple.abap"
     },
     "operators": {
@@ -346,15 +346,15 @@
       "name": "keyword.control.simple.abap"
     },
     "reserved_names": {
-      "match": "(?i)(?<=\\s)(me|super)(?=\\s|\\.|,|->)",
+      "match": "(?ix)(?<=\\s)(me|super)(?=\\s|\\.|,|->)",
       "name": "constant.language.abap"
     },
     "sql_functions": {
-      "match": "(?i)(?<=\\s)(abap_system_timezone|abap_user_timezone|abs|add_days|add_months|allow_precision_loss|as_geo_json|avg|bintohex|cast|ceil|coalesce|concat_with_space|concat|corr_spearman|corr|count|currency_conversion|datn_add_days|datn_add_months|datn_days_between|dats_add_days|dats_add_months|dats_days_between|dats_from_datn|dats_is_valid|dats_tims_to_tstmp|dats_to_datn|dayname|days_between|dense_rank|division|div|extract_day|extract_hour|extract_minute|extract_month|extract_second|extract_year|first_value|floor|grouping|hextobin|initcap|instr|is_valid|lag|last_value|lead|left|length|like_regexpr|locate_regexpr_after|locate_regexpr|locate|lower|lpad|ltrim|max|median|min|mod|monthname|ntile|occurrences_regexpr|over|product|rank|replace_regexpr|replace|rigth|round|row_number|rpad|rtrim|stddev|string_agg|substring_regexpr|substring|sum|tims_from_timn|tims_is_valid|tims_to_timn|to_blob|to_clob|tstmp_add_seconds|tstmp_current_utctimestamp|tstmp_is_valid|tstmp_seconds_between|tstmp_to_dats|tstmp_to_dst|tstmp_to_tims|tstmpl_from_utcl|tstmpl_to_utcl|unit_conversion|upper|utcl_add_seconds|utcl_current|utcl_seconds_between|uuid|var|weekday)(?=\\()",
+      "match": "(?ix)(?<=\\s)(\nabap_system_timezone|\nabap_user_timezone|\nabs|\nadd_days|\nadd_months|\nallow_precision_loss|\nas_geo_json|\navg|\nbintohex|\ncast|\nceil|\ncoalesce|\nconcat_with_space|\nconcat|\ncorr_spearman|\ncorr|\ncount|\ncurrency_conversion|\ndatn_add_days|\ndatn_add_months|\ndatn_days_between|\ndats_add_days|\ndats_add_months|\ndats_days_between|\ndats_from_datn|\ndats_is_valid|\ndats_tims_to_tstmp|\ndats_to_datn|\ndayname|\ndays_between|\ndense_rank|\ndivision|\ndiv|\nextract_day|\nextract_hour|\nextract_minute|\nextract_month|\nextract_second|\nextract_year|\nfirst_value|\nfloor|\ngrouping|\nhextobin|\ninitcap|\ninstr|\nis_valid|\nlag|\nlast_value|\nlead|\nleft|\nlength|\nlike_regexpr|\nlocate_regexpr_after|\nlocate_regexpr|\nlocate|\nlower|\nlpad|\nltrim|\nmax|\nmedian|\nmin|\nmod|\nmonthname|\nntile|\noccurrences_regexpr|\nover|\nproduct|\nrank|\nreplace_regexpr|\nreplace|\nrigth|\nround|\nrow_number|\nrpad|\nrtrim|\nstddev|\nstring_agg|\nsubstring_regexpr|\nsubstring|\nsum|\ntims_from_timn|\ntims_is_valid|\ntims_to_timn|\nto_blob|\nto_clob|\ntstmp_add_seconds|\ntstmp_current_utctimestamp|\ntstmp_is_valid|\ntstmp_seconds_between|\ntstmp_to_dats|\ntstmp_to_dst|\ntstmp_to_tims|\ntstmpl_from_utcl|\ntstmpl_to_utcl|\nunit_conversion|\nupper|\nutcl_add_seconds|\nutcl_current|\nutcl_seconds_between|\nuuid|\nvar|\nweekday\n                                )(?=\\()",
       "name": "entity.name.function.sql.abap"
     },
     "sql_types": {
-      "match": "(?i)(?<=\\s)(char|clnt|cuky|curr|datn|dats|dec|decfloat16|decfloat34|fltp|int1|int2|int4|int8|lang|numc|quan|raw|sstring|timn|tims|unit|utclong)(?=\\s|\\(|\\))",
+      "match": "(?ix)(?<=\\s)(char|clnt|cuky|curr|datn|dats|dec|decfloat16|decfloat34|fltp|int1|int2|int4|int8|lang|numc|quan|raw|sstring|timn|tims|unit|utclong)(?=\\s|\\(|\\))",
       "name": "entity.name.type.sql.abap"
     },
     "system_fields": {
@@ -366,7 +366,7 @@
           "name": "variable.language.abap"
         }
       },
-      "match": "(?i)\\b(sy)-(abcde|batch|binpt|calld|callr|colno|cpage|cprog|cucol|curow|datar|datlo|datum|dayst|dbcnt|dbnam|dbsysc|dyngr|dynnr|fdayw|fdpos|host|index|langu|ldbpg|lilli|linct|linno|linsz|lisel|listi|loopc|lsind|macol|mandt|marow|modno|msgid|msgli|msgno|msgty|msgv[1-4]|opsysc|pagno|pfkey|repid|saprl|scols|slset|spono|srows|staco|staro|stepl|subrc|sysid|tabix|tcode|tfill|timlo|title|tleng|tvar\\d|tzone|ucomm|uline|uname|uzeit|vline|wtitl|zonlo)(?=\\.|\\s)"
+      "match": "(?ix)\\b(sy)-(abcde|batch|binpt|calld|callr|colno|cpage|cprog|cucol|curow|datar|datlo|datum|dayst|dbcnt|dbnam|dbsysc|dyngr|dynnr|fdayw|fdpos|host|index|langu|ldbpg|lilli|linct|linno|linsz|lisel|listi|loopc|lsind|macol|mandt|marow|modno|msgid|msgli|msgno|msgty|msgv[1-4]|opsysc|pagno|pfkey|repid|saprl|scols|slset|spono|srows|staco|staro|stepl|subrc|sysid|tabix|tcode|tfill|timlo|title|tleng|tvar[0-9]|tzone|ucomm|uline|uname|uzeit|vline|wtitl|zonlo)(?=\\.|\\s)"
     },
     "text_symbols": {
       "captures": {
@@ -377,7 +377,7 @@
           "name": "constant.numeric.abap"
         }
       },
-      "match": "(?i)(?<=^|\\s)(text)-([A-Z0-9]{1,3})(?=\\s|\\.|:|,)"
+      "match": "(?ix)(?<=^|\\s)(text)-([A-Z0-9]{1,3})(?=\\s|\\.|:|,)"
     }
   },
   "scopeName": "source.abap"

package/grammars/actionscript-3.json

@@ -92,7 +92,7 @@
   ],
   "repository": {
     "arithmetic_operators": {
-      "match": "(\\+|-|/|%|(?<!:)\\*)",
+      "match": "(\\+|\\-|/|%|(?<!:)\\*)",
       "name": "keyword.operator.actionscript.3"
     },
     "array_access_operators": {
@@ -358,7 +358,7 @@
       ]
     },
     "functions": {
-      "begin": "\\b(function)\\b(?:\\s+\\b(get|set)\\b\\s+)?\\s*([a-zA-Z0-9_$]+\\b)?",
+      "begin": "\\b(function)\\b(?:\\s+\\b(get|set)\\b\\s+)?\\s*([a-zA-Z0-9_\\$]+\\b)?",
       "beginCaptures": {
         "1": {
           "name": "storage.type.function.actionscript.3"
@@ -391,7 +391,7 @@
         }
       },
       "comment": "Following convention, let's guess that anything in all caps/digits (possible underscores) is a constant.",
-      "match": "\\b([A-Z$][A-Z0-9_]+)\\b"
+      "match": "\\b([A-Z\\$][A-Z0-9_]+)\\b"
     },
     "guess_type": {
       "captures": {
@@ -400,7 +400,7 @@
         }
       },
       "comment": "Following convention, let's guess that any word starting with one or more capital letters (that contains at least some lower-case letters so that constants aren't detected) refers to a class/type. May be fully-qualified.",
-      "match": "\\b((?:[A-Za-z0-9_$]+\\.)*[A-Z][A-Z0-9]*[a-z]+[A-Za-z0-9_$]*)\\b"
+      "match": "\\b((?:[A-Za-z0-9_\\$]+\\.)*[A-Z][A-Z0-9]*[a-z]+[A-Za-z0-9_\\$]*)\\b"
     },
     "implements": {
       "captures": {
@@ -426,7 +426,7 @@
           "name": "support.type.actionscript.3"
         }
       },
-      "match": "(^|\\s+|;)\\b(import)\\b\\s+([A-Za-z0-9$_\\.]+(?:\\.\\*)?)\\s*(?=;|$)",
+      "match": "(^|\\s+|;)\\b(import)\\b\\s+([A-Za-z0-9\\$_\\.]+(?:\\.\\*)?)\\s*(?=;|$)",
       "name": "meta.import.actionscript.3"
     },
     "interface": {
@@ -642,11 +642,11 @@
           "name": "storage.modifier.actionscript.3"
         }
       },
-      "match": "((\\w+)\\s+)?(namespace)\\s+(?:[A-Za-z0-9_$]+)",
+      "match": "((\\w+)\\s+)?(namespace)\\s+(?:[A-Za-z0-9_\\$]+)",
       "name": "meta.namespace_declaration.actionscript.3"
     },
     "numbers": {
-      "match": "\\b((0(x|X)[0-9a-fA-F]*)|((\\d+\\.?\\d*)|(\\.\\d+))((e|E)(\\+|-)?\\d+)?)(L|l|UL|ul|u|U|F|f)?\\b",
+      "match": "\\b((0(x|X)[0-9a-fA-F]*)|(([0-9]+\\.?[0-9]*)|(\\.[0-9]+))((e|E)(\\+|-)?[0-9]+)?)(L|l|UL|ul|u|U|F|f)?\\b",
       "name": "constant.numeric.actionscript.3"
     },
     "object_literal": {
@@ -772,7 +772,7 @@
       "name": "meta.package_name.actionscript.3"
     },
     "parameters": {
-      "begin": "(\\.\\.\\.)?\\s*([A-Za-z_$][A-Za-z0-9_$]*)(?:\\s*(:)\\s*(?:(?:([A-Za-z$][A-Za-z0-9_$]+(?:\\.[A-Za-z$][A-Za-z0-9_$]+)*)(?:\\.<([A-Za-z$][A-Za-z0-9_$]+(?:\\.[A-Za-z$][A-Za-z0-9_$]+)*)>)?)|(\\*)))?(?:\\s*(=))?",
+      "begin": "(\\.\\.\\.)?\\s*([A-Za-z\\_\\$][A-Za-z0-9_\\$]*)(?:\\s*(\\:)\\s*(?:(?:([A-Za-z\\$][A-Za-z0-9_\\$]+(?:\\.[A-Za-z\\$][A-Za-z0-9_\\$]+)*)(?:\\.<([A-Za-z\\$][A-Za-z0-9_\\$]+(?:\\.[A-Za-z\\$][A-Za-z0-9_\\$]+)*)>)?)|(\\*)))?(?:\\s*(=))?",
       "beginCaptures": {
         "1": {
           "name": "keyword.operator.actionscript.3"
@@ -881,7 +881,7 @@
           "name": "support.type.actionscript.3"
         }
       },
-      "match": "(:)\\s*(?:([A-Za-z$][A-Za-z0-9_$]+(?:\\.[A-Za-z$][A-Za-z0-9_$]+)*)(?:\\.<([A-Za-z$][A-Za-z0-9_$]+(?:\\.[A-Za-z$][A-Za-z0-9_$]+)*)>)?)|(\\*)"
+      "match": "(\\:)\\s*(?:([A-Za-z\\$][A-Za-z0-9_\\$]+(?:\\.[A-Za-z\\$][A-Za-z0-9_\\$]+)*)(?:\\.<([A-Za-z\\$][A-Za-z0-9_\\$]+(?:\\.[A-Za-z\\$][A-Za-z0-9_\\$]+)*)>)?)|(\\*)"
     },
     "strings": {
       "patterns": [
@@ -944,7 +944,7 @@
           "name": "keyword.operator.actionscript.3"
         }
       },
-      "match": "((static)\\s+)?((\\w+)\\s+)?((static)\\s+)?(const|var)\\s+(?:[A-Za-z0-9_$]+)(?:\\s*(:))?",
+      "match": "((static)\\s+)?((\\w+)\\s+)?((static)\\s+)?(const|var)\\s+(?:[A-Za-z0-9_\\$]+)(?:\\s*(:))?",
       "name": "meta.variable_declaration.actionscript.3"
     },
     "vector_creation_operators": {

package/grammars/ada.json

@@ -198,7 +198,7 @@
           ]
         }
       },
-      "match": "(?i)\\b([^(=>)]*)\\s*(=>)\\s*([^,)]+)",
+      "match": "(?i)\\b([^(=>)]*)\\s*(=>)\\s*([^,\\)]+)",
       "name": "meta.definition.array.aggregate.component.ada"
     },
     "array_dimensions": {
@@ -534,7 +534,7 @@
           ]
         }
       },
-      "match": "(?i)(\\d(?:(_)?\\d)*#)[0-9a-f](?:(_)?[0-9a-f])*(?:(\\.)[0-9a-f](?:(_)?[0-9a-f])*)?(#)([eE](?:\\+|-)?\\d(?:_?\\d)*)?",
+      "match": "(?i)(\\d(?:(_)?\\d)*#)[0-9a-f](?:(_)?[0-9a-f])*(?:(\\.)[0-9a-f](?:(_)?[0-9a-f])*)?(#)([eE](?:\\+|\\-)?\\d(?:_?\\d)*)?",
       "name": "constant.numeric.ada"
     },
     "basic_declaration": {
@@ -941,7 +941,7 @@
               ]
             }
           },
-          "match": "(?i)\\b((?:\\w|\\d|_)+)\\s*(=>)\\s*([^,)])+\\b"
+          "match": "(?i)\\b((?:\\w|\\d|_)+)\\s*(=>)\\s*([^,\\)])+\\b"
         },
         {
           "include": "#expression"
@@ -967,7 +967,7 @@
           ]
         }
       },
-      "match": "\\d(?:(_)?\\d)*(?:(\\.)\\d(?:(_)?\\d)*)?([eE](?:\\+|-)?\\d(?:_?\\d)*)?",
+      "match": "\\d(?:(_)?\\d)*(?:(\\.)\\d(?:(_)?\\d)*)?([eE](?:\\+|\\-)?\\d(?:_?\\d)*)?",
       "name": "constant.numeric.ada"
     },
     "declarative_item": {
@@ -1330,7 +1330,7 @@
           "name": "punctuation.ada"
         }
       },
-      "match": "([eE])(\\+|-)?\\d(?:(_)?\\d)*"
+      "match": "([eE])(\\+|\\-)?\\d(?:(_)?\\d)*"
     },
     "expression": {
       "name": "meta.expression.ada",
@@ -2312,7 +2312,7 @@
               ]
             }
           },
-          "match": "(?i)\\b(others)\\s*(=>)\\s*([^,)]+)"
+          "match": "(?i)\\b(others)\\s*(=>)\\s*([^,\\)]+)"
         },
         {
           "include": "#expression"

package/grammars/angular-expression.json

@@ -53,7 +53,7 @@
               "name": "entity.name.function.pipe.ng"
             }
           },
-          "match": "((?<!\\|)\\|(?!\\|))\\s?([a-zA-Z0-9\\-_$]*)"
+          "match": "((?<!\\|)\\|(?!\\|))\\s?([a-zA-Z0-9\\-\\_\\$]*)"
         },
         {
           "match": "(?<!\\.|\\$)\\b(let)\\b(?!\\$)",
@@ -114,7 +114,7 @@
           ]
         },
         {
-          "match": "\\*=|(?<!\\()\\/=|%=|\\+=|-=",
+          "match": "\\*=|(?<!\\()\\/=|%=|\\+=|\\-=",
           "name": "keyword.operator.assignment.compound.ts"
         },
         {
@@ -134,7 +134,7 @@
           "name": "keyword.operator.relational.ts"
         },
         {
-          "match": "!|&&|\\?\\?|\\|\\|",
+          "match": "\\!|&&|\\?\\?|\\|\\|",
           "name": "keyword.operator.logical.ts"
         },
         {
@@ -142,7 +142,7 @@
           "name": "keyword.operator.bitwise.ts"
         },
         {
-          "match": "=",
+          "match": "\\=",
           "name": "keyword.operator.assignment.ts"
         },
         {
@@ -163,7 +163,7 @@
               "name": "keyword.operator.arithmetic.ts"
             }
           },
-          "match": "(?<=[_$0-9A-Za-z])\\s*(\\/)(?![\\/*])"
+          "match": "(?<=[_$[:alnum:]])\\s*(\\/)(?![\\/*])"
         },
         {
           "include": "#typeofOperator"
@@ -171,8 +171,8 @@
       ]
     },
     "functionCall": {
-      "begin": "(?=(\\??\\.\\s*)?([_$A-Za-z][_$0-9A-Za-z]*)\\s*(<([^<>]|<[^<>]+>)+>\\s*)?\\()",
-      "end": "(?<=\\))(?!(\\??\\.\\s*)?([_$A-Za-z][_$0-9A-Za-z]*)\\s*(<([^<>]|<[^<>]+>)+>\\s*)?\\()",
+      "begin": "(?=(\\??\\.\\s*)?([_$[:alpha:]][_$[:alnum:]]*)\\s*(<([^<>]|\\<[^<>]+\\>)+>\\s*)?\\()",
+      "end": "(?<=\\))(?!(\\??\\.\\s*)?([_$[:alpha:]][_$[:alnum:]]*)\\s*(<([^<>]|\\<[^<>]+\\>)+>\\s*)?\\()",
       "patterns": [
         {
           "match": "\\?",
@@ -183,17 +183,17 @@
           "name": "punctuation.accessor.ts"
         },
         {
-          "match": "([_$A-Za-z][_$0-9A-Za-z]*)",
+          "match": "([_$[:alpha:]][_$[:alnum:]]*)",
           "name": "entity.name.function.ts"
         },
         {
-          "begin": "<",
+          "begin": "\\<",
           "beginCaptures": {
             "0": {
               "name": "punctuation.definition.typeparameters.begin.ts"
             }
           },
-          "end": ">",
+          "end": "\\>",
           "endCaptures": {
             "0": {
               "name": "punctuation.definition.typeparameters.end.ts"
@@ -247,7 +247,7 @@
     "identifiers": {
       "patterns": [
         {
-          "match": "([_$A-Za-z][_$0-9A-Za-z]*)(?=\\s*\\.\\s*prototype\\b(?!\\$))",
+          "match": "([_$[:alpha:]][_$[:alnum:]]*)(?=\\s*\\.\\s*prototype\\b(?!\\$))",
           "name": "support.class.ts"
         },
         {
@@ -262,7 +262,7 @@
               "name": "variable.other.object.property.ts"
             }
           },
-          "match": "([?!]?\\.)\\s*(?:([A-Z][_$\\dA-Z]*)|([_$A-Za-z][_$0-9A-Za-z]*))(?=\\s*\\.\\s*[_$A-Za-z][_$0-9A-Za-z]*)"
+          "match": "([?!]?\\.)\\s*(?:([[:upper:]][_$[:digit:][:upper:]]*)|([_$[:alpha:]][_$[:alnum:]]*))(?=\\s*\\.\\s*[_$[:alpha:]][_$[:alnum:]]*)"
         },
         {
           "captures": {
@@ -273,7 +273,7 @@
               "name": "entity.name.function.ts"
             }
           },
-          "match": "(?:([?!]?\\.)\\s*)?([_$A-Za-z][_$0-9A-Za-z]*)(?=\\s*=\\s*((async\\s+)|(function\\s*[(<])|(function\\s+)|([_$A-Za-z][_$0-9A-Za-z]*\\s*=>)|((<([^<>]|<[^<>]+>)+>\\s*)?\\(([^()]|\\([^()]*\\))*\\)(\\s*:\\s*(.)*)?\\s*=>)))"
+          "match": "(?:([?!]?\\.)\\s*)?([_$[:alpha:]][_$[:alnum:]]*)(?=\\s*=\\s*((async\\s+)|(function\\s*[(<])|(function\\s+)|([_$[:alpha:]][_$[:alnum:]]*\\s*=>)|((<([^<>]|\\<[^<>]+\\>)+>\\s*)?\\(([^()]|\\([^()]*\\))*\\)(\\s*:\\s*(.)*)?\\s*=>)))"
         },
         {
           "captures": {
@@ -284,7 +284,7 @@
               "name": "constant.other.property.ts"
             }
           },
-          "match": "([?!]?\\.)\\s*([A-Z][_$\\dA-Z]*)(?![_$0-9A-Za-z])"
+          "match": "([?!]?\\.)\\s*([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])"
         },
         {
           "captures": {
@@ -295,7 +295,7 @@
               "name": "variable.other.property.ts"
             }
           },
-          "match": "([?!]?\\.)\\s*([_$A-Za-z][_$0-9A-Za-z]*)"
+          "match": "([?!]?\\.)\\s*([_$[:alpha:]][_$[:alnum:]]*)"
         },
         {
           "captures": {
@@ -306,14 +306,14 @@
               "name": "variable.other.object.ts"
             }
           },
-          "match": "(?:([A-Z][_$\\dA-Z]*)|([_$A-Za-z][_$0-9A-Za-z]*))(?=\\s*\\.\\s*[_$A-Za-z][_$0-9A-Za-z]*)"
+          "match": "(?:([[:upper:]][_$[:digit:][:upper:]]*)|([_$[:alpha:]][_$[:alnum:]]*))(?=\\s*\\.\\s*[_$[:alpha:]][_$[:alnum:]]*)"
         },
         {
-          "match": "([A-Z][_$\\dA-Z]*)(?![_$0-9A-Za-z])",
+          "match": "([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])",
           "name": "constant.character.other"
         },
         {
-          "match": "[_$A-Za-z][_$0-9A-Za-z]*",
+          "match": "[_$[:alpha:]][_$[:alnum:]]*",
           "name": "variable.other.readwrite.ts"
         }
       ]
@@ -430,7 +430,7 @@
               "name": "meta.delimiter.decimal.period.ts"
             }
           },
-          "match": "(?<!\\$)(?:(?:\\b\\d+(\\.)\\d+[eE][+-]?\\d+\\b)|#1.1E+3(?:\\b\\d+(\\.)[eE][+-]?\\d+\\b)|#1.E+3(?:\\B(\\.)\\d+[eE][+-]?\\d+\\b)|#.1E+3(?:\\b\\d+[eE][+-]?\\d+\\b)|#1E+3(?:\\b\\d+(\\.)\\d+\\b)|#1.1(?:\\b\\d+(\\.)\\B)|#1.(?:\\B(\\.)\\d+\\b)|#.1(?:\\b\\d+\\b(?!\\.))#1)(?!\\$)"
+          "match": "(?<!\\$)(?:(?:\\b[0-9]+(\\.)[0-9]+[eE][+-]?[0-9]+\\b)|#1.1E+3(?:\\b[0-9]+(\\.)[eE][+-]?[0-9]+\\b)|#1.E+3(?:\\B(\\.)[0-9]+[eE][+-]?[0-9]+\\b)|#.1E+3(?:\\b[0-9]+[eE][+-]?[0-9]+\\b)|#1E+3(?:\\b[0-9]+(\\.)[0-9]+\\b)|#1.1(?:\\b[0-9]+(\\.)\\B)|#1.(?:\\B(\\.)[0-9]+\\b)|#.1(?:\\b[0-9]+\\b(?!\\.))#1)(?!\\$)"
         }
       ]
     },
@@ -454,7 +454,7 @@
               "name": "keyword.operator.optional.ts"
             }
           },
-          "match": "(?:\\s*\\b(readonly)\\s+)?(?:\\s*\\b(public|private|protected)\\s+)?(\\.\\.\\.)?\\s*(?<!=|:)([_$A-Za-z][_$0-9A-Za-z]*)\\s*(\\??)(?=\\s*(=\\s*((async\\s+)|(function\\s*[(<])|(function\\s+)|([_$A-Za-z][_$0-9A-Za-z]*\\s*=>)|((<([^<>]|<[^<>]+>)+>\\s*)?\\(([^()]|\\([^()]*\\))*\\)(\\s*:\\s*(.)*)?\\s*=>)))|(:\\s*((<)|([(]\\s*(([)])|(\\.\\.\\.)|([_$0-9A-Za-z]+\\s*(([:,?=])|([)]\\s*=>))))))))"
+          "match": "(?:\\s*\\b(readonly)\\s+)?(?:\\s*\\b(public|private|protected)\\s+)?(\\.\\.\\.)?\\s*(?<!=|:)([_$[:alpha:]][_$[:alnum:]]*)\\s*(\\??)(?=\\s*(=\\s*((async\\s+)|(function\\s*[(<])|(function\\s+)|([_$[:alpha:]][_$[:alnum:]]*\\s*=>)|((<([^<>]|\\<[^<>]+\\>)+>\\s*)?\\(([^()]|\\([^()]*\\))*\\)(\\s*:\\s*(.)*)?\\s*=>)))|(:\\s*((<)|([(]\\s*(([)])|(\\.\\.\\.)|([_$[:alnum:]]+\\s*(([:,?=])|([)]\\s*=>))))))))"
         },
         {
           "captures": {
@@ -474,7 +474,7 @@
               "name": "keyword.operator.optional.ts"
             }
           },
-          "match": "(?:\\s*\\b(readonly)\\s+)?(?:\\s*\\b(public|private|protected)\\s+)?(\\.\\.\\.)?\\s*(?<!=|:)([_$A-Za-z][_$0-9A-Za-z]*)\\s*(\\??)"
+          "match": "(?:\\s*\\b(readonly)\\s+)?(?:\\s*\\b(public|private|protected)\\s+)?(\\.\\.\\.)?\\s*(?<!=|:)([_$[:alpha:]][_$[:alnum:]]*)\\s*(\\??)"
         }
       ]
     },
@@ -501,7 +501,7 @@
       ]
     },
     "punctuationAccessor": {
-      "match": "\\?\\.|!\\.|\\.",
+      "match": "\\?\\.|\\!\\.|\\.",
       "name": "punctuation.accessor.ts"
     },
     "punctuationComma": {
@@ -573,7 +573,7 @@
       "name": "constant.character.escape.ts"
     },
     "ternaryExpression": {
-      "begin": "(?!\\?\\.\\s*[^\\d])(\\?)(?!\\?)",
+      "begin": "(?!\\?\\.\\s*[^[:digit:]])(\\?)(?!\\?)",
       "beginCaptures": {
         "1": {
           "name": "keyword.operator.ternary.ts"
@@ -634,7 +634,7 @@
           "name": "keyword.operator.type.annotation.ts"
         }
       },
-      "end": "(?=$|[,);}\\]]|\\/\\/|\")|(?==[^>])|(?<=[}>\\])]|[_$A-Za-z])\\s*(?=\\{)",
+      "end": "(?=$|[,);\\}\\]]|\\/\\/|\")|(?==[^>])|(?<=[\\}>\\]\\)]|[_$[:alpha:]])\\s*(?=\\{)",
       "name": "meta.type.annotation.ts",
       "patterns": [
         {
@@ -654,7 +654,7 @@
               "name": "keyword.control.new.ts"
             }
           },
-          "match": "(?<!\\.|\\$)\\b(new)\\b(?=\\s*<)",
+          "match": "(?<!\\.|\\$)\\b(new)\\b(?=\\s*\\<)",
           "name": "meta.type.constructor.ts"
         },
         {
@@ -673,7 +673,7 @@
           ]
         },
         {
-          "begin": "(?<=>)\\s*(?=\\()",
+          "begin": "(?<=\\>)\\s*(?=\\()",
           "end": "(?<=\\))",
           "include": "#typeofOperator",
           "name": "meta.type.function.ts",
@@ -684,7 +684,7 @@
           ]
         },
         {
-          "begin": "((?=[(]\\s*(([)])|(\\.\\.\\.)|([_$0-9A-Za-z]+\\s*(([:,?=])|([)]\\s*=>))))))",
+          "begin": "((?=[(]\\s*(([)])|(\\.\\.\\.)|([_$[:alnum:]]+\\s*(([:,?=])|([)]\\s*=>))))))",
           "end": "(?<=\\))",
           "name": "meta.type.function.ts",
           "patterns": [
@@ -706,10 +706,10 @@
               "name": "punctuation.accessor.ts"
             }
           },
-          "match": "([_$A-Za-z][_$0-9A-Za-z]*)\\s*([?!]?\\.)"
+          "match": "([_$[:alpha:]][_$[:alnum:]]*)\\s*([?!]?\\.)"
         },
         {
-          "match": "[_$A-Za-z][_$0-9A-Za-z]*",
+          "match": "[_$[:alpha:]][_$[:alnum:]]*",
           "name": "entity.name.type.ts"
         }
       ]

package/grammars/angular-let-declaration.json

@@ -13,7 +13,7 @@
   ],
   "repository": {
     "letDeclaration": {
-      "begin": "(@let)\\s+([_$A-Za-z][_$0-9A-Za-z]*)\\s*(=)?",
+      "begin": "(@let)\\s+([_$[:alpha:]][_$[:alnum:]]*)\\s*(=)?",
       "beginCaptures": {
         "1": {
           "name": "storage.type.ng"