@wooorm/starry-night/lang/source.cadence.js

Syntax highlighting, like GitHub

// This is a TextMate grammar distributed by `starry-night`.
// This grammar is developed at
// <https://github.com/onflow/vscode-cadence>
// and licensed `apache-2.0`.
// See <https://github.com/wooorm/starry-night> for more info.
/**
 * @import {Grammar} from '@wooorm/starry-night'
 */

/** @type {Grammar} */
const grammar = {
  extensions: ['.cdc'],
  names: ['cadence'],
  patterns: [
    {include: '#comments'},
    {include: '#declarations'},
    {include: '#keywords'},
    {include: '#code-block'},
    {include: '#expressions'},
    {include: '#composite'},
    {include: '#event'}
  ],
  repository: {
    'code-block': {
      begin: '\\{',
      beginCaptures: {0: {name: 'punctuation.section.scope.begin.cadence'}},
      end: '\\}',
      endCaptures: {0: {name: 'punctuation.section.scope.end.cadence'}},
      patterns: [{include: '$self'}]
    },
    comments: {
      patterns: [
        {
          captures: {1: {name: 'punctuation.definition.comment.cadence'}},
          match: '\\A^(#!).*$\\n?',
          name: 'comment.line.number-sign.cadence'
        },
        {
          begin: '/\\*\\*(?!/)',
          beginCaptures: {
            0: {name: 'punctuation.definition.comment.begin.cadence'}
          },
          end: '\\*/',
          endCaptures: {
            0: {name: 'punctuation.definition.comment.end.cadence'}
          },
          name: 'comment.block.documentation.cadence',
          patterns: [{include: '#nested'}]
        },
        {
          begin: '/\\*:',
          beginCaptures: {
            0: {name: 'punctuation.definition.comment.begin.cadence'}
          },
          end: '\\*/',
          endCaptures: {
            0: {name: 'punctuation.definition.comment.end.cadence'}
          },
          name: 'comment.block.documentation.playground.cadence',
          patterns: [{include: '#nested'}]
        },
        {
          begin: '/\\*',
          beginCaptures: {
            0: {name: 'punctuation.definition.comment.begin.cadence'}
          },
          end: '\\*/',
          endCaptures: {
            0: {name: 'punctuation.definition.comment.end.cadence'}
          },
          name: 'comment.block.cadence',
          patterns: [{include: '#nested'}]
        },
        {
          match: '\\*/',
          name: 'invalid.illegal.unexpected-end-of-block-comment.cadence'
        },
        {
          begin: '(^[ \\t]+)?(?=//)',
          beginCaptures: {
            1: {name: 'punctuation.whitespace.comment.leading.cadence'}
          },
          end: '(?!\\G)',
          patterns: [
            {
              begin: '///',
              beginCaptures: {
                0: {name: 'punctuation.definition.comment.cadence'}
              },
              end: '$',
              name: 'comment.line.triple-slash.documentation.cadence'
            },
            {
              begin: '//:',
              beginCaptures: {
                0: {name: 'punctuation.definition.comment.cadence'}
              },
              end: '$',
              name: 'comment.line.double-slash.documentation.cadence'
            },
            {
              begin: '//',
              beginCaptures: {
                0: {name: 'punctuation.definition.comment.cadence'}
              },
              end: '$',
              name: 'comment.line.double-slash.cadence'
            }
          ]
        }
      ],
      repository: {
        nested: {begin: '/\\*', end: '\\*/', patterns: [{include: '#nested'}]}
      }
    },
    composite: {
      begin:
        '\\b((?:(?:struct|resource|contract|attachment)(?:\\s+interface)?)|enum)\\s+([\\p{L}_][\\p{L}_\\p{N}\\p{M}]*)',
      beginCaptures: {
        1: {name: 'storage.type.$1.cadence'},
        2: {name: 'entity.name.type.$1.cadence'}
      },
      end: '(?<=\\})|(?=\\s*\\Z)',
      name: 'meta.definition.type.composite.cadence',
      patterns: [
        {include: '#comments'},
        {include: '#conformance-clause'},
        {
          begin: '\\{',
          beginCaptures: {0: {name: 'punctuation.section.type.begin.cadence'}},
          end: '\\}',
          endCaptures: {0: {name: 'punctuation.section.type.end.cadence'}},
          name: 'meta.definition.type.body.cadence',
          patterns: [{include: '$self'}]
        }
      ]
    },
    'conformance-clause': {
      begin: '(:)(?=\\s*\\{)|(:)\\s*',
      beginCaptures: {
        1: {name: 'invalid.illegal.empty-conformance-clause.cadence'},
        2: {name: 'punctuation.separator.conformance-clause.cadence'}
      },
      end: '(?!\\G)$|(?=[={}])',
      name: 'meta.conformance-clause.cadence',
      patterns: [
        {
          begin: '\\G',
          end: '(?!\\G)$|(?=[={}])',
          patterns: [{include: '#comments'}, {include: '#type'}]
        }
      ]
    },
    declarations: {
      patterns: [
        {include: '#var-let-declaration'},
        {include: '#function'},
        {include: '#initializer'},
        {include: '#prepare-execute'},
        {include: '#execute-phase'},
        {include: '#pre-post'},
        {include: '#transaction'}
      ]
    },
    event: {
      begin: '\\b(event)\\b\\s+([\\p{L}_][\\p{L}_\\p{N}\\p{M}]*)\\s*',
      beginCaptures: {
        1: {name: 'storage.type.event.cadence'},
        2: {name: 'entity.name.type.event.cadence'}
      },
      end: '(?<=\\))',
      name: 'meta.definition.type.event.cadence',
      patterns: [{include: '#comments'}, {include: '#parameter-clause'}]
    },
    'execute-phase': {
      begin: '(?<!\\.)\\b(execute)\\b\\s*(?=\\{)',
      beginCaptures: {1: {name: 'storage.modifier.phase.cadence'}},
      end: '(?<=\\})',
      name: 'meta.definition.transaction.phase.cadence',
      patterns: [
        {include: '#comments'},
        {
          begin: '\\{',
          beginCaptures: {0: {name: 'punctuation.section.phase.begin.cadence'}},
          end: '\\}',
          endCaptures: {0: {name: 'punctuation.section.phase.end.cadence'}},
          patterns: [{include: '$self'}]
        }
      ]
    },
    'expression-element-list': {
      patterns: [
        {include: '#comments'},
        {
          begin: '([\\p{L}_][\\p{L}_\\p{N}\\p{M}]*)\\s*(:)',
          beginCaptures: {
            1: {name: 'variable.parameter.function-call.cadence'},
            2: {name: 'punctuation.separator.argument-label.cadence'}
          },
          end: '(?=[,)\\]])',
          patterns: [{include: '#expressions'}]
        },
        {
          begin: '(?![,)\\]])(?=\\S)',
          end: '(?=[,)\\]])',
          patterns: [{include: '#expressions'}]
        }
      ]
    },
    expressions: {
      patterns: [
        {include: '#comments'},
        {include: '#keywords'},
        {include: '#language-variables'},
        {include: '#function-expression'},
        {include: '#path-literals'},
        {
          begin:
            '(?!\\b(?:if|while|for|return|create|destroy|emit|as)\\b)([\\p{L}_][\\p{L}_\\p{N}\\p{M}]*)\\s*(<)(?=[\\p{Lu}_&@\\[{(]|auth\\b|\\s*$)',
          beginCaptures: {
            1: {name: 'entity.name.function.cadence'},
            2: {name: 'punctuation.definition.type-arguments.begin.cadence'}
          },
          end: '(>)(?!\\s*[=<>])',
          endCaptures: {
            1: {name: 'punctuation.definition.type-arguments.end.cadence'}
          },
          name: 'meta.type.arguments.cadence',
          patterns: [
            {include: '#type'},
            {match: ',', name: 'punctuation.separator.type-argument.cadence'}
          ]
        },
        {
          begin: '(\\()',
          beginCaptures: {
            1: {name: 'punctuation.definition.arguments.begin.cadence'}
          },
          end: '(\\))',
          endCaptures: {
            1: {name: 'punctuation.definition.arguments.end.cadence'}
          },
          name: 'meta.group.cadence',
          patterns: [{include: '#expression-element-list'}]
        },
        {
          begin: '(?<=\\.)([\\p{L}_][\\p{L}_\\p{N}\\p{M}]*)\\s*(\\()',
          beginCaptures: {
            1: {name: 'entity.name.function.cadence'},
            2: {name: 'punctuation.definition.arguments.begin.cadence'}
          },
          end: '(\\))',
          endCaptures: {
            1: {name: 'punctuation.definition.arguments.end.cadence'}
          },
          name: 'meta.function-call.method.cadence',
          patterns: [{include: '#expression-element-list'}]
        },
        {
          match: '(?<=\\.)[\\p{L}_][\\p{L}_\\p{N}\\p{M}]*',
          name: 'variable.other.member.cadence'
        },
        {include: '#function-call-expression'},
        {
          match:
            '(?<!\\.)\\b(?!(?:contract|struct|resource|event|enum|attachment|entitlement|import|fun|let|var|if|else|switch|case|default|while|for|in|break|continue|return|emit|as|create|destroy|attach|to|remove|from|pub|priv|access|all|self|view|auth|transaction|prepare|execute|pre|post|init|true|false|nil|Type|Int|UInt|Int8|Int16|Int32|Int64|Int128|Int256|UInt8|UInt16|UInt32|UInt64|UInt128|UInt256|Word8|Word16|Word32|Word64|Fix64|Fix128|UFix64|UFix128|String|Character|Bool|Address|Void|AnyStruct|AnyResource|Any|Never|mapping|include)\\b)[\\p{L}_][\\p{L}_\\p{N}\\p{M}]*\\b',
          name: 'variable.other.readwrite.cadence'
        },
        {include: '#literals'},
        {include: '#operators'}
      ]
    },
    function: {
      begin: '\\b(fun)\\b\\s+([\\p{L}_][\\p{L}_\\p{N}\\p{M}]*)\\s*',
      beginCaptures: {
        1: {name: 'storage.type.function.cadence'},
        2: {name: 'entity.name.function.cadence'}
      },
      end: '(?<=\\})|;|(?=\\}[\\s]*$)|$',
      name: 'meta.definition.function.cadence',
      patterns: [
        {include: '#comments'},
        {include: '#parameter-clause'},
        {include: '#function-result'},
        {
          begin: '(\\{)',
          beginCaptures: {
            1: {name: 'punctuation.section.function.begin.cadence'}
          },
          end: '(\\})',
          endCaptures: {1: {name: 'punctuation.section.function.end.cadence'}},
          name: 'meta.definition.function.body.cadence',
          patterns: [{include: '$self'}]
        }
      ]
    },
    'function-call-expression': {
      patterns: [
        {
          begin:
            '(?<!\\.)\\b(?!(?:set|init|transaction|prepare|execute|access|auth))([\\p{L}_][\\p{L}_\\p{N}\\p{M}]*)\\s*(\\()',
          beginCaptures: {
            1: {name: 'entity.name.function.cadence'},
            2: {name: 'punctuation.definition.arguments.begin.cadence'}
          },
          end: '(\\))',
          endCaptures: {
            1: {name: 'punctuation.definition.arguments.end.cadence'}
          },
          name: 'meta.function-call.cadence',
          patterns: [{include: '#expression-element-list'}]
        }
      ]
    },
    'function-expression': {
      begin: '(?<!\\.)\\b(?:(view)\\s+)?(fun)\\b(?=\\s*\\()',
      beginCaptures: {
        1: {name: 'storage.modifier.view.cadence'},
        2: {name: 'storage.type.function.cadence'}
      },
      end: '(?<=\\})|$',
      name: 'meta.function.expression.cadence',
      patterns: [
        {include: '#comments'},
        {include: '#parameter-clause'},
        {include: '#function-result'},
        {
          begin: '(\\{)',
          beginCaptures: {
            1: {name: 'punctuation.section.function.begin.cadence'}
          },
          end: '(\\})',
          endCaptures: {1: {name: 'punctuation.section.function.end.cadence'}},
          name: 'meta.definition.function.body.cadence',
          patterns: [{include: '$self'}]
        }
      ]
    },
    'function-result': {
      begin: '(?<![/=\\-+!*%<>&|\\^~.])(:)(?![/=\\-+!*%<>&|\\^~.])\\s*',
      beginCaptures: {1: {name: 'keyword.operator.function-result.cadence'}},
      end: '(?<![@&\\[<])(?!\\G)(?=\\s*\\{)|(?=;|(?<!\\{)\\})|$',
      name: 'meta.function-result.cadence',
      patterns: [{include: '#type'}]
    },
    initializer: {
      begin: '(?<!\\.)\\b(init)\\s*(?=\\(|<)',
      beginCaptures: {1: {name: 'storage.type.function.cadence'}},
      end: '(?<=\\})|$',
      name: 'meta.definition.function.initializer.cadence',
      patterns: [
        {include: '#comments'},
        {include: '#parameter-clause'},
        {
          begin: '(\\{)',
          beginCaptures: {
            1: {name: 'punctuation.section.function.begin.cadence'}
          },
          end: '(\\})',
          endCaptures: {1: {name: 'punctuation.section.function.end.cadence'}},
          name: 'meta.definition.function.body.cadence',
          patterns: [{include: '$self'}]
        }
      ]
    },
    keywords: {
      patterns: [
        {match: '(?<!\\.)\\bvar\\b', name: 'storage.type.var.cadence'},
        {match: '(?<!\\.)\\blet\\b', name: 'storage.type.let.cadence'},
        {
          begin:
            '(?<!\\.)\\b(entitlement)\\s+(mapping)\\s+([\\p{L}_][\\p{L}_\\p{N}\\p{M}]*)\\s*(\\{)',
          beginCaptures: {
            1: {name: 'keyword.declaration.entitlement.cadence'},
            2: {name: 'keyword.other.mapping.cadence'},
            3: {name: 'entity.name.type.entitlement-mapping.cadence'},
            4: {name: 'punctuation.definition.type.begin.cadence'}
          },
          end: '(\\})',
          endCaptures: {1: {name: 'punctuation.definition.type.end.cadence'}},
          name: 'meta.definition.entitlement-mapping.cadence',
          patterns: [
            {include: '#comments'},
            {
              match: '\\binclude\\b',
              name: 'keyword.other.mapping.include.cadence'
            },
            {
              captures: {
                1: {name: 'entity.name.type.entitlement-mapping.cadence'}
              },
              match: '(?<=\\binclude)\\s+([\\p{L}_][\\p{L}_\\p{N}\\p{M}.]*)'
            },
            {
              match: '[\\p{L}_][\\p{L}_\\p{N}\\p{M}.]*',
              name: 'entity.name.type.entitlement.cadence'
            },
            {match: '->', name: 'punctuation.separator.mapping.cadence'}
          ]
        },
        {
          captures: {
            1: {name: 'keyword.declaration.entitlement.cadence'},
            2: {name: 'entity.name.type.entitlement.cadence'}
          },
          match:
            '(?<!\\.)\\b(entitlement)\\b\\s+([\\p{L}_][\\p{L}_\\p{N}\\p{M}]*)'
        },
        {
          begin: '(?<!\\.)\\b(access)\\b\\s*(\\()',
          beginCaptures: {
            1: {name: 'storage.modifier.access.cadence'},
            2: {name: 'punctuation.section.group.begin.cadence'}
          },
          end: '(\\))',
          endCaptures: {1: {name: 'punctuation.section.group.end.cadence'}},
          name: 'meta.access.modifier.cadence',
          patterns: [
            {include: '#comments'},
            {match: '\\bmapping\\b', name: 'keyword.other.mapping.cadence'},
            {
              captures: {
                1: {name: 'entity.name.type.entitlement-mapping.cadence'}
              },
              match: '(?<=\\bmapping)\\s+([\\p{L}_][\\p{L}_\\p{N}\\p{M}.]*)'
            },
            {
              match: '\\b(?:all|self|contract|account)\\b',
              name: 'constant.language.access.audience.cadence'
            },
            {match: ',', name: 'punctuation.separator.entitlement.cadence'},
            {match: '\\|', name: 'punctuation.separator.entitlement.cadence'},
            {
              match: '[\\p{L}_][\\p{L}_\\p{N}\\p{M}.]*',
              name: 'entity.name.type.entitlement.cadence'
            }
          ]
        },
        {
          match: '(?<!\\.)\\b(?:if|else|switch|case|default)\\b',
          name: 'keyword.control.branch.cadence'
        },
        {
          match: '(?<!\\.)\\b(?:return|continue|break)\\b',
          name: 'keyword.control.transfer.cadence'
        },
        {
          match: '(?<!\\.)\\b(?:while|for|in)\\b',
          name: 'keyword.control.loop.cadence'
        },
        {
          match: '(?<!\\.)\\b(?:create|destroy|emit|attach|to|remove|from)\\b',
          name: 'keyword.other.cadence'
        },
        {
          match: '(?<!\\.)\\b(pub|priv)\\b',
          name: 'invalid.deprecated.keyword.cadence'
        },
        {match: '(?<!\\.)\\bview\\b', name: 'storage.modifier.view.cadence'},
        {match: '(?<!\\.)\\b(auth)\\b', name: 'keyword.other.auth.cadence'},
        {
          begin: '(?<!\\.)\\b(import)\\b',
          beginCaptures: {1: {name: 'keyword.control.import.cadence'}},
          end: '(?=$|//|/\\*|;)',
          name: 'meta.import.cadence',
          patterns: [
            {match: '\\bfrom\\b', name: 'keyword.control.import.cadence'},
            {include: '#literals'},
            {
              match: '\\b[\\p{L}_][\\p{L}_\\p{N}\\p{M}]*\\b',
              name: 'variable.other.readwrite.cadence'
            }
          ]
        }
      ]
    },
    'language-variables': {
      patterns: [{match: '\\b(self)\\b', name: 'variable.language.cadence'}]
    },
    literals: {
      patterns: [
        {include: '#boolean'},
        {include: '#numeric'},
        {include: '#string'},
        {match: '\\bnil\\b', name: 'constant.language.nil.cadence'}
      ],
      repository: {
        boolean: {
          match: '\\b(true|false)\\b',
          name: 'constant.language.boolean.cadence'
        },
        numeric: {
          patterns: [
            {include: '#binary'},
            {include: '#octal'},
            {include: '#hexadecimal'},
            {include: '#fixed-point'},
            {include: '#decimal'}
          ],
          repository: {
            binary: {
              match: '(\\B\\-|\\b)0b[01]([_01]*[01])?\\b',
              name: 'constant.numeric.integer.binary.cadence'
            },
            decimal: {
              match: '(\\B\\-|\\b)[0-9]([_0-9]*[0-9])?\\b',
              name: 'constant.numeric.integer.decimal.cadence'
            },
            'fixed-point': {
              match:
                '(\\B\\-|\\b)[0-9]([_0-9]*[0-9])?\\.[0-9]([_0-9]*[0-9])?\\b',
              name: 'constant.numeric.float.cadence'
            },
            hexadecimal: {
              match: '(\\B\\-|\\b)0x[0-9A-Fa-f]([_0-9A-Fa-f]*[0-9A-Fa-f])?\\b',
              name: 'constant.numeric.integer.hexadecimal.cadence'
            },
            octal: {
              match: '(\\B\\-|\\b)0o[0-7]([_0-7]*[0-7])?\\b',
              name: 'constant.numeric.integer.octal.cadence'
            }
          }
        },
        string: {
          patterns: [
            {
              begin: '"',
              beginCaptures: {
                0: {name: 'punctuation.definition.string.begin.cadence'}
              },
              end: '"',
              endCaptures: {
                0: {name: 'punctuation.definition.string.end.cadence'}
              },
              name: 'string.quoted.double.single-line.cadence',
              patterns: [
                {
                  match: '\\r|\\n',
                  name: 'invalid.illegal.returns-not-allowed.cadence'
                },
                {
                  begin: '\\\\\\(',
                  beginCaptures: {
                    0: {
                      name: 'punctuation.section.embedded.begin.cadence meta.embedded.cadence'
                    }
                  },
                  contentName: 'meta.embedded.line.cadence',
                  end: '\\)',
                  endCaptures: {
                    0: {
                      name: 'punctuation.section.embedded.end.cadence meta.embedded.cadence'
                    }
                  },
                  name: 'meta.interpolation.cadence',
                  patterns: [
                    {
                      begin: '\\(',
                      beginCaptures: {
                        0: {name: 'punctuation.section.group.begin.cadence'}
                      },
                      end: '\\)',
                      endCaptures: {
                        0: {name: 'punctuation.section.group.end.cadence'}
                      },
                      patterns: [{include: '#expressions'}]
                    },
                    {include: '#expressions'}
                  ]
                },
                {include: '#string-guts'}
              ]
            }
          ],
          repository: {
            'string-guts': {
              patterns: [
                {
                  match: '\\\\[0\\\\tnr"\']',
                  name: 'constant.character.escape.cadence'
                },
                {
                  match: '\\\\u\\{[0-9a-fA-F]{1,8}\\}',
                  name: 'constant.character.escape.unicode.cadence'
                }
              ]
            }
          }
        }
      }
    },
    operators: {
      patterns: [
        {match: '<->', name: 'keyword.operator.swap.cadence'},
        {match: '\\?\\.', name: 'keyword.operator.optional.chain.cadence'},
        {
          begin: '\\b(as\\?|as!|as)\\b',
          beginCaptures: {0: {name: 'keyword.operator.type.cast.cadence'}},
          end: '(?=$|;|//|/\\\\*|\\")|(?=\\)|,|\\})|(?<=\\>)(?=\\s*\\{(?!\\s*[\\p{L}_][\\p{L}_\\p{N}\\p{M}.]*\\s*:))|(?<=[\\p{L}\\p{N}\\}\\>\\)\\]\\?])(?=\\s*\\{(?!\\s*[\\p{L}_][\\p{L}_\\p{N}\\p{M}.]*\\s*:))|(?=\\?\\?)',
          name: 'meta.type.cast-target.cadence',
          patterns: [
            {
              begin: '\\{(?=\\s*[\\p{L}_][\\p{L}_\\p{N}\\p{M}.]*\\s*:)',
              beginCaptures: {
                0: {
                  name: 'punctuation.definition.type.dictionary.begin.cadence'
                }
              },
              end: '(\\})',
              endCaptures: {
                1: {name: 'punctuation.definition.type.dictionary.end.cadence'}
              },
              name: 'meta.type.dictionary.cadence',
              patterns: [
                {include: '#comments'},
                {include: '#type'},
                {
                  match: ':',
                  name: 'punctuation.separator.type.dictionary.cadence'
                },
                {
                  match: ',',
                  name: 'punctuation.separator.type.dictionary.cadence'
                }
              ]
            },
            {include: '#type'}
          ]
        },
        {match: '\\-', name: 'keyword.operator.arithmetic.unary.cadence'},
        {match: '(?<=\\))!', name: 'keyword.operator.force-unwrap.cadence'},
        {match: '!', name: 'keyword.operator.logical.not.cadence'},
        {match: '=', name: 'keyword.operator.assignment.cadence'},
        {match: '<-', name: 'keyword.operator.move.cadence'},
        {match: '<-!', name: 'keyword.operator.force-move.cadence'},
        {match: '\\+|\\-|\\*|/', name: 'keyword.operator.arithmetic.cadence'},
        {match: '%', name: 'keyword.operator.arithmetic.remainder.cadence'},
        {match: '>>', name: 'keyword.operator.bitwise.shift.cadence'},
        {match: '<<', name: 'keyword.operator.bitwise.shift.cadence'},
        {match: '==|!=|>|<|>=|<=', name: 'keyword.operator.comparison.cadence'},
        {match: '\\?\\?', name: 'keyword.operator.coalescing.cadence'},
        {match: '&&|\\|\\|', name: 'keyword.operator.logical.cadence'},
        {match: '[?!]', name: 'keyword.operator.type.optional.cadence'}
      ]
    },
    'parameter-clause': {
      begin: '(\\()',
      beginCaptures: {
        1: {name: 'punctuation.definition.parameters.begin.cadence'}
      },
      end: '(\\))',
      endCaptures: {1: {name: 'punctuation.definition.parameters.end.cadence'}},
      name: 'meta.parameter-clause.cadence',
      patterns: [{include: '#comments'}, {include: '#parameter-list'}]
    },
    'parameter-list': {
      patterns: [
        {include: '#comments'},
        {
          captures: {
            1: {name: 'keyword.operator.unnamed-parameter.cadence'},
            2: {name: 'variable.parameter.cadence'}
          },
          match: '(_)\\s+([\\p{L}_][\\p{L}_\\p{N}\\p{M}]*)(?=\\s*:)'
        },
        {
          captures: {
            1: {name: 'entity.name.label.cadence'},
            2: {name: 'variable.parameter.cadence'}
          },
          match:
            '([\\p{L}_][\\p{L}_\\p{N}\\p{M}]*)\\s+([\\p{L}_][\\p{L}_\\p{N}\\p{M}]*)(?=\\s*:)'
        },
        {
          captures: {1: {name: 'variable.parameter.cadence'}},
          match: '([\\p{L}_][\\p{L}_\\p{N}\\p{M}]*)(?=\\s*:)'
        },
        {
          begin: ':\\s*(?!\\s)',
          end: '(?=[,)])',
          patterns: [
            {include: '#type'},
            {
              match: ':',
              name: 'invalid.illegal.extra-colon-in-parameter-list.cadence'
            }
          ]
        }
      ]
    },
    'path-literals': {
      patterns: [
        {
          captures: {
            1: {name: 'punctuation.separator.path.cadence'},
            2: {name: 'constant.other.path.cadence'}
          },
          match: '(/)((storage|public)(/[\\p{L}_][\\p{L}_\\p{N}\\p{M}]*)?)'
        }
      ]
    },
    'pre-post': {
      begin: '(?<!\\.)\\b(pre|post)\\b\\s*(?=\\{)',
      beginCaptures: {1: {name: 'storage.modifier.phase.cadence'}},
      end: '(?<=\\})',
      name: 'meta.definition.transaction.phase.cadence',
      patterns: [
        {include: '#comments'},
        {
          begin: '\\{',
          beginCaptures: {0: {name: 'punctuation.section.phase.begin.cadence'}},
          end: '\\}',
          endCaptures: {0: {name: 'punctuation.section.phase.end.cadence'}},
          patterns: [{include: '$self'}]
        }
      ]
    },
    'prepare-execute': {
      begin: '(?<!\\.)\\b(prepare)\\b\\s*(?=\\()',
      beginCaptures: {1: {name: 'storage.modifier.phase.cadence'}},
      end: '(?<=\\})',
      name: 'meta.definition.transaction.phase.cadence',
      patterns: [
        {include: '#comments'},
        {include: '#parameter-clause'},
        {
          begin: '\\{',
          beginCaptures: {0: {name: 'punctuation.section.phase.begin.cadence'}},
          end: '\\}',
          endCaptures: {0: {name: 'punctuation.section.phase.end.cadence'}},
          patterns: [{include: '$self'}]
        }
      ]
    },
    transaction: {
      begin: '\\b(transaction)\\b',
      beginCaptures: {1: {name: 'storage.type.transaction.cadence'}},
      end: '(?<=\\))|(?<=\\})',
      name: 'meta.definition.transaction.cadence',
      patterns: [
        {include: '#comments'},
        {include: '#parameter-clause'},
        {
          begin: '\\{',
          beginCaptures: {
            0: {name: 'punctuation.section.transaction.begin.cadence'}
          },
          end: '\\}',
          endCaptures: {
            0: {name: 'punctuation.section.transaction.end.cadence'}
          },
          name: 'meta.definition.transaction.body.cadence',
          patterns: [{include: '$self'}]
        }
      ]
    },
    type: {
      patterns: [
        {
          begin: '(?<!\\.)\\b(?:(view)\\s+)?(fun)\\b\\s*(\\()',
          beginCaptures: {
            1: {name: 'storage.modifier.view.cadence'},
            2: {name: 'storage.type.function.cadence'},
            3: {name: 'punctuation.definition.parameters.begin.cadence'}
          },
          end: '(?=,|[)>}\\]]|$)',
          name: 'meta.type.function.cadence',
          patterns: [
            {include: '#comments'},
            {
              begin: '\\G',
              end: '(\\))',
              endCaptures: {
                1: {name: 'punctuation.definition.parameters.end.cadence'}
              },
              patterns: [
                {include: '#type'},
                {match: ',', name: 'punctuation.separator.parameter.cadence'}
              ]
            },
            {
              begin: '(:)',
              beginCaptures: {
                1: {name: 'keyword.operator.function-result.cadence'}
              },
              end: '(?=,|[)>}\\]]|$)',
              name: 'meta.function-result.cadence',
              patterns: [{include: '#type'}]
            }
          ]
        },
        {include: '#comments'},
        {
          begin: '(?<!\\.)([\\p{L}_][\\p{L}_\\p{N}\\p{M}]*)\\s*(<)',
          beginCaptures: {
            1: {name: 'entity.name.type.cadence'},
            2: {name: 'punctuation.definition.type-arguments.begin.cadence'}
          },
          end: '(>)',
          endCaptures: {
            1: {name: 'punctuation.definition.type-arguments.end.cadence'}
          },
          name: 'meta.type.arguments.cadence',
          patterns: [
            {include: '#type'},
            {match: ',', name: 'punctuation.separator.type-argument.cadence'}
          ]
        },
        {
          begin: '(?<!\\.)\\b(auth)\\b\\s*(\\()',
          beginCaptures: {
            1: {name: 'keyword.other.auth.cadence'},
            2: {name: 'punctuation.section.group.begin.cadence'}
          },
          end: '(\\))',
          endCaptures: {1: {name: 'punctuation.section.group.end.cadence'}},
          name: 'meta.auth.entitlements.cadence',
          patterns: [
            {include: '#comments'},
            {match: '\\bmapping\\b', name: 'keyword.other.mapping.cadence'},
            {
              captures: {
                1: {name: 'entity.name.type.entitlement-mapping.cadence'}
              },
              match: '(?<=\\bmapping)\\s+([\\p{L}_][\\p{L}_\\p{N}\\p{M}.]*)'
            },
            {match: ',', name: 'punctuation.separator.entitlement.cadence'},
            {match: '\\|', name: 'punctuation.separator.entitlement.cadence'},
            {
              match: '[\\p{L}_][\\p{L}_\\p{N}\\p{M}.]*',
              name: 'entity.name.type.entitlement.cadence'
            }
          ]
        },
        {
          begin: '\\{(?![^}]*:)(?!.*\\}\\s*\\()',
          beginCaptures: {
            0: {name: 'punctuation.definition.type.intersection.begin.cadence'}
          },
          end: '(\\})',
          endCaptures: {
            1: {name: 'punctuation.definition.type.intersection.end.cadence'}
          },
          patterns: [
            {include: '#comments'},
            {include: '#type'},
            {
              match: ',',
              name: 'punctuation.separator.type.intersection.cadence'
            }
          ]
        },
        {
          begin:
            '\\{(?=\\s*[\\p{L}_][\\p{L}_\\p{N}\\p{M}.]*\\s*:)(?!.*\\}\\s*\\()',
          beginCaptures: {
            0: {name: 'punctuation.definition.type.dictionary.begin.cadence'}
          },
          end: '(\\})',
          endCaptures: {
            1: {name: 'punctuation.definition.type.dictionary.end.cadence'}
          },
          name: 'meta.type.dictionary.cadence',
          patterns: [
            {include: '#comments'},
            {include: '#type'},
            {match: ':', name: 'punctuation.separator.type.dictionary.cadence'},
            {match: ',', name: 'punctuation.separator.type.dictionary.cadence'}
          ]
        },
        {
          begin: '\\[',
          beginCaptures: {
            0: {name: 'punctuation.definition.type.array.begin.cadence'}
          },
          end: '(\\])',
          endCaptures: {
            1: {name: 'punctuation.definition.type.array.end.cadence'}
          },
          name: 'meta.type.array.cadence',
          patterns: [{include: '#comments'}, {include: '#type'}]
        },
        {
          captures: {
            1: {name: 'punctuation.definition.type.reference.cadence'}
          },
          match: '(&|@)(?=\\s*\\{)'
        },
        {
          captures: {
            1: {name: 'punctuation.definition.type.reference.cadence'},
            2: {name: 'entity.name.type.cadence'}
          },
          match: '(&|@)\\s*([\\p{L}_][\\p{L}_\\p{N}\\p{M}.]*)'
        },
        {
          match: '([\\p{L}_][\\p{L}_\\p{N}\\p{M}]*)',
          name: 'entity.name.type.cadence'
        },
        {match: '[?!]', name: 'keyword.operator.type.optional.cadence'}
      ]
    },
    'var-let-declaration': {
      begin: '\\b(var|let)\\b\\s+([\\p{L}_][\\p{L}_\\p{N}\\p{M}]*)',
      beginCaptures: {
        1: {name: 'storage.type.$1.cadence'},
        2: {name: 'variable.other.declaration.cadence'}
      },
      end: '=|<-|<-!|;|(?=//)|$',
      patterns: [
        {include: '#comments'},
        {
          begin: ':\\s*(?!\\s)',
          beginCaptures: {
            0: {name: 'keyword.operator.type.annotation.cadence'}
          },
          end: '(?=//|=|<-|<-!|;|$)',
          patterns: [{include: '#type'}, {include: '#comments'}]
        }
      ]
    }
  },
  scopeName: 'source.cadence'
}

export default grammar