cfg

2 files changed, 412 insertions, 0 deletions

diff --git a/cfg/nvim/init.vim b/cfg/nvim/init.vim
new file mode 100644
index 0000000..825403b
--- /dev/null
+++ b/cfg/nvim/init.vim
@@ -0,0 +1,36 @@
+set nocompatible
+set hlsearch
+set shiftwidth=4
+set autoindent
+set number
+set relativenumber
+set cc=80
+filetype plugin indent on 
+syntax on 
+set cursorline
+color wildcharm
+set autochdir
+
+call plug#begin()
+
+Plug 'nvim-lua/plenary.nvim'
+Plug 'nvim-telescope/telescope-fzf-native.nvim'
+Plug 'nvim-telescope/telescope.nvim', { 'branch': '0.1.x' }
+
+Plug 'NLKNguyen/papercolor-theme'
+Plug 'https://gitlab.com/protesilaos/tempus-themes-vim.git'
+Plug 'yorickpeterse/vim-paper'
+Plug 'morhetz/gruvbox'
+Plug 'EdenEast/nightfox.nvim'
+Plug 'rebelot/kanagawa.nvim'
+Plug 'craftzdog/solarized-osaka.nvim'
+Plug 'nyoom-engineering/oxocarbon.nvim'
+Plug 'whatyouhide/vim-gotham'
+Plug 'miikanissi/modus-themes.nvim'
+Plug 'tjdevries/colorbuddy.nvim'
+Plug 'zootedb0t/citruszest.nvim'
+Plug 'Love-Pengy/lillilac.nvim'
+Plug 'kyazdani42/blue-moon'
+
+call plug#end()
+
diff --git a/cfg/nvim/syntax/close.vim b/cfg/nvim/syntax/close.vim
new file mode 100644
index 0000000..1bc8994
--- /dev/null
+++ b/cfg/nvim/syntax/close.vim
@@ -0,0 +1,376 @@
+" Vim syntax file
+" Language:     Close
+" Maintainer:   George Abbott <george@gabbott.dev>
+" Last Change:  2024-08-03
+" For bugs, patches and license go to https://github.com/close-lang/close.vim
+
+if version < 600
+    syntax clear
+elseif exists("b:current_syntax")
+    finish
+endif
+
+" Syntax definitions {{{1
+" Basic keywords {{{2
+syn keyword   closeConditional switch if else elif unless 
+syn keyword   closeRepeat loop while for until
+" `:syn match` must be used to prioritize highlighting `for` keyword.
+syn keyword   closeStructure struct enum error record 
+syn keyword   closeUnion union nextgroup=closeIdentifier skipwhite skipempty contained
+syn match closeUnionContextual /\<union\_s\+\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*/ transparent contains=closeUnion
+syn keyword   closeOperator    as
+syn keyword   closeExistential existential nextgroup=closeTypedef skipwhite skipempty contained
+syn match closeExistentialContextual /\<existential\_s\+type/ transparent contains=closeExistential,closeTypedef
+
+syn match     closeAssert      "\<assert\(\w\)*!" contained
+syn match     closeAsync       "\<async\%(\s\|\n\)\@="
+syn keyword   closeKeyword     then do end in out has with c asm goto label is where
+syn keyword   closeKeyword     construct destruct deconstruct
+syn keyword   closeKeyword     default default_initialized zero_initialized uninitialized
+syn keyword   closeKeyword     panic recklessly recover rescue ensure retry
+syn keyword   closeKeyword     type typeof sizeof sized unsized assert
+syn keyword   closeKeyword     abstract virtual final override
+syn keyword   closeKeyword     generic generator immediate packed repr
+syn keyword   closeKeyword     permitted 
+
+syn keyword   closeKeyword     break redo next skip
+syn keyword   closeKeyword     box
+syn keyword   closeKeyword     next 
+syn keyword   closeKeyword     crate
+syn keyword   closeKeyword     priv typeof unsized abstract virtual final override nopanic
+syn keyword   closeKeyword     extern nextgroup=closeExternCrate,closeObsoleteExternMod skipwhite skipempty
+syn keyword   closeKeyword     fn nextgroup=closeFuncName skipwhite skipempty
+syn keyword   closeKeyword     pub priv nextgroup=closePubScope skipwhite skipempty
+syn keyword   closeKeyword     return
+syn keyword   closeKeyword     yield
+syn keyword   closeKeyword     import nextgroup=closeModPath skipwhite skipempty
+" FIXME: Scoped impl's name is also fallen in this category
+syn keyword   closeKeyword     module trait nextgroup=closeIdentifier skipwhite skipempty
+syn keyword   closeStorage     move mut ref static const
+syn match     closeDefault     /\<default\ze\_s\+\(impl\|fn\|type\|const\)\>/
+syn keyword   closeAwait       await
+syn keyword   closeKeyword     try catch propagate or_else
+
+syn keyword closePubScopeCrate crate contained
+syn match closePubScopeDelim /[()]/ contained
+syn match closePubScope /([^()]*)/ contained contains=closePubScopeDelim,closePubScopeCrate,closeSuper,closeModPath,closeModPathSep,closeSelf transparent
+
+syn keyword   closeExternCrate crate contained nextgroup=closeIdentifier,closeExternCrateString skipwhite skipempty
+" This is to get the `bar` part of `extern crate "foo" as bar;` highlighting.
+syn match   closeExternCrateString /".*"\_s*as/ contained nextgroup=closeIdentifier skipwhite transparent skipempty contains=closeString,closeOperator
+syn keyword   closeObsoleteExternMod mod contained nextgroup=closeIdentifier skipwhite skipempty
+
+syn match     closeIdentifier  contains=closeIdentifierPrime "\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained
+syn match     closeFuncName    "\%(r#\)\=\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*" display contained
+
+syn region closeMacroRepeat matchgroup=closeMacroRepeatDelimiters start="$(" end="),\=[*+]" contains=TOP
+syn match closeMacroVariable "$\w\+"
+syn match closeRawIdent "\<r#\h\w*" contains=NONE
+
+
+" Built-in types {{{2
+syn keyword   closeType        isize usize char bool u8 u16 u32 u64 u128 f32
+syn keyword   closeType        f64 i8 i16 i32 i64 i128 str void size noreturn
+
+" Things from the libstd v1 prelude (src/libstd/prelude/v1.rs) {{{2
+" This section is just straight transformation of the contents of the prelude,
+" to make it easy to update.
+
+" Reexported core operators {{{3
+syn keyword   closeTrait       Copy Send Sized Sync
+syn keyword   closeTrait       Drop Fn FnMut FnOnce
+
+" Reexported functions {{{3
+" There’s no point in highlighting these; when one writes drop( or drop::< it
+" gets the same highlighting anyway, and if someone writes `let drop = …;` we
+" don’t really want *that* drop to be highlighted.
+"syn keyword closeFunction drop
+
+" Reexported types and traits {{{3
+syn keyword closeTrait Box
+syn keyword closeTrait ToOwned
+syn keyword closeTrait Clone
+syn keyword closeTrait PartialEq PartialOrd Eq Ord
+syn keyword closeTrait Default
+syn keyword closeTrait Iterator Extend IntoIterator
+syn keyword closeTrait DoubleEndedIterator ExactSizeIterator
+syn keyword closeEnum Option
+syn keyword closeEnumVariant Some None
+syn keyword closeEnum Result
+syn keyword closeEnumVariant Ok Err
+syn keyword closeTrait SliceConcatExt
+syn keyword closeTrait String ToString
+syn keyword closeTrait Vec
+
+" Other syntax {{{2
+syn keyword   closeSelf        self
+syn keyword   closeBoolean     true false
+
+" If foo::bar changes to foo.bar, change this ("::" to "\.").
+" If foo::bar changes to Foo::bar, change this (first "\w" to "\u").
+syn match     closeModPath     "\w\(\w\)*::[^<]"he=e-3,me=e-3
+syn match     closeModPathSep  "::"
+
+syn match     closeFuncCall    "\w\(\w\)*("he=e-1,me=e-1
+syn match     closeFuncCall    "\w\(\w\)*::<"he=e-3,me=e-3 " foo::<T>();
+
+" This is merely a convention; note also the use of [A-Z], restricting it to
+" latin identifiers rather than the full Unicode uppercase. I have not used
+" [:upper:] as it depends upon 'noignorecase'
+"syn match     closeCapsIdent    display "[A-Z]\w\(\w\)*"
+
+syn match     closeOperator     display "\%(+\|-\|/\|*\|=\|\^\|&\||\|!\|>\|<\|%\)=\?"
+" This one isn't *quite* right, as we could have binary-& with a reference
+syn match     closeSigil        display /&\s\+[&~@*][^)= \t\r\n]/he=e-1,me=e-1
+syn match     closeSigil        display /[&~@*][^)= \t\r\n]/he=e-1,me=e-1
+" This isn't actually correct; a closure with no arguments can be `|| { }`.
+" Last, because the & in && isn't a sigil
+syn match     closeOperator     display "&&\|||"
+" This is closeArrowCharacter rather than closeArrow for the sake of matchparen,
+" so it skips the ->; see http://stackoverflow.com/a/30309949 for details.
+syn match     closeArrowCharacter display "->"
+syn match     closeQuestionMark display "?\([a-zA-Z]\+\)\@!"
+
+syn match     closeMacro       '\w\(\w\)*!' contains=closeAssert,closePanic
+syn match     closeMacro       '#\w\(\w\)*' contains=closeAssert,closePanic
+
+syn match     closeEscapeError   display contained /\\./
+syn match     closeEscape        display contained /\\\([nrt0\\'"]\|x\x\{2}\)/
+syn match     closeEscapeUnicode display contained /\\u{\%(\x_*\)\{1,6}}/
+syn match     closeStringContinuation display contained /\\\n\s*/
+syn region    closeString      matchgroup=closeStringDelimiter start=+b"+ skip=+\\\\\|\\"+ end=+"+ contains=closeEscape,closeEscapeError,closeStringContinuation
+syn region    closeString      matchgroup=closeStringDelimiter start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=closeEscape,closeEscapeUnicode,closeEscapeError,closeStringContinuation,@Spell
+syn region    closeString      matchgroup=closeStringDelimiter start='b\?r\z(#*\)"' end='"\z1' contains=@Spell
+
+" Match attributes with either arbitrary syntax or special highlighting for
+" derives. We still highlight strings and comments inside of the attribute.
+syn region    closeAttribute   start="#!\?\[" end="\]" contains=@closeAttributeContents,closeAttributeParenthesizedParens,closeAttributeParenthesizedCurly,closeAttributeParenthesizedBrackets,closeDerive
+syn region    closeAttributeParenthesizedParens matchgroup=closeAttribute start="\w\%(\w\)*("rs=e end=")"re=s transparent contained contains=closeAttributeBalancedParens,@closeAttributeContents
+syn region    closeAttributeParenthesizedCurly matchgroup=closeAttribute start="\w\%(\w\)*{"rs=e end="}"re=s transparent contained contains=closeAttributeBalancedCurly,@closeAttributeContents
+syn region    closeAttributeParenthesizedBrackets matchgroup=closeAttribute start="\w\%(\w\)*\["rs=e end="\]"re=s transparent contained contains=closeAttributeBalancedBrackets,@closeAttributeContents
+syn region    closeAttributeBalancedParens matchgroup=closeAttribute start="("rs=e end=")"re=s transparent contained contains=closeAttributeBalancedParens,@closeAttributeContents
+syn region    closeAttributeBalancedCurly matchgroup=closeAttribute start="{"rs=e end="}"re=s transparent contained contains=closeAttributeBalancedCurly,@closeAttributeContents
+syn region    closeAttributeBalancedBrackets matchgroup=closeAttribute start="\["rs=e end="\]"re=s transparent contained contains=closeAttributeBalancedBrackets,@closeAttributeContents
+syn cluster   closeAttributeContents contains=closeString,closeCommentLine,closeCommentBlock,closeCommentLineDocError,closeCommentBlockDocError
+syn region    closeDerive      start="derive(" end=")" contained contains=closeDeriveTrait
+" This list comes from src/libsyntax/ext/deriving/mod.rs
+" Some are deprecated (Encodable, Decodable) or to be removed after a new snapshot (Show).
+syn keyword   closeDeriveTrait contained Clone Hash RustcEncodable RustcDecodable Encodable Decodable PartialEq Eq PartialOrd Ord Rand Show Debug Default FromPrimitive Send Sync Copy
+
+" dyn keyword: It's only a keyword when used inside a type expression, so
+" we make effort here to highlight it only when Rust identifiers follow it
+" (not minding the case of pre-2018 Rust where a path starting with :: can
+" follow).
+"
+" This is so that uses of dyn variable names such as in 'let &dyn = &2'
+" and 'let dyn = 2' will not get highlighted as a keyword.
+syn match     closeKeyword "\<dyn\ze\_s\+\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)" contains=closeDynKeyword
+syn keyword   closeDynKeyword  dyn contained
+
+" Number literals
+syn match     closeDecNumber   display "\<[0-9][0-9_]*\%([iu]\%(size\|8\|16\|32\|64\|128\)\)\="
+syn match     closeHexNumber   display "\<0x[a-fA-F0-9_]\+\%([iu]\%(size\|8\|16\|32\|64\|128\)\)\="
+syn match     closeOctNumber   display "\<0o[0-7_]\+\%([iu]\%(size\|8\|16\|32\|64\|128\)\)\="
+syn match     closeBinNumber   display "\<0b[01_]\+\%([iu]\%(size\|8\|16\|32\|64\|128\)\)\="
+
+" Special case for numbers of the form "1." which are float literals, unless followed by
+" an identifier, which makes them integer literals with a method call or field access,
+" or by another ".", which makes them integer literals followed by the ".." token.
+" (This must go first so the others take precedence.)
+syn match     closeFloat       display "\<[0-9][0-9_]*\.\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\|\.\)\@!"
+" To mark a number as a normal float, it must have at least one of the three things integral values don't have:
+" a decimal point and more numbers; an exponent; and a type suffix.
+syn match     closeFloat       display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\%([eE][+-]\=[0-9_]\+\)\=\(f32\|f64\)\="
+syn match     closeFloat       display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\=\%([eE][+-]\=[0-9_]\+\)\(f32\|f64\)\="
+syn match     closeFloat       display "\<[0-9][0-9_]*\%(\.[0-9][0-9_]*\)\=\%([eE][+-]\=[0-9_]\+\)\=\(f32\|f64\)"
+
+" For the benefit of delimitMate
+syn region closeLifetimeCandidate display start=/&'\%(\([^'\\]\|\\\(['nrt0\\\"]\|x\x\{2}\|u{\%(\x_*\)\{1,6}}\)\)'\)\@!/ end=/[[:cntrl:][:space:][:punct:]]\@=\|$/ contains=closeSigil,closeLifetime
+syn region closeGenericRegion display start=/<\%('\|[^[:cntrl:][:space:][:punct:]]\)\@=')\S\@=/ end=/>/ contains=closeGenericLifetimeCandidate
+syn region closeGenericLifetimeCandidate display start=/\%(<\|,\s*\)\@<='/ end=/[[:cntrl:][:space:][:punct:]]\@=\|$/ contains=closeSigil,closeLifetime
+
+"closeLifetime must appear before closeCharacter, or chars will get the lifetime highlighting
+syn match     closeLifetime    display "\'\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*"
+syn match     closeLabel       display "\'\%([^[:cntrl:][:space:][:punct:][:digit:]]\|_\)\%([^[:cntrl:][:punct:][:space:]]\|_\)*:"
+syn match   closeCharacterInvalid   display contained /b\?'\zs[\n\r\t']\ze'/
+" The groups negated here add up to 0-255 but nothing else (they do not seem to go beyond ASCII).
+syn match   closeCharacterInvalidUnicode   display contained /b'\zs[^[:cntrl:][:graph:][:alnum:][:space:]]\ze'/
+syn match   closeCharacter   /b'\([^\\]\|\\\(.\|x\x\{2}\)\)'/ contains=closeEscape,closeEscapeError,closeCharacterInvalid,closeCharacterInvalidUnicode
+syn match   closeCharacter   /'\([^\\]\|\\\(.\|x\x\{2}\|u{\%(\x_*\)\{1,6}}\)\)'/ contains=closeEscape,closeEscapeUnicode,closeEscapeError,closeCharacterInvalid
+
+syn match closeShebang /\%^#![^[].*/
+syn region closeCommentLine                                                  start="//"                      end="$"   contains=closeTodo,@Spell
+syn region closeCommentLineDoc                                               start="//\%(//\@!\|!\)"         end="$"   contains=closeTodo,@Spell
+syn region closeCommentLineDocError                                          start="//\%(//\@!\|!\)"         end="$"   contains=closeTodo,@Spell contained
+syn region closeCommentBlock             matchgroup=closeCommentBlock         start="/\*\%(!\|\*[*/]\@!\)\@!" end="\*/" contains=closeTodo,closeCommentBlockNest,@Spell
+syn region closeCommentBlockDoc          matchgroup=closeCommentBlockDoc      start="/\*\%(!\|\*[*/]\@!\)"    end="\*/" contains=closeTodo,closeCommentBlockDocNest,closeCommentBlockDocRustCode,@Spell
+syn region closeCommentBlockDocError     matchgroup=closeCommentBlockDocError start="/\*\%(!\|\*[*/]\@!\)"    end="\*/" contains=closeTodo,closeCommentBlockDocNestError,@Spell contained
+syn region closeCommentBlockNest         matchgroup=closeCommentBlock         start="/\*"                     end="\*/" contains=closeTodo,closeCommentBlockNest,@Spell contained transparent
+syn region closeCommentBlockDocNest      matchgroup=closeCommentBlockDoc      start="/\*"                     end="\*/" contains=closeTodo,closeCommentBlockDocNest,@Spell contained transparent
+syn region closeCommentBlockDocNestError matchgroup=closeCommentBlockDocError start="/\*"                     end="\*/" contains=closeTodo,closeCommentBlockDocNestError,@Spell contained transparent
+
+" FIXME: this is a really ugly and not fully correct implementation. Most
+" importantly, a case like ``/* */*`` should have the final ``*`` not being in
+" a comment, but in practice at present it leaves comments open two levels
+" deep. But as long as you stay away from that particular case, I *believe*
+" the highlighting is correct. Due to the way Vim's syntax engine works
+" (greedy for start matches, unlike Rust's tokeniser which is searching for
+" the earliest-starting match, start or end), I believe this cannot be solved.
+" Oh you who would fix it, don't bother with things like duplicating the Block
+" rules and putting ``\*\@<!`` at the start of them; it makes it worse, as
+" then you must deal with cases like ``/*/**/*/``. And don't try making it
+" worse with ``\%(/\@<!\*\)\@<!``, either...
+
+syn keyword closeTodo contained TODO FIXME XXX NB NOTE SAFETY
+
+" Clobbered registers
+syn keyword closeAsmDirSpec in out lateout inout inlateout contained nextgroup=closeAsmReg skipwhite skipempty
+syn region  closeAsmReg start="(" end=")" contained contains=closeString
+
+" Symbol operands
+syn keyword closeAsmSym sym contained nextgroup=closeAsmSymPath skipwhite skipempty
+syn region  closeAsmSymPath start="\S" end=",\|)"me=s-1 contained contains=closeComment.*,closeIdentifier
+
+" Const
+syn region  closeAsmConstBalancedParens start="("ms=s+1 end=")" contained contains=@closeAsmConstExpr
+syn cluster closeAsmConstExpr contains=closeComment.*,close.*Number,closeString,closeAsmConstBalancedParens
+syn region  closeAsmConst start="const" end=",\|)"me=s-1 contained contains=closeStorage,@closeAsmConstExpr
+
+" Options
+syn region  closeAsmOptionsGroup start="options\s*(" end=")" contained contains=closeAsmOptions,closeAsmOptionsKey
+syn keyword closeAsmOptionsKey options contained
+syn keyword closeAsmOptions pure nomem readonly preserves_flags noreturn nostack att_syntax contained
+
+" Folding rules {{{2
+" Trivial folding rules to begin with.
+" FIXME: use the AST to make really good folding
+syn region closeFoldBraces start="{" end="}" transparent fold
+
+if !exists("b:current_syntax_embed")
+    let b:current_syntax_embed = 1
+    syntax include @RustCodeInComment <sfile>:p:h/close.vim
+    unlet b:current_syntax_embed
+
+    " Currently regions marked as ```<some-other-syntax> will not get
+    " highlighted at all. In the future, we can do as vim-markdown does and
+    " highlight with the other syntax. But for now, let's make sure we find
+    " the closing block marker, because the rules below won't catch it.
+    syn region closeCommentLinesDocNonRustCode matchgroup=closeCommentDocCodeFence start='^\z(\s*//[!/]\s*```\).\+$' end='^\z1$' keepend contains=closeCommentLineDoc
+
+    " We borrow the rules from close’s src/libclosedoc/html/markdown.rs, so that
+    " we only highlight as Rust what it would perceive as Rust (almost; it’s
+    " possible to trick it if you try hard, and indented code blocks aren’t
+    " supported because Markdown is a menace to parse and only mad dogs and
+    " Englishmen would try to handle that case correctly in this syntax file).
+    syn region closeCommentLinesDocRustCode matchgroup=closeCommentDocCodeFence start='^\z(\s*//[!/]\s*```\)[^A-Za-z0-9_-]*\%(\%(should_panic\|no_run\|ignore\|allow_fail\|close\|test_harness\|compile_fail\|E\d\{4}\|edition201[58]\)\%([^A-Za-z0-9_-]\+\|$\)\)*$' end='^\z1$' keepend contains=@RustCodeInComment,closeCommentLineDocLeader
+    syn region closeCommentBlockDocRustCode matchgroup=closeCommentDocCodeFence start='^\z(\%(\s*\*\)\?\s*```\)[^A-Za-z0-9_-]*\%(\%(should_panic\|no_run\|ignore\|allow_fail\|close\|test_harness\|compile_fail\|E\d\{4}\|edition201[58]\)\%([^A-Za-z0-9_-]\+\|$\)\)*$' end='^\z1$' keepend contains=@RustCodeInComment,closeCommentBlockDocStar
+    " Strictly, this may or may not be correct; this code, for example, would
+    " mishighlight:
+    "
+    "     /**
+    "     ```close
+    "     println!("{}", 1
+    "     * 1);
+    "     ```
+    "     */
+    "
+    " … but I don’t care. Balance of probability, and all that.
+    syn match closeCommentBlockDocStar /^\s*\*\s\?/ contained
+    syn match closeCommentLineDocLeader "^\s*//\%(//\@!\|!\)" contained
+endif
+
+" Default highlighting {{{1
+hi def link closeDecNumber       closeNumber
+hi def link closeHexNumber       closeNumber
+hi def link closeOctNumber       closeNumber
+hi def link closeBinNumber       closeNumber
+hi def link closeIdentifierPrime closeIdentifier
+hi def link closeTrait           closeType
+hi def link closeDeriveTrait     closeTrait
+
+hi def link closeMacroRepeatDelimiters   Macro
+hi def link closeMacroVariable Define
+hi def link closeSigil         StorageClass
+hi def link closeEscape        Special
+hi def link closeEscapeUnicode closeEscape
+hi def link closeEscapeError   Error
+hi def link closeStringContinuation Special
+hi def link closeString        String
+hi def link closeStringDelimiter String
+hi def link closeCharacterInvalid Error
+hi def link closeCharacterInvalidUnicode closeCharacterInvalid
+hi def link closeCharacter     Character
+hi def link closeNumber        Number
+hi def link closeBoolean       Boolean
+hi def link closeEnum          closeType
+hi def link closeEnumVariant   closeConstant
+hi def link closeConstant      Constant
+hi def link closeSelf          Constant
+hi def link closeFloat         Float
+hi def link closeArrowCharacter closeOperator
+hi def link closeOperator      Operator
+hi def link closeKeyword       Keyword
+hi def link closeDynKeyword    closeKeyword
+hi def link closeTypedef       Keyword " More precise is Typedef, but it doesn't feel right for Rust
+hi def link closeStructure     Keyword " More precise is Structure
+hi def link closeUnion         closeStructure
+hi def link closeExistential   closeKeyword
+hi def link closePubScopeDelim Delimiter
+hi def link closePubScopeCrate closeKeyword
+hi def link closeSuper         closeKeyword
+hi def link closeUnsafeKeyword Exception
+hi def link closeReservedKeyword Error
+hi def link closeRepeat        Conditional
+hi def link closeConditional   Conditional
+hi def link closeIdentifier    Identifier
+hi def link closeCapsIdent     closeIdentifier
+hi def link closeModPath       Include
+hi def link closeModPathSep    Delimiter
+hi def link closeFunction      Function
+hi def link closeFuncName      Function
+hi def link closeFuncCall      Function
+hi def link closeShebang       Comment
+hi def link closeCommentLine   Comment
+hi def link closeCommentLineDoc SpecialComment
+hi def link closeCommentLineDocLeader closeCommentLineDoc
+hi def link closeCommentLineDocError Error
+hi def link closeCommentBlock  closeCommentLine
+hi def link closeCommentBlockDoc closeCommentLineDoc
+hi def link closeCommentBlockDocStar closeCommentBlockDoc
+hi def link closeCommentBlockDocError Error
+hi def link closeCommentDocCodeFence closeCommentLineDoc
+hi def link closeAssert        PreCondit
+hi def link closePanic         PreCondit
+hi def link closeMacro         Macro
+hi def link closeType          Type
+hi def link closeTodo          Todo
+hi def link closeAttribute     PreProc
+hi def link closeDerive        PreProc
+hi def link closeDefault       StorageClass
+hi def link closeStorage       StorageClass
+hi def link closeObsoleteStorage Error
+hi def link closeLifetime      Special
+hi def link closeLabel         Label
+hi def link closeExternCrate   closeKeyword
+hi def link closeObsoleteExternMod Error
+hi def link closeQuestionMark  Special
+hi def link closeAsync         closeKeyword
+hi def link closeAwait         closeKeyword
+hi def link closeAsmDirSpec    closeKeyword
+hi def link closeAsmSym        closeKeyword
+hi def link closeAsmOptions    closeKeyword
+hi def link closeAsmOptionsKey closeAttribute
+
+" Other Suggestions:
+" hi closeAttribute ctermfg=cyan
+" hi closeDerive ctermfg=cyan
+" hi closeAssert ctermfg=yellow
+" hi closePanic ctermfg=red
+" hi closeMacro ctermfg=magenta
+
+syn sync minlines=200
+syn sync maxlines=500
+
+let b:current_syntax = "close"
+
+" vim: set et sw=4 sts=4 ts=8: