// This is a TextMate grammar distributed by `starry-night`.
// This grammar is developed at
// <https://github.com/surrealdb/surrealql-grammar>
// 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: ['.surql'],
  names: ['surrealql', 'surql'],
  patterns: [
    {include: '#comment'},
    {include: '#js-function'},
    {include: '#function'},
    {include: '#keywords'},
    {include: '#operators'},
    {include: '#value'}
  ],
  repository: {
    array: {begin: '\\[', end: '\\]', patterns: [{include: '#array-content'}]},
    'array-content': {
      patterns: [
        {include: '$self'},
        {match: ',', name: 'punctuation.separator.array'}
      ]
    },
    block: {
      begin: '\\{',
      end: '\\}',
      name: 'surrealql.block',
      patterns: [{include: '#block-content'}]
    },
    'block-content': {
      patterns: [
        {include: '#string'},
        {include: '#object-key'},
        {include: '$self'}
      ]
    },
    boolean: {
      match: '\\b(true|TRUE|false|FALSE|True|False)\\b',
      name: 'constant.language.bool'
    },
    comment: {
      patterns: [
        {include: '#comment.line.dash'},
        {include: '#comment.line.slash'},
        {include: '#comment.line.hash'},
        {include: '#comment.block'}
      ]
    },
    'comment.block': {
      begin: '/\\*',
      end: '\\*/',
      name: 'comment.block.surrealql'
    },
    'comment.line.dash': {
      begin: '--',
      end: '\\n',
      name: 'comment.line.double-dash'
    },
    'comment.line.hash': {
      begin: '#',
      end: '\\n',
      name: 'comment.line.number-sign'
    },
    'comment.line.slash': {
      begin: '//',
      end: '\\n',
      name: 'comment.line.double-slash'
    },
    duration: {match: '(\\d+(ns|µs|ms|s|m|h|d|w|y))+', name: 'constant.other'},
    function: {
      begin: '(?=((?:\\b\\w+(?:::\\b\\w+)+)|count|rand)\\s*\\()',
      beginCaptures: {1: {name: 'support.function'}},
      end: '(?<=\\))',
      patterns: [
        {include: '#comment'},
        {
          begin: '\\(',
          end: '\\)',
          name: 'meta.function.arguments',
          patterns: [{include: '#value'}]
        }
      ]
    },
    ident: {
      patterns: [
        {begin: '`', end: '(?<!\\\\)`', name: 'support.type.property-name'},
        {begin: '⟨', end: '(?<!\\\\)⟩', name: 'support.type.property-name'}
      ]
    },
    'js-function': {
      begin: '(?=(\\bfunction\\b))',
      beginCaptures: {1: {name: 'support.function.js'}},
      end: '(?<=})',
      patterns: [
        {include: '#comment'},
        {
          begin: '\\(',
          end: '\\)',
          name: 'meta.function.arguments',
          patterns: [{include: '#value'}]
        },
        {
          begin: '{',
          end: '}',
          name: 'meta.embedded.block.javascript',
          patterns: [{include: 'source.js'}]
        }
      ]
    },
    keywords: {
      patterns: [
        {
          match: '\\b(ACCESS|access)\\b',
          name: 'keyword.control.access.surrealql'
        },
        {
          match: '\\b(ALGORITHM|algorithm)\\b',
          name: 'keyword.control.algorithm.surrealql'
        },
        {match: '\\b(ALL|all)\\b', name: 'keyword.control.all.surrealql'},
        {match: '\\b(ALTER|alter)\\b', name: 'keyword.control.alter.surrealql'},
        {
          match: '\\b(ALWAYS|always)\\b',
          name: 'keyword.control.always.surrealql'
        },
        {
          match: '\\b(ANALYZER|analyzer)\\b',
          name: 'keyword.control.analyzer.surrealql'
        },
        {match: '\\b(AND|and)\\b', name: 'keyword.control.and.surrealql'},
        {match: '\\b(ANY|any)\\b', name: 'keyword.control.any.surrealql'},
        {match: '\\b(API|api)\\b', name: 'keyword.control.api.surrealql'},
        {match: '\\b(AS|as)\\b', name: 'keyword.control.as.surrealql'},
        {match: '\\b(ASC|asc)\\b', name: 'keyword.control.asc.surrealql'},
        {
          match: '\\b(ASSERT|assert)\\b',
          name: 'keyword.control.assert.surrealql'
        },
        {match: '\\b(AT|at)\\b', name: 'keyword.control.at.surrealql'},
        {
          match: '\\b(AUTHENTICATE|authenticate)\\b',
          name: 'keyword.control.authenticate.surrealql'
        },
        {match: '\\b(AUTO|auto)\\b', name: 'keyword.control.auto.surrealql'},
        {
          match: '\\b(BACKEND|backend)\\b',
          name: 'keyword.control.backend.surrealql'
        },
        {match: '\\b(BEGIN|begin)\\b', name: 'keyword.control.begin.surrealql'},
        {match: '\\b(BM25|bm25)\\b', name: 'keyword.control.bm25.surrealql'},
        {match: '\\b(BREAK|break)\\b', name: 'keyword.control.break.surrealql'},
        {
          match: '\\b(BUCKET|bucket)\\b',
          name: 'keyword.control.bucket.surrealql'
        },
        {match: '\\b(BY|by)\\b', name: 'keyword.control.by.surrealql'},
        {
          match: '\\b(CANCEL|cancel)\\b',
          name: 'keyword.control.cancel.surrealql'
        },
        {
          match: '\\b(CAPACITY|capacity)\\b',
          name: 'keyword.control.capacity.surrealql'
        },
        {
          match: '\\b(CASCADE|cascade)\\b',
          name: 'keyword.control.cascade.surrealql'
        },
        {
          match: '\\b(CHANGEFEED|changefeed)\\b',
          name: 'keyword.control.changefeed.surrealql'
        },
        {
          match: '\\b(CHANGES|changes)\\b',
          name: 'keyword.control.changes.surrealql'
        },
        {
          match: '\\b(COLLATE|collate)\\b',
          name: 'keyword.control.collate.surrealql'
        },
        {
          match: '\\b(COLUMNS|columns)\\b',
          name: 'keyword.control.columns.surrealql'
        },
        {
          match: '\\b(COMMENT|comment)\\b',
          name: 'keyword.control.comment.surrealql'
        },
        {
          match: '\\b(COMMIT|commit)\\b',
          name: 'keyword.control.commit.surrealql'
        },
        {
          match: '\\b(COMPUTED|computed)\\b',
          name: 'keyword.control.computed.surrealql'
        },
        {
          match: '\\b(CONCURRENTLY|concurrently)\\b',
          name: 'keyword.control.concurrently.surrealql'
        },
        {
          match: '\\b(CONFIG|config)\\b',
          name: 'keyword.control.config.surrealql'
        },
        {
          match: '\\b(CONTENT|content)\\b',
          name: 'keyword.control.content.surrealql'
        },
        {
          match: '\\b(CONTINUE|continue)\\b',
          name: 'keyword.control.continue.surrealql'
        },
        {
          match: '\\b(CREATE|create)\\b',
          name: 'keyword.control.create.surrealql'
        },
        {
          match: '\\b(DATABASE|database)\\b',
          name: 'keyword.control.database.surrealql'
        },
        {match: '\\b(DB|db)\\b', name: 'keyword.control.db.surrealql'},
        {
          match: '\\b(DEFAULT|default)\\b',
          name: 'keyword.control.default.surrealql'
        },
        {match: '\\b(DEFER|defer)\\b', name: 'keyword.control.defer.surrealql'},
        {
          match: '\\b(DEFINE|define)\\b',
          name: 'keyword.control.define.surrealql'
        },
        {
          match: '\\b(DELETE|delete)\\b',
          name: 'keyword.control.delete.surrealql'
        },
        {match: '\\b(DESC|desc)\\b', name: 'keyword.control.desc.surrealql'},
        {
          match: '\\b(DIMENSION|dimension)\\b',
          name: 'keyword.control.dimension.surrealql'
        },
        {match: '\\b(DIST|dist)\\b', name: 'keyword.control.dist.surrealql'},
        {
          match: '\\b(DOC_IDS_CACHE|doc_ids_cache)\\b',
          name: 'keyword.control.doc_ids_cache.surrealql'
        },
        {
          match: '\\b(DOC_IDS_ORDER|doc_ids_order)\\b',
          name: 'keyword.control.doc_ids_order.surrealql'
        },
        {
          match: '\\b(DOC_LENGTHS_CACHE|doc_lengths_cache)\\b',
          name: 'keyword.control.doc_lengths_cache.surrealql'
        },
        {
          match: '\\b(DOC_LENGTHS_ORDER|doc_lengths_order)\\b',
          name: 'keyword.control.doc_lengths_order.surrealql'
        },
        {match: '\\b(DROP|drop)\\b', name: 'keyword.control.drop.surrealql'},
        {
          match: '\\b(DUPLICATE|duplicate)\\b',
          name: 'keyword.control.duplicate.surrealql'
        },
        {
          match: '\\b(DURATION|duration)\\b',
          name: 'keyword.control.duration.surrealql'
        },
        {match: '\\b(EFC|efc)\\b', name: 'keyword.control.efc.surrealql'},
        {match: '\\b(ELSE|else)\\b', name: 'keyword.control.else.surrealql'},
        {match: '\\b(END|end)\\b', name: 'keyword.control.end.surrealql'},
        {
          match: '\\b(ENFORCED|enforced)\\b',
          name: 'keyword.control.enforced.surrealql'
        },
        {match: '\\b(EVENT|event)\\b', name: 'keyword.control.event.surrealql'},
        {
          match: '\\b(EXCLUDE|exclude)\\b',
          name: 'keyword.control.exclude.surrealql'
        },
        {
          match: '\\b(EXISTS|exists)\\b',
          name: 'keyword.control.exists.surrealql'
        },
        {
          match: '\\b(EXPLAIN|explain)\\b',
          name: 'keyword.control.explain.surrealql'
        },
        {
          match: '\\b(EXPUNGE|expunge)\\b',
          name: 'keyword.control.expunge.surrealql'
        },
        {
          match: '\\b(EXTEND_CANDIDATES|extend_candidates)\\b',
          name: 'keyword.control.extend_candidates.surrealql'
        },
        {match: '\\b(FETCH|fetch)\\b', name: 'keyword.control.fetch.surrealql'},
        {match: '\\b(FIELD|field)\\b', name: 'keyword.control.field.surrealql'},
        {
          match: '\\b(FIELDS|fields)\\b',
          name: 'keyword.control.fields.surrealql'
        },
        {
          match: '\\b(FILTERS|filters)\\b',
          name: 'keyword.control.filters.surrealql'
        },
        {
          match: '\\b(FLEXIBLE|flexible)\\b',
          name: 'keyword.control.flexible.surrealql'
        },
        {match: '\\b(FOR|for)\\b', name: 'keyword.control.for.surrealql'},
        {match: '\\b(FROM|from)\\b', name: 'keyword.control.from.surrealql'},
        {
          match: '\\b(FUNCTION|function)\\b',
          name: 'keyword.control.function.surrealql'
        },
        {
          match: '\\b(FUNCTIONS|functions)\\b',
          name: 'keyword.control.functions.surrealql'
        },
        {match: '\\b(GET|get)\\b', name: 'keyword.control.get.surrealql'},
        {
          match: '\\b(GRAPHQL|graphql)\\b',
          name: 'keyword.control.graphql.surrealql'
        },
        {match: '\\b(GROUP|group)\\b', name: 'keyword.control.group.surrealql'},
        {
          match: '\\b(HIGHLIGHTS|highlights)\\b',
          name: 'keyword.control.highlights.surrealql'
        },
        {match: '\\b(HNSW|hnsw)\\b', name: 'keyword.control.hnsw.surrealql'},
        {match: '\\b(IF|if)\\b', name: 'keyword.control.if.surrealql'},
        {
          match: '\\b(IGNORE|ignore)\\b',
          name: 'keyword.control.ignore.surrealql'
        },
        {match: '\\b(IN|in)\\b', name: 'keyword.control.in.surrealql'},
        {
          match: '\\b(INCLUDE|include)\\b',
          name: 'keyword.control.include.surrealql'
        },
        {match: '\\b(INDEX|index)\\b', name: 'keyword.control.index.surrealql'},
        {match: '\\b(INFO|info)\\b', name: 'keyword.control.info.surrealql'},
        {
          match: '\\b(INSERT|insert)\\b',
          name: 'keyword.control.insert.surrealql'
        },
        {match: '\\b(INTO|into)\\b', name: 'keyword.control.into.surrealql'},
        {
          match: '\\b(ISSUER|issuer)\\b',
          name: 'keyword.control.issuer.surrealql'
        },
        {match: '\\b(JWT|jwt)\\b', name: 'keyword.control.jwt.surrealql'},
        {
          match: '\\b(KEEP_PRUNED_CONNECTIONS|keep_pruned_connections)\\b',
          name: 'keyword.control.keep_pruned_connections.surrealql'
        },
        {match: '\\b(KEY|key)\\b', name: 'keyword.control.key.surrealql'},
        {match: '\\b(KILL|kill)\\b', name: 'keyword.control.kill.surrealql'},
        {match: '\\b(LET|let)\\b', name: 'keyword.control.let.surrealql'},
        {match: '\\b(LIMIT|limit)\\b', name: 'keyword.control.limit.surrealql'},
        {match: '\\b(LIVE|live)\\b', name: 'keyword.control.live.surrealql'},
        {match: '\\b(LM|lm)\\b', name: 'keyword.control.lm.surrealql'},
        {match: '\\b(M|m)\\b', name: 'keyword.control.m.surrealql'},
        {match: '\\b(M0|m0)\\b', name: 'keyword.control.m0.surrealql'},
        {match: '\\b(MERGE|merge)\\b', name: 'keyword.control.merge.surrealql'},
        {
          match: '\\b(MIDDLEWARE|middleware)\\b',
          name: 'keyword.control.middleware.surrealql'
        },
        {match: '\\b(MTREE|mtree)\\b', name: 'keyword.control.mtree.surrealql'},
        {
          match: '\\b(MTREE_CACHE|mtree_cache)\\b',
          name: 'keyword.control.mtree_cache.surrealql'
        },
        {
          match: '\\b(NAMESPACE|namespace)\\b',
          name: 'keyword.control.namespace.surrealql'
        },
        {
          match: '\\b(NOINDEX|noindex)\\b',
          name: 'keyword.control.noindex.surrealql'
        },
        {
          match: '\\b(NORMAL|normal)\\b',
          name: 'keyword.control.normal.surrealql'
        },
        {match: '\\b(NOT|not)\\b', name: 'keyword.control.not.surrealql'},
        {match: '\\b(NS|ns)\\b', name: 'keyword.control.ns.surrealql'},
        {
          match: '\\b(NUMERIC|numeric)\\b',
          name: 'keyword.control.numeric.surrealql'
        },
        {match: '\\b(OMIT|omit)\\b', name: 'keyword.control.omit.surrealql'},
        {match: '\\b(ON|on)\\b', name: 'keyword.control.on.surrealql'},
        {match: '\\b(ONLY|only)\\b', name: 'keyword.control.only.surrealql'},
        {
          match: '\\b(OPTION|option)\\b',
          name: 'keyword.control.option.surrealql'
        },
        {match: '\\b(ORDER|order)\\b', name: 'keyword.control.order.surrealql'},
        {match: '\\b(OUT|out)\\b', name: 'keyword.control.out.surrealql'},
        {
          match: '\\b(OVERWRITE|overwrite)\\b',
          name: 'keyword.control.overwrite.surrealql'
        },
        {
          match: '\\b(PARALLEL|parallel)\\b',
          name: 'keyword.control.parallel.surrealql'
        },
        {match: '\\b(PARAM|param)\\b', name: 'keyword.control.param.surrealql'},
        {
          match: '\\b(PASSHASH|passhash)\\b',
          name: 'keyword.control.passhash.surrealql'
        },
        {
          match: '\\b(PASSWORD|password)\\b',
          name: 'keyword.control.password.surrealql'
        },
        {match: '\\b(PATCH|patch)\\b', name: 'keyword.control.patch.surrealql'},
        {
          match: '\\b(PERMISSIONS|permissions)\\b',
          name: 'keyword.control.permissions.surrealql'
        },
        {match: '\\b(POST|post)\\b', name: 'keyword.control.post.surrealql'},
        {
          match: '\\b(POSTINGS_CACHE|postings_cache)\\b',
          name: 'keyword.control.postings_cache.surrealql'
        },
        {
          match: '\\b(POSTINGS_ORDER|postings_order)\\b',
          name: 'keyword.control.postings_order.surrealql'
        },
        {match: '\\b(PUT|put)\\b', name: 'keyword.control.put.surrealql'},
        {
          match: '\\b(READONLY|readonly)\\b',
          name: 'keyword.control.readonly.surrealql'
        },
        {
          match: '\\b(REBUILD|rebuild)\\b',
          name: 'keyword.control.rebuild.surrealql'
        },
        {
          match: '\\b(RECORD|record)\\b',
          name: 'keyword.control.record.surrealql'
        },
        {
          match: '\\b(REFERENCE|reference)\\b',
          name: 'keyword.control.reference.surrealql'
        },
        {
          match: '\\b(REJECT|reject)\\b',
          name: 'keyword.control.reject.surrealql'
        },
        {
          match: '\\b(RELATE|relate)\\b',
          name: 'keyword.control.relate.surrealql'
        },
        {
          match: '\\b(RELATION|relation)\\b',
          name: 'keyword.control.relation.surrealql'
        },
        {
          match: '\\b(REMOVE|remove)\\b',
          name: 'keyword.control.remove.surrealql'
        },
        {
          match: '\\b(REPLACE|replace)\\b',
          name: 'keyword.control.replace.surrealql'
        },
        {
          match: '\\b(RETURN|return)\\b',
          name: 'keyword.control.return.surrealql'
        },
        {match: '\\b(ROLES|roles)\\b', name: 'keyword.control.roles.surrealql'},
        {match: '\\b(ROOT|root)\\b', name: 'keyword.control.root.surrealql'},
        {match: '\\b(SC|sc)\\b', name: 'keyword.control.sc.surrealql'},
        {
          match: '\\b(SCHEMAFULL|schemafull)\\b',
          name: 'keyword.control.schemafull.surrealql'
        },
        {
          match: '\\b(SCHEMALESS|schemaless)\\b',
          name: 'keyword.control.schemaless.surrealql'
        },
        {match: '\\b(SCOPE|scope)\\b', name: 'keyword.control.scope.surrealql'},
        {
          match: '\\b(SEARCH|search)\\b',
          name: 'keyword.control.search.surrealql'
        },
        {
          match: '\\b(SELECT|select)\\b',
          name: 'keyword.control.select.surrealql'
        },
        {
          match: '\\b(SESSION|session)\\b',
          name: 'keyword.control.session.surrealql'
        },
        {match: '\\b(SET|set)\\b', name: 'keyword.control.set.surrealql'},
        {match: '\\b(SHOW|show)\\b', name: 'keyword.control.show.surrealql'},
        {
          match: '\\b(SIGNIN|signin)\\b',
          name: 'keyword.control.signin.surrealql'
        },
        {
          match: '\\b(SIGNUP|signup)\\b',
          name: 'keyword.control.signup.surrealql'
        },
        {match: '\\b(SINCE|since)\\b', name: 'keyword.control.since.surrealql'},
        {match: '\\b(SLEEP|sleep)\\b', name: 'keyword.control.sleep.surrealql'},
        {match: '\\b(SPLIT|split)\\b', name: 'keyword.control.split.surrealql'},
        {match: '\\b(START|start)\\b', name: 'keyword.control.start.surrealql'},
        {
          match: '\\b(STRUCTURE|structure)\\b',
          name: 'keyword.control.structure.surrealql'
        },
        {match: '\\b(TABLE|table)\\b', name: 'keyword.control.table.surrealql'},
        {
          match: '\\b(TABLES|tables)\\b',
          name: 'keyword.control.tables.surrealql'
        },
        {match: '\\b(TB|tb)\\b', name: 'keyword.control.tb.surrealql'},
        {
          match: '\\b(TEMPFILES|tempfiles)\\b',
          name: 'keyword.control.tempfiles.surrealql'
        },
        {
          match: '\\b(TERMS_CACHE|terms_cache)\\b',
          name: 'keyword.control.terms_cache.surrealql'
        },
        {
          match: '\\b(TERMS_ORDER|terms_order)\\b',
          name: 'keyword.control.terms_order.surrealql'
        },
        {match: '\\b(THEN|then)\\b', name: 'keyword.control.then.surrealql'},
        {match: '\\b(THROW|throw)\\b', name: 'keyword.control.throw.surrealql'},
        {
          match: '\\b(TIMEOUT|timeout)\\b',
          name: 'keyword.control.timeout.surrealql'
        },
        {match: '\\b(TO|to)\\b', name: 'keyword.control.to.surrealql'},
        {match: '\\b(TOKEN|token)\\b', name: 'keyword.control.token.surrealql'},
        {
          match: '\\b(TOKENIZERS|tokenizers)\\b',
          name: 'keyword.control.tokenizers.surrealql'
        },
        {match: '\\b(TRACE|trace)\\b', name: 'keyword.control.trace.surrealql'},
        {
          match: '\\b(TRANSACTION|transaction)\\b',
          name: 'keyword.control.transaction.surrealql'
        },
        {match: '\\b(TYPE|type)\\b', name: 'keyword.control.type.surrealql'},
        {
          match: '\\b(UNIQUE|unique)\\b',
          name: 'keyword.control.unique.surrealql'
        },
        {match: '\\b(UNSET|unset)\\b', name: 'keyword.control.unset.surrealql'},
        {
          match: '\\b(UPDATE|update)\\b',
          name: 'keyword.control.update.surrealql'
        },
        {
          match: '\\b(UPSERT|upsert)\\b',
          name: 'keyword.control.upsert.surrealql'
        },
        {match: '\\b(URL|url)\\b', name: 'keyword.control.url.surrealql'},
        {match: '\\b(USE|use)\\b', name: 'keyword.control.use.surrealql'},
        {match: '\\b(USER|user)\\b', name: 'keyword.control.user.surrealql'},
        {match: '\\b(VALUE|value)\\b', name: 'keyword.control.value.surrealql'},
        {
          match: '\\b(VALUES|values)\\b',
          name: 'keyword.control.values.surrealql'
        },
        {
          match: '\\b(VERSION|version)\\b',
          name: 'keyword.control.version.surrealql'
        },
        {match: '\\b(WHEN|when)\\b', name: 'keyword.control.when.surrealql'},
        {match: '\\b(WHERE|where)\\b', name: 'keyword.control.where.surrealql'},
        {match: '\\b(WITH|with)\\b', name: 'keyword.control.with.surrealql'}
      ]
    },
    number: {
      patterns: [
        {
          match: '\\b\\d+\\.\\d+(?:f|dec)?\\b',
          name: 'constant.numeric.decimal'
        },
        {match: '\\b\\d+(?:f|dec)?\\b', name: 'constant.numeric.int'}
      ]
    },
    'object-key': {
      patterns: [
        {
          captures: {1: {name: 'string.quoted.double'}},
          match: '(?:^|{|,)[ \t]*("[^(?:\\")]+")(?=:(?!:))'
        },
        {
          captures: {1: {name: 'string.quoted.single'}},
          match: "(?:^|{|,)[ \t]*('[^(?:\\')]+')(?=:(?!:))"
        },
        {
          captures: {2: {name: 'meta.object-literal.key'}},
          match: '(^|\\{|\\,)[ \t]*([a-zA-Z_0-9]+)(?=:(?!:))'
        }
      ]
    },
    operators: {
      patterns: [
        {match: '<->|->|<-|<~', name: 'keyword.operator.arrow.surrealql'},
        {match: '\\b(AND|and)\\b|&&', name: 'keyword.operator.and.surrealql'},
        {match: '\\b(OR|or)\\b|\\|\\|', name: 'keyword.operator.or.surrealql'},
        {
          match: '\\b(IS NOT|is not)\\b|!=',
          name: 'keyword.operator.is-not.surrealql'
        },
        {match: '\\b(IS|is)\\b|=', name: 'keyword.operator.is.surrealql'},
        {
          match: '\\b(CONTAINSALL|containsall)\\b|⊇',
          name: 'keyword.operator.containsall.surrealql'
        },
        {
          match: '\\b(CONTAINSANY|containsany)\\b|⊃',
          name: 'keyword.operator.containsany.surrealql'
        },
        {
          match: '\\b(CONTAINSNONE|containsnone)\\b|⊅',
          name: 'keyword.operator.containsnone.surrealql'
        },
        {
          match: '\\b(CONTAINSSOME|containssome)\\b',
          name: 'keyword.operator.containssome.surrealql'
        },
        {
          match: '\\b(CONTAINSNOT|containsnot)\\b|∌',
          name: 'keyword.operator.containsnot.surrealql'
        },
        {
          match: '\\b(CONTAINS|contains)\\b|∋',
          name: 'keyword.operator.contains.surrealql'
        },
        {
          match: '\\b(ALLINSIDE|allinside)\\b|⊆',
          name: 'keyword.operator.allinside.surrealql'
        },
        {
          match: '\\b(ANYINSIDE|anyinside)\\b|⊂',
          name: 'keyword.operator.anyinside.surrealql'
        },
        {
          match: '\\b(NONEINSIDE|noneinside)\\b|⊄',
          name: 'keyword.operator.noneinside.surrealql'
        },
        {
          match: '\\b(SOMEINSIDE|someinside)\\b',
          name: 'keyword.operator.someinside.surrealql'
        },
        {
          match: '\\b(NOTINSIDE|notinside|NOT IN|not in)\\b|∉',
          name: 'keyword.operator.notinside.surrealql'
        },
        {
          match: '\\b(INSIDE|inside)\\b|∈',
          name: 'keyword.operator.inside.surrealql'
        },
        {
          match: '\\b(OUTSIDE|outside)\\b',
          name: 'keyword.operator.outside.surrealql'
        },
        {
          match: '\\b(INTERSECTS|intersects)\\b',
          name: 'keyword.operator.intersects.surrealql'
        },
        {match: '==', name: 'keyword.operator.equal.surrealql'},
        {match: '\\*=', name: 'keyword.operator.all-equal.surrealql'},
        {match: '\\?=', name: 'keyword.operator.any-equal.surrealql'},
        {match: '!~', name: 'keyword.operator.fuzzy-inequal.surrealql'},
        {match: '\\*~', name: 'keyword.operator.fuzzy-all-equal.surrealql'},
        {match: '\\?~', name: 'keyword.operator.fuzzy-any-equal.surrealql'},
        {match: '~', name: 'keyword.operator.fuzzy-equal.surrealql'},
        {match: '<=', name: 'keyword.operator.less-or-equal.surrealql'},
        {match: '<(?!-|[a-z]+[^:])', name: 'keyword.operator.less.surrealql'},
        {match: '>=', name: 'keyword.operator.more-or-equal.surrealql'},
        {match: '(?<!-)>', name: 'keyword.operator.more.surrealql'},
        {match: '\\+', name: 'keyword.operator.add.surrealql'},
        {match: '-', name: 'keyword.operator.subtract.surrealql'},
        {match: '\\*|×|∙', name: 'keyword.operator.multiply.surrealql'},
        {match: '\\/|÷', name: 'keyword.operator.devide.surrealql'},
        {
          captures: {1: {name: 'constant.numeric.int'}},
          match: '@([0-9]+)?@',
          name: 'keyword.operator.matches.surrealql'
        },
        {match: '\\?:', name: 'keyword.operator.either.surrealql'},
        {match: '\\?\\?', name: 'keyword.operator.truthy.surrealql'},
        {
          match: '\\<\\|([a-zA-Z|\\d|,])+\\|\\>',
          name: 'keyword.operator.knn.surrealql'
        }
      ]
    },
    positional: {
      match: '\\b(AFTER|after|BEFORE|before)\\b',
      name: 'constant.language.positional'
    },
    query: {patterns: [{include: '$self'}]},
    record: {
      patterns: [
        {
          captures: {
            1: {name: 'entity.name.class'},
            2: {name: 'entity.name.class'}
          },
          match: '(\\b\\w+\\b):⟨([^⟩]+)⟩'
        },
        {
          captures: {
            1: {name: 'entity.name.class'},
            2: {name: 'entity.name.class'}
          },
          match: '(\\b\\w+\\b):`([^`]+)`'
        },
        {
          begin: '(\\b\\w+\\b):(?=(\\b[\\w:]+\\b)\\s*\\()',
          beginCaptures: {
            1: {name: 'entity.name.class'},
            2: {name: 'support.function'}
          },
          end: '(?<=\\))',
          patterns: [
            {include: '#comment'},
            {
              begin: '\\(',
              end: '\\)',
              name: 'meta.function.arguments',
              patterns: [{include: '#value'}]
            }
          ]
        },
        {
          captures: {
            1: {name: 'entity.name.class'},
            2: {name: 'entity.name.class'}
          },
          match: '(\\b\\w+\\b):(\\b\\w+\\b)'
        },
        {
          begin: '(\\b\\w+\\b):\\[',
          captures: {1: {name: 'entity.name.class'}},
          end: '\\]',
          patterns: [{include: '#array-content'}]
        },
        {
          begin: '(\\b\\w+\\b):(?=\\{)',
          captures: {1: {name: 'entity.name.class'}},
          end: '\\}',
          patterns: [{include: '#block-content'}]
        }
      ]
    },
    string: {
      patterns: [
        {begin: '[a-z]?"', end: '(?<!\\\\)"', name: 'string.quoted.double'},
        {begin: "[a-z]?'", end: "(?<!\\\\)'", name: 'string.quoted.single'}
      ]
    },
    subquery: {
      begin: '\\(',
      end: '\\)',
      patterns: [{include: '#query'}, {include: '#value'}]
    },
    type: {
      captures: {
        0: {
          patterns: [
            {match: '<|>', name: 'entity.name.type.surrealql'},
            {include: '#number'},
            {include: '#void-type'}
          ]
        }
      },
      match: '[a-z]*<[a-zA-Z][a-zA-Z0-9<>|, _]+[a-zA-Z0-9>]+>',
      name: 'test'
    },
    value: {
      patterns: [
        {include: '#comment'},
        {include: '#js-function'},
        {include: '#function'},
        {include: '#block'},
        {include: '#array'},
        {include: '#var-name'},
        {include: '#boolean'},
        {include: '#string'},
        {include: '#ident'},
        {include: '#void-type'},
        {include: '#positional'},
        {include: '#number'},
        {include: '#duration'},
        {include: '#record'},
        {include: '#subquery'},
        {include: '#type'}
      ]
    },
    'var-name': {
      patterns: [
        {match: '\\$\\w+', name: 'variable.name'},
        {match: '\\$`\\w+`', name: 'variable.name'},
        {match: '\\$⟨\\w+⟩', name: 'variable.name'}
      ]
    },
    'void-type': {
      match: '\\b(null|NULL|none|NONE)\\b',
      name: 'constant.language.void'
    }
  },
  scopeName: 'source.surrealql'
}

export default grammar