├── .all-contributorsrc
├── .editorconfig
├── .eslintignore
├── .eslintrc
├── .github
    ├── FUNDING.yml
    └── renovate.json
├── .gitignore
├── .vscode
    ├── launch.json
    ├── settings.json
    └── tasks.json
├── .vscodeignore
├── CHANGELOG.md
├── LICENSE
├── Makefile
├── README.md
├── assets
    ├── README.png
    ├── github_sponsor_btn.png
    └── logo.png
├── cgmanifest.json
├── package.json
├── src
    └── extension.ts
├── syntaxes
    ├── codeblock.json
    ├── help.language-configuration.json
    ├── help.tmLanguage.json
    ├── snippet.language-configuration.json
    ├── snippet.tmLanguage.json
    ├── viml.language-configuration.json
    ├── viml.tmLanguage.json
    ├── vroom.language-configuration.json
    └── vroom.tmLanguage.json
├── tsconfig.json
└── vroom-examples
    ├── basics.vroom
    ├── blocks.vroom
    ├── buffer.vroom
    ├── continuations.vroom
    ├── controls.vroom
    ├── directives.vroom
    ├── escaping.vroom
    ├── macros.vroom
    ├── messages.vroom
    ├── mode.vroom
    ├── range.vroom
    └── system.vroom


/.all-contributorsrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "files": [
 3 |     "README.md"
 4 |   ],
 5 |   "imageSize": 100,
 6 |   "commit": false,
 7 |   "contributors": [
 8 |     {
 9 |       "login": "XadillaX",
10 |       "name": "Khaidi Chu",
11 |       "avatar_url": "https://avatars.githubusercontent.com/u/2842176?v=4",
12 |       "profile": "https://xcoder.in/",
13 |       "contributions": [
14 |         "maintenance",
15 |         "code"
16 |       ]
17 |     },
18 |     {
19 |       "login": "GitMensch",
20 |       "name": "Simon Sobisch",
21 |       "avatar_url": "https://avatars.githubusercontent.com/u/6699539?v=4",
22 |       "profile": "https://github.com/GitMensch",
23 |       "contributions": [
24 |         "ideas"
25 |       ]
26 |     },
27 |     {
28 |       "login": "dawsers",
29 |       "name": "dawsers",
30 |       "avatar_url": "https://avatars.githubusercontent.com/u/47487972?v=4",
31 |       "profile": "https://github.com/dawsers",
32 |       "contributions": [
33 |         "code"
34 |       ]
35 |     },
36 |     {
37 |       "login": "beastmatser",
38 |       "name": "mrts",
39 |       "avatar_url": "https://avatars.githubusercontent.com/u/79206232?v=4",
40 |       "profile": "https://github.com/beastmatser",
41 |       "contributions": [
42 |         "code"
43 |       ]
44 |     },
45 |     {
46 |       "login": "wenfangdu",
47 |       "name": "Wenfang Du",
48 |       "avatar_url": "https://avatars.githubusercontent.com/u/28700378?v=4",
49 |       "profile": "https://stackoverflow.com/u/7881859",
50 |       "contributions": [
51 |         "code"
52 |       ]
53 |     }
54 |   ],
55 |   "contributorsPerLine": 7,
56 |   "projectName": "vscode-language-viml",
57 |   "projectOwner": "XadillaX",
58 |   "repoType": "github",
59 |   "repoHost": "https://github.com",
60 |   "skipCi": true,
61 |   "badgeTemplate": "<a href=\"#contributors-\"><img src=\"https://img.shields.io/badge/<%= contributors.length %>-ALL%20CONTRIBUTORS?style=for-the-badge&colorA=FF69b4&colorB=cc47a4&label=ALL%20CONTRIBUTORS\" /></a>",
62 |   "commitConvention": "angular"
63 | }
64 | 


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | [*]
 4 | end_of_line = lf
 5 | insert_final_newline = true
 6 | 
 7 | charset = utf-8
 8 | indent_style = space
 9 | indent_size = 2
10 | 
11 | [Makefile]
12 | indent_style = tab
13 | indent_size = 8
14 | 


--------------------------------------------------------------------------------
/.eslintignore:
--------------------------------------------------------------------------------
1 | out/**/*
2 | 


--------------------------------------------------------------------------------
/.eslintrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "extends": [
 3 |     "eslint-config-egg/typescript"
 4 |   ],
 5 |   "parserOptions": {
 6 |     "project": "./tsconfig.json"
 7 |   },
 8 |   "rules": {
 9 |     "@typescript-eslint/ban-types": "off"
10 |   }
11 | }
12 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
 1 | # These are supported funding model platforms
 2 | 
 3 | github: XadillaX # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
 4 | patreon: # Replace with a single Patreon username
 5 | open_collective: # Replace with a single Open Collective username
 6 | ko_fi: # Replace with a single Ko-fi username
 7 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 8 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 9 | liberapay: # Replace with a single Liberapay username
10 | issuehunt: # Replace with a single IssueHunt username
11 | otechie: # Replace with a single Otechie username
12 | lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
13 | custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
14 | 


--------------------------------------------------------------------------------
/.github/renovate.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "extends": [
 3 |     "config:base"
 4 |   ],
 5 |   "ignoreDeps": [
 6 |     "@types/vscode",
 7 |     "eslint",
 8 |     "eslint-config-egg",
 9 |     "vscode"
10 |   ],
11 |   "lockFileMaintenance": {
12 |     "enabled": false
13 |   },
14 |   "updatePinnedDependencies": false,
15 |   "rangeStrategy": "bump"
16 | }
17 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Logs
 2 | logs
 3 | *.log
 4 | npm-debug.log*
 5 | yarn-debug.log*
 6 | yarn-error.log*
 7 | 
 8 | # Runtime data
 9 | pids
10 | *.pid
11 | *.seed
12 | *.pid.lock
13 | 
14 | # Directory for instrumented libs generated by jscoverage/JSCover
15 | lib-cov
16 | 
17 | # Coverage directory used by tools like istanbul
18 | coverage
19 | 
20 | # nyc test coverage
21 | .nyc_output
22 | 
23 | # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
24 | .grunt
25 | 
26 | # Bower dependency directory (https://bower.io/)
27 | bower_components
28 | 
29 | # node-waf configuration
30 | .lock-wscript
31 | 
32 | # Compiled binary addons (https://nodejs.org/api/addons.html)
33 | build/Release
34 | 
35 | # Dependency directories
36 | node_modules/
37 | jspm_packages/
38 | 
39 | # TypeScript v1 declaration files
40 | typings/
41 | 
42 | # Optional npm cache directory
43 | .npm
44 | 
45 | # Optional eslint cache
46 | .eslintcache
47 | 
48 | # Optional REPL history
49 | .node_repl_history
50 | 
51 | # Output of 'npm pack'
52 | *.tgz
53 | 
54 | # Yarn Integrity file
55 | .yarn-integrity
56 | 
57 | # dotenv environment variables file
58 | .env
59 | 
60 | # next.js build output
61 | .next
62 | 
63 | *.vsix
64 | out
65 | package-lock.json
66 | 


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "version": "0.0.1",
 3 |   "configurations": [{
 4 |     "name": "Extension",
 5 |     "type": "extensionHost",
 6 |     "request": "launch",
 7 |     "runtimeExecutable": "${execPath}",
 8 |     "args": [
 9 |       "--extensionDevelopmentPath=${workspaceFolder}"
10 |     ]
11 |   }]
12 | }


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "eslint.validate": [
 3 |     "javascript",
 4 |     "javascriptreact",
 5 |     {
 6 |       "language": "typescript",
 7 |       "autoFix": true
 8 |     },
 9 |   ]
10 | }
11 | 


--------------------------------------------------------------------------------
/.vscode/tasks.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "tasks": [
 3 |     {
 4 |       "type": "typescript",
 5 |       "tsconfig": "tsconfig.json",
 6 |       "option": "watch",
 7 |       "presentation": {
 8 |         "echo": true,
 9 |         "reveal": "silent",
10 |         "focus": false,
11 |         "panel": "shared"
12 |       },
13 |       "isBackground": true,
14 |       "runOptions": {
15 |         "runOn": "folderOpen"
16 |       },
17 |       "problemMatcher": [
18 |         "$tsc-watch"
19 |       ],
20 |       "group": {
21 |         "kind": "build",
22 |         "isDefault": true
23 |       }
24 |     }
25 |   ]
26 | }
27 | 


--------------------------------------------------------------------------------
/.vscodeignore:
--------------------------------------------------------------------------------
1 | .vscode/**
2 | .gitignore
3 | 
4 | *.vsix
5 | src
6 | vroom-examples


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | ### Changelog
  2 | 
  3 | All notable changes to this project will be documented in this file. Dates are displayed in UTC.
  4 | 
  5 | Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
  6 | 
  7 | #### [v2.2.0](https://github.com/XadillaX/vscode-language-viml/compare/v2.1.2...v2.2.0)
  8 | 
  9 | - feat: support vroom's highlight (#45) [`#53`](https://github.com/XadillaX/vscode-language-viml/pull/53)
 10 | - chore(deps): update dependency all-contributors-cli to ^6.25.0 [`#50`](https://github.com/XadillaX/vscode-language-viml/pull/50)
 11 | - chore(deps): update dependency @types/node to ^18.16.3 [`#49`](https://github.com/XadillaX/vscode-language-viml/pull/49)
 12 | - style: `"` for comment [`#38`](https://github.com/XadillaX/vscode-language-viml/pull/38)
 13 | - chore(deps): update dependency @types/node to ^18.16.0 [`#46`](https://github.com/XadillaX/vscode-language-viml/pull/46)
 14 | - chore(deps): update dependency typescript to ^5.0.4 [`#47`](https://github.com/XadillaX/vscode-language-viml/pull/47)
 15 | - fix(deps): update dependency vscode-languageclient to ^8.1.0 [`#39`](https://github.com/XadillaX/vscode-language-viml/pull/39)
 16 | - chore(deps): update dependency @types/node to v18 [`#42`](https://github.com/XadillaX/vscode-language-viml/pull/42)
 17 | - chore(deps): update dependency typescript to v5 [`#44`](https://github.com/XadillaX/vscode-language-viml/pull/44)
 18 | - chore(deps): update dependency typescript to ^4.9.5 [`#40`](https://github.com/XadillaX/vscode-language-viml/pull/40)
 19 | - fix(deps): update dependency vim-language-server to ^2.3.0 [`#43`](https://github.com/XadillaX/vscode-language-viml/pull/43)
 20 | - chore(deps): update dependency all-contributors-cli to ^6.24.0 [`#41`](https://github.com/XadillaX/vscode-language-viml/pull/41)
 21 | - chore(deps): update dependency typescript to ^4.7.4 [`#35`](https://github.com/XadillaX/vscode-language-viml/pull/35)
 22 | - fix(deps): update dependency vscode-languageclient to v8 [`#33`](https://github.com/XadillaX/vscode-language-viml/pull/33)
 23 | - chore(deps): update dependency typescript to ^4.7.2 [`#34`](https://github.com/XadillaX/vscode-language-viml/pull/34)
 24 | - chore(deps): update dependency typescript to ^4.6.4 [`#32`](https://github.com/XadillaX/vscode-language-viml/pull/32)
 25 | - docs: add beastmatser as a contributor for code [`#31`](https://github.com/XadillaX/vscode-language-viml/pull/31)
 26 | 
 27 | #### [v2.1.2](https://github.com/XadillaX/vscode-language-viml/compare/v2.1.1...v2.1.2)
 28 | 
 29 | > 27 April 2022
 30 | 
 31 | - refactor: Modify activationEvents [`#29`](https://github.com/XadillaX/vscode-language-viml/pull/29)
 32 | - fix(deps): update dependency vim-language-server to ^2.2.10 [`#27`](https://github.com/XadillaX/vscode-language-viml/pull/27)
 33 | - fix(deps): update dependency vim-language-server to ^2.2.9 [`#26`](https://github.com/XadillaX/vscode-language-viml/pull/26)
 34 | - fix(deps): update dependency vim-language-server to ^2.2.8 [`#25`](https://github.com/XadillaX/vscode-language-viml/pull/25)
 35 | - fix(deps): update dependency vim-language-server to ^2.2.7 [`#23`](https://github.com/XadillaX/vscode-language-viml/pull/23)
 36 | - chore: update CHANGELOG.md [`45b1cbe`](https://github.com/XadillaX/vscode-language-viml/commit/45b1cbe4cd91384c016126129777b7456c4a86a2)
 37 | - chore: bump version to v2.1.2 [`61cc432`](https://github.com/XadillaX/vscode-language-viml/commit/61cc432108334d7f71b52df0f539e140295ab5f1)
 38 | 
 39 | #### [v2.1.1](https://github.com/XadillaX/vscode-language-viml/compare/v2.1.0...v2.1.1)
 40 | 
 41 | > 31 March 2022
 42 | 
 43 | - chore(deps): update dependency typescript to ^4.6.3 [`#21`](https://github.com/XadillaX/vscode-language-viml/pull/21)
 44 | - chore: Configure Renovate [`#16`](https://github.com/XadillaX/vscode-language-viml/pull/16)
 45 | - chore: bump to 2.1.1 [`68572b3`](https://github.com/XadillaX/vscode-language-viml/commit/68572b3645675e6fd722dd642e989b32833130c3)
 46 | - chore: update renovate.json [`1457612`](https://github.com/XadillaX/vscode-language-viml/commit/14576128a27628f4bd2c2bf1d879b94bfdd10346)
 47 | - Create FUNDING.yml [`2f25d62`](https://github.com/XadillaX/vscode-language-viml/commit/2f25d620b68566dcef87f0d58bb653a0fdf7f888)
 48 | 
 49 | #### [v2.1.0](https://github.com/XadillaX/vscode-language-viml/compare/v2.0.0...v2.1.0)
 50 | 
 51 | > 11 March 2022
 52 | 
 53 | - docs: add dawsers as a contributor for code [`#15`](https://github.com/XadillaX/vscode-language-viml/pull/15)
 54 | - docs: add GitMensch as a contributor for ideas [`#14`](https://github.com/XadillaX/vscode-language-viml/pull/14)
 55 | - docs: add XadillaX as a contributor for maintenance, code [`#13`](https://github.com/XadillaX/vscode-language-viml/pull/13)
 56 | - docs: Update README.md [`#11`](https://github.com/XadillaX/vscode-language-viml/pull/11)
 57 | - feat: support embed vim help files and vim snippet files in Markdown [`02216fd`](https://github.com/XadillaX/vscode-language-viml/commit/02216fd19002da4bf68bee5b14e850485079194b)
 58 | - docs: update README.md [`c03dc51`](https://github.com/XadillaX/vscode-language-viml/commit/c03dc51e480dc7d1de9f8f3700de5009184b019f)
 59 | - feat: add support for vim/viml Markdown fenced code blocks (#12) [`7e70ed2`](https://github.com/XadillaX/vscode-language-viml/commit/7e70ed252e17ac56baacb1695ad996a150ef63c3)
 60 | 
 61 | ### [v2.0.0](https://github.com/XadillaX/vscode-language-viml/compare/v1.1.1...v2.0.0)
 62 | 
 63 | > 10 March 2022
 64 | 
 65 | - feat: add LSP support and Vim Help files, Vim Snippet files [`e70b9b9`](https://github.com/XadillaX/vscode-language-viml/commit/e70b9b931ac426ac8540d4d03ff7ba4d9e35861e)
 66 | - chore: bump version to 2.0.0 [`6486a26`](https://github.com/XadillaX/vscode-language-viml/commit/6486a267a10908ea2dd09994520b8e8f5f141ede)
 67 | 
 68 | #### [v1.1.1](https://github.com/XadillaX/vscode-language-viml/compare/v1.1.0...v1.1.1)
 69 | 
 70 | > 10 March 2022
 71 | 
 72 | - fix: missing changelog process [`70744d1`](https://github.com/XadillaX/vscode-language-viml/commit/70744d108f36ebd66b05c330782325db7b72e770)
 73 | - chore: bump version to v1.1.1 [`6b1b328`](https://github.com/XadillaX/vscode-language-viml/commit/6b1b3286adc6904e9ac89336731a59d14b627f61)
 74 | 
 75 | #### [v1.1.0](https://github.com/XadillaX/vscode-language-viml/compare/v1.0.1...v1.1.0)
 76 | 
 77 | > 10 March 2022
 78 | 
 79 | - chore: Updated viml.tmLanguage.json to Alhadis/language-viml@5030985 (2021-06-26) [`38b4b11`](https://github.com/XadillaX/vscode-language-viml/commit/38b4b115ab72d487e3e2521cde152344a3f66773)
 80 | - chore: bump to v1.1.0 [`d643af6`](https://github.com/XadillaX/vscode-language-viml/commit/d643af69515d211f4f303550ed40321e88172c4f)
 81 | - feat: support _vimrc (#10) [`06620ea`](https://github.com/XadillaX/vscode-language-viml/commit/06620ea0d9eb20619534fe750e5fba793f10d99d)
 82 | 
 83 | #### [v1.0.1](https://github.com/XadillaX/vscode-language-viml/compare/v1.0.0...v1.0.1)
 84 | 
 85 | > 10 March 2022
 86 | 
 87 | - fix repository URL [`#5`](https://github.com/XadillaX/vscode-language-viml/pull/5)
 88 | - feat: update from upstream [`3d32a41`](https://github.com/XadillaX/vscode-language-viml/commit/3d32a4150926720d400e3e7553245ea2e2c7a4ef)
 89 | - feat: add .ideavimrc [`1b1323f`](https://github.com/XadillaX/vscode-language-viml/commit/1b1323f40525a92663e8ac26af2127ff7063858e)
 90 | 
 91 | ### [v1.0.0](https://github.com/XadillaX/vscode-language-viml/compare/v0.0.2...v1.0.0)
 92 | 
 93 | > 10 March 2022
 94 | 
 95 | - feat: update grammar via vscode-grammar-update-tool [`#3`](https://github.com/XadillaX/vscode-language-viml/pull/3)
 96 | - feat: Added .exrc extension [`#2`](https://github.com/XadillaX/vscode-language-viml/pull/2)
 97 | - feat: Highlight vimrc [`#1`](https://github.com/XadillaX/vscode-language-viml/pull/1)
 98 | - chore: bump version to 1.0.0 [`aeb7bea`](https://github.com/XadillaX/vscode-language-viml/commit/aeb7bea40f13e3a26ac6a28c66b773cdd669df76)
 99 | 
100 | #### [v0.0.2](https://github.com/XadillaX/vscode-language-viml/compare/v0.0.1...v0.0.2)
101 | 
102 | > 10 March 2022
103 | 
104 | - fix: add missing language configuration [`2228b3c`](https://github.com/XadillaX/vscode-language-viml/commit/2228b3c55a383b05affb145725c66d3d0a6ac3bc)
105 | 
106 | #### v0.0.1
107 | 
108 | > 10 March 2022
109 | 
110 | - refactor: first commit [`4ce2568`](https://github.com/XadillaX/vscode-language-viml/commit/4ce25689be082ad8a087ee05e8f8e6265f1e4a77)
111 | - Initial commit [`6ff39d2`](https://github.com/XadillaX/vscode-language-viml/commit/6ff39d20d8b3a22ea0768b419538670d2b362a8a)
112 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2022 Khaidi Chu
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | UPDATE_GRAMMAR_BIN = ./node_modules/.bin/update-grammar
 2 | 
 3 | .PHONY: update_grammar pack
 4 | 
 5 | update-grammar:
 6 | 	$(UPDATE_GRAMMAR_BIN) Alhadis/language-viml grammars/viml.cson syntaxes/viml.tmLanguage.json
 7 | 	$(UPDATE_GRAMMAR_BIN) Alhadis/language-viml grammars/help.cson syntaxes/help.tmLanguage.json
 8 | 	$(UPDATE_GRAMMAR_BIN) Alhadis/language-viml grammars/snippet.cson syntaxes/snippet.tmLanguage.json
 9 | 
10 | pack:
11 | 	npm install
12 | 	npm run compile
13 | 	rm -rf node_modules
14 | 	npm install --prod
15 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | <p align="center">
 2 |   <img height="200" src="https://github.com/XadillaX/vscode-language-viml/raw/master/assets/README.png" />
 3 | </p>
 4 | 
 5 | <p align="center">
 6 |   <a href="https://github.com/sponsors/XadillaX"><img src="https://github.com/XadillaX/vscode-language-viml/raw/master/assets/github_sponsor_btn.png" /></a>
 7 | </p>
 8 | 
 9 | <p align="center">
10 |   <a href="https://marketplace.visualstudio.com/items?itemName=XadillaX.viml">
11 |     <img src="https://vsmarketplacebadges.dev/version-short/XadillaX.viml.svg.?style=for-the-badge&colorA=FF7800&colorB=CC5600&label=VS%20MARKETPLACE" />
12 |   </a>
13 |   <a href="https://marketplace.visualstudio.com/items?itemName=XadillaX.viml">
14 |     <img src="https://vsmarketplacebadges.dev/downloads-short/XadillaX.viml.svg.?style=for-the-badge&colorA=5DDB61&colorB=4BC74F&label=DOWNLOADS" />
15 |   </a>
16 |   <a href="https://marketplace.visualstudio.com/items?itemName=XadillaX.viml">
17 |     <img src="https://vsmarketplacebadges.dev/rating-star/XadillaX.viml.svg.?style=for-the-badge&colorA=FBBD30&colorB=F2AA08" />
18 |   </a>
19 | <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
20 | <a href="#contributors-"><img src="https://img.shields.io/badge/5-ALL%20CONTRIBUTORS?style=for-the-badge&colorA=FF69b4&colorB=cc47a4&label=ALL%20CONTRIBUTORS" /></a>
21 | <!-- ALL-CONTRIBUTORS-BADGE:END -->
22 | </p>
23 | 
24 | ## What does this extension do?
25 | 
26 | [**VimL**](https://en.wikipedia.org/wiki/Vim_(text_editor)#Vim_script) (Also known as **Vim Language**, **VimScript**) support for [VSCode](https://code.visualstudio.com/).
27 | 
28 | Syntax Highlighting is synchronized from [Atom VimL](https://github.com/Alhadis/language-viml) with ❤ by [vscode-grammar-update-tool](https://github.com/XadillaX/vscode-update-grammar-tool).
29 | 
30 | Language Server Protocol depends on [vim-language-server](https://github.com/iamcco/vim-language-server).
31 | 
32 | > Thanks to [Alhadis/language-viml](https://github.com/Alhadis/language-viml), [iamcco/vim-language-server](https://github.com/iamcco/vim-language-server) and [XadillaX/vscode-update-grammar-tool](https://github.com/XadillaX/vscode-update-grammar-tool).
33 | 
34 | ## Features
35 | 
36 | + Language Server Protocol (Refer to [vim-language-server](https://github.com/iamcco/vim-language-server)):
37 |   - Auto completion;
38 |   - Function signature help;
39 |   - Hover document;
40 |   - Go to definition;
41 |   - Go to references;
42 |   - Document symbols;
43 |   - Folding range;
44 |   - Select range;
45 |   - Rename;
46 |   - Snippets;
47 |   - Diagnostic;
48 | + Syntax highlighting for
49 |   - **VimL files** (`*.vim`, `*.vimrc`, `_vimrc`, `*.gvimrc`, `*.ideavim`, `.ideavim`, `.ideavimrc`, `*.exrc`, etc);
50 |   - **Vim Help files** (`*.txt` with matching a certain RegExp in file);
51 |   - **Vim Snippet files** (`*.snip`, `*.snippet`, `*.snippets`, etc);
52 |   - [**Vroom files**](https://github.com/google/vroom) (`*.vroom`);
53 | + Syntax highlighting for embedding **Vim related syntaxes** (see above) in **Markdown files**.
54 | 
55 | ## Contributors ✨
56 | 
57 | Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
58 | 
59 | <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
60 | <!-- prettier-ignore-start -->
61 | <!-- markdownlint-disable -->
62 | <table>
63 |   <tbody>
64 |     <tr>
65 |       <td align="center" valign="top" width="14.28%"><a href="https://xcoder.in/"><img src="https://avatars.githubusercontent.com/u/2842176?v=4?s=100" width="100px;" alt="Khaidi Chu"/><br /><sub><b>Khaidi Chu</b></sub></a><br /><a href="#maintenance-XadillaX" title="Maintenance">🚧</a> <a href="https://github.com/XadillaX/vscode-language-viml/commits?author=XadillaX" title="Code">💻</a></td>
66 |       <td align="center" valign="top" width="14.28%"><a href="https://github.com/GitMensch"><img src="https://avatars.githubusercontent.com/u/6699539?v=4?s=100" width="100px;" alt="Simon Sobisch"/><br /><sub><b>Simon Sobisch</b></sub></a><br /><a href="#ideas-GitMensch" title="Ideas, Planning, & Feedback">🤔</a></td>
67 |       <td align="center" valign="top" width="14.28%"><a href="https://github.com/dawsers"><img src="https://avatars.githubusercontent.com/u/47487972?v=4?s=100" width="100px;" alt="dawsers"/><br /><sub><b>dawsers</b></sub></a><br /><a href="https://github.com/XadillaX/vscode-language-viml/commits?author=dawsers" title="Code">💻</a></td>
68 |       <td align="center" valign="top" width="14.28%"><a href="https://github.com/beastmatser"><img src="https://avatars.githubusercontent.com/u/79206232?v=4?s=100" width="100px;" alt="mrts"/><br /><sub><b>mrts</b></sub></a><br /><a href="https://github.com/XadillaX/vscode-language-viml/commits?author=beastmatser" title="Code">💻</a></td>
69 |       <td align="center" valign="top" width="14.28%"><a href="https://stackoverflow.com/u/7881859"><img src="https://avatars.githubusercontent.com/u/28700378?v=4?s=100" width="100px;" alt="Wenfang Du"/><br /><sub><b>Wenfang Du</b></sub></a><br /><a href="https://github.com/XadillaX/vscode-language-viml/commits?author=wenfangdu" title="Code">💻</a></td>
70 |     </tr>
71 |   </tbody>
72 | </table>
73 | 
74 | <!-- markdownlint-restore -->
75 | <!-- prettier-ignore-end -->
76 | 
77 | <!-- ALL-CONTRIBUTORS-LIST:END -->
78 | 
79 | This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!
80 | 


--------------------------------------------------------------------------------
/assets/README.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/XadillaX/vscode-language-viml/f31f4ede6e1586c4b4ee946228a704f9f1f320d7/assets/README.png


--------------------------------------------------------------------------------
/assets/github_sponsor_btn.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/XadillaX/vscode-language-viml/f31f4ede6e1586c4b4ee946228a704f9f1f320d7/assets/github_sponsor_btn.png


--------------------------------------------------------------------------------
/assets/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/XadillaX/vscode-language-viml/f31f4ede6e1586c4b4ee946228a704f9f1f320d7/assets/logo.png


--------------------------------------------------------------------------------
/cgmanifest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "registrations": [
 3 |     {
 4 |       "component": {
 5 |         "type": "git",
 6 |         "git": {
 7 |           "name": "Alhadis/language-viml",
 8 |           "repositoryUrl": "https://github.com/Alhadis/language-viml",
 9 |           "commitHash": "a8e1770846b4d994ab2be04371f7d97a16b1a08f"
10 |         },
11 |         "license": "MIT",
12 |         "description": "Vim Script language support for Atom"
13 |       },
14 |       "version": "1.2.2"
15 |     }
16 |   ]
17 | }


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "name": "viml",
  3 |   "displayName": "VimL (Vim Language, Vim Script)",
  4 |   "version": "2.2.0",
  5 |   "description": "Vim Script language server protocol and highlighting support for VSCode.",
  6 |   "scripts": {
  7 |     "update-grammar": "make update-grammar",
  8 |     "update-changelog": "npx auto-changelog -p",
  9 |     "postinstall": "rm -f package-lock.json",
 10 |     "compile": "tsc -p ./",
 11 |     "vscode:prepublish": "make pack"
 12 |   },
 13 |   "engines": {
 14 |     "vscode": "^1.20.0"
 15 |   },
 16 |   "categories": [
 17 |     "Programming Languages"
 18 |   ],
 19 |   "publisher": "XadillaX",
 20 |   "repository": {
 21 |     "type": "git",
 22 |     "url": "https://github.com/XadillaX/vscode-language-viml.git"
 23 |   },
 24 |   "author": "XadillaX <i@2333.moe>",
 25 |   "license": "MIT",
 26 |   "bugs": {
 27 |     "url": "https://github.com/XadillaX/vscode-language-viml/issues"
 28 |   },
 29 |   "homepage": "https://github.com/XadillaX/vscode-language-viml#readme",
 30 |   "galleryBanner": {
 31 |     "color": "#569cd6",
 32 |     "theme": "dark"
 33 |   },
 34 |   "icon": "assets/logo.png",
 35 |   "devDependencies": {
 36 |     "@types/node": "^20.16.5",
 37 |     "@types/vscode": "^1.20.0",
 38 |     "all-contributors-cli": "^6.26.1",
 39 |     "auto-changelog": "^2.4.0",
 40 |     "eslint": "^8.0.0",
 41 |     "eslint-config-egg": "^11.0.0",
 42 |     "typescript": "^5.5.4",
 43 |     "vscode-update-grammar-tool": "^1.0.0"
 44 |   },
 45 |   "contributes": {
 46 |     "configuration": {
 47 |       "title": "VimL",
 48 |       "properties": {
 49 |         "viml.highVimHelpIndentStylePriority": {
 50 |           "type": "boolean",
 51 |           "default": true,
 52 |           "description": "Force use 8-spaces-size and tab as Vim Help file's indentation style (Even higher priority than EditorConfig, etc.)"
 53 |         }
 54 |       }
 55 |     },
 56 |     "grammars": [
 57 |       {
 58 |         "language": "viml",
 59 |         "scopeName": "source.viml",
 60 |         "path": "./syntaxes/viml.tmLanguage.json"
 61 |       },
 62 |       {
 63 |         "language": "vim-help",
 64 |         "scopeName": "text.vim-help",
 65 |         "path": "./syntaxes/help.tmLanguage.json"
 66 |       },
 67 |       {
 68 |         "language": "vim-snippet",
 69 |         "scopeName": "source.vim-snippet",
 70 |         "path": "./syntaxes/snippet.tmLanguage.json"
 71 |       },
 72 |       {
 73 |         "language": "vroom",
 74 |         "scopeName": "source.vroom",
 75 |         "path": "./syntaxes/vroom.tmLanguage.json"
 76 |       },
 77 |       {
 78 |         "scopeName": "markdown.vim.codeblock",
 79 |         "path": "./syntaxes/codeblock.json",
 80 |         "injectTo": [
 81 |           "text.html.markdown"
 82 |         ],
 83 |         "embeddedLanguages": {
 84 |           "meta.embedded.block.viml": "viml",
 85 |           "meta.embedded.block.vim-help": "vim-help",
 86 |           "meta.embedded.block.vim-snippet": "vim-snippet"
 87 |         }
 88 |       }
 89 |     ],
 90 |     "languages": [
 91 |       {
 92 |         "id": "viml",
 93 |         "aliases": [
 94 |           "VimL",
 95 |           "VimScript",
 96 |           "Vim Language"
 97 |         ],
 98 |         "extensions": [
 99 |           ".vim",
100 |           ".vimrc",
101 |           ".gvim",
102 |           ".ideavim",
103 |           ".exrc"
104 |         ],
105 |         "filenames": [
106 |           "_vimrc",
107 |           "vimrc",
108 |           ".ideavim",
109 |           ".ideavimrc"
110 |         ],
111 |         "configuration": "./syntaxes/viml.language-configuration.json"
112 |       },
113 |       {
114 |         "id": "vim-help",
115 |         "aliases": [
116 |           "Vim Help"
117 |         ],
118 |         "configuration": "./syntaxes/help.language-configuration.json"
119 |       },
120 |       {
121 |         "id": "vim-snippet",
122 |         "aliases": [
123 |           "Vim Snippet"
124 |         ],
125 |         "extensions": [
126 |           ".snip",
127 |           ".snippet",
128 |           ".snippets"
129 |         ],
130 |         "configuration": "./syntaxes/snippet.language-configuration.json"
131 |       },
132 |       {
133 |         "id": "vroom",
134 |         "aliases": [
135 |           "Vroom"
136 |         ],
137 |         "extensions": [
138 |           ".vroom"
139 |         ],
140 |         "configuration": "./syntaxes/vroom.language-configuration.json"
141 |       }
142 |     ]
143 |   },
144 |   "activationEvents": [
145 |     "onLanguage:viml",
146 |     "onLanguage:vim-help",
147 |     "onLanguage:vim-snippet",
148 |     "onLanguage:vroom",
149 |     "workspaceContains:**/.*txt"
150 |   ],
151 |   "main": "./out/extension.js",
152 |   "dependencies": {
153 |     "vim-language-server": "^2.3.1",
154 |     "vscode-languageclient": "^9.0.1"
155 |   }
156 | }
157 | 


--------------------------------------------------------------------------------
/src/extension.ts:
--------------------------------------------------------------------------------
  1 | import {
  2 |   languages,
  3 |   OutputChannel,
  4 |   TextEditor,
  5 |   TextEditorOptionsChangeEvent,
  6 |   window,
  7 |   WindowState,
  8 |   workspace,
  9 | } from 'vscode';
 10 | import {
 11 |   LanguageClient,
 12 |   LanguageClientOptions,
 13 |   ServerOptions,
 14 |   TransportKind,
 15 | } from 'vscode-languageclient/node';
 16 | 
 17 | const VIM_MODELINE = /(?:(?:^|[ \t])(?:vi|Vi(?=m))(?:m[<=>]?[0-9]+|m)?|[ \t]ex)(?=:(?=[ \t]*set?[ \t][^\r\n:]+:)|:(?![ \t]*set?[ \t]))(?:(?:[ \t]*:[ \t]*|[ \t])\w*(?:[ \t]*=(?:[^\\\s]|\\.)*)?)*[ \t:](?:filetype|ft|syntax)[ \t]*=(\w+)(?=$|\s|:)/mi;
 18 | 
 19 | let client: LanguageClient | undefined;
 20 | let outputChannel: OutputChannel;
 21 | 
 22 | function startVimLLanguageServer() {
 23 |   outputChannel.append('Start VimL Language Server.\n');
 24 |   const serverModule = require.resolve('vim-language-server');
 25 |   const debugOptions = { execArgv: [ '--nolazy', '--inspect=6009' ] };
 26 |   const serverOptions: ServerOptions = {
 27 |     run: { module: serverModule, transport: TransportKind.ipc },
 28 |     debug: {
 29 |       module: serverModule,
 30 |       transport: TransportKind.ipc,
 31 |       options: debugOptions,
 32 |     },
 33 |   };
 34 | 
 35 |   const clientOptions: LanguageClientOptions = {
 36 |     documentSelector: [{ scheme: 'file', language: 'viml' }],
 37 |   };
 38 | 
 39 |   client = new LanguageClient(
 40 |     'VimLLanguageServer',
 41 |     'VimL Language Server',
 42 |     serverOptions,
 43 |     clientOptions);
 44 | 
 45 |   client.start();
 46 | }
 47 | 
 48 | function startVimLLanguageServerWhenVimLFile() {
 49 |   if (window.activeTextEditor &&
 50 |       window.activeTextEditor.document &&
 51 |       window.activeTextEditor.document.languageId === 'viml') {
 52 |     startVimLLanguageServer();
 53 |     return;
 54 |   }
 55 | 
 56 |   window.onDidChangeActiveTextEditor((editor: TextEditor | undefined) => {
 57 |     if (client) return;
 58 |     if (!editor || !editor.document || editor.document.languageId !== 'viml') {
 59 |       return;
 60 |     }
 61 |     startVimLLanguageServer();
 62 |   });
 63 | 
 64 |   window.onDidChangeWindowState((e: WindowState) => {
 65 |     if (client) return;
 66 |     if (!e.focused) return;
 67 |     if (window.activeTextEditor &&
 68 |         window.activeTextEditor.document &&
 69 |         window.activeTextEditor.document.languageId === 'viml') {
 70 |       startVimLLanguageServer();
 71 |     }
 72 |   });
 73 | }
 74 | 
 75 | function tryApplyVimHelpEditorOption(
 76 |   editor: TextEditor,
 77 |   dependsOnHighPriorityConfig = false) {
 78 |   if (!editor) return;
 79 |   if (dependsOnHighPriorityConfig) {
 80 |     const config = workspace.getConfiguration('viml');
 81 |     const highPriority = config.get<boolean>('highVimHelpIndentStylePriority');
 82 |     if (!highPriority) {
 83 |       outputChannel.append(
 84 |         'viml.highVimHelpIndentStylePriority is false, ignore.\n');
 85 |       return;
 86 |     }
 87 | 
 88 |     outputChannel.append(
 89 |       'viml.highVimHelpIndentStylePriority is true, force indentation.\n');
 90 |   }
 91 | 
 92 |   outputChannel.append(`Set ${editor.document.fileName}'s indentation\n`);
 93 | 
 94 |   editor.options = {
 95 |     tabSize: 8,
 96 |     insertSpaces: false,
 97 |   };
 98 | }
 99 | 
100 | function detectIfVimHelp(editor: TextEditor) {
101 |   const document = editor.document;
102 |   // Refer to https://github.com/Alhadis/language-viml/blob/769b532/index.js
103 |   if (/\.txt$/i.test(document.fileName) &&
104 |       VIM_MODELINE.test(document.getText()) &&
105 |       RegExp.lastParen === 'help') {
106 |     outputChannel.append(`vim-help detected on ${document.fileName}.\n`);
107 |     languages.setTextDocumentLanguage(document, 'vim-help');
108 |     tryApplyVimHelpEditorOption(editor, true);
109 |   }
110 | }
111 | 
112 | function startVimHelpLogic() {
113 |   if (window.activeTextEditor && window.activeTextEditor.document) {
114 |     if (window.activeTextEditor.document.languageId === 'vim-help') {
115 |       tryApplyVimHelpEditorOption(window.activeTextEditor, true);
116 |     } else if (![
117 |       'viml',
118 |       'vim-snippet',
119 |     ].includes(window.activeTextEditor.document.languageId)) {
120 |       detectIfVimHelp(window.activeTextEditor);
121 |     }
122 |   }
123 | 
124 |   window.onDidChangeTextEditorOptions(
125 |     // For EditorConfig
126 |     async (e: TextEditorOptionsChangeEvent) => {
127 |       if (e.textEditor &&
128 |           e.textEditor.document &&
129 |           e.textEditor.document.languageId === 'vim-help') {
130 |         if (e.options.tabSize !== 8 || e.options.insertSpaces) {
131 |           tryApplyVimHelpEditorOption(e.textEditor, true);
132 |         }
133 |       }
134 |     });
135 | 
136 |   window.onDidChangeActiveTextEditor(async (editor: TextEditor | undefined) => {
137 |     if (editor && editor.document) {
138 |       if (editor.document.languageId === 'vim-help') {
139 |         tryApplyVimHelpEditorOption(editor);
140 |       } else {
141 |         detectIfVimHelp(editor);
142 |       }
143 |     }
144 |   });
145 | 
146 |   window.onDidChangeWindowState(async (state: WindowState) => {
147 |     const editor: TextEditor | undefined = window.activeTextEditor;
148 |     if (state.focused && editor && editor.document) {
149 |       if (editor.document.languageId === 'vim-help') {
150 |         tryApplyVimHelpEditorOption(editor);
151 |       } else {
152 |         detectIfVimHelp(editor);
153 |       }
154 |     }
155 |   });
156 | }
157 | 
158 | export function activate() {
159 |   outputChannel = window.createOutputChannel('VimL');
160 |   startVimLLanguageServerWhenVimLFile();
161 |   startVimHelpLogic();
162 | }
163 | 
164 | export function deactivate(): Thenable<void> | undefined {
165 |   if (!client) return;
166 |   const old: LanguageClient = client;
167 |   client = undefined;
168 |   return old.stop();
169 | }
170 | 


--------------------------------------------------------------------------------
/syntaxes/codeblock.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "fileTypes": [],
  3 |   "injectionSelector": "L:text.html.markdown",
  4 |   "patterns": [
  5 |     {
  6 |       "include": "#viml-code-block"
  7 |     },
  8 |     {
  9 |       "include": "#vim-help-code-block"
 10 |     },
 11 |     {
 12 |       "include": "#vim-snippet-code-block"
 13 |     }
 14 |   ],
 15 |   "repository": {
 16 |     "viml-code-block": {
 17 |       "begin": "(^|\\G)(\\s*)(\\`{3,}|~{3,})\\s*(?i:(vim|viml|vimscript)(\\s+[^`~]*)?$)",
 18 |       "name": "markup.fenced_code.block.markdown",
 19 |       "end": "(^|\\G)(\\2|\\s{0,3})(\\3)\\s*$",
 20 |       "beginCaptures": {
 21 |         "3": {
 22 |           "name": "punctuation.definition.markdown"
 23 |         },
 24 |         "4": {
 25 |           "name": "fenced_code.block.language.markdown"
 26 |         },
 27 |         "5": {
 28 |           "name": "fenced_code.block.language.attributes.markdown"
 29 |         }
 30 |       },
 31 |       "endCaptures": {
 32 |         "3": {
 33 |           "name": "punctuation.definition.markdown"
 34 |         }
 35 |       },
 36 |       "patterns": [
 37 |         {
 38 |           "begin": "(^|\\G)(\\s*)(.*)",
 39 |           "while": "(^|\\G)(?!\\s*([`~]{3,})\\s*$)",
 40 |           "contentName": "meta.embedded.block.viml",
 41 |           "patterns": [
 42 |             {
 43 |               "include": "source.viml"
 44 |             }
 45 |           ]
 46 |         }
 47 |       ]
 48 |     },
 49 |     "vim-help-code-block": {
 50 |       "begin": "(^|\\G)(\\s*)(\\`{3,}|~{3,})\\s*(?i:(vim-help|vimhelp)(\\s+[^`~]*)?$)",
 51 |       "name": "markup.fenced_code.block.markdown",
 52 |       "end": "(^|\\G)(\\2|\\s{0,3})(\\3)\\s*$",
 53 |       "beginCaptures": {
 54 |         "3": {
 55 |           "name": "punctuation.definition.markdown"
 56 |         },
 57 |         "4": {
 58 |           "name": "fenced_code.block.language.markdown"
 59 |         },
 60 |         "5": {
 61 |           "name": "fenced_code.block.language.attributes.markdown"
 62 |         }
 63 |       },
 64 |       "endCaptures": {
 65 |         "3": {
 66 |           "name": "punctuation.definition.markdown"
 67 |         }
 68 |       },
 69 |       "patterns": [
 70 |         {
 71 |           "begin": "(^|\\G)(\\s*)(.*)",
 72 |           "while": "(^|\\G)(?!\\s*([`~]{3,})\\s*$)",
 73 |           "contentName": "meta.embedded.block.vim-help",
 74 |           "patterns": [
 75 |             {
 76 |               "include": "text.vim-help"
 77 |             }
 78 |           ]
 79 |         }
 80 |       ]
 81 |     },
 82 |     "vim-snippet-code-block": {
 83 |       "begin": "(^|\\G)(\\s*)(\\`{3,}|~{3,})\\s*(?i:(vim-snippet|vimsnippet)(\\s+[^`~]*)?$)",
 84 |       "name": "markup.fenced_code.block.markdown",
 85 |       "end": "(^|\\G)(\\2|\\s{0,3})(\\3)\\s*$",
 86 |       "beginCaptures": {
 87 |         "3": {
 88 |           "name": "punctuation.definition.markdown"
 89 |         },
 90 |         "4": {
 91 |           "name": "fenced_code.block.language.markdown"
 92 |         },
 93 |         "5": {
 94 |           "name": "fenced_code.block.language.attributes.markdown"
 95 |         }
 96 |       },
 97 |       "endCaptures": {
 98 |         "3": {
 99 |           "name": "punctuation.definition.markdown"
100 |         }
101 |       },
102 |       "patterns": [
103 |         {
104 |           "begin": "(^|\\G)(\\s*)(.*)",
105 |           "while": "(^|\\G)(?!\\s*([`~]{3,})\\s*$)",
106 |           "contentName": "meta.embedded.block.vim-snippet",
107 |           "patterns": [
108 |             {
109 |               "include": "source.vim-snippet"
110 |             }
111 |           ]
112 |         }
113 |       ]
114 |     }
115 |   },
116 |   "scopeName": "markdown.vim.codeblock"
117 | }
118 | 


--------------------------------------------------------------------------------
/syntaxes/help.language-configuration.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "brackets": [
 3 |     [ "*", "*" ],
 4 |     [ "|", "|" ],
 5 |     [ "(", ")" ],
 6 |     [ "[", "]" ],
 7 |     [ "{", "}" ]
 8 |   ],
 9 |   "autoClosingPairs": [
10 |     [ "*", "*" ],
11 |     [ "|", "|" ],
12 |     [ "(", ")" ],
13 |     [ "[", "]" ],
14 |     [ "{", "}" ],
15 |     [ "\"", "\"" ],
16 |     [ "'", "'" ]
17 |   ],
18 |   "surroundingPairs": [
19 |     [ "{", "}" ],
20 |     [ "[", "]" ],
21 |     [ "(", ")" ],
22 |     [ "{", "}" ],
23 |     [ "'", "'" ],
24 |     [ "\"", "\"" ],
25 |     [ "|", "|" ],
26 |     [ "*", "*" ]
27 |   ]
28 | }
29 | 


--------------------------------------------------------------------------------
/syntaxes/help.tmLanguage.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "information_for_contributors": [
  3 |     "This file has been converted from https://github.com/Alhadis/language-viml/blob/master/grammars/help.cson",
  4 |     "If you want to provide a fix or improvement, please create a pull request against the original repository.",
  5 |     "Once accepted there, we are happy to receive an update request."
  6 |   ],
  7 |   "version": "https://github.com/Alhadis/language-viml/commit/2e90a584dc4be6483d9b2061d257a5bc962c8b4a",
  8 |   "name": "Vim Help",
  9 |   "scopeName": "text.vim-help",
 10 |   "patterns": [
 11 |     {
 12 |       "name": "meta.file-header.vim-help",
 13 |       "match": "(?i)\\A(\\*[#-)!+-~]+\\*)[ \\t]+(For\\s+Vim\\s+version\\s*[\\d.]+)[ \\t]+Last\\s+changed?:\\s*(\\S.*?)\\s*$",
 14 |       "captures": {
 15 |         "1": {
 16 |           "patterns": [
 17 |             {
 18 |               "include": "#tag"
 19 |             }
 20 |           ]
 21 |         },
 22 |         "2": {
 23 |           "patterns": [
 24 |             {
 25 |               "include": "#vimVersion"
 26 |             }
 27 |           ]
 28 |         },
 29 |         "3": {
 30 |           "name": "constant.numeric.date.last-changed.vim-help"
 31 |         }
 32 |       }
 33 |     },
 34 |     {
 35 |       "include": "#main"
 36 |     }
 37 |   ],
 38 |   "repository": {
 39 |     "main": {
 40 |       "patterns": [
 41 |         {
 42 |           "include": "#tag"
 43 |         },
 44 |         {
 45 |           "include": "#link"
 46 |         },
 47 |         {
 48 |           "include": "#special"
 49 |         },
 50 |         {
 51 |           "include": "#option"
 52 |         },
 53 |         {
 54 |           "include": "#command"
 55 |         },
 56 |         {
 57 |           "include": "#codeBlock"
 58 |         },
 59 |         {
 60 |           "include": "#manualTitle"
 61 |         },
 62 |         {
 63 |           "include": "#columnHeading"
 64 |         },
 65 |         {
 66 |           "include": "#sectionDelimiter"
 67 |         },
 68 |         {
 69 |           "include": "#vimVersion"
 70 |         },
 71 |         {
 72 |           "include": "#url"
 73 |         },
 74 |         {
 75 |           "include": "#other"
 76 |         }
 77 |       ]
 78 |     },
 79 |     "codeBlock": {
 80 |       "name": "meta.example.vim-help",
 81 |       "begin": "(?:(?<=\\s)|^)(>)$",
 82 |       "end": "^(<)|(?=^\\S)",
 83 |       "beginCaptures": {
 84 |         "1": {
 85 |           "name": "keyword.control.example.begin.vim-help"
 86 |         }
 87 |       },
 88 |       "endCaptures": {
 89 |         "1": {
 90 |           "name": "keyword.control.example.end.vim-help"
 91 |         }
 92 |       },
 93 |       "contentName": "markup.raw.code.verbatim.vim-help"
 94 |     },
 95 |     "columnHeading": {
 96 |       "name": "markup.heading.column-title.vim-help",
 97 |       "match": "^\\s*\\S.*(~)$",
 98 |       "captures": {
 99 |         "1": {
100 |           "name": "keyword.operator.column-marker.tilde.vim-help"
101 |         }
102 |       }
103 |     },
104 |     "command": {
105 |       "name": "markup.raw.command.vim-help",
106 |       "match": "(`)([^` \\t]+)(`)",
107 |       "captures": {
108 |         "1": {
109 |           "name": "punctuation.definition.link.begin.vim-help"
110 |         },
111 |         "2": {
112 |           "patterns": [
113 |             {
114 |               "include": "source.viml"
115 |             }
116 |           ]
117 |         },
118 |         "3": {
119 |           "name": "punctuation.definition.link.end.vim-help"
120 |         }
121 |       }
122 |     },
123 |     "link": {
124 |       "name": "meta.link.vim-help",
125 |       "match": "(\\|)([^\"*|]+)(\\|)",
126 |       "captures": {
127 |         "1": {
128 |           "name": "meta.separator.punctuation.link.begin.vim-help"
129 |         },
130 |         "2": {
131 |           "name": "constant.other.link.vim-help"
132 |         },
133 |         "3": {
134 |           "name": "meta.separator.punctuation.link.end.vim-help"
135 |         }
136 |       }
137 |     },
138 |     "special": {
139 |       "patterns": [
140 |         {
141 |           "name": "entity.name.keyword.vim-help",
142 |           "match": "(<)N(>)",
143 |           "captures": {
144 |             "1": {
145 |               "name": "punctuation.definition.bracket.angle.begin.vim-help"
146 |             },
147 |             "2": {
148 |               "name": "punctuation.definition.bracket.angle.end.vim-help"
149 |             }
150 |           }
151 |         },
152 |         {
153 |           "name": "entity.name.keyword.vim-help",
154 |           "match": "(<)N(?=\\.(?:$|\\s))",
155 |           "captures": {
156 |             "1": {
157 |               "name": "punctuation.definition.bracket.angle.begin.vim-help"
158 |             }
159 |           }
160 |         },
161 |         {
162 |           "name": "entity.name.keyword.vim-help",
163 |           "match": "(\\()N(>)",
164 |           "captures": {
165 |             "1": {
166 |               "name": "punctuation.definition.bracket.round.begin.vim-help"
167 |             },
168 |             "2": {
169 |               "name": "punctuation.definition.bracket.angle.end.vim-help"
170 |             }
171 |           }
172 |         },
173 |         {
174 |           "name": "entity.name.keyword.vim-help",
175 |           "match": "(\\[)N(\\])",
176 |           "captures": {
177 |             "1": {
178 |               "name": "punctuation.definition.bracket.square.begin.vim-help"
179 |             },
180 |             "2": {
181 |               "name": "punctuation.definition.bracket.square.end.vim-help"
182 |             }
183 |           }
184 |         },
185 |         {
186 |           "match": "(N)  (N)",
187 |           "captures": {
188 |             "1": {
189 |               "name": "entity.name.keyword.vim-help"
190 |             },
191 |             "2": {
192 |               "name": "entity.name.keyword.vim-help"
193 |             }
194 |           }
195 |         },
196 |         {
197 |           "name": "entity.name.keyword.vim-help",
198 |           "match": "N(?=th|-1)"
199 |         },
200 |         {
201 |           "name": "entity.name.keyword.vim-help",
202 |           "match": "({)[-a-zA-Z0-9'\"*+/:%#=\\[\\]<>.,]+(})",
203 |           "captures": {
204 |             "1": {
205 |               "name": "punctuation.definition.bracket.curly.begin.vim-help"
206 |             },
207 |             "2": {
208 |               "name": "punctuation.definition.bracket.curly.end.vim-help"
209 |             }
210 |           }
211 |         },
212 |         {
213 |           "name": "entity.name.keyword.vim-help",
214 |           "match": "(?<=\\s)(\\[)[-a-z^A-Z0-9_]{2,}(\\])",
215 |           "captures": {
216 |             "1": {
217 |               "name": "punctuation.definition.bracket.square.begin.vim-help"
218 |             },
219 |             "2": {
220 |               "name": "punctuation.definition.bracket.square.end.vim-help"
221 |             }
222 |           }
223 |         },
224 |         {
225 |           "name": "entity.name.keyword.vim-help",
226 |           "match": "(<)[-a-zA-Z0-9_]+(>)",
227 |           "captures": {
228 |             "1": {
229 |               "name": "punctuation.definition.bracket.angle.begin.vim-help"
230 |             },
231 |             "2": {
232 |               "name": "punctuation.definition.bracket.angle.end.vim-help"
233 |             }
234 |           }
235 |         },
236 |         {
237 |           "name": "entity.name.keyword.vim-help",
238 |           "match": "(<)[SCM]-.(>)",
239 |           "captures": {
240 |             "1": {
241 |               "name": "punctuation.definition.bracket.angle.begin.vim-help"
242 |             },
243 |             "2": {
244 |               "name": "punctuation.definition.bracket.angle.end.vim-help"
245 |             }
246 |           }
247 |         },
248 |         {
249 |           "name": "entity.name.keyword.vim-help",
250 |           "match": "(\\[)(?:\\+\\+opt|[-+]?num|\\+?cmd|addr|arguments|arg|count|group|ident|line|offset|range)(\\])",
251 |           "captures": {
252 |             "1": {
253 |               "name": "punctuation.definition.bracket.square.begin.vim-help"
254 |             },
255 |             "2": {
256 |               "name": "punctuation.definition.bracket.square.end.vim-help"
257 |             }
258 |           }
259 |         },
260 |         {
261 |           "name": "entity.name.keyword.vim-help",
262 |           "match": "\\bCTRL(-)(?:.|Break|Del|Insert|PageDown|PageUp|({)char(}))",
263 |           "captures": {
264 |             "1": {
265 |               "name": "punctuation.delimiter.separator.dash.hyphen.vim-help"
266 |             },
267 |             "2": {
268 |               "name": "punctuation.definition.bracket.curly.begin.vim-help"
269 |             },
270 |             "3": {
271 |               "name": "punctuation.definition.bracket.curly.end.vim-help"
272 |             }
273 |           }
274 |         }
275 |       ]
276 |     },
277 |     "tag": {
278 |       "name": "storage.link.hypertext.vim-help",
279 |       "match": "(\\*)[#-)!+-~]+(\\*)(?=\\s|$)",
280 |       "captures": {
281 |         "1": {
282 |           "name": "punctuation.definition.begin.vim-help"
283 |         },
284 |         "2": {
285 |           "name": "punctuation.definition.end.vim-help"
286 |         }
287 |       }
288 |     },
289 |     "manualTitle": {
290 |       "name": "markup.heading.manual-title.vim-help",
291 |       "match": "^[ \\t]+(VIM REFERENCE.*)\\s*$",
292 |       "captures": {
293 |         "1": {
294 |           "name": "constant.other.title-text.vim-help"
295 |         }
296 |       }
297 |     },
298 |     "option": {
299 |       "patterns": [
300 |         {
301 |           "name": "entity.name.tag.option.vim-help",
302 |           "match": "(')[a-z]{2,}(')",
303 |           "captures": {
304 |             "1": {
305 |               "name": "punctuation.definition.begin.option.vim-help"
306 |             },
307 |             "2": {
308 |               "name": "punctuation.definition.end.option.vim-help"
309 |             }
310 |           }
311 |         }
312 |       ]
313 |     },
314 |     "sectionDelimiter": {
315 |       "name": "constant.other.section.delimiter.vim-help",
316 |       "match": "^===.*===$|^---.*--$"
317 |     },
318 |     "url": {
319 |       "name": "constant.other.reference.link.vim-help",
320 |       "match": "(?x)\n(?:(?:(?:https?|ftp|gopher)://|(?:mailto|file|news):)[^'\\x20\\t<>\"]+\n|(?:www|web|w3)[a-z0-9_-]*\\.[a-z0-9._-]+\\.[^'\\x20\\t<>\"]+)\n[a-zA-Z0-9/]"
321 |     },
322 |     "vimVersion": {
323 |       "name": "entity.other.vim-version.vim-help",
324 |       "match": "\\bVim version [0-9][0-9.a-z]*"
325 |     },
326 |     "other": {
327 |       "patterns": [
328 |         {
329 |           "name": "markup.changed.${1:/downcase}.vim-help",
330 |           "match": "\\b(DEPRECATED|WARNING|(?:Deprecated|Warning)(?=:))(:|\\b)",
331 |           "captures": {
332 |             "2": {
333 |               "name": "keyword.operator.assignment.key-value.colon.vim-help"
334 |             }
335 |           }
336 |         },
337 |         {
338 |           "name": "invalid.illegal.error.vim-help",
339 |           "match": "\\t[* ]Error\\t+[a-z].*",
340 |           "captures": {
341 |             "1": {
342 |               "name": "punctuation.separator.list-item.marker.vim-help"
343 |             }
344 |           }
345 |         },
346 |         {
347 |           "name": "markup.ignored.todo.vim-help",
348 |           "match": "\\t[* ]Todo\\t+[a-z].*",
349 |           "captures": {
350 |             "1": {
351 |               "name": "punctuation.separator.list-item.marker.vim-help"
352 |             }
353 |           }
354 |         },
355 |         {
356 |           "name": "comment.line.vim-help",
357 |           "match": "\\t[* ](Comment)\\t+([a-z].*)",
358 |           "captures": {
359 |             "1": {
360 |               "name": "punctuation.separator.list-item.marker.vim-help"
361 |             }
362 |           }
363 |         },
364 |         {
365 |           "name": "constant.other.reference.link.vim-help",
366 |           "match": "\\t[* ]Underlined\\t+[a-z].*"
367 |         },
368 |         {
369 |           "name": "meta.${2:/downcase}-line.vim-help",
370 |           "match": "(?x) \\t (\\*|\\x20)\n(Boolean|Character|Conditional|Constant|Debug|Define|Delimiter\n|Exception|Float|Function|Identifier|Include|Keyword|Label|Macro\n|Number|Operator|PreCondit|PreProc|Repeat|SpecialChar\n|SpecialComment|Special|Statement|StorageClass|String\n|Structure|Tag|Typedef|Type)\n(\\t+ ([\"Aa-z].*))",
371 |           "captures": {
372 |             "1": {
373 |               "name": "punctuation.separator.list-item.marker.vim-help"
374 |             },
375 |             "2": {
376 |               "name": "storage.type.${2:/downcase}.vim-help"
377 |             },
378 |             "3": {
379 |               "name": "meta.output.vim-help"
380 |             },
381 |             "4": {
382 |               "name": "${2:/downcase}.vim-help"
383 |             }
384 |           }
385 |         }
386 |       ]
387 |     }
388 |   }
389 | }


--------------------------------------------------------------------------------
/syntaxes/snippet.language-configuration.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "comments": {
 3 |     "lineComment": "# ",
 4 |   },
 5 |   "brackets": [
 6 |     [ "{", "}" ],
 7 |     [ "[", "]" ],
 8 |     [ "(", ")" ]
 9 |   ],
10 |   "autoClosingPairs": [
11 |     [ "{", "}" ],
12 |     [ "[", "]" ],
13 |     [ "(", ")" ],
14 |     [ "'", "'" ],
15 |     [ "\"", "\"" ]
16 |   ],
17 |   "surroundingPairs": [
18 |     [ "{", "}" ],
19 |     [ "[", "]" ],
20 |     [ "(", ")" ],
21 |     [ "'", "'" ],
22 |     [ "\"", "\"" ]
23 |   ],
24 |   "indentationRules": {
25 |     "increaseIndentPattern": "^snippet.+(?<!\")",
26 |     "decreaseIndentPattern": "^[^ ]$",
27 |     "comment": "^[^ ]$ is a noop regexp"
28 |   }
29 | }
30 | 


--------------------------------------------------------------------------------
/syntaxes/snippet.tmLanguage.json:
--------------------------------------------------------------------------------
  1 | {
  2 |   "information_for_contributors": [
  3 |     "This file has been converted from https://github.com/Alhadis/language-viml/blob/master/grammars/snippet.cson",
  4 |     "If you want to provide a fix or improvement, please create a pull request against the original repository.",
  5 |     "Once accepted there, we are happy to receive an update request."
  6 |   ],
  7 |   "version": "https://github.com/Alhadis/language-viml/commit/a8e1770846b4d994ab2be04371f7d97a16b1a08f",
  8 |   "name": "Vim Snippet",
  9 |   "scopeName": "source.vim-snippet",
 10 |   "patterns": [
 11 |     {
 12 |       "include": "#main"
 13 |     }
 14 |   ],
 15 |   "repository": {
 16 |     "main": {
 17 |       "patterns": [
 18 |         {
 19 |           "include": "#snippet"
 20 |         },
 21 |         {
 22 |           "include": "#comment"
 23 |         },
 24 |         {
 25 |           "include": "#extends"
 26 |         },
 27 |         {
 28 |           "include": "#global"
 29 |         },
 30 |         {
 31 |           "include": "#priority"
 32 |         },
 33 |         {
 34 |           "include": "#expression"
 35 |         },
 36 |         {
 37 |           "include": "#version"
 38 |         },
 39 |         {
 40 |           "include": "#ultisnips"
 41 |         },
 42 |         {
 43 |           "include": "#neosnippet"
 44 |         }
 45 |       ]
 46 |     },
 47 |     "comment": {
 48 |       "name": "comment.line.number-sign.vim-snippet",
 49 |       "begin": "^#",
 50 |       "end": "$",
 51 |       "beginCaptures": {
 52 |         "0": {
 53 |           "name": "punctuation.definition.comment.number-sign.vim-snippet"
 54 |         }
 55 |       }
 56 |     },
 57 |     "extends": {
 58 |       "name": "meta.$1.directive.vim-snippet",
 59 |       "begin": "^(extends|include|source)(?=\\s|$)",
 60 |       "end": "$",
 61 |       "beginCaptures": {
 62 |         "1": {
 63 |           "name": "keyword.control.$1.directive.vim-snippet"
 64 |         }
 65 |       },
 66 |       "patterns": [
 67 |         {
 68 |           "match": ",",
 69 |           "name": "punctuation.separator.delimiter.comma.vim-snippet"
 70 |         },
 71 |         {
 72 |           "match": "[^,\\s]+",
 73 |           "name": "entity.other.inherited-class.vim-snippet"
 74 |         }
 75 |       ]
 76 |     },
 77 |     "expression": {
 78 |       "patterns": [
 79 |         {
 80 |           "name": "string.interpolated.python-code.vim-snippet",
 81 |           "begin": "(`)(!p)",
 82 |           "end": "`",
 83 |           "beginCaptures": {
 84 |             "1": {
 85 |               "name": "punctuation.section.begin.embedded.vim-snippet"
 86 |             },
 87 |             "2": {
 88 |               "name": "keyword.operator.use-python.vim-snippet"
 89 |             }
 90 |           },
 91 |           "endCaptures": {
 92 |             "0": {
 93 |               "name": "punctuation.section.end.embedded.vim-snippet"
 94 |             }
 95 |           },
 96 |           "patterns": [
 97 |             {
 98 |               "name": "source.embedded.python",
 99 |               "match": "(?:[^\\\\`]|\\\\.)+",
100 |               "captures": {
101 |                 "0": {
102 |                   "patterns": [
103 |                     {
104 |                       "include": "source.python"
105 |                     }
106 |                   ]
107 |                 }
108 |               }
109 |             }
110 |           ]
111 |         },
112 |         {
113 |           "name": "string.interpolated.viml-code.vim-snippet",
114 |           "begin": "(`)(!v)",
115 |           "end": "`",
116 |           "beginCaptures": {
117 |             "1": {
118 |               "name": "punctuation.section.begin.embedded.vim-snippet"
119 |             },
120 |             "2": {
121 |               "name": "keyword.operator.use-viml.vim-snippet"
122 |             }
123 |           },
124 |           "endCaptures": {
125 |             "0": {
126 |               "name": "punctuation.section.end.embedded.vim-snippet"
127 |             }
128 |           },
129 |           "patterns": [
130 |             {
131 |               "name": "source.embedded.viml",
132 |               "match": "(?:[^\\\\`]|\\\\.)+",
133 |               "captures": {
134 |                 "0": {
135 |                   "patterns": [
136 |                     {
137 |                       "include": "source.viml"
138 |                     }
139 |                   ]
140 |                 }
141 |               }
142 |             }
143 |           ]
144 |         },
145 |         {
146 |           "name": "string.interpolated.vim-snippet",
147 |           "begin": "`",
148 |           "end": "`",
149 |           "beginCaptures": {
150 |             "0": {
151 |               "name": "punctuation.section.begin.embedded.vim-snippet"
152 |             }
153 |           },
154 |           "endCaptures": {
155 |             "0": {
156 |               "name": "punctuation.section.end.embedded.vim-snippet"
157 |             }
158 |           },
159 |           "patterns": [
160 |             {
161 |               "name": "source.embedded.viml",
162 |               "match": "(?:[^\\\\`]|\\\\.)+",
163 |               "captures": {
164 |                 "0": {
165 |                   "patterns": [
166 |                     {
167 |                       "include": "source.viml"
168 |                     }
169 |                   ]
170 |                 }
171 |               }
172 |             }
173 |           ]
174 |         }
175 |       ]
176 |     },
177 |     "global": {
178 |       "name": "meta.ultisnip.global.vim-snippet",
179 |       "begin": "^(global)\\s+(!p)[ \\t]*$",
180 |       "end": "^(endglobal)(?=\\s|$)",
181 |       "beginCaptures": {
182 |         "1": {
183 |           "name": "keyword.control.global.begin.vim-snippet"
184 |         },
185 |         "2": {
186 |           "name": "keyword.operator.use-python.vim-snippet"
187 |         }
188 |       },
189 |       "endCaptures": {
190 |         "1": {
191 |           "name": "keyword.control.global.end.vim-snippet"
192 |         }
193 |       },
194 |       "contentName": "source.embedded.python",
195 |       "patterns": [
196 |         {
197 |           "include": "source.python"
198 |         }
199 |       ]
200 |     },
201 |     "neosnippet": {
202 |       "patterns": [
203 |         {
204 |           "name": "meta.neosnippet-field.vim-snippet",
205 |           "match": "(?:\\G|^)(abbr|alias|delete|options)\\s+(\\S.*)",
206 |           "captures": {
207 |             "1": {
208 |               "name": "keyword.operator.$1.vim-snippet"
209 |             },
210 |             "2": {
211 |               "name": "entity.other.neosnippet-keyword.vim-snippet"
212 |             }
213 |           }
214 |         },
215 |         {
216 |           "name": "meta.neosnippet-field.vim-snippet",
217 |           "match": "(?x) (?:\\G|^)\n(regexp) \\s+\n( (')([^']*)(') # Single-quoted\n| (\")([^\"]*)(\") # Double-quoted\n| ([^'\"\\s]\\.) # Unquoted (?)\n)",
218 |           "captures": {
219 |             "1": {
220 |               "name": "keyword.operator.regex.vim-snippet"
221 |             },
222 |             "2": {
223 |               "name": "string.regexp.quoted.single.vim-snippet"
224 |             },
225 |             "3": {
226 |               "name": "punctuation.definition.string.regexp.begin.vim-snippet"
227 |             },
228 |             "4": {
229 |               "patterns": [
230 |                 {
231 |                   "include": "source.regexp"
232 |                 }
233 |               ]
234 |             },
235 |             "5": {
236 |               "name": "punctuation.definition.string.regexp.end.vim-snippet"
237 |             },
238 |             "6": {
239 |               "name": "punctuation.definition.string.regexp.begin.vim-snippet"
240 |             },
241 |             "7": {
242 |               "patterns": [
243 |                 {
244 |                   "include": "source.regexp"
245 |                 }
246 |               ]
247 |             },
248 |             "8": {
249 |               "name": "punctuation.definition.string.regexp.end.vim-snippet"
250 |             },
251 |             "9": {
252 |               "patterns": [
253 |                 {
254 |                   "include": "source.regexp"
255 |                 }
256 |               ]
257 |             }
258 |           }
259 |         }
260 |       ]
261 |     },
262 |     "snippet": {
263 |       "name": "meta.snippet.vim-snippet",
264 |       "begin": "^(snippet)(!{0,2})(?=[ \\t]|$)",
265 |       "end": "^(endsnippet)\\s*$|(?=^\\S)|(?<=endsnippet)(?=\\s|$)",
266 |       "beginCaptures": {
267 |         "1": {
268 |           "name": "storage.type.class.vim-snippet"
269 |         },
270 |         "2": {
271 |           "name": "keyword.operator.scope.modifier.vim-snippet"
272 |         }
273 |       },
274 |       "endCaptures": {
275 |         "1": {
276 |           "name": "storage.type.class.end.vim-snippet"
277 |         }
278 |       },
279 |       "patterns": [
280 |         {
281 |           "include": "#snippetHead"
282 |         },
283 |         {
284 |           "include": "#snippetNeck"
285 |         },
286 |         {
287 |           "include": "#snippetBody"
288 |         }
289 |       ]
290 |     },
291 |     "snippetHead": {
292 |       "begin": "\\G",
293 |       "end": "(?=^)|(?=\\s*$)",
294 |       "patterns": [
295 |         {
296 |           "begin": "\\G\\s*((\\S+))",
297 |           "end": "(?=^|\\S)",
298 |           "beginCaptures": {
299 |             "1": {
300 |               "name": "entity.name.trigger.vim-snippet"
301 |             },
302 |             "2": {
303 |               "name": "markup.heading.vim-snippet"
304 |             }
305 |           },
306 |           "patterns": [
307 |             {
308 |               "include": "#snippetNeck"
309 |             }
310 |           ]
311 |         },
312 |         {
313 |           "begin": "(?<=\\s)(\")[^\"]*(\")",
314 |           "end": "(?=^|\\S)",
315 |           "beginCaptures": {
316 |             "0": {
317 |               "name": "string.quoted.double.description.vim-snippet"
318 |             },
319 |             "1": {
320 |               "name": "punctuation.definition.string.begin.vim-snippet"
321 |             },
322 |             "2": {
323 |               "name": "punctuation.definition.string.end.vim-snippet"
324 |             }
325 |           },
326 |           "patterns": [
327 |             {
328 |               "include": "#snippetNeck"
329 |             }
330 |           ]
331 |         },
332 |         {
333 |           "begin": "(?<=\\s)[Abeimrstw]+(?=\\s*$)",
334 |           "end": "(?=^|\\S)",
335 |           "beginCaptures": {
336 |             "0": {
337 |               "name": "constant.language.other.options.vim-snippet"
338 |             }
339 |           },
340 |           "patterns": [
341 |             {
342 |               "include": "#snippetNeck"
343 |             }
344 |           ]
345 |         },
346 |         {
347 |           "begin": "(?<=\\s)\\S+",
348 |           "end": "(?=^|\\S)",
349 |           "beginCaptures": {
350 |             "0": {
351 |               "name": "entity.other.description.vim-snippet"
352 |             }
353 |           },
354 |           "patterns": [
355 |             {
356 |               "include": "#snippetNeck"
357 |             }
358 |           ]
359 |         },
360 |         {
361 |           "include": "#snippetNeck"
362 |         }
363 |       ]
364 |     },
365 |     "snippetNeck": {
366 |       "begin": "\\G\\s*$\\s*",
367 |       "end": "^(endsnippet)\\s*$|(?=^\\s)|(?<=endsnippet)(?=\\s|$)",
368 |       "endCaptures": {
369 |         "1": {
370 |           "name": "storage.type.class.end.vim-snippet"
371 |         }
372 |       },
373 |       "contentName": "meta.snippet-body.vim-snippet",
374 |       "patterns": [
375 |         {
376 |           "begin": "(?<=^)(?=\\S)(?!endsnippet|(?:abbr|alias|regexp|options)\\s+\\S)",
377 |           "end": "^(endsnippet)(?=$|[ \\t])",
378 |           "endCaptures": {
379 |             "1": {
380 |               "name": "storage.type.class.end.vim-snippet"
381 |             }
382 |           },
383 |           "patterns": [
384 |             {
385 |               "include": "#snippetBody"
386 |             }
387 |           ]
388 |         },
389 |         {
390 |           "begin": "(?<=^)(?=(?:abbr|alias|regexp|options)\\s+\\S)",
391 |           "end": "(?=^\\s)",
392 |           "patterns": [
393 |             {
394 |               "include": "#neosnippet"
395 |             }
396 |           ]
397 |         }
398 |       ]
399 |     },
400 |     "snippetBody": {
401 |       "patterns": [
402 |         {
403 |           "include": "#escape"
404 |         },
405 |         {
406 |           "include": "#expression"
407 |         },
408 |         {
409 |           "include": "#tabStop"
410 |         }
411 |       ]
412 |     },
413 |     "escape": {
414 |       "name": "constant.character.escape.dollar-sign.vim-snippet",
415 |       "match": "(\\\\).",
416 |       "captures": {
417 |         "1": {
418 |           "name": "punctuation.definition.escape.vim-snippet"
419 |         }
420 |       }
421 |     },
422 |     "priority": {
423 |       "begin": "^priority(?=\\s|$)",
424 |       "end": "$",
425 |       "beginCaptures": {
426 |         "0": {
427 |           "name": "keyword.control.version.directive.vim-snippet"
428 |         }
429 |       },
430 |       "patterns": [
431 |         {
432 |           "name": "constant.numeric.integer.int.vim-snippet",
433 |           "match": "[-+]?[\\d.]+"
434 |         }
435 |       ]
436 |     },
437 |     "tabStop": {
438 |       "patterns": [
439 |         {
440 |           "name": "variable.language.tab-stop.$2-nth.vim-snippet",
441 |           "match": "(\\$)([0-9]+)",
442 |           "captures": {
443 |             "1": {
444 |               "name": "punctuation.definition.variable.vim-snippet"
445 |             }
446 |           }
447 |         },
448 |         {
449 |           "name": "variable.language.tab-stop.$2-nth.vim-snippet",
450 |           "match": "(\\${)([0-9]+)(})",
451 |           "captures": {
452 |             "1": {
453 |               "name": "punctuation.definition.variable.begin.vim-snippet"
454 |             },
455 |             "3": {
456 |               "name": "punctuation.definition.variable.end.vim-snippet"
457 |             }
458 |           }
459 |         },
460 |         {
461 |           "name": "variable.language.tab-stop.$2-nth.placeholder.vim-snippet",
462 |           "begin": "(\\${)([0-9]+)(:)",
463 |           "end": "}",
464 |           "beginCaptures": {
465 |             "1": {
466 |               "name": "punctuation.definition.variable.begin.vim-snippet"
467 |             },
468 |             "3": {
469 |               "name": "keyword.operator.assignment.key-value.vim-snippet"
470 |             }
471 |           },
472 |           "endCaptures": {
473 |             "0": {
474 |               "name": "punctuation.definition.variable.end.vim-snippet"
475 |             }
476 |           },
477 |           "contentName": "markup.inserted.placeholder.vim-snippet",
478 |           "patterns": [
479 |             {
480 |               "include": "#visual"
481 |             },
482 |             {
483 |               "include": "#escape"
484 |             },
485 |             {
486 |               "include": "#tabStop"
487 |             }
488 |           ]
489 |         },
490 |         {
491 |           "name": "meta.transform.tab-stop.$2-nth.vim-snippet",
492 |           "begin": "(\\${)([0-9]+)(?=/)",
493 |           "end": "}",
494 |           "beginCaptures": {
495 |             "1": {
496 |               "name": "punctuation.definition.variable.begin.vim-snippet"
497 |             },
498 |             "2": {
499 |               "name": "variable.language.tab-stop.vim-snippet"
500 |             }
501 |           },
502 |           "endCaptures": {
503 |             "0": {
504 |               "name": "punctuation.definition.variable.end.vim-snippet"
505 |             }
506 |           },
507 |           "patterns": [
508 |             {
509 |               "name": "string.regexp.transform.vim-snippet",
510 |               "begin": "\\G/",
511 |               "end": "/",
512 |               "beginCaptures": {
513 |                 "0": {
514 |                   "name": "keyword.control.transform.begin.vim-snippet"
515 |                 }
516 |               },
517 |               "endCaptures": {
518 |                 "0": {
519 |                   "name": "keyword.control.transform.middle.vim-snippet"
520 |                 }
521 |               },
522 |               "contentName": "markup.deleted.transform.vim-snippet",
523 |               "patterns": [
524 |                 {
525 |                   "include": "source.regexp"
526 |                 }
527 |               ]
528 |             },
529 |             {
530 |               "contentName": "markup.inserted.transform.vim-snippet",
531 |               "begin": "(?<=/)",
532 |               "end": "(/)([gima]*)",
533 |               "endCaptures": {
534 |                 "1": {
535 |                   "name": "keyword.control.transform.end.vim-snippet"
536 |                 },
537 |                 "2": {
538 |                   "name": "storage.modifier.transform.option.vim-snippet"
539 |                 }
540 |               },
541 |               "patterns": [
542 |                 {
543 |                   "include": "source.regexp"
544 |                 }
545 |               ]
546 |             }
547 |           ]
548 |         }
549 |       ]
550 |     },
551 |     "ultisnips": {
552 |       "patterns": [
553 |         {
554 |           "name": "meta.clear.directive.vim-snippet",
555 |           "begin": "^(clearsnippets)(?=\\s|$)",
556 |           "end": "$",
557 |           "beginCaptures": {
558 |             "1": {
559 |               "name": "keyword.control.clearsnippets.directive.vim-snippet"
560 |             }
561 |           },
562 |           "patterns": [
563 |             {
564 |               "name": "variable.parameter.function.vim-snippet",
565 |               "match": "[^\\s]+"
566 |             }
567 |           ]
568 |         },
569 |         {
570 |           "name": "meta.$1.directive.vim-snippet",
571 |           "begin": "^(context|pre_expand|post_expand|post_jump)(?=[ \\t]|$)",
572 |           "end": "$",
573 |           "beginCaptures": {
574 |             "1": {
575 |               "name": "keyword.control.$1.directive.vim-snippet"
576 |             }
577 |           },
578 |           "patterns": [
579 |             {
580 |               "name": "string.quoted.double.python-code.vim-snippet",
581 |               "match": "(\")([^\"]*)(\")",
582 |               "captures": {
583 |                 "1": {
584 |                   "name": "punctuation.definition.string.begin.vim-snippet"
585 |                 },
586 |                 "2": {
587 |                   "patterns": [
588 |                     {
589 |                       "include": "source.python"
590 |                     }
591 |                   ]
592 |                 },
593 |                 "3": {
594 |                   "name": "punctuation.definition.string.end.vim-snippet"
595 |                 }
596 |               }
597 |             }
598 |           ]
599 |         }
600 |       ]
601 |     },
602 |     "version": {
603 |       "match": "^(version)\\s+(\\d)",
604 |       "captures": {
605 |         "1": {
606 |           "name": "keyword.control.version.directive.vim-snippet"
607 |         },
608 |         "2": {
609 |           "name": "constant.numeric.integer.int.vim-snippet"
610 |         }
611 |       }
612 |     },
613 |     "visual": {
614 |       "patterns": [
615 |         {
616 |           "name": "constant.language.visual-content.unbraced.vim-snippet",
617 |           "match": "(\\$)VISUAL",
618 |           "captures": {
619 |             "1": {
620 |               "name": "punctuation.definition.vim-snippet"
621 |             }
622 |           }
623 |         },
624 |         {
625 |           "name": "constant.language.visual-content.braced.vim-snippet",
626 |           "match": "(\\${)VISUAL(})",
627 |           "captures": {
628 |             "1": {
629 |               "name": "punctuation.definition.begin.vim-snippet"
630 |             },
631 |             "2": {
632 |               "name": "punctuation.definition.end.vim-snippet"
633 |             }
634 |           }
635 |         },
636 |         {
637 |           "name": "constant.language.visual-content.v0-syntax.vim-snippet",
638 |           "match": "({)VISUAL(})",
639 |           "captures": {
640 |             "1": {
641 |               "name": "punctuation.definition.begin.vim-snippet"
642 |             },
643 |             "2": {
644 |               "name": "punctuation.definition.end.vim-snippet"
645 |             }
646 |           }
647 |         }
648 |       ]
649 |     }
650 |   }
651 | }


--------------------------------------------------------------------------------
/syntaxes/viml.language-configuration.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "comments": {
 3 |     "lineComment": "\"",
 4 |   },
 5 |   "brackets": [
 6 |     [ "{", "}" ],
 7 |     [ "[", "]" ],
 8 |     [ "(", ")" ],
 9 |     [ "<", ">" ]
10 |   ],
11 |   "autoClosingPairs": [
12 |     [ "{", "}" ],
13 |     [ "[", "]" ],
14 |     [ "(", ")" ],
15 |     [ "'", "'" ]
16 |   ],
17 |   "surroundingPairs": [
18 |     [ "{", "}" ],
19 |     [ "[", "]" ],
20 |     [ "(", ")" ],
21 |     [ "'", "'" ],
22 |     [ "\"", "\"" ],
23 |     [ "<", ">" ]
24 |   ],
25 |   "indentationRules": {
26 |     "increaseIndentPattern": "(?:^|\\s)(?:if|else|elseif|for|function!?|fu|fun|func|augroup|aug|try|catch|while)(?:\\s|$)",
27 |     "decreaseIndentPattern": "(?:^|\\s)(?:endif|endfor|endf|endfun|endfunction|endtry|endwhile|(?:augroup|aug)\\.END)(?:\\s|$)"
28 |   }
29 | }
30 | 


--------------------------------------------------------------------------------
/syntaxes/viml.tmLanguage.json:
--------------------------------------------------------------------------------
   1 | {
   2 |   "information_for_contributors": [
   3 |     "This file has been converted from https://github.com/Alhadis/language-viml/blob/master/grammars/viml.cson",
   4 |     "If you want to provide a fix or improvement, please create a pull request against the original repository.",
   5 |     "Once accepted there, we are happy to receive an update request."
   6 |   ],
   7 |   "version": "https://github.com/Alhadis/language-viml/commit/5030985ab9f5a84a3a18d999d7c3a82f581b0283",
   8 |   "name": "VimL",
   9 |   "scopeName": "source.viml",
  10 |   "patterns": [
  11 |     {
  12 |       "name": "meta.file-archive.vimball",
  13 |       "begin": "\\A(?=\" Vimball Archiver)",
  14 |       "end": "(?=A)B",
  15 |       "patterns": [
  16 |         {
  17 |           "name": "meta.file-record.help-file.vimball",
  18 |           "begin": "^(.*?\\S.*?\\.txt)(\\t)(\\[{3}1)(?=$)",
  19 |           "end": "(?!\\G)(?=^.*?\\S.*?\\t\\[{3}1$)",
  20 |           "beginCaptures": {
  21 |             "0": {
  22 |               "name": "markup.heading.1.vimball"
  23 |             },
  24 |             "1": {
  25 |               "name": "entity.name.file.path.vimball"
  26 |             },
  27 |             "2": {
  28 |               "name": "punctuation.whitespace.tab.separator.vimball"
  29 |             },
  30 |             "3": {
  31 |               "name": "punctuation.definition.header.vimball"
  32 |             }
  33 |           },
  34 |           "contentName": "text.embedded.vim-help",
  35 |           "patterns": [
  36 |             {
  37 |               "begin": "\\G",
  38 |               "end": "^(\\d+$)?",
  39 |               "endCaptures": {
  40 |                 "0": {
  41 |                   "name": "comment.ignored.line-count.viml"
  42 |                 },
  43 |                 "1": {
  44 |                   "name": "sublimelinter.gutter-mark"
  45 |                 }
  46 |               }
  47 |             },
  48 |             {
  49 |               "include": "text.vim-help"
  50 |             }
  51 |           ]
  52 |         },
  53 |         {
  54 |           "name": "meta.file-record.vimball.viml",
  55 |           "begin": "^(.*?\\S.*?[ \\t]*?)(\\t)(\\[{3}1)(?=$)",
  56 |           "end": "(?!\\G)(?=^.*?\\S.*?\\t\\[{3}1$)",
  57 |           "beginCaptures": {
  58 |             "0": {
  59 |               "name": "markup.heading.1.vimball"
  60 |             },
  61 |             "1": {
  62 |               "name": "entity.name.file.path.vimball"
  63 |             },
  64 |             "2": {
  65 |               "name": "punctuation.whitespace.tab.separator.vimball"
  66 |             },
  67 |             "3": {
  68 |               "name": "punctuation.definition.header.vimball"
  69 |             }
  70 |           },
  71 |           "patterns": [
  72 |             {
  73 |               "begin": "\\G",
  74 |               "end": "^(\\d+$)?",
  75 |               "endCaptures": {
  76 |                 "0": {
  77 |                   "name": "comment.ignored.line-count.viml"
  78 |                 },
  79 |                 "1": {
  80 |                   "name": "sublimelinter.gutter-mark"
  81 |                 }
  82 |               }
  83 |             },
  84 |             {
  85 |               "include": "#main"
  86 |             }
  87 |           ]
  88 |         },
  89 |         {
  90 |           "include": "#main"
  91 |         }
  92 |       ]
  93 |     },
  94 |     {
  95 |       "include": "#main"
  96 |     }
  97 |   ],
  98 |   "repository": {
  99 |     "main": {
 100 |       "patterns": [
 101 |         {
 102 |           "include": "#vimTodo"
 103 |         },
 104 |         {
 105 |           "include": "#comments"
 106 |         },
 107 |         {
 108 |           "include": "#modelines"
 109 |         },
 110 |         {
 111 |           "include": "#pathname"
 112 |         },
 113 |         {
 114 |           "include": "#escape"
 115 |         },
 116 |         {
 117 |           "include": "#strings"
 118 |         },
 119 |         {
 120 |           "include": "#hashbang"
 121 |         },
 122 |         {
 123 |           "include": "#numbers"
 124 |         },
 125 |         {
 126 |           "include": "#syntax"
 127 |         },
 128 |         {
 129 |           "include": "#highlightLink"
 130 |         },
 131 |         {
 132 |           "include": "#funcDef"
 133 |         },
 134 |         {
 135 |           "include": "#auCmd"
 136 |         },
 137 |         {
 138 |           "include": "#auGroup"
 139 |         },
 140 |         {
 141 |           "include": "#parameter"
 142 |         },
 143 |         {
 144 |           "include": "#assignment"
 145 |         },
 146 |         {
 147 |           "include": "#expr"
 148 |         },
 149 |         {
 150 |           "include": "#keyword"
 151 |         },
 152 |         {
 153 |           "include": "#register"
 154 |         },
 155 |         {
 156 |           "include": "#filetype"
 157 |         },
 158 |         {
 159 |           "include": "#variable"
 160 |         },
 161 |         {
 162 |           "include": "#supportType"
 163 |         },
 164 |         {
 165 |           "include": "#supportVariable"
 166 |         },
 167 |         {
 168 |           "include": "#extraVimOptions"
 169 |         },
 170 |         {
 171 |           "include": "#extraVimFunc"
 172 |         },
 173 |         {
 174 |           "include": "#keywordLists"
 175 |         }
 176 |       ]
 177 |     },
 178 |     "strings": {
 179 |       "patterns": [
 180 |         {
 181 |           "name": "string.quoted.double.empty.viml",
 182 |           "match": "(\")(\")",
 183 |           "captures": {
 184 |             "1": {
 185 |               "name": "punctuation.definition.string.begin.viml"
 186 |             },
 187 |             "2": {
 188 |               "name": "punctuation.definition.string.end.viml"
 189 |             }
 190 |           }
 191 |         },
 192 |         {
 193 |           "name": "string.quoted.single.empty.viml",
 194 |           "match": "(')(')",
 195 |           "captures": {
 196 |             "1": {
 197 |               "name": "punctuation.definition.string.begin.viml"
 198 |             },
 199 |             "2": {
 200 |               "name": "punctuation.definition.string.end.viml"
 201 |             }
 202 |           }
 203 |         },
 204 |         {
 205 |           "name": "string.quoted.double.viml",
 206 |           "match": "(\")((?:[^\\\\\"]|\\\\.)*)(\")",
 207 |           "captures": {
 208 |             "1": {
 209 |               "name": "punctuation.definition.string.begin.viml"
 210 |             },
 211 |             "2": {
 212 |               "patterns": [
 213 |                 {
 214 |                   "include": "#escape"
 215 |                 }
 216 |               ]
 217 |             },
 218 |             "3": {
 219 |               "name": "punctuation.definition.string.end.viml"
 220 |             }
 221 |           }
 222 |         },
 223 |         {
 224 |           "name": "string.quoted.single.viml",
 225 |           "match": "(')((?:[^']|'')*)(')",
 226 |           "captures": {
 227 |             "1": {
 228 |               "name": "punctuation.definition.string.begin.viml"
 229 |             },
 230 |             "2": {
 231 |               "patterns": [
 232 |                 {
 233 |                   "name": "constant.character.escape.quotes.viml",
 234 |                   "match": "''"
 235 |                 }
 236 |               ]
 237 |             },
 238 |             "3": {
 239 |               "name": "punctuation.definition.string.end.viml"
 240 |             }
 241 |           }
 242 |         },
 243 |         {
 244 |           "name": "string.regexp.interpolated.viml",
 245 |           "match": "(/)(?:\\\\\\\\|\\\\/|[^\\n/])*(/)",
 246 |           "captures": {
 247 |             "1": {
 248 |               "name": "punctuation.section.regexp.begin.viml"
 249 |             },
 250 |             "2": {
 251 |               "name": "punctuation.section.regexp.end.viml"
 252 |             }
 253 |           }
 254 |         }
 255 |       ]
 256 |     },
 257 |     "escape": {
 258 |       "patterns": [
 259 |         {
 260 |           "include": "#escapedCodePoint"
 261 |         },
 262 |         {
 263 |           "include": "#escapedKey"
 264 |         },
 265 |         {
 266 |           "match": "(\\\\)b",
 267 |           "name": "constant.character.escape.backspace.viml",
 268 |           "captures": {
 269 |             "1": {
 270 |               "name": "punctuation.definition.escape.viml"
 271 |             }
 272 |           }
 273 |         },
 274 |         {
 275 |           "match": "(\\\\)e",
 276 |           "name": "constant.character.escape.escape.viml",
 277 |           "captures": {
 278 |             "1": {
 279 |               "name": "punctuation.definition.escape.viml"
 280 |             }
 281 |           }
 282 |         },
 283 |         {
 284 |           "match": "(\\\\)f",
 285 |           "name": "constant.character.escape.form-feed.viml",
 286 |           "captures": {
 287 |             "1": {
 288 |               "name": "punctuation.definition.escape.viml"
 289 |             }
 290 |           }
 291 |         },
 292 |         {
 293 |           "match": "(\\\\)n",
 294 |           "name": "constant.character.escape.newline.viml",
 295 |           "captures": {
 296 |             "1": {
 297 |               "name": "punctuation.definition.escape.viml"
 298 |             }
 299 |           }
 300 |         },
 301 |         {
 302 |           "match": "(\\\\)r",
 303 |           "name": "constant.character.escape.return.viml",
 304 |           "captures": {
 305 |             "1": {
 306 |               "name": "punctuation.definition.escape.viml"
 307 |             }
 308 |           }
 309 |         },
 310 |         {
 311 |           "match": "(\\\\)t",
 312 |           "name": "constant.character.escape.tab.viml",
 313 |           "captures": {
 314 |             "1": {
 315 |               "name": "punctuation.definition.escape.viml"
 316 |             }
 317 |           }
 318 |         },
 319 |         {
 320 |           "match": "(\\\\)\\1",
 321 |           "name": "constant.character.escape.backslash.viml",
 322 |           "captures": {
 323 |             "1": {
 324 |               "name": "punctuation.definition.escape.viml"
 325 |             }
 326 |           }
 327 |         },
 328 |         {
 329 |           "match": "(\\\\)\"",
 330 |           "name": "constant.character.escape.quote.viml",
 331 |           "captures": {
 332 |             "1": {
 333 |               "name": "punctuation.definition.escape.viml"
 334 |             }
 335 |           }
 336 |         },
 337 |         {
 338 |           "match": "(\\\\).",
 339 |           "name": "constant.character.escape.other.viml",
 340 |           "captures": {
 341 |             "1": {
 342 |               "name": "punctuation.definition.escape.viml"
 343 |             }
 344 |           }
 345 |         }
 346 |       ]
 347 |     },
 348 |     "escapedCodePoint": {
 349 |       "patterns": [
 350 |         {
 351 |           "name": "constant.character.escape.codepoint.hex.short.viml",
 352 |           "match": "(\\\\)[xX][0-9A-Fa-f]{1,2}",
 353 |           "captures": {
 354 |             "1": {
 355 |               "name": "punctuation.definition.escape.backslash.viml"
 356 |             }
 357 |           }
 358 |         },
 359 |         {
 360 |           "name": "constant.character.escape.codepoint.hex.long.viml",
 361 |           "match": "(\\\\)(?:u[0-9A-Fa-f]{1,4}|U[0-9A-Fa-f]{1,8})",
 362 |           "captures": {
 363 |             "1": {
 364 |               "name": "punctuation.definition.escape.backslash.viml"
 365 |             }
 366 |           }
 367 |         },
 368 |         {
 369 |           "name": "constant.character.escape.codepoint.octal.viml",
 370 |           "match": "(\\\\)([0-7]{1,3})",
 371 |           "captures": {
 372 |             "1": {
 373 |               "name": "punctuation.definition.escape.backslash.viml"
 374 |             }
 375 |           }
 376 |         }
 377 |       ]
 378 |     },
 379 |     "escapedKey": {
 380 |       "name": "constant.character.escape.keymapping.viml",
 381 |       "match": "(\\\\<\\*?)(?:[^\">\\\\]|\\\\.)+(>)",
 382 |       "captures": {
 383 |         "1": {
 384 |           "name": "punctuation.definition.escape.key.begin.viml"
 385 |         },
 386 |         "2": {
 387 |           "name": "punctuation.definition.escape.key.end.viml"
 388 |         }
 389 |       }
 390 |     },
 391 |     "pathname": {
 392 |       "name": "constant.pathname.viml",
 393 |       "begin": "~/",
 394 |       "end": "(?=\\s)"
 395 |     },
 396 |     "comments": {
 397 |       "patterns": [
 398 |         {
 399 |           "name": "comment.line.quotes.viml",
 400 |           "begin": "^\\s*(\")(?=(\\s*[A-Z]\\w+)+:)",
 401 |           "end": "((:))(.*)$",
 402 |           "contentName": "support.constant.field.viml",
 403 |           "beginCaptures": {
 404 |             "1": {
 405 |               "name": "punctuation.definition.comment.viml"
 406 |             }
 407 |           },
 408 |           "endCaptures": {
 409 |             "1": {
 410 |               "name": "support.constant.field.viml"
 411 |             },
 412 |             "2": {
 413 |               "name": "punctuation.separator.key-value.colon.viml"
 414 |             },
 415 |             "3": {
 416 |               "patterns": [
 417 |                 {
 418 |                   "include": "#commentInnards"
 419 |                 }
 420 |               ]
 421 |             }
 422 |           }
 423 |         },
 424 |         {
 425 |           "name": "comment.line.quotes.viml",
 426 |           "begin": "^\\s*(\")",
 427 |           "end": "$",
 428 |           "beginCaptures": {
 429 |             "1": {
 430 |               "name": "punctuation.definition.comment.viml"
 431 |             }
 432 |           },
 433 |           "patterns": [
 434 |             {
 435 |               "include": "#commentInnards"
 436 |             }
 437 |           ]
 438 |         },
 439 |         {
 440 |           "name": "comment.inline.quotes.viml",
 441 |           "patterns": [
 442 |             {
 443 |               "include": "#commentInnards"
 444 |             }
 445 |           ],
 446 |           "begin": "(?<!^)\\s*(\")(?=[^\\n\"]*$)",
 447 |           "end": "$",
 448 |           "beginCaptures": {
 449 |             "1": {
 450 |               "name": "punctuation.definition.comment.viml"
 451 |             }
 452 |           }
 453 |         }
 454 |       ]
 455 |     },
 456 |     "commentInnards": {
 457 |       "patterns": [
 458 |         {
 459 |           "include": "#modelines"
 460 |         },
 461 |         {
 462 |           "include": "#todo"
 463 |         }
 464 |       ]
 465 |     },
 466 |     "modelines": {
 467 |       "patterns": [
 468 |         {
 469 |           "name": "string.other.modeline.viml",
 470 |           "patterns": [
 471 |             {
 472 |               "include": "#main"
 473 |             }
 474 |           ],
 475 |           "begin": "(?:(?:\\s|^)vi(?:m[<=>]?\\d+|m)?|[\\t\\x20]ex):\\s*(?=set?\\s)",
 476 |           "end": ":|$"
 477 |         },
 478 |         {
 479 |           "name": "string.other.modeline.viml",
 480 |           "patterns": [
 481 |             {
 482 |               "include": "#main"
 483 |             }
 484 |           ],
 485 |           "begin": "(?:(?:\\s|^)vi(?:m[<=>]?\\d+|m)?|[\\t\\x20]ex):",
 486 |           "end": "$"
 487 |         }
 488 |       ]
 489 |     },
 490 |     "hashbang": {
 491 |       "name": "comment.line.shebang.viml",
 492 |       "begin": "\\A#!",
 493 |       "end": "$",
 494 |       "beginCaptures": {
 495 |         "0": {
 496 |           "name": "punctuation.definition.comment.shebang.viml"
 497 |         }
 498 |       }
 499 |     },
 500 |     "numbers": {
 501 |       "patterns": [
 502 |         {
 503 |           "name": "constant.numeric.hex.short.viml",
 504 |           "match": "0[xX][0-9A-Fa-f]+"
 505 |         },
 506 |         {
 507 |           "name": "constant.numeric.hex.long.viml",
 508 |           "match": "0[zZ][0-9A-Fa-f]+"
 509 |         },
 510 |         {
 511 |           "name": "constant.numeric.float.exponential.viml",
 512 |           "match": "(?<!\\w)-?\\d+\\.\\d+[eE][-+]?\\d+"
 513 |         },
 514 |         {
 515 |           "name": "constant.numeric.float.viml",
 516 |           "match": "(?<!\\w)-?\\d+\\.\\d+"
 517 |         },
 518 |         {
 519 |           "name": "constant.numeric.integer.viml",
 520 |           "match": "(?<!\\w)-?\\d+"
 521 |         }
 522 |       ]
 523 |     },
 524 |     "funcDef": {
 525 |       "patterns": [
 526 |         {
 527 |           "name": "storage.function.viml",
 528 |           "match": "\\b(fu(nc?|nction)?|end(f|fu|func?|function)?)\\b"
 529 |         },
 530 |         {
 531 |           "name": "entity.name.function.viml",
 532 |           "match": "(?:([sSgGbBwWtTlL]?(:))?[\\w#]+)(?=\\()",
 533 |           "captures": {
 534 |             "1": {
 535 |               "name": "storage.modifier.scope.viml"
 536 |             },
 537 |             "2": {
 538 |               "name": "punctuation.definition.scope.key-value.viml"
 539 |             }
 540 |           }
 541 |         },
 542 |         {
 543 |           "name": "storage.modifier.$1.function.viml",
 544 |           "match": "(?<=\\)|\\s)(abort|dict|closure|range)(?=\\s|$)"
 545 |         }
 546 |       ]
 547 |     },
 548 |     "auCmd": {
 549 |       "name": "meta.autocmd.viml",
 550 |       "match": "\\b(autocmd|au)(!)?\\b\\s+(?!\\*)(\\S+)\\s+(\\S+)(?:\\s+(\\+\\+(nested|once)))?",
 551 |       "captures": {
 552 |         "1": {
 553 |           "name": "storage.type.autocmd.viml"
 554 |         },
 555 |         "2": {
 556 |           "name": "storage.modifier.force.viml"
 557 |         },
 558 |         "3": {
 559 |           "name": "meta.events-list.viml",
 560 |           "patterns": [
 561 |             {
 562 |               "include": "#main"
 563 |             }
 564 |           ]
 565 |         },
 566 |         "4": {
 567 |           "name": "string.unquoted.autocmd-suffix-list.viml"
 568 |         },
 569 |         "5": {
 570 |           "name": "storage.modifier.$6.viml"
 571 |         }
 572 |       }
 573 |     },
 574 |     "auGroup": {
 575 |       "patterns": [
 576 |         {
 577 |           "name": "meta.augroup.viml",
 578 |           "begin": "\\b(augroup|aug)(!)?\\b\\s*([\\w#]+)",
 579 |           "end": "\\b(\\1)\\s+(END)\\b",
 580 |           "patterns": [
 581 |             {
 582 |               "include": "#main"
 583 |             }
 584 |           ],
 585 |           "beginCaptures": {
 586 |             "1": {
 587 |               "name": "storage.type.function.viml"
 588 |             },
 589 |             "2": {
 590 |               "name": "storage.modifier.force.viml"
 591 |             },
 592 |             "3": {
 593 |               "name": "entity.name.function.viml"
 594 |             }
 595 |           },
 596 |           "endCaptures": {
 597 |             "1": {
 598 |               "name": "storage.type.augroup.viml"
 599 |             },
 600 |             "2": {
 601 |               "name": "keyword.control.end"
 602 |             }
 603 |           }
 604 |         }
 605 |       ]
 606 |     },
 607 |     "parameter": {
 608 |       "name": "meta.parameter.viml",
 609 |       "match": "(-)(\\w+)(=)",
 610 |       "captures": {
 611 |         "1": {
 612 |           "name": "punctuation.definition.parameter.viml"
 613 |         },
 614 |         "2": {
 615 |           "name": "entity.name.parameter.viml"
 616 |         },
 617 |         "3": {
 618 |           "name": "punctuation.assignment.parameter.viml"
 619 |         }
 620 |       }
 621 |     },
 622 |     "assignment": {
 623 |       "patterns": [
 624 |         {
 625 |           "name": "keyword.operator.assignment.compound.viml",
 626 |           "match": "[-+.]="
 627 |         },
 628 |         {
 629 |           "name": "keyword.operator.assignment.viml",
 630 |           "match": "="
 631 |         }
 632 |       ]
 633 |     },
 634 |     "expr": {
 635 |       "patterns": [
 636 |         {
 637 |           "name": "keyword.operator.logical.viml",
 638 |           "match": "[&|=]{2}[?#]?|[!><]=[#?]?|[=!]~(?!\\/)[#?]?|[><][#?*]|\\b(?:isnot|is)\\b|\\\\|[-+%*]"
 639 |         },
 640 |         {
 641 |           "match": "\\s[><]\\s",
 642 |           "name": "keyword.operator.logical.viml"
 643 |         },
 644 |         {
 645 |           "match": "(?<=\\S)!",
 646 |           "name": "storage.modifier.force.viml"
 647 |         },
 648 |         {
 649 |           "match": "!(?=\\S)",
 650 |           "name": "keyword.operator.logical.not.viml"
 651 |         },
 652 |         {
 653 |           "match": "{",
 654 |           "name": "punctuation.expression.bracket.curly.begin.viml"
 655 |         },
 656 |         {
 657 |           "match": "}",
 658 |           "name": "punctuation.expression.bracket.curly.end.viml"
 659 |         },
 660 |         {
 661 |           "match": "\\[",
 662 |           "name": "punctuation.expression.bracket.square.begin.viml"
 663 |         },
 664 |         {
 665 |           "match": "\\]",
 666 |           "name": "punctuation.expression.bracket.square.end.viml"
 667 |         },
 668 |         {
 669 |           "match": "\\(",
 670 |           "name": "punctuation.expression.bracket.round.begin.viml"
 671 |         },
 672 |         {
 673 |           "match": "\\)",
 674 |           "name": "punctuation.expression.bracket.round.end.viml"
 675 |         },
 676 |         {
 677 |           "match": "\\|",
 678 |           "name": "punctuation.separator.statement.viml"
 679 |         },
 680 |         {
 681 |           "match": ",",
 682 |           "name": "punctuation.separator.comma.viml"
 683 |         },
 684 |         {
 685 |           "match": ":",
 686 |           "name": "punctuation.separator.colon.viml"
 687 |         },
 688 |         {
 689 |           "match": "\\.{3}",
 690 |           "name": "keyword.operator.rest.viml"
 691 |         },
 692 |         {
 693 |           "match": "\\.",
 694 |           "name": "punctuation.delimiter.property.dot.viml"
 695 |         },
 696 |         {
 697 |           "match": "&(?=\\w+)",
 698 |           "name": "punctuation.definition.option.viml"
 699 |         }
 700 |       ]
 701 |     },
 702 |     "keyword": {
 703 |       "patterns": [
 704 |         {
 705 |           "name": "keyword.control.$1.viml",
 706 |           "match": "\\b(if|while|for|return|try|catch|finally|finish|end(if|for|while|try)?|else(if)?|do|in|:)\\b"
 707 |         },
 708 |         {
 709 |           "name": "keyword.operator.$1.viml",
 710 |           "match": "\\b(unlet)\\b"
 711 |         },
 712 |         {
 713 |           "name": "storage.type.let.viml",
 714 |           "match": "\\blet\\b"
 715 |         },
 716 |         {
 717 |           "name": "support.constant.vimball.use.viml",
 718 |           "match": "(?<=^|\\n)UseVimball(?=\\s*$)"
 719 |         }
 720 |       ]
 721 |     },
 722 |     "register": {
 723 |       "name": "variable.other.register.viml",
 724 |       "match": "(@)([-\"A-Za-z\\d:.%#=*+~_/])",
 725 |       "captures": {
 726 |         "1": {
 727 |           "name": "punctuation.definition.register.viml"
 728 |         }
 729 |       }
 730 |     },
 731 |     "variable": {
 732 |       "patterns": [
 733 |         {
 734 |           "name": "variable.language.self.viml",
 735 |           "match": "\\b(self)\\b"
 736 |         },
 737 |         {
 738 |           "name": "support.variable.environment.viml",
 739 |           "match": "(\\$)\\w+",
 740 |           "captures": {
 741 |             "1": {
 742 |               "name": "punctuation.definition.variable.viml"
 743 |             }
 744 |           }
 745 |         },
 746 |         {
 747 |           "name": "variable.other.viml",
 748 |           "match": "(&?)(?:([sSgGbBwWlLaAvV](:))|[@$]|&(?!&))\\w*",
 749 |           "captures": {
 750 |             "1": {
 751 |               "name": "punctuation.definition.reference.viml"
 752 |             },
 753 |             "2": {
 754 |               "name": "storage.modifier.scope.viml"
 755 |             },
 756 |             "3": {
 757 |               "name": "punctuation.definition.scope.key-value.viml"
 758 |             }
 759 |           }
 760 |         }
 761 |       ]
 762 |     },
 763 |     "supportType": {
 764 |       "name": "entity.tag.name.viml",
 765 |       "match": "(<).*?(>)",
 766 |       "captures": {
 767 |         "1": {
 768 |           "name": "punctuation.definition.bracket.angle.begin.viml"
 769 |         },
 770 |         "2": {
 771 |           "name": "punctuation.definition.bracket.angle.end.viml"
 772 |         }
 773 |       }
 774 |     },
 775 |     "supportVariable": {
 776 |       "name": "support.variable.viml",
 777 |       "match": "\\b(?:am(?:enu)?|(?:hl|inc)?search|[Bb]uf(?:[Nn]ew[Ff]ile|[Rr]ead)?|[Ff]ile[Tt]ype)\\b"
 778 |     },
 779 |     "highlightLink": {
 780 |       "match": "(?x)^\\s* (:)? \\s*              (?# 1: punctuation.separator.key-value.colon.viml) (hi|highlight)         (?# 2: support.function.highlight.viml) (!)?                   (?# 3: storage.modifier.force.viml) (?:\\s+(def|default))? (?# 4: support.function.highlight-default.viml) (?:\\s+(link))         (?# 5: support.function.highlight-link.viml) (?:\\s+([-\\w]+))      (?# 6: variable.parameter.group-name.viml) (?:\\s+(?:(NONE)|([-\\w]+)))?",
 781 |       "captures": {
 782 |         "1": {
 783 |           "name": "punctuation.separator.key-value.colon.viml"
 784 |         },
 785 |         "2": {
 786 |           "name": "support.function.highlight.viml"
 787 |         },
 788 |         "3": {
 789 |           "name": "storage.modifier.force.viml"
 790 |         },
 791 |         "4": {
 792 |           "name": "support.function.highlight-default.viml"
 793 |         },
 794 |         "5": {
 795 |           "name": "support.function.highlight-link.viml"
 796 |         },
 797 |         "6": {
 798 |           "name": "variable.parameter.group-name.viml"
 799 |         },
 800 |         "7": {
 801 |           "name": "support.constant.highlighting.viml"
 802 |         },
 803 |         "8": {
 804 |           "name": "variable.parameter.group-name.viml"
 805 |         }
 806 |       }
 807 |     },
 808 |     "filetype": {
 809 |       "match": "\\b(?:(setf|setfiletype)(?:\\s+(FALLBACK))?\\s+|(ft|filetype)\\s*(=))([.\\w]+)",
 810 |       "captures": {
 811 |         "1": {
 812 |           "name": "support.function.command.viml"
 813 |         },
 814 |         "2": {
 815 |           "name": "support.variable.option.viml"
 816 |         },
 817 |         "3": {
 818 |           "name": "storage.modifier.fallback.viml"
 819 |         },
 820 |         "4": {
 821 |           "name": "keyword.operator.assignment.viml"
 822 |         },
 823 |         "5": {
 824 |           "name": "variable.parameter.function.filetype.viml"
 825 |         }
 826 |       }
 827 |     },
 828 |     "syntax": {
 829 |       "name": "meta.syntax-item.viml",
 830 |       "begin": "^\\s*(:)?(?:(VimFold\\w)\\s+)?\\s*(syntax|syn?)(?=\\s|$)",
 831 |       "end": "$",
 832 |       "beginCaptures": {
 833 |         "1": {
 834 |           "name": "punctuation.separator.key-value.colon.viml"
 835 |         },
 836 |         "2": {
 837 |           "name": "support.function.fold-command.viml"
 838 |         },
 839 |         "3": {
 840 |           "name": "storage.type.syntax-item.viml"
 841 |         }
 842 |       },
 843 |       "patterns": [
 844 |         {
 845 |           "match": "\\G\\s+(case)(?:\\s+(match|ignore))?(?=\\s|$)",
 846 |           "captures": {
 847 |             "1": {
 848 |               "name": "support.function.syntax-case.viml"
 849 |             },
 850 |             "2": {
 851 |               "name": "support.constant.$2-case.viml"
 852 |             }
 853 |           }
 854 |         },
 855 |         {
 856 |           "match": "\\G\\s+(spell)(?:\\s+(toplevel|notoplevel|default))?(?=\\s|$)",
 857 |           "captures": {
 858 |             "1": {
 859 |               "name": "support.function.syntax-spellcheck.viml"
 860 |             },
 861 |             "2": {
 862 |               "name": "support.constant.$2-checking.viml"
 863 |             }
 864 |           }
 865 |         },
 866 |         {
 867 |           "begin": "\\G\\s+(keyword)(?:\\s+([-\\w]+))?",
 868 |           "end": "(?=$)",
 869 |           "beginCaptures": {
 870 |             "1": {
 871 |               "name": "support.function.syntax-keywords.viml"
 872 |             },
 873 |             "2": {
 874 |               "name": "variable.parameter.group-name.viml"
 875 |             }
 876 |           },
 877 |           "contentName": "keyword.other.syntax-definition.viml",
 878 |           "patterns": [
 879 |             {
 880 |               "include": "#syntaxOptions"
 881 |             },
 882 |             {
 883 |               "include": "#assignment"
 884 |             },
 885 |             {
 886 |               "include": "#expr"
 887 |             }
 888 |           ]
 889 |         },
 890 |         {
 891 |           "begin": "\\G\\s+(match)(?:\\s+([-\\w]+))?\\s*",
 892 |           "end": "(?=$)",
 893 |           "beginCaptures": {
 894 |             "1": {
 895 |               "name": "support.function.syntax-match.viml"
 896 |             },
 897 |             "2": {
 898 |               "name": "variable.parameter.group-name.viml"
 899 |             }
 900 |           },
 901 |           "patterns": [
 902 |             {
 903 |               "include": "#syntaxRegex"
 904 |             }
 905 |           ]
 906 |         },
 907 |         {
 908 |           "begin": "\\G\\s+(region)(?:\\s+([-\\w]+))?",
 909 |           "end": "(?=$)",
 910 |           "beginCaptures": {
 911 |             "1": {
 912 |               "name": "support.function.syntax-region.viml"
 913 |             },
 914 |             "2": {
 915 |               "name": "variable.parameter.group-name.viml"
 916 |             }
 917 |           },
 918 |           "patterns": [
 919 |             {
 920 |               "include": "#syntaxOptions"
 921 |             },
 922 |             {
 923 |               "include": "#main"
 924 |             }
 925 |           ]
 926 |         },
 927 |         {
 928 |           "begin": "\\G\\s+(cluster)(?:\\s+([-\\w]+))?(?=\\s|$)",
 929 |           "end": "(?=$)",
 930 |           "beginCaptures": {
 931 |             "1": {
 932 |               "name": "support.function.syntax-cluster.viml"
 933 |             },
 934 |             "2": {
 935 |               "name": "variable.parameter.group-name.viml"
 936 |             }
 937 |           },
 938 |           "patterns": [
 939 |             {
 940 |               "include": "#syntaxOptions"
 941 |             },
 942 |             {
 943 |               "include": "#main"
 944 |             }
 945 |           ]
 946 |         },
 947 |         {
 948 |           "match": "\\G\\s+(conceal)(?:\\s+(on|off)(?=\\s|$))?",
 949 |           "captures": {
 950 |             "1": {
 951 |               "name": "support.function.syntax-conceal.viml"
 952 |             },
 953 |             "2": {
 954 |               "name": "support.constant.boolean.$2.viml"
 955 |             }
 956 |           }
 957 |         },
 958 |         {
 959 |           "match": "\\G\\s+(include)(?:\\s+((@)?[-\\w]+))?(?:\\s+(\\S+))?",
 960 |           "captures": {
 961 |             "1": {
 962 |               "name": "support.function.syntax-include.viml"
 963 |             },
 964 |             "2": {
 965 |               "name": "variable.parameter.group-name.viml"
 966 |             },
 967 |             "3": {
 968 |               "name": "punctuation.definition.group-reference.viml"
 969 |             },
 970 |             "4": {
 971 |               "name": "string.unquoted.filename.viml",
 972 |               "patterns": [
 973 |                 {
 974 |                   "include": "#supportType"
 975 |                 }
 976 |               ]
 977 |             }
 978 |           }
 979 |         },
 980 |         {
 981 |           "begin": "\\G\\s+(sync)(?=\\s|$)",
 982 |           "end": "$",
 983 |           "beginCaptures": {
 984 |             "1": {
 985 |               "name": "support.function.syntax-sync.viml"
 986 |             }
 987 |           },
 988 |           "patterns": [
 989 |             {
 990 |               "match": "\\G\\s+(fromstart)(?=\\s|$)",
 991 |               "captures": {
 992 |                 "1": {
 993 |                   "name": "support.constant.sync-$1.viml"
 994 |                 }
 995 |               }
 996 |             },
 997 |             {
 998 |               "match": "\\G\\s+(ccomment|clear)(?:\\s+(?![-\\w]+\\s*=)([-\\w]+))?",
 999 |               "captures": {
1000 |                 "1": {
1001 |                   "name": "support.constant.sync-$1.viml"
1002 |                 },
1003 |                 "2": {
1004 |                   "name": "variable.parameter.group-name.viml"
1005 |                 }
1006 |               }
1007 |             },
1008 |             {
1009 |               "match": "\\G\\s+(minlines|lines)\\s*(=)(\\d*)",
1010 |               "captures": {
1011 |                 "1": {
1012 |                   "name": "support.constant.sync-mode.viml"
1013 |                 },
1014 |                 "2": {
1015 |                   "name": "punctuation.assignment.parameter.viml"
1016 |                 },
1017 |                 "3": {
1018 |                   "name": "constant.numeric.integer.viml"
1019 |                 }
1020 |               }
1021 |             },
1022 |             {
1023 |               "match": "(?x)\\G\\s+(match|region)(?:\\s+(?![-\\w]+\\s*=)([-\\w]+))?",
1024 |               "captures": {
1025 |                 "1": {
1026 |                   "name": "support.constant.sync-mode.viml"
1027 |                 },
1028 |                 "2": {
1029 |                   "name": "variable.parameter.group-name.viml"
1030 |                 },
1031 |                 "3": {
1032 |                   "name": "support.constant.sync-mode-location.viml"
1033 |                 }
1034 |               }
1035 |             },
1036 |             {
1037 |               "begin": "(?<=\\s)(groupt?here|linecont)(?:\\s+(?![-\\w]+\\s*=)([-\\w]+))?(?=\\s|$)",
1038 |               "end": "(?=$)",
1039 |               "beginCaptures": {
1040 |                 "1": {
1041 |                   "name": "support.constant.sync-match.viml"
1042 |                 },
1043 |                 "2": {
1044 |                   "name": "variable.parameter.group-name.viml"
1045 |                 }
1046 |               },
1047 |               "patterns": [
1048 |                 {
1049 |                   "include": "#syntaxRegex"
1050 |                 }
1051 |               ]
1052 |             },
1053 |             {
1054 |               "include": "#syntaxOptions"
1055 |             }
1056 |           ]
1057 |         },
1058 |         {
1059 |           "include": "#main"
1060 |         }
1061 |       ]
1062 |     },
1063 |     "syntaxOptions": {
1064 |       "patterns": [
1065 |         {
1066 |           "name": "meta.syntax-item.pattern-argument.viml",
1067 |           "begin": "(?<=\\s)(start|skip|end)(?:\\s*(=))",
1068 |           "end": "(?=$|\\s)",
1069 |           "beginCaptures": {
1070 |             "1": {
1071 |               "name": "support.constant.$1-pattern.viml"
1072 |             },
1073 |             "2": {
1074 |               "name": "punctuation.assignment.parameter.viml"
1075 |             }
1076 |           },
1077 |           "patterns": [
1078 |             {
1079 |               "include": "#regex"
1080 |             }
1081 |           ]
1082 |         },
1083 |         {
1084 |           "name": "meta.syntax-item.argument.viml",
1085 |           "match": "(?x)(?<=\\s)\n((?:matchgroup|contains|containedin|nextgroup|add|remove|minlines|linebreaks|maxlines)(?=\\s*=)\n|(?:cchar|conceal|concealends|contained|display|excludenl|extend|fold|keepend|oneline|skipempty|skipnl|skipwhite|transparent))\n(?:(?=$|\\s)|\\s*(=)(\\S*)?)",
1086 |           "captures": {
1087 |             "1": {
1088 |               "name": "support.constant.syntax-$1.viml"
1089 |             },
1090 |             "2": {
1091 |               "name": "punctuation.assignment.parameter.viml"
1092 |             },
1093 |             "3": {
1094 |               "name": "string.unquoted.syntax-option.viml",
1095 |               "patterns": [
1096 |                 {
1097 |                   "include": "#numbers"
1098 |                 },
1099 |                 {
1100 |                   "match": ",",
1101 |                   "name": "punctuation.separator.comma.viml"
1102 |                 },
1103 |                 {
1104 |                   "match": "@",
1105 |                   "name": "punctuation.definition.group-reference.viml"
1106 |                 }
1107 |               ]
1108 |             }
1109 |           }
1110 |         }
1111 |       ]
1112 |     },
1113 |     "syntaxRegex": {
1114 |       "patterns": [
1115 |         {
1116 |           "include": "#syntaxOptions"
1117 |         },
1118 |         {
1119 |           "name": "string.regexp.viml",
1120 |           "begin": "(?<=\\s)(\\S)",
1121 |           "end": "(?:(\\1)(\\S*)(.*))?$",
1122 |           "patterns": [
1123 |             {
1124 |               "include": "#regexInnards"
1125 |             }
1126 |           ],
1127 |           "beginCaptures": {
1128 |             "1": {
1129 |               "name": "punctuation.definition.string.begin.viml"
1130 |             }
1131 |           },
1132 |           "endCaptures": {
1133 |             "1": {
1134 |               "name": "punctuation.definition.string.end.viml"
1135 |             },
1136 |             "2": {
1137 |               "patterns": [
1138 |                 {
1139 |                   "include": "#regexOffset"
1140 |                 }
1141 |               ]
1142 |             },
1143 |             "3": {
1144 |               "patterns": [
1145 |                 {
1146 |                   "include": "#syntaxOptions"
1147 |                 },
1148 |                 {
1149 |                   "include": "#main"
1150 |                 }
1151 |               ]
1152 |             }
1153 |           }
1154 |         }
1155 |       ]
1156 |     },
1157 |     "regex": {
1158 |       "name": "string.regexp.viml",
1159 |       "begin": "(?<=\\s|=)(\\S)",
1160 |       "end": "$|(\\1)(\\S*)",
1161 |       "patterns": [
1162 |         {
1163 |           "include": "#regexInnards"
1164 |         }
1165 |       ],
1166 |       "beginCaptures": {
1167 |         "1": {
1168 |           "name": "punctuation.definition.string.begin.viml"
1169 |         }
1170 |       },
1171 |       "endCaptures": {
1172 |         "1": {
1173 |           "name": "punctuation.definition.string.end.viml"
1174 |         },
1175 |         "2": {
1176 |           "patterns": [
1177 |             {
1178 |               "include": "#regexOffset"
1179 |             }
1180 |           ]
1181 |         }
1182 |       }
1183 |     },
1184 |     "regexOffset": {
1185 |       "name": "meta.pattern-offset.viml",
1186 |       "match": "(ms|me|hs|he|rs|re|lc)(=)(?:(\\d+)|([se])(?:([-+])(\\d+))?)(,)?",
1187 |       "captures": {
1188 |         "1": {
1189 |           "name": "constant.language.pattern-offset.viml"
1190 |         },
1191 |         "2": {
1192 |           "name": "punctuation.assignment.parameter.viml"
1193 |         },
1194 |         "3": {
1195 |           "name": "constant.numeric.integer.viml"
1196 |         },
1197 |         "4": {
1198 |           "name": "constant.language.pattern-position.viml"
1199 |         },
1200 |         "5": {
1201 |           "name": "keyword.operator.arithmetic.viml"
1202 |         },
1203 |         "6": {
1204 |           "name": "constant.numeric.integer.viml"
1205 |         },
1206 |         "7": {
1207 |           "name": "punctuation.separator.comma.viml"
1208 |         }
1209 |       }
1210 |     },
1211 |     "regexInnards": {
1212 |       "patterns": [
1213 |         {
1214 |           "begin": "\\[",
1215 |           "end": "\\]|$",
1216 |           "beginCaptures": {
1217 |             "0": {
1218 |               "name": "punctuation.definition.character-class.begin.viml"
1219 |             }
1220 |           },
1221 |           "endCaptures": {
1222 |             "0": {
1223 |               "name": "punctuation.definition.character-class.end.viml"
1224 |             }
1225 |           },
1226 |           "patterns": [
1227 |             {
1228 |               "include": "#regexInnards"
1229 |             }
1230 |           ]
1231 |         },
1232 |         {
1233 |           "name": "constant.character.escape.viml",
1234 |           "match": "(\\\\).",
1235 |           "captures": {
1236 |             "1": {
1237 |               "name": "punctuation.definition.backslash.escape.viml"
1238 |             }
1239 |           }
1240 |         }
1241 |       ]
1242 |     },
1243 |     "extraVimFunc": {
1244 |       "name": "support.function.viml",
1245 |       "match": "(?x)\\b\n\t((?:echo(?:hl?)?)|exe(?:c(?:ute)?)?|[lxvn]?noremap|smapc(?:lear)?|mapmode|xmap|(?:[xs]un|snore)map\n\t|Plugin|autocmd|[cinvo]?(?:un|nore)?(?:map|menu)|(?:range)?go(?:to)?|(?:count)?(?:pop?|tag?|tn(?:ext)?|tp(?:revious)?|tr(?:ewind)?)\n\t|(?:range)?(?:s(?:ubstitute)?|ret(?:ab)?|g(?:lobal)?)|unm(?:ap)?|map_l|mapc(?:lear)?|N?buffer|N?bnext|N?bNext|N?bprevious|N?bmod\n\t|ab(?:breviate)?|norea(?:bbrev)?|[ic](?:un|nore)?ab|split_f|rangefold|[ic](?:un|nore)?ab|[ic]abbrev|edit_f|next_f|[vcoxli]u\n\t|(?:range)?(?:w(?:rite)?|up(?:date)?)|sar|cno|[vl]n|[io]?no|[xn]n|snor|lm(?:ap)?|lunmap|lear|[vnx]m|om|[ci]m|ap|nun|sunm)\n\\b"
1246 |     },
1247 |     "extraVimOptions": {
1248 |       "name": "support.variable.option.viml",
1249 |       "match": "(?x)\\b (no)?\n\t(altwerase|bf|escapetime|extended|filec|iclower|keytime|leftright|li|lock|noprint|octal|recdir|searchincr\n\t|shellmeta|ttywerase|windowname|wl|wraplen)\n\\b"
1250 |     },
1251 |     "keywordLists": {
1252 |       "patterns": [
1253 |         {
1254 |           "include": "#vimTodo"
1255 |         },
1256 |         {
1257 |           "include": "#vimAugroupKey"
1258 |         },
1259 |         {
1260 |           "include": "#vimAutoEvent"
1261 |         },
1262 |         {
1263 |           "include": "#vimBehaveModel"
1264 |         },
1265 |         {
1266 |           "include": "#vimCommand"
1267 |         },
1268 |         {
1269 |           "include": "#vimFTCmd"
1270 |         },
1271 |         {
1272 |           "include": "#vimFTOption"
1273 |         },
1274 |         {
1275 |           "include": "#vimFgBgAttrib"
1276 |         },
1277 |         {
1278 |           "include": "#vimFuncKey"
1279 |         },
1280 |         {
1281 |           "include": "#vimFuncName"
1282 |         },
1283 |         {
1284 |           "include": "#vimGroup"
1285 |         },
1286 |         {
1287 |           "include": "#vimGroupSpecial"
1288 |         },
1289 |         {
1290 |           "include": "#vimHLGroup"
1291 |         },
1292 |         {
1293 |           "include": "#vimHiAttrib"
1294 |         },
1295 |         {
1296 |           "include": "#vimHiClear"
1297 |         },
1298 |         {
1299 |           "include": "#vimHiCtermColor"
1300 |         },
1301 |         {
1302 |           "include": "#vimMapModKey"
1303 |         },
1304 |         {
1305 |           "include": "#vimOption"
1306 |         },
1307 |         {
1308 |           "include": "#vimPattern"
1309 |         },
1310 |         {
1311 |           "include": "#vimStdPlugin"
1312 |         },
1313 |         {
1314 |           "include": "#vimSynCase"
1315 |         },
1316 |         {
1317 |           "include": "#vimSynType"
1318 |         },
1319 |         {
1320 |           "include": "#vimSyncC"
1321 |         },
1322 |         {
1323 |           "include": "#vimSyncLinecont"
1324 |         },
1325 |         {
1326 |           "include": "#vimSyncMatch"
1327 |         },
1328 |         {
1329 |           "include": "#vimSyncNone"
1330 |         },
1331 |         {
1332 |           "include": "#vimSyncRegion"
1333 |         },
1334 |         {
1335 |           "include": "#vimUserAttrbCmplt"
1336 |         },
1337 |         {
1338 |           "include": "#vimUserAttrbKey"
1339 |         },
1340 |         {
1341 |           "include": "#vimUserCommand"
1342 |         },
1343 |         {
1344 |           "include": "#vimErrSetting"
1345 |         }
1346 |       ]
1347 |     },
1348 |     "vimTodo": {
1349 |       "name": "support.constant.${1:/downcase}.viml",
1350 |       "match": "(?x) \\b\n( COMBAK\n| FIXME\n| TODO\n| XXX\n) \\b"
1351 |     },
1352 |     "vimAugroupKey": {
1353 |       "name": "support.function.vimAugroupKey.viml",
1354 |       "match": "(?x) \\b\n( aug\n| augroup\n) \\b"
1355 |     },
1356 |     "vimAutoEvent": {
1357 |       "name": "support.function.auto-event.viml",
1358 |       "match": "(?xi) \\b\n( BufAdd\n| BufCreate\n| BufDelete\n| BufEnter\n| BufFilePost\n| BufFilePre\n| BufHidden\n| BufLeave\n| BufNewFile\n| BufNew\n| BufReadCmd\n| BufReadPost\n| BufReadPre\n| BufRead\n| BufUnload\n| BufWinEnter\n| BufWinLeave\n| BufWipeout\n| BufWriteCmd\n| BufWritePost\n| BufWritePre\n| BufWrite\n| CmdUndefined\n| CmdlineChanged\n| CmdlineEnter\n| CmdlineLeave\n| CmdwinEnter\n| CmdwinLeave\n| ColorSchemePre\n| ColorScheme\n| CompleteChanged\n| CompleteDonePre\n| CompleteDone\n| CursorHoldI\n| CursorHold\n| CursorMovedI\n| CursorMoved\n| DiffUpdated\n| DirChanged\n| EncodingChanged\n| ExitPre\n| FileAppendCmd\n| FileAppendPost\n| FileAppendPre\n| FileChangedRO\n| FileChangedShellPost\n| FileChangedShell\n| FileEncoding\n| FileReadCmd\n| FileReadPost\n| FileReadPre\n| FileType\n| FileWriteCmd\n| FileWritePost\n| FileWritePre\n| FilterReadPost\n| FilterReadPre\n| FilterWritePost\n| FilterWritePre\n| FocusGained\n| FocusLost\n| FuncUndefined\n| GUIEnter\n| GUIFailed\n| InsertChange\n| InsertCharPre\n| InsertEnter\n| InsertLeavePre\n| InsertLeave\n| MenuPopup\n| OptionSet\n| QuickFixCmdPost\n| QuickFixCmdPre\n| QuitPre\n| RemoteReply\n| SafeStateAgain\n| SafeState\n| SessionLoadPost\n| ShellCmdPost\n| ShellFilterPost\n| SigUSR1\n| SourceCmd\n| SourcePost\n| SourcePre\n| SpellFileMissing\n| StdinReadPost\n| StdinReadPre\n| SwapExists\n| Syntax\n| TabClosed\n| TabEnter\n| TabLeave\n| TabNew\n| TermChanged\n| TermResponse\n| TerminalOpen\n| TerminalWinOpen\n| TextChangedI\n| TextChangedP\n| TextChanged\n| TextYankPost\n| User\n| VimEnter\n| VimLeavePre\n| VimLeave\n| VimResized\n| VimResume\n| VimSuspend\n| WinEnter\n| WinLeave\n| WinNew\n) \\b"
1359 |     },
1360 |     "vimBehaveModel": {
1361 |       "name": "support.function.vimBehaveModel.viml",
1362 |       "match": "(?x) \\b\n( mswin\n| xterm\n) \\b"
1363 |     },
1364 |     "vimCommand": {
1365 |       "name": "support.function.command.viml",
1366 |       "match": "(?x) \\b\n( abc\n| abclear\n| abo\n| aboveleft\n| ab\n| addd\n| all?\n| ar\n| args\n| arga\n| argadd\n| argd\n| argdelete\n| argdo\n| arge\n| argedit\n| argg\n| argglobal\n| argl\n| arglocal\n| argu\n| argument\n| as\n| ascii\n| au\n| a\n| bN\n| bNext\n| b\n| buffer\n| ba\n| ball\n| badd?\n| balt\n| bd\n| bdelete\n| bel\n| belowright\n| bf\n| bfirst\n| bl\n| blast\n| bm\n| bmodified\n| bn\n| bnext\n| bo\n| botright\n| bp\n| bprevious\n| br\n| brewind\n| break?\n| breaka\n| breakadd\n| breakd\n| breakdel\n| breakl\n| breaklist\n| bro\n| browse\n| bufdo\n| buffers\n| bun\n| bunload\n| bw\n| bwipeout\n| cN\n| cNext\n| cNf\n| cNfile\n| c\n| change\n| cabc\n| cabclear\n| cabo\n| cabove\n| cad\n| caddbuffer\n| cadde\n| caddexpr\n| caddf\n| caddfile\n| caf\n| cafter\n| call?\n| cat\n| catch\n| ca\n| cb\n| cbuffer\n| cbe\n| cbefore\n| cbel\n| cbelow\n| cbo\n| cbottom\n| ccl\n| cclose\n| cc\n| cdo\n| cd\n| ce\n| center\n| cex\n| cexpr\n| cf\n| cfile\n| cfdo\n| cfir\n| cfirst\n| cg\n| cgetfile\n| cgetb\n| cgetbuffer\n| cgete\n| cgetexpr\n| changes\n| chd\n| chdir\n| che\n| checkpath\n| checkt\n| checktime\n| chi\n| chistory\n| cl\n| clist\n| cla\n| clast\n| class\n| cle\n| clearjumps\n| clo\n| close\n| cmapc\n| cmapclear\n| cn\n| cnext\n| cnew\n| cnewer\n| cnf\n| cnfile\n| cnor\n| co\n| copy\n| col\n| colder\n| colo\n| colorscheme\n| comc\n| comclear\n| comp\n| compiler\n| com\n| con\n| continue\n| conf\n| confirm\n| const?\n| copen?\n| cp\n| cprevious\n| cpf\n| cpfile\n| cq\n| cquit\n| cr\n| crewind\n| cscope\n| cstag\n| cs\n| cuna\n| cunabbrev\n| cun\n| cw\n| cwindow\n| d\n| delete\n| debugg\n| debuggreedy\n| debug\n| defc\n| defcompile\n| def\n| delc\n| delcommand\n| delel\n| delep\n| deletel\n| deletep\n| deletl\n| deletp\n| delf\n| delfunction\n| dell\n| delm\n| delmarks\n| delp\n| dep\n| di\n| display\n| dif\n| diffupdate\n| diffg\n| diffget\n| diffo\n| diffoff\n| diffp\n| diffpatch\n| diffput?\n| diffs\n| diffsplit\n| difft\n| diffthis\n| dig\n| digraphs\n| dir\n| disa\n| disassemble\n| dj\n| djump\n| dli\n| dlist\n| dl\n| doaut\n| doau\n| do\n| dp\n| dr\n| drop\n| ds\n| dsearch\n| dsp\n| dsplit\n| e\n| edit\n| earlier\n| ea\n| echoc\n| echoconsole\n| echoe\n| echoerr\n| echom\n| echomsg\n| echon\n| ec\n| el\n| else\n| elseif?\n| em\n| emenu\n| en\n| endif\n| enddef\n| endf\n| endfunction\n| endfor?\n| endt\n| endtry\n| endw\n| endwhile\n| enew?\n| eval\n| exit?\n| export\n| exp\n| exu\n| exusage\n| ex\n| f\n| file\n| files\n| filetype\n| filet\n| filt\n| filter\n| find?\n| fina\n| finally\n| fini\n| finish\n| fir\n| first\n| fix\n| fixdel\n| fo\n| fold\n| foldc\n| foldclose\n| foldd\n| folddoopen\n| folddoc\n| folddoclosed\n| foldo\n| foldopen\n| for\n| fu\n| function\n| go\n| goto\n| gr\n| grep\n| grepa\n| grepadd\n| gui\n| gvim\n| g\n| h\n| help\n| ha\n| hardcopy\n| helpc\n| helpclose\n| helpf\n| helpfind\n| helpg\n| helpgrep\n| helpt\n| helptags\n| hide?\n| his\n| history\n| hi\n| iabc\n| iabclear\n| ia\n| if\n| ij\n| ijump\n| il\n| ilist\n| imapc\n| imapclear\n| import\n| imp\n| inor\n| interface\n| intro\n| in\n| is\n| isearch\n| isp\n| isplit\n| iuna\n| iunabbrev\n| i\n| j\n| join\n| ju\n| jumps\n| kee\n| keepmarks\n| keepalt\n| keepa\n| keepj\n| keepjumps\n| keepp\n| keeppatterns\n| k\n| lN\n| lNext\n| lNf\n| lNfile\n| l\n| list\n| la\n| last\n| lab\n| labove\n| lad\n| laddexpr\n| laddb\n| laddbuffer\n| laddf\n| laddfile\n| laf\n| lafter\n| lan\n| language\n| later\n| lat\n| lb\n| lbuffer\n| lbe\n| lbefore\n| lbel\n| lbelow\n| lbo\n| lbottom\n| lcd?\n| lch\n| lchdir\n| lcl\n| lclose\n| lcscope\n| lcs\n| ldo?\n| le\n| left\n| lefta\n| leftabove\n| leg\n| legacy\n| lex\n| lexpr\n| lf\n| lfile\n| lfdo\n| lfir\n| lfirst\n| lg\n| lgetfile\n| lgetb\n| lgetbuffer\n| lgete\n| lgetexpr\n| lgr\n| lgrep\n| lgrepa\n| lgrepadd\n| lh\n| lhelpgrep\n| lhi\n| lhistory\n| lla\n| llast\n| lli\n| llist\n| ll\n| lmake?\n| lmapc\n| lmapclear\n| lma\n| lne\n| lnext\n| lnew\n| lnewer\n| lnf\n| lnfile\n| lo\n| loadview\n| loadkeymap\n| loadk\n| loc\n| lockmarks\n| lockv\n| lockvar\n| lol\n| lolder\n| lop\n| lopen\n| lp\n| lprevious\n| lpf\n| lpfile\n| lr\n| lrewind\n| ls\n| lt\n| ltag\n| luado\n| luafile\n| lua\n| lv\n| lvimgrep\n| lvimgrepa\n| lvimgrepadd\n| lw\n| lwindow\n| m\n| move\n| ma\n| mark\n| make?\n| marks\n| mat\n| match\n| menut\n| menutranslate\n| mes\n| messages\n| mk\n| mkexrc\n| mks\n| mksession\n| mksp\n| mkspell\n| mkv\n| mkvimrc\n| mkview?\n| mode?\n| mz\n| mzscheme\n| mzf\n| mzfile\n| n\n| next\n| nb\n| nbkey\n| nbc\n| nbclose\n| nbs\n| nbstart\n| new\n| nmapc\n| nmapclear\n| noautocmd\n| noa\n| noh\n| nohlsearch\n| nore\n| nor\n| nos\n| noswapfile\n| nu\n| number\n| o\n| open\n| ol\n| oldfiles\n| omapc\n| omapclear\n| on\n| only\n| opt\n| options\n| ownsyntax\n| p\n| print\n| pa\n| packadd\n| packl\n| packloadall\n| pc\n| pclose\n| pe\n| perl\n| ped\n| pedit\n| perldo?\n| pop?\n| popup?\n| pp\n| ppop\n| pre\n| preserve\n| prev\n| previous\n| prof\n| profile\n| profd\n| profdel\n| promptf\n| promptfind\n| promptr\n| promptrepl\n| pro\n| ps\n| psearch\n| ptN\n| ptNext\n| ptag?\n| ptf\n| ptfirst\n| ptj\n| ptjump\n| ptl\n| ptlast\n| ptn\n| ptnext\n| ptp\n| ptprevious\n| ptr\n| ptrewind\n| pts\n| ptselect\n| put?\n| pwd?\n| py3do\n| py3f\n| py3file\n| py3\n| py\n| python\n| pydo\n| pyf\n| pyfile\n| python3\n| pythonx\n| pyxdo\n| pyxfile\n| pyx\n| q\n| quit\n| qa\n| qall\n| quita\n| quitall\n| r\n| read\n| rec\n| recover\n| redo?\n| redir?\n| redr\n| redraw\n| redraws\n| redrawstatus\n| redrawt\n| redrawtabline\n| reg\n| registers\n| res\n| resize\n| ret\n| retab\n| retu\n| return\n| rew\n| rewind\n| ri\n| right\n| rightb\n| rightbelow\n| ru\n| runtime\n| ruby?\n| rubydo?\n| rubyf\n| rubyfile\n| rundo\n| rv\n| rviminfo\n| sIc\n| sIe\n| sIg\n| sIl\n| sIn\n| sIp\n| sIr\n| sI\n| sN\n| sNext\n| sa\n| sargument\n| sall?\n| san\n| sandbox\n| sav\n| saveas\n| sbN\n| sbNext\n| sb\n| sbuffer\n| sba\n| sball\n| sbf\n| sbfirst\n| sbl\n| sblast\n| sbm\n| sbmodified\n| sbn\n| sbnext\n| sbp\n| sbprevious\n| sbr\n| sbrewind\n| scI\n| sce\n| scg\n| sci\n| scl\n| scp\n| scr\n| scriptnames\n| scripte\n| scriptencoding\n| scriptv\n| scriptversion\n| scscope\n| scs\n| sc\n| set?\n| setf\n| setfiletype\n| setg\n| setglobal\n| setl\n| setlocal\n| sf\n| sfind\n| sfir\n| sfirst\n| sgI\n| sgc\n| sge\n| sgi\n| sgl\n| sgn\n| sgp\n| sgr\n| sg\n| sh\n| shell\n| sic\n| sie\n| sign\n| sig\n| sil\n| silent\n| sim\n| simalt\n| sin\n| sip\n| sir\n| si\n| sl\n| sleep\n| sla\n| slast\n| sm\n| smagic\n| sm\n| smap\n| smenu\n| sme\n| smile\n| sn\n| snext\n| sno\n| snomagic\n| snoremenu\n| snoreme\n| so\n| source\n| sort?\n| sp\n| split\n| spe\n| spellgood\n| spelld\n| spelldump\n| spelli\n| spellinfo\n| spellr\n| spellrare\n| spellr\n| spellrepall\n| spellr\n| spellrrare\n| spellu\n| spellundo\n| spellw\n| spellwrong\n| spr\n| sprevious\n| srI\n| src\n| sre\n| srewind\n| srg\n| sri\n| srl\n| srn\n| srp\n| sr\n| st\n| stop\n| stag?\n| star\n| startinsert\n| startg\n| startgreplace\n| startr\n| startreplace\n| stj\n| stjump\n| stopi\n| stopinsert\n| sts\n| stselect\n| substitutepattern\n| substituterepeat\n| sun\n| sunhide\n| sunmenu\n| sunme\n| sus\n| suspend\n| sv\n| sview\n| sw\n| swapname\n| syncbind\n| sync\n| syntime\n| syn\n| sy\n| tN\n| tNext\n| tag?\n| tabN\n| tabNext\n| tabc\n| tabclose\n| tabdo?\n| tabe\n| tabedit\n| tabf\n| tabfind\n| tabfir\n| tabfirst\n| tabl\n| tablast\n| tabm\n| tabmove\n| tabn\n| tabnext\n| tabnew\n| tabo\n| tabonly\n| tabp\n| tabprevious\n| tabr\n| tabrewind\n| tabs\n| tab\n| tags\n| tcl?\n| tcd\n| tch\n| tchdir\n| tcldo?\n| tclf\n| tclfile\n| te\n| tearoff\n| ter\n| terminal\n| tf\n| tfirst\n| th\n| throw\n| tj\n| tjump\n| tl\n| tlast\n| tlmenu\n| tlm\n| tlnoremenu\n| tln\n| tlunmenu\n| tlu\n| tm\n| tmenu\n| tmap?\n| tmapc\n| tmapclear\n| tn\n| tnext\n| tno\n| tnoremap\n| to\n| topleft\n| tp\n| tprevious\n| tr\n| trewind\n| try\n| ts\n| tselect\n| tu\n| tunmenu\n| tunmap?\n| type\n| t\n| u\n| undo\n| una\n| unabbreviate\n| undoj\n| undojoin\n| undol\n| undolist\n| unh\n| unhide\n| unlo\n| unlockvar\n| unl\n| uns\n| unsilent\n| up\n| update\n| var\n| ve\n| version\n| verb\n| verbose\n| vert\n| vertical\n| vi\n| visual\n| view?\n| vim9\n| vim9cmd\n| vim9s\n| vim9script\n| vim\n| vimgrep\n| vimgrepa\n| vimgrepadd\n| viu\n| viusage\n| vmapc\n| vmapclear\n| vnew?\n| vs\n| vsplit\n| v\n| wN\n| wNext\n| w\n| write\n| wa\n| wall\n| wh\n| while\n| win\n| winsize\n| winc\n| wincmd\n| windo\n| winp\n| winpos\n| wn\n| wnext\n| wp\n| wprevious\n| wqa\n| wqall\n| wq\n| wundo\n| wv\n| wviminfo\n| x\n| xit\n| xa\n| xall\n| xmapc\n| xmapclear\n| xmenu\n| xme\n| xnoremenu\n| xnoreme\n| xprop\n| xr\n| xrestore\n| xunmenu\n| xunme\n| xwininfo\n| y\n| yank\n) \\b"
1367 |     },
1368 |     "vimErrSetting": {
1369 |       "name": "invalid.deprecated.legacy-setting.viml",
1370 |       "match": "(?x) \\b\n( autoprint\n| beautify\n| bioskey\n| biosk\n| conskey\n| consk\n| flash\n| graphic\n| hardtabs\n| ht\n| mesg\n| noautoprint\n| nobeautify\n| nobioskey\n| nobiosk\n| noconskey\n| noconsk\n| noflash\n| nographic\n| nohardtabs\n| nomesg\n| nonovice\n| noopen\n| nooptimize\n| noop\n| noredraw\n| noslowopen\n| noslow\n| nosourceany\n| novice\n| now1200\n| now300\n| now9600\n| open\n| optimize\n| op\n| redraw\n| slowopen\n| slow\n| sourceany\n| w1200\n| w300\n| w9600\n) \\b"
1371 |     },
1372 |     "vimFTCmd": {
1373 |       "name": "support.function.vimFTCmd.viml",
1374 |       "match": "(?x) \\b\n( filet\n| filetype\n) \\b"
1375 |     },
1376 |     "vimFTOption": {
1377 |       "name": "support.function.vimFTOption.viml",
1378 |       "match": "(?x) \\b\n( detect\n| indent\n| off\n| on\n| plugin\n) \\b"
1379 |     },
1380 |     "vimFgBgAttrib": {
1381 |       "name": "support.constant.attribute.viml",
1382 |       "match": "(?x) \\b\n( background\n| bg\n| fg\n| foreground\n| none\n) \\b"
1383 |     },
1384 |     "vimFuncKey": {
1385 |       "name": "support.function.vimFuncKey.viml",
1386 |       "match": "(?x) \\b\n( def\n| fu\n| function\n) \\b"
1387 |     },
1388 |     "vimFuncName": {
1389 |       "name": "support.function.viml",
1390 |       "match": "(?x) \\b\n( abs\n| acos\n| add\n| and\n| appendbufline\n| append\n| argc\n| argidx\n| arglistid\n| argv\n| asin\n| assert_beeps\n| assert_equalfile\n| assert_equal\n| assert_exception\n| assert_fails\n| assert_false\n| assert_inrange\n| assert_match\n| assert_nobeep\n| assert_notequal\n| assert_notmatch\n| assert_report\n| assert_true\n| atan2\n| atan\n| balloon_gettext\n| balloon_show\n| balloon_split\n| browsedir\n| browse\n| bufadd\n| bufexists\n| buflisted\n| bufloaded\n| bufload\n| bufname\n| bufnr\n| bufwinid\n| bufwinnr\n| byte2line\n| byteidxcomp\n| byteidx\n| call\n| ceil\n| ch_canread\n| ch_close_in\n| ch_close\n| ch_evalexpr\n| ch_evalraw\n| ch_getbufnr\n| ch_getjob\n| ch_info\n| ch_logfile\n| ch_log\n| ch_open\n| ch_readblob\n| ch_readraw\n| ch_read\n| ch_sendexpr\n| ch_sendraw\n| ch_setoptions\n| ch_status\n| changenr\n| char2nr\n| charclass\n| charcol\n| charidx\n| chdir\n| cindent\n| clearmatches\n| col\n| complete_add\n| complete_check\n| complete_info\n| complete\n| confirm\n| copy\n| cosh\n| cos\n| count\n| cscope_connection\n| cursor\n| debugbreak\n| deepcopy\n| deletebufline\n| delete\n| did_filetype\n| diff_filler\n| diff_hlID\n| echoraw\n| empty\n| environ\n| escape\n| eval\n| eventhandler\n| executable\n| execute\n| exepath\n| exists\n| expandcmd\n| expand\n| exp\n| extendnew\n| extend\n| feedkeys\n| filereadable\n| filewritable\n| filter\n| finddir\n| findfile\n| flattennew\n| flatten\n| float2nr\n| floor\n| fmod\n| fnameescape\n| fnamemodify\n| foldclosedend\n| foldclosed\n| foldlevel\n| foldtextresult\n| foldtext\n| foreground\n| fullcommand\n| funcref\n| function\n| garbagecollect\n| getbufinfo\n| getbufline\n| getbufvar\n| getchangelist\n| getcharmod\n| getcharpos\n| getcharsearch\n| getchar\n| getcmdline\n| getcmdpos\n| getcmdtype\n| getcmdwintype\n| getcompletion\n| getcurpos\n| getcursorcharpos\n| getcwd\n| getenv\n| getfontname\n| getfperm\n| getfsize\n| getftime\n| getftype\n| getimstatus\n| getjumplist\n| getline\n| getloclist\n| getmarklist\n| getmatches\n| getmousepos\n| getpid\n| getpos\n| getqflist\n| getreginfo\n| getregtype\n| getreg\n| gettabinfo\n| gettabvar\n| gettabwinvar\n| gettagstack\n| gettext\n| getwininfo\n| getwinposx\n| getwinposy\n| getwinpos\n| getwinvar\n| get\n| glob2regpat\n| globpath\n| glob\n| has_key\n| haslocaldir\n| hasmapto\n| has\n| histadd\n| histdel\n| histget\n| histnr\n| hlID\n| hlexists\n| hostname\n| iconv\n| indent\n| index\n| inputdialog\n| inputlist\n| inputrestore\n| inputsave\n| inputsecret\n| input\n| insert\n| interrupt\n| invert\n| isdirectory\n| isinf\n| islocked\n| isnan\n| items\n| job_getchannel\n| job_info\n| job_setoptions\n| job_start\n| job_status\n| job_stop\n| join\n| js_decode\n| js_encode\n| json_decode\n| json_encode\n| keys\n| len\n| libcallnr\n| libcall\n| line2byte\n| line\n| lispindent\n| list2str\n| listener_add\n| listener_flush\n| listener_remove\n| localtime\n| log10\n| log\n| luaeval\n| maparg\n| mapcheck\n| mapnew\n| mapset\n| map\n| matchaddpos\n| matchadd\n| matcharg\n| matchdelete\n| matchend\n| matchfuzzypos\n| matchfuzzy\n| matchlist\n| matchstrpos\n| matchstr\n| match\n| max\n| menu_info\n| min\n| mkdir\n| mode\n| mzeval\n| nextnonblank\n| nr2char\n| or\n| pathshorten\n| perleval\n| popup_atcursor\n| popup_beval\n| popup_clear\n| popup_close\n| popup_create\n| popup_dialog\n| popup_filter_menu\n| popup_filter_yesno\n| popup_findinfo\n| popup_findpreview\n| popup_getoptions\n| popup_getpos\n| popup_hide\n| popup_list\n| popup_locate\n| popup_menu\n| popup_move\n| popup_notification\n| popup_setoptions\n| popup_settext\n| popup_show\n| pow\n| prevnonblank\n| printf\n| prompt_getprompt\n| prompt_setcallback\n| prompt_setinterrupt\n| prompt_setprompt\n| prop_add\n| prop_clear\n| prop_find\n| prop_list\n| prop_remove\n| prop_type_add\n| prop_type_change\n| prop_type_delete\n| prop_type_get\n| prop_type_list\n| pum_getpos\n| pumvisible\n| py3eval\n| pyeval\n| pyxeval\n| rand\n| range\n| readblob\n| readdirex\n| readdir\n| readfile\n| reduce\n| reg_executing\n| reg_recording\n| reltimefloat\n| reltimestr\n| reltime\n| remote_expr\n| remote_foreground\n| remote_peek\n| remote_read\n| remote_send\n| remote_startserver\n| remove\n| rename\n| repeat\n| resolve\n| reverse\n| round\n| rubyeval\n| screenattr\n| screenchars\n| screenchar\n| screencol\n| screenpos\n| screenrow\n| screenstring\n| searchcount\n| searchdecl\n| searchpairpos\n| searchpair\n| searchpos\n| search\n| server2client\n| serverlist\n| setbufline\n| setbufvar\n| setcellwidths\n| setcharpos\n| setcharsearch\n| setcmdpos\n| setcursorcharpos\n| setenv\n| setfperm\n| setline\n| setloclist\n| setmatches\n| setpos\n| setqflist\n| setreg\n| settabvar\n| settabwinvar\n| settagstack\n| setwinvar\n| sha256\n| shellescape\n| shiftwidth\n| sign_define\n| sign_getdefined\n| sign_getplaced\n| sign_jump\n| sign_placelist\n| sign_place\n| sign_undefine\n| sign_unplacelist\n| sign_unplace\n| simplify\n| sinh\n| sin\n| slice\n| sort\n| sound_clear\n| sound_playevent\n| sound_playfile\n| sound_stop\n| soundfold\n| spellbadword\n| spellsuggest\n| split\n| sqrt\n| srand\n| state\n| str2float\n| str2list\n| str2nr\n| strcharlen\n| strcharpart\n| strchars\n| strdisplaywidth\n| strftime\n| strgetchar\n| stridx\n| string\n| strlen\n| strpart\n| strptime\n| strridx\n| strtrans\n| strwidth\n| submatch\n| substitute\n| swapinfo\n| swapname\n| synIDattr\n| synIDtrans\n| synID\n| synconcealed\n| synstack\n| systemlist\n| system\n| tabpagebuflist\n| tabpagenr\n| tabpagewinnr\n| tagfiles\n| taglist\n| tanh\n| tan\n| tempname\n| term_dumpdiff\n| term_dumpload\n| term_dumpwrite\n| term_getaltscreen\n| term_getansicolors\n| term_getattr\n| term_getcursor\n| term_getjob\n| term_getline\n| term_getscrolled\n| term_getsize\n| term_getstatus\n| term_gettitle\n| term_gettty\n| term_list\n| term_scrape\n| term_sendkeys\n| term_setansicolors\n| term_setapi\n| term_setkill\n| term_setrestore\n| term_setsize\n| term_start\n| term_wait\n| terminalprops\n| test_alloc_fail\n| test_autochdir\n| test_feedinput\n| test_garbagecollect_now\n| test_garbagecollect_soon\n| test_getvalue\n| test_ignore_error\n| test_null_blob\n| test_null_channel\n| test_null_dict\n| test_null_function\n| test_null_job\n| test_null_list\n| test_null_partial\n| test_null_string\n| test_option_not_set\n| test_override\n| test_refcount\n| test_scrollbar\n| test_setmouse\n| test_settime\n| test_srand_seed\n| test_unknown\n| test_void\n| timer_info\n| timer_pause\n| timer_start\n| timer_stopall\n| timer_stop\n| tolower\n| toupper\n| trim\n| trunc\n| tr\n| typename\n| type\n| undofile\n| undotree\n| uniq\n| values\n| virtcol\n| visualmode\n| wildmenumode\n| win_execute\n| win_findbuf\n| win_getid\n| win_gettype\n| win_gotoid\n| win_id2tabwin\n| win_id2win\n| win_screenpos\n| win_splitmove\n| winbufnr\n| wincol\n| windowsversion\n| winheight\n| winlayout\n| winline\n| winnr\n| winrestcmd\n| winrestview\n| winsaveview\n| winwidth\n| wordcount\n| writefile\n| xor\n) \\b"
1391 |     },
1392 |     "vimGroup": {
1393 |       "name": "support.type.group.viml",
1394 |       "match": "(?xi) \\b\n( Boolean\n| Character\n| Comment\n| Conditional\n| Constant\n| Debug\n| Define\n| Delimiter\n| Error\n| Exception\n| Float\n| Function\n| Identifier\n| Ignore\n| Include\n| Keyword\n| Label\n| Macro\n| Number\n| Operator\n| PreCondit\n| PreProc\n| Repeat\n| SpecialChar\n| SpecialComment\n| Special\n| Statement\n| StorageClass\n| String\n| Structure\n| Tag\n| Todo\n| Typedef\n| Type\n| Underlined\n) \\b"
1395 |     },
1396 |     "vimGroupSpecial": {
1397 |       "name": "support.function.vimGroupSpecial.viml",
1398 |       "match": "(?x) \\b\n( ALLBUT\n| ALL\n| CONTAINED\n| TOP\n) \\b"
1399 |     },
1400 |     "vimHLGroup": {
1401 |       "name": "support.type.highlight-group.viml",
1402 |       "match": "(?xi) \\b\n( ColorColumn\n| CursorColumn\n| CursorIM\n| CursorLineNr\n| CursorLine\n| Cursor\n| DiffAdd\n| DiffChange\n| DiffDelete\n| DiffText\n| Directory\n| EndOfBuffer\n| ErrorMsg\n| FoldColumn\n| Folded\n| IncSearch\n| LineNrAbove\n| LineNrBelow\n| LineNr\n| MatchParen\n| Menu\n| ModeMsg\n| MoreMsg\n| NonText\n| Normal\n| PmenuSbar\n| PmenuSel\n| PmenuThumb\n| Pmenu\n| Question\n| QuickFixLine\n| Scrollbar\n| Search\n| SignColumn\n| SpecialKey\n| SpellBad\n| SpellCap\n| SpellLocal\n| SpellRare\n| StatusLineNC\n| StatusLineTerm\n| StatusLine\n| TabLineFill\n| TabLineSel\n| TabLine\n| Terminal\n| Title\n| Tooltip\n| VertSplit\n| VisualNOS\n| Visual\n| WarningMsg\n| WildMenu\n) \\b"
1403 |     },
1404 |     "vimHiAttrib": {
1405 |       "name": "support.function.vimHiAttrib.viml",
1406 |       "match": "(?x) \\b\n( bold\n| inverse\n| italic\n| nocombine\n| none\n| reverse\n| standout\n| strikethrough\n| undercurl\n| underline\n) \\b"
1407 |     },
1408 |     "vimHiClear": {
1409 |       "name": "support.function.vimHiClear.viml",
1410 |       "match": "(?x) \\b\n( clear\n) \\b"
1411 |     },
1412 |     "vimHiCtermColor": {
1413 |       "name": "support.constant.colour.color.$1.viml",
1414 |       "match": "(?x) \\b\n( black\n| blue\n| brown\n| cyan\n| darkblue\n| darkcyan\n| darkgray\n| darkgreen\n| darkgrey\n| darkmagenta\n| darkred\n| darkyellow\n| gray\n| green\n| grey40\n| grey50\n| grey90\n| grey\n| lightblue\n| lightcyan\n| lightgray\n| lightgreen\n| lightgrey\n| lightmagenta\n| lightred\n| lightyellow\n| magenta\n| red\n| seagreen\n| white\n| yellow\n) \\b"
1415 |     },
1416 |     "vimMapModKey": {
1417 |       "name": "support.function.vimMapModKey.viml",
1418 |       "match": "(?x) \\b\n( buffer\n| expr\n| leader\n| localleader\n| nowait\n| plug\n| script\n| sid\n| silent\n| unique\n) \\b"
1419 |     },
1420 |     "vimOption": {
1421 |       "name": "support.variable.option.viml",
1422 |       "match": "(?x) \\b\n( acd\n| ai\n| akm\n| aleph\n| allowrevins\n| altkeymap\n| al\n| ambiwidth\n| ambw\n| antialias\n| anti\n| arabicshape\n| arabic\n| arab\n| ari\n| arshape\n| ar\n| asd\n| autochdir\n| autoindent\n| autoread\n| autoshelldir\n| autowriteall\n| autowrite\n| awa\n| aw\n| background\n| backspace\n| backupcopy\n| backupdir\n| backupext\n| backupskip\n| backup\n| balloondelay\n| balloonevalterm\n| ballooneval\n| balloonexpr\n| bdir\n| bdlay\n| belloff\n| bevalterm\n| beval\n| bexpr\n| bex\n| bg\n| bh\n| binary\n| bin\n| bkc\n| bk\n| bl\n| bomb\n| bo\n| breakat\n| breakindentopt\n| breakindent\n| briopt\n| bri\n| brk\n| browsedir\n| bsdir\n| bsk\n| bs\n| bt\n| bufhidden\n| buflisted\n| buftype\n| casemap\n| cb\n| ccv\n| cc\n| cdpath\n| cd\n| cedit\n| cfu\n| cf\n| charconvert\n| ch\n| cindent\n| cinkeys\n| cink\n| cinoptions\n| cino\n| cinwords\n| cinw\n| cin\n| ci\n| clipboard\n| cmdheight\n| cmdwinheight\n| cmp\n| cms\n| cm\n| cocu\n| cole\n| colorcolumn\n| columns\n| commentstring\n| comments\n| compatible\n| completefunc\n| completeopt\n| completepopup\n| completeslash\n| complete\n| com\n| confirm\n| copyindent\n| cot\n| co\n| cpoptions\n| cpo\n| cpp\n| cpt\n| cp\n| crb\n| cryptmethod\n| cscopepathcomp\n| cscopeprg\n| cscopequickfix\n| cscoperelative\n| cscopetagorder\n| cscopetag\n| cscopeverbose\n| csl\n| cspc\n| csprg\n| csqf\n| csre\n| csto\n| cst\n| csverb\n| cuc\n| culopt\n| cul\n| cursorbind\n| cursorcolumn\n| cursorlineopt\n| cursorline\n| cursor\n| cwh\n| debug\n| deco\n| define\n| def\n| delcombine\n| dex\n| dg\n| dictionary\n| dict\n| diffexpr\n| diffopt\n| diff\n| digraph\n| dip\n| directory\n| dir\n| display\n| dy\n| eadirection\n| ead\n| ea\n| eb\n| edcompatible\n| ed\n| efm\n| ef\n| ei\n| ek\n| emoji\n| emo\n| encoding\n| enc\n| endofline\n| eol\n| ep\n| equalalways\n| equalprg\n| errorbells\n| errorfile\n| errorformat\n| esckeys\n| et\n| eventignore\n| expandtab\n| exrc\n| ex\n| fcl\n| fcs\n| fdc\n| fde\n| fdi\n| fdls\n| fdl\n| fdm\n| fdn\n| fdo\n| fdt\n| fencs\n| fenc\n| fen\n| fex\n| ffs\n| ff\n| fic\n| fileencodings\n| fileencoding\n| fileformats\n| fileformat\n| fileignorecase\n| filetype\n| fillchars\n| fixendofline\n| fixeol\n| fkmap\n| fk\n| flp\n| fml\n| fmr\n| foldclose\n| foldcolumn\n| foldenable\n| foldexpr\n| foldignore\n| foldlevelstart\n| foldlevel\n| foldmarker\n| foldmethod\n| foldminlines\n| foldnestmax\n| foldopen\n| foldtext\n| formatexpr\n| formatlistpat\n| formatoptions\n| formatprg\n| fo\n| fp\n| fsync\n| fs\n| ft\n| gcr\n| gdefault\n| gd\n| gfm\n| gfn\n| gfs\n| gfw\n| ghr\n| go\n| gp\n| grepformat\n| grepprg\n| gtl\n| gtt\n| guicursor\n| guifontset\n| guifontwide\n| guifont\n| guiheadroom\n| guioptions\n| guipty\n| guitablabel\n| guitabtooltip\n| helpfile\n| helpheight\n| helplang\n| hf\n| hh\n| hidden\n| hid\n| highlight\n| history\n| hi\n| hkmapp\n| hkmap\n| hkp\n| hk\n| hlg\n| hlsearch\n| hls\n| hl\n| iconstring\n| icon\n| ic\n| ignorecase\n| imactivatefunc\n| imactivatekey\n| imaf\n| imak\n| imcmdline\n| imc\n| imdisable\n| imd\n| iminsert\n| imi\n| imsearch\n| imsf\n| imstatusfunc\n| imstyle\n| imst\n| ims\n| im\n| includeexpr\n| include\n| incsearch\n| inc\n| indentexpr\n| indentkeys\n| inde\n| indk\n| inex\n| infercase\n| inf\n| insertmode\n| invacd\n| invai\n| invakm\n| invallowrevins\n| invaltkeymap\n| invantialias\n| invanti\n| invarabicshape\n| invarabic\n| invarab\n| invari\n| invarshape\n| invar\n| invasd\n| invautochdir\n| invautoindent\n| invautoread\n| invautoshelldir\n| invautowriteall\n| invautowrite\n| invawa\n| invaw\n| invbackup\n| invballoonevalterm\n| invballooneval\n| invbevalterm\n| invbeval\n| invbinary\n| invbin\n| invbk\n| invbl\n| invbomb\n| invbreakindent\n| invbri\n| invbuflisted\n| invcf\n| invcindent\n| invcin\n| invci\n| invcompatible\n| invconfirm\n| invcopyindent\n| invcp\n| invcrb\n| invcscoperelative\n| invcscopetag\n| invcscopeverbose\n| invcsre\n| invcst\n| invcsverb\n| invcuc\n| invcul\n| invcursorbind\n| invcursorcolumn\n| invcursorline\n| invdeco\n| invdelcombine\n| invdg\n| invdiff\n| invdigraph\n| invea\n| inveb\n| invedcompatible\n| inved\n| invek\n| invemoji\n| invemo\n| invendofline\n| inveol\n| invequalalways\n| inverrorbells\n| invesckeys\n| invet\n| invexpandtab\n| invexrc\n| invex\n| invfen\n| invfic\n| invfileignorecase\n| invfixendofline\n| invfixeol\n| invfkmap\n| invfk\n| invfoldenable\n| invfsync\n| invfs\n| invgdefault\n| invgd\n| invguipty\n| invhidden\n| invhid\n| invhkmapp\n| invhkmap\n| invhkp\n| invhk\n| invhlsearch\n| invhls\n| invicon\n| invic\n| invignorecase\n| invimcmdline\n| invimc\n| invimdisable\n| invimd\n| invim\n| invincsearch\n| invinfercase\n| invinf\n| invinsertmode\n| invis\n| invjoinspaces\n| invjs\n| invlangnoremap\n| invlangremap\n| invlazyredraw\n| invlbr\n| invlinebreak\n| invlisp\n| invlist\n| invlnr\n| invloadplugins\n| invlpl\n| invlrm\n| invlz\n| invmacatsui\n| invmagic\n| invma\n| invmh\n| invmle\n| invml\n| invmodelineexpr\n| invmodeline\n| invmodifiable\n| invmodified\n| invmod\n| invmore\n| invmousefocus\n| invmousef\n| invmousehide\n| invnumber\n| invnu\n| invodev\n| invopendevice\n| invpaste\n| invpi\n| invpreserveindent\n| invpreviewwindow\n| invprompt\n| invpvw\n| invreadonly\n| invrelativenumber\n| invremap\n| invrestorescreen\n| invrevins\n| invrightleft\n| invri\n| invrl\n| invrnu\n| invro\n| invrs\n| invruler\n| invru\n| invsb\n| invscb\n| invscf\n| invscrollbind\n| invscrollfocus\n| invscs\n| invsc\n| invsecure\n| invsft\n| invshellslash\n| invshelltemp\n| invshiftround\n| invshortname\n| invshowcmd\n| invshowfulltag\n| invshowmatch\n| invshowmode\n| invsi\n| invsmartcase\n| invsmartindent\n| invsmarttab\n| invsmd\n| invsm\n| invsn\n| invsol\n| invspell\n| invsplitbelow\n| invsplitright\n| invspr\n| invsr\n| invssl\n| invstartofline\n| invsta\n| invstmp\n| invswapfile\n| invswf\n| invtagbsearch\n| invtagrelative\n| invtagstack\n| invta\n| invtbidi\n| invtbi\n| invtbs\n| invtermbidi\n| invterse\n| invtextauto\n| invtextmode\n| invtf\n| invtgst\n| invtildeop\n| invtimeout\n| invtitle\n| invtop\n| invto\n| invtr\n| invttimeout\n| invttybuiltin\n| invttyfast\n| invtx\n| invudf\n| invundofile\n| invvb\n| invvisualbell\n| invwarn\n| invwa\n| invwb\n| invweirdinvert\n| invwfh\n| invwfw\n| invwic\n| invwildignorecase\n| invwildmenu\n| invwinfixheight\n| invwinfixwidth\n| invwiv\n| invwmnu\n| invwrapscan\n| invwrap\n| invwriteany\n| invwritebackup\n| invwrite\n| invws\n| isfname\n| isf\n| isident\n| isi\n| iskeyword\n| isk\n| isprint\n| isp\n| is\n| joinspaces\n| js\n| keymap\n| keymodel\n| keywordprg\n| key\n| kmp\n| km\n| kp\n| langmap\n| langmenu\n| langnoremap\n| langremap\n| laststatus\n| lazyredraw\n| lbr\n| lcs\n| level\n| linebreak\n| linespace\n| lines\n| lispwords\n| lisp\n| listchars\n| list\n| lmap\n| lm\n| lnr\n| loadplugins\n| lpl\n| lrm\n| lsp\n| ls\n| luadll\n| lw\n| lz\n| macatsui\n| magic\n| makeef\n| makeencoding\n| makeprg\n| matchpairs\n| matchtime\n| mat\n| maxcombine\n| maxfuncdepth\n| maxmapdepth\n| maxmempattern\n| maxmemtot\n| maxmem\n| ma\n| mco\n| mef\n| menc\n| menuitems\n| mfd\n| mh\n| mis\n| mkspellmem\n| mle\n| mls\n| ml\n| mmd\n| mmp\n| mmt\n| mm\n| modelineexpr\n| modelines\n| modeline\n| modifiable\n| modified\n| mod\n| more\n| mousefocus\n| mousef\n| mousehide\n| mousemodel\n| mousem\n| mouseshape\n| mouses\n| mousetime\n| mouset\n| mouse\n| mps\n| mp\n| msm\n| mzquantum\n| mzq\n| mzschemedll\n| mzschemegcdll\n| nf\n| noacd\n| noai\n| noakm\n| noallowrevins\n| noaltkeymap\n| noantialias\n| noanti\n| noarabicshape\n| noarabic\n| noarab\n| noari\n| noarshape\n| noar\n| noasd\n| noautochdir\n| noautoindent\n| noautoread\n| noautoshelldir\n| noautowriteall\n| noautowrite\n| noawa\n| noaw\n| nobackup\n| noballoonevalterm\n| noballooneval\n| nobevalterm\n| nobeval\n| nobinary\n| nobin\n| nobk\n| nobl\n| nobomb\n| nobreakindent\n| nobri\n| nobuflisted\n| nocf\n| nocindent\n| nocin\n| noci\n| nocompatible\n| noconfirm\n| nocopyindent\n| nocp\n| nocrb\n| nocscoperelative\n| nocscopetag\n| nocscopeverbose\n| nocsre\n| nocst\n| nocsverb\n| nocuc\n| nocul\n| nocursorbind\n| nocursorcolumn\n| nocursorline\n| nodeco\n| nodelcombine\n| nodg\n| nodiff\n| nodigraph\n| noea\n| noeb\n| noedcompatible\n| noed\n| noek\n| noemoji\n| noemo\n| noendofline\n| noeol\n| noequalalways\n| noerrorbells\n| noesckeys\n| noet\n| noexpandtab\n| noexrc\n| noex\n| nofen\n| nofic\n| nofileignorecase\n| nofixendofline\n| nofixeol\n| nofkmap\n| nofk\n| nofoldenable\n| nofsync\n| nofs\n| nogdefault\n| nogd\n| noguipty\n| nohidden\n| nohid\n| nohkmapp\n| nohkmap\n| nohkp\n| nohk\n| nohlsearch\n| nohls\n| noicon\n| noic\n| noignorecase\n| noimcmdline\n| noimc\n| noimdisable\n| noimd\n| noim\n| noincsearch\n| noinfercase\n| noinf\n| noinsertmode\n| nois\n| nojoinspaces\n| nojs\n| nolangnoremap\n| nolangremap\n| nolazyredraw\n| nolbr\n| nolinebreak\n| nolisp\n| nolist\n| nolnr\n| noloadplugins\n| nolpl\n| nolrm\n| nolz\n| nomacatsui\n| nomagic\n| noma\n| nomh\n| nomle\n| noml\n| nomodelineexpr\n| nomodeline\n| nomodifiable\n| nomodified\n| nomod\n| nomore\n| nomousefocus\n| nomousef\n| nomousehide\n| nonumber\n| nonu\n| noodev\n| noopendevice\n| nopaste\n| nopi\n| nopreserveindent\n| nopreviewwindow\n| noprompt\n| nopvw\n| noreadonly\n| norelativenumber\n| noremap\n| norestorescreen\n| norevins\n| norightleft\n| nori\n| norl\n| nornu\n| noro\n| nors\n| noruler\n| noru\n| nosb\n| noscb\n| noscf\n| noscrollbind\n| noscrollfocus\n| noscs\n| nosc\n| nosecure\n| nosft\n| noshellslash\n| noshelltemp\n| noshiftround\n| noshortname\n| noshowcmd\n| noshowfulltag\n| noshowmatch\n| noshowmode\n| nosi\n| nosmartcase\n| nosmartindent\n| nosmarttab\n| nosmd\n| nosm\n| nosn\n| nosol\n| nospell\n| nosplitbelow\n| nosplitright\n| nospr\n| nosr\n| nossl\n| nostartofline\n| nosta\n| nostmp\n| noswapfile\n| noswf\n| notagbsearch\n| notagrelative\n| notagstack\n| nota\n| notbidi\n| notbi\n| notbs\n| notermbidi\n| noterse\n| notextauto\n| notextmode\n| notf\n| notgst\n| notildeop\n| notimeout\n| notitle\n| notop\n| noto\n| notr\n| nottimeout\n| nottybuiltin\n| nottyfast\n| notx\n| noudf\n| noundofile\n| novb\n| novisualbell\n| nowarn\n| nowa\n| nowb\n| noweirdinvert\n| nowfh\n| nowfw\n| nowic\n| nowildignorecase\n| nowildmenu\n| nowinfixheight\n| nowinfixwidth\n| nowiv\n| nowmnu\n| nowrapscan\n| nowrap\n| nowriteany\n| nowritebackup\n| nowrite\n| nows\n| nrformats\n| numberwidth\n| number\n| nuw\n| nu\n| odev\n| oft\n| ofu\n| omnifunc\n| opendevice\n| operatorfunc\n| opfunc\n| osfiletype\n| packpath\n| paragraphs\n| para\n| pastetoggle\n| paste\n| patchexpr\n| patchmode\n| path\n| pa\n| pdev\n| penc\n| perldll\n| pexpr\n| pex\n| pfn\n| pheader\n| ph\n| pi\n| pmbcs\n| pmbfn\n| pm\n| popt\n| pp\n| preserveindent\n| previewheight\n| previewpopup\n| previewwindow\n| printdevice\n| printencoding\n| printexpr\n| printfont\n| printheader\n| printmbcharset\n| printmbfont\n| printoptions\n| prompt\n| pt\n| pumheight\n| pumwidth\n| pvh\n| pvp\n| pvw\n| pw\n| pythondll\n| pythonhome\n| pythonthreedll\n| pythonthreehome\n| pyxversion\n| pyx\n| qe\n| qftf\n| quickfixtextfunc\n| quoteescape\n| rdt\n| readonly\n| redrawtime\n| regexpengine\n| relativenumber\n| remap\n| renderoptions\n| report\n| restorescreen\n| revins\n| re\n| rightleftcmd\n| rightleft\n| ri\n| rlc\n| rl\n| rnu\n| rop\n| ro\n| rs\n| rtp\n| rubydll\n| ruf\n| rulerformat\n| ruler\n| runtimepath\n| ru\n| sbo\n| sbr\n| sb\n| scb\n| scf\n| scl\n| scrollbind\n| scrollfocus\n| scrolljump\n| scrolloff\n| scrollopt\n| scroll\n| scr\n| scs\n| sc\n| sections\n| sect\n| secure\n| selection\n| selectmode\n| sel\n| sessionoptions\n| sft\n| shcf\n| shellcmdflag\n| shellpipe\n| shellquote\n| shellredir\n| shellslash\n| shelltemp\n| shelltype\n| shellxescape\n| shellxquote\n| shell\n| shiftround\n| shiftwidth\n| shm\n| shortmess\n| shortname\n| showbreak\n| showcmd\n| showfulltag\n| showmatch\n| showmode\n| showtabline\n| shq\n| sh\n| sidescrolloff\n| sidescroll\n| signcolumn\n| siso\n| si\n| sj\n| slm\n| smartcase\n| smartindent\n| smarttab\n| smc\n| smd\n| sm\n| sn\n| softtabstop\n| sol\n| so\n| spc\n| spellcapcheck\n| spellfile\n| spelllang\n| spelloptions\n| spellsuggest\n| spell\n| spf\n| splitbelow\n| splitright\n| spl\n| spo\n| spr\n| sps\n| sp\n| srr\n| sr\n| ssl\n| ssop\n| ss\n| stal\n| startofline\n| statusline\n| sta\n| stl\n| stmp\n| sts\n| st\n| sua\n| suffixesadd\n| suffixes\n| su\n| swapfile\n| swapsync\n| swb\n| swf\n| switchbuf\n| sws\n| sw\n| sxe\n| sxq\n| synmaxcol\n| syntax\n| syn\n| t_8b\n| t_8f\n| t_8u\n| t_AB\n| t_AF\n| t_AL\n| t_AU\n| t_BD\n| t_BE\n| t_CS\n| t_CV\n| t_Ce\n| t_Co\n| t_Cs\n| t_DL\n| t_EC\n| t_EI\n| t_F1\n| t_F2\n| t_F3\n| t_F4\n| t_F5\n| t_F6\n| t_F7\n| t_F8\n| t_F9\n| t_GP\n| t_IE\n| t_IS\n| t_K1\n| t_K3\n| t_K4\n| t_K5\n| t_K6\n| t_K7\n| t_K8\n| t_K9\n| t_KA\n| t_KB\n| t_KC\n| t_KD\n| t_KE\n| t_KF\n| t_KG\n| t_KH\n| t_KI\n| t_KJ\n| t_KK\n| t_KL\n| t_PE\n| t_PS\n| t_RB\n| t_RC\n| t_RF\n| t_RI\n| t_RS\n| t_RT\n| t_RV\n| t_Ri\n| t_SC\n| t_SH\n| t_SI\n| t_SR\n| t_ST\n| t_Sb\n| t_Sf\n| t_Si\n| t_TE\n| t_TI\n| t_Te\n| t_Ts\n| t_VS\n| t_WP\n| t_WS\n| t_ZH\n| t_ZR\n| t_al\n| t_bc\n| t_cd\n| t_ce\n| t_cl\n| t_cm\n| t_cs\n| t_da\n| t_db\n| t_dl\n| t_fd\n| t_fe\n| t_fs\n| t_k1\n| t_k2\n| t_k3\n| t_k4\n| t_k5\n| t_k6\n| t_k7\n| t_k8\n| t_k9\n| t_kB\n| t_kD\n| t_kI\n| t_kN\n| t_kP\n| t_kb\n| t_kd\n| t_ke\n| t_kh\n| t_kl\n| t_kr\n| t_ks\n| t_ku\n| t_le\n| t_mb\n| t_md\n| t_me\n| t_mr\n| t_ms\n| t_nd\n| t_op\n| t_se\n| t_so\n| t_sr\n| t_te\n| t_ti\n| t_ts\n| t_u7\n| t_ue\n| t_us\n| t_ut\n| t_vb\n| t_ve\n| t_vi\n| t_vs\n| t_xn\n| t_xs\n| tabline\n| tabpagemax\n| tabstop\n| tagbsearch\n| tagcase\n| tagfunc\n| taglength\n| tagrelative\n| tagstack\n| tags\n| tag\n| tal\n| ta\n| tbidi\n| tbis\n| tbi\n| tbs\n| tb\n| tcldll\n| tc\n| tenc\n| termbidi\n| termencoding\n| termguicolors\n| termwinkey\n| termwinscroll\n| termwinsize\n| termwintype\n| term\n| terse\n| textauto\n| textmode\n| textwidth\n| tfu\n| tf\n| tgc\n| tgst\n| thesaurus\n| tildeop\n| timeoutlen\n| timeout\n| titlelen\n| titleold\n| titlestring\n| title\n| tl\n| tm\n| toolbariconsize\n| toolbar\n| top\n| to\n| tpm\n| tr\n| tsl\n| tsr\n| ts\n| ttimeoutlen\n| ttimeout\n| ttm\n| ttybuiltin\n| ttyfast\n| ttymouse\n| ttym\n| ttyscroll\n| ttytype\n| tty\n| twk\n| twsl\n| tws\n| twt\n| tw\n| tx\n| uc\n| udf\n| udir\n| ul\n| undodir\n| undofile\n| undolevels\n| undoreload\n| updatecount\n| updatetime\n| ur\n| ut\n| varsofttabstop\n| vartabstop\n| vbs\n| vb\n| vdir\n| verbosefile\n| verbose\n| ve\n| vfile\n| viewdir\n| viewoptions\n| vif\n| viminfofile\n| viminfo\n| virtualedit\n| visualbell\n| vi\n| vop\n| vsts\n| vts\n| wak\n| warn\n| wa\n| wb\n| wcm\n| wcr\n| wc\n| wd\n| weirdinvert\n| wfh\n| wfw\n| whichwrap\n| wh\n| wic\n| wig\n| wildcharm\n| wildchar\n| wildignorecase\n| wildignore\n| wildmenu\n| wildmode\n| wildoptions\n| wim\n| winaltkeys\n| wincolor\n| window\n| winfixheight\n| winfixwidth\n| winheight\n| winminheight\n| winminwidth\n| winptydll\n| winwidth\n| wiv\n| wiw\n| wi\n| wmh\n| wmnu\n| wmw\n| wm\n| wop\n| wrapmargin\n| wrapscan\n| wrap\n| writeany\n| writebackup\n| writedelay\n| write\n| ws\n| ww\n) \\b"
1423 |     },
1424 |     "vimPattern": {
1425 |       "name": "support.function.vimPattern.viml",
1426 |       "match": "(?x) \\b\n( end\n| skip\n| start\n) \\b"
1427 |     },
1428 |     "vimStdPlugin": {
1429 |       "name": "support.class.stdplugin.viml",
1430 |       "match": "(?x) \\b\n( Arguments\n| Asm\n| Break\n| Cfilter\n| Clear\n| Continue\n| DiffOrig\n| Evaluate\n| Finish\n| Gdb\n| Lfilter\n| Man\n| N\n| Next\n| Over\n| P\n| Print\n| Program\n| Run\n| Source\n| Step\n| Stop\n| S\n| TOhtml\n| TermdebugCommand\n| Termdebug\n| Winbar\n| XMLent\n| XMLns\n) \\b"
1431 |     },
1432 |     "vimSynCase": {
1433 |       "name": "support.function.vimSynCase.viml",
1434 |       "match": "(?x) \\b\n( ignore\n| match\n) \\b"
1435 |     },
1436 |     "vimSynType": {
1437 |       "name": "support.function.vimSynType.viml",
1438 |       "match": "(?x) \\b\n( case\n| clear\n| cluster\n| enable\n| include\n| iskeyword\n| keyword\n| list\n| manual\n| match\n| off\n| on\n| region\n| reset\n| sync\n) \\b"
1439 |     },
1440 |     "vimSyncC": {
1441 |       "name": "support.function.vimSyncC.viml",
1442 |       "match": "(?x) \\b\n( ccomment\n| clear\n| fromstart\n) \\b"
1443 |     },
1444 |     "vimSyncLinecont": {
1445 |       "name": "support.function.vimSyncLinecont.viml",
1446 |       "match": "(?x) \\b\n( linecont\n) \\b"
1447 |     },
1448 |     "vimSyncMatch": {
1449 |       "name": "support.function.vimSyncMatch.viml",
1450 |       "match": "(?x) \\b\n( match\n) \\b"
1451 |     },
1452 |     "vimSyncNone": {
1453 |       "name": "support.function.vimSyncNone.viml",
1454 |       "match": "(?x) \\b\n( NONE\n) \\b"
1455 |     },
1456 |     "vimSyncRegion": {
1457 |       "name": "support.function.vimSyncRegion.viml",
1458 |       "match": "(?x) \\b\n( region\n) \\b"
1459 |     },
1460 |     "vimUserAttrbCmplt": {
1461 |       "name": "support.function.vimUserAttrbCmplt.viml",
1462 |       "match": "(?x) \\b\n( augroup\n| behave\n| buffer\n| color\n| command\n| compiler\n| cscope\n| customlist\n| custom\n| dir\n| environment\n| event\n| expression\n| file_in_path\n| filetype\n| file\n| function\n| help\n| highlight\n| history\n| locale\n| mapping\n| menu\n| option\n| packadd\n| shellcmd\n| sign\n| syntax\n| syntime\n| tag_listfiles\n| tag\n| user\n| var\n) \\b"
1463 |     },
1464 |     "vimUserAttrbKey": {
1465 |       "name": "support.function.vimUserAttrbKey.viml",
1466 |       "match": "(?x) \\b\n( bang?\n| bar\n| com\n| complete\n| cou\n| count\n| n\n| nargs\n| ra\n| range\n| re\n| register\n) \\b"
1467 |     },
1468 |     "vimUserCommand": {
1469 |       "name": "support.function.vimUserCommand.viml",
1470 |       "match": "(?x) \\b\n( com\n| command\n) \\b"
1471 |     }
1472 |   }
1473 | }


--------------------------------------------------------------------------------
/syntaxes/vroom.language-configuration.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "brackets": [
 3 |         ["{", "}"],
 4 |         ["[", "]"],
 5 |         ["(", ")"]
 6 |     ],
 7 |     "autoClosingPairs": [
 8 |         { "open": "{", "close": "}" },
 9 |         { "open": "[", "close": "]" },
10 |         { "open": "(", "close": ")" },
11 |         { "open": "\"", "close": "\"", "notIn": ["string"] },
12 |         { "open": "'", "close": "'", "notIn": ["string", "comment"] }
13 |     ],
14 |     "surroundingPairs": [
15 |         { "open": "{", "close": "}" },
16 |         { "open": "[", "close": "]" },
17 |         { "open": "(", "close": ")" },
18 |         { "open": "\"", "close": "\"" },
19 |         { "open": "'", "close": "'" }
20 |     ]
21 | }


--------------------------------------------------------------------------------
/syntaxes/vroom.tmLanguage.json:
--------------------------------------------------------------------------------
  1 | {
  2 |     "scopeName": "source.vroom",
  3 |     "fileTypes": ["vroom"],
  4 |     "patterns": [
  5 |       {
  6 |         "match": "^(  >)( .*)?$",
  7 |         "name": "markup.bold.entity.input.vroom",
  8 |         "captures": {
  9 |           "1": {
 10 |             "name": "support.type.input.vroom"
 11 |           },
 12 |           "2": {
 13 |             "patterns": [{"include": "#vroomControls"}, {"include": "source.viml"}]
 14 |           }
 15 |         }
 16 |       },
 17 |       {
 18 |         "match": "^(  %)( .*)?$",
 19 |         "name": "entity.text.vroom",
 20 |         "captures": {
 21 |           "1": {
 22 |             "name": "support.type.text.vroom"
 23 |           },
 24 |           "2": {
 25 |             "patterns": [{"include": "#vroomControls"}, {"include": "source.viml"}]
 26 |           }
 27 |         }
 28 |       },
 29 |       {
 30 |         "begin": "^  :",
 31 |         "end": "$",
 32 |         "name": "markup.italic.command.vroom",
 33 |         "patterns": [{"include": "#vroomControls"}, {"include": "source.viml"}, {
 34 |           "match": "^(  :)",
 35 |           "name": "support.type.command.vroom"
 36 |         }]
 37 |       },
 38 |       {
 39 |         "match": "^(  &)( .*)?$",
 40 |         "name": "entity.output.vroom",
 41 |         "captures": {
 42 |           "1": {
 43 |             "name": "support.type.output.vroom"
 44 |           },
 45 |           "2": {
 46 |             "name": "text.output.vroom",
 47 |             "patterns": [{"include": "#vroomControls"}]
 48 |           }
 49 |         }
 50 |       },
 51 |       {
 52 |         "match": "^(  \\~)( .*)?$",
 53 |         "name": "entity.message.vroom",
 54 |         "captures": {
 55 |           "1": {
 56 |             "name": "support.type.message.vroom"
 57 |           },
 58 |           "2": {
 59 |             "name": "string.message.vroom",
 60 |             "patterns": [{"include": "#vroomControls"}]
 61 |           }
 62 |         }
 63 |       },
 64 |       {
 65 |         "match": "^(  \\$)( .*)?$",
 66 |         "name": "entity.hijack.vroom",
 67 |         "captures": {
 68 |           "1": {
 69 |             "name": "support.type.hijack.vroom"
 70 |           },
 71 |           "2": {
 72 |             "name": "support.function.hijack.vroom",
 73 |             "patterns": [{"include": "#vroomControls"}]
 74 |           }
 75 |         }
 76 |       },
 77 |       {
 78 |         "match": "^(  !)( .*)?$",
 79 |         "name": "markup.italic.shell.vroom",
 80 |         "captures": {
 81 |           "1": {
 82 |             "name": "support.type.shell.vroom"
 83 |           },
 84 |           "2": {
 85 |               "name": "text.shell.vroom",
 86 |               "patterns": [{"include": "#vroomControls"}, {"include": "source.shell"}]
 87 |           }
 88 |         }
 89 |       },
 90 |       {
 91 |         "match": "^(  @)(\\w+)(\\W\\(.+\\))?$",
 92 |         "name": "markup.italic.directive.vroom",
 93 |         "captures": {
 94 |           "1": {
 95 |             "name": "support.type.directive.vroom"
 96 |           },
 97 |           "2": {
 98 |             "name": "keyword.control.directive.vroom"
 99 |           },
100 |           "3": {
101 |             "patterns": [{"include": "#vroomControls"}]
102 |           }
103 |         }
104 |       },
105 |       {
106 |         "match": "^(  \\|)(.*)?$",
107 |         "name": "entity.continuation.vroom",
108 |         "captures": {
109 |           "1": {
110 |             "name": "support.type.continuation.vroom"
111 |           }
112 |         }
113 |       },
114 |       {
115 |         "match": "^  ([^>:&\\~\\$!@\\|].*)$",
116 |         "name": "markup.italic.output_buffer.vroom",
117 |         "captures": {
118 |           "1": {
119 |             "patterns": [{"include": "#vroomControls"}]
120 |           }
121 |         }
122 |       },
123 |       {
124 |         "match": "^[^ ].*$",
125 |         "name": "comment.line.vroom"
126 |       }
127 |     ],
128 |     "repository": {
129 |       "source.vim": {
130 |         "path": "./syntaxes/viml.tmLanguage.json"
131 |       },
132 |       "vroomControls": {
133 |         "match": "(\\()(.+)(\\))$",
134 |         "name": "variable.control.vroom",
135 |         "captures": {
136 |           "1": {
137 |             "name": "punctuation.definition.control.vroom"
138 |           },
139 |           "3": {
140 |             "name": "punctuation.definition.control.vroom"
141 |           },
142 |           "2": {
143 |             "patterns": [{
144 |               "match": "\\.(,\\+?(\\d+|\\$)?)?$",
145 |               "name": "constant.numeric.range.vroom"
146 |             }, {
147 |               "match": "\\d+$",
148 |               "name": "constant.numeric.range.vroom"
149 |             }, {
150 |               "match": "\\d*(,\\+?(\\d+|\\$))$",
151 |               "name": "constant.numeric.range.vroom"
152 |             }, {
153 |               "match": "(regex|glob|verbatim)$",
154 |               "name": "variable.control.mode.vroom"
155 |             }, {
156 |               "match": "(stderr|stdout|command|status)$",
157 |               "name": "variable.control.channel.vroom"
158 |             }, {
159 |               "match": "bind$",
160 |               "name": "variable.control.bind.vroom"
161 |             }, {
162 |               "match": "(STRICT|RELAXED|GUESS-ERRORS)$",
163 |               "name": "variable.control.strictness.vroom"
164 |             }, {
165 |               "match": "&.",
166 |               "name": "text.escaped.vroom"
167 |             }, {
168 |               "match": ",",
169 |               "name": "punctuation.separator.vroom"
170 |             }, {
171 |               "match": "=",
172 |               "name": "punctuation.separator.vroom"
173 |             }, {
174 |               "begin": "'",
175 |               "end": "'",
176 |               "name": "string.single.vroom"
177 |             }, {
178 |               "begin": "\"",
179 |               "end": "\"",
180 |               "name": "string.double.vroom"
181 |             }, {
182 |               "match": "[a-zA-Z0-9_]+",
183 |               "name": "variable.other.vroom"
184 |             }]
185 |           }
186 |         }
187 |       }
188 |     }
189 |   }


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "module": "commonjs",
 4 |     "target": "es2020",
 5 |     "lib": [
 6 |       "es2020"
 7 |     ],
 8 |     "outDir": "out",
 9 |     "rootDir": "src",
10 |     "sourceMap": true,
11 |     "strict": true,
12 |     "allowJs": false
13 |   },
14 |   "include": [
15 |     "src"
16 |   ],
17 |   "exclude": [
18 |     "node_modules"
19 |   ],
20 |   "compileOnSave": true
21 | }
22 | 


--------------------------------------------------------------------------------
/vroom-examples/basics.vroom:
--------------------------------------------------------------------------------
  1 | This is a vroom script.
  2 | 
  3 | Everything that doesn't start with two spaces is a comment. Feel free to
  4 | explain your tests.
  5 | 
  6 | Vroom input lines start with `  > `. That's two spaces, a greater-than sign,
  7 | and another space. They're passed like :map commands:
  8 | 
  9 |   > iHello, world!<ESC>
 10 | 
 11 | Easy as that. Output lines start with two spaces and check the current buffer.
 12 | 
 13 |   Hello, world!
 14 | 
 15 | Whenever you break up your output tests, vroom goes back to checking the top of
 16 | the buffer. Let's check the output again to make sure it hasn't changed:
 17 | 
 18 |   Hello, world!
 19 | 
 20 | It's still good.
 21 | 
 22 | You start a new test with three blank lines:
 23 | 
 24 | 
 25 | 
 26 | This is a new test! Starting a new test is roughly equivalent to running
 27 | 
 28 |   > :stopinsert<CR>
 29 |   > :silent! bufdo! bdelete!<CR>
 30 | 
 31 | and then increasing vroom's test counter. If you think three blank lines are
 32 | unsightly, you may also begin a new test with the @clear directive. See
 33 | examples/directives.vroom for details.
 34 | 
 35 | 
 36 | 
 37 | You can leave vim in insert mode between commands, though it's not recommended:
 38 | 
 39 |   > iHello,
 40 |   Hello,
 41 |   >  world!<ESC>
 42 |   Hello, world!
 43 | 
 44 | 
 45 | 
 46 | You may also change which buffer you're checking.
 47 | 
 48 |   > iThis text is in buffer THREE<ESC>
 49 |   > :vnew<CR>
 50 |   > iThis text is in buffer 4.<ESC>
 51 |   This text is in buffer THREE (3)
 52 |   This text is in buffer 4. (4)
 53 | 
 54 | Notice the (3) and (4) at the end of the lines -- these are choosing the buffer
 55 | to check, and they're called "vroom controls".
 56 | 
 57 | (Why 3 and 4 instead of 1 and 2? Vim buffer numbers are sequential, but they
 58 | don't ever reset during a vim session -- you just have to count how many buffers
 59 | you've used. It's the nature of the beast.)
 60 | 
 61 | Most vroom lines can end in vroom controls, which are a space followed by
 62 | parenthesis at the end of a line.  You may also do things like select a range of
 63 | lines to check or change the match mode. See examples/controls.vroom for more.
 64 | 
 65 | 
 66 | 
 67 | You may check message output with `  ~ ` lines. This is useful for catching and
 68 | handling errors. Make sure you use `:echomsg` and not vanilla `:echo`! Echos are
 69 | not persistent, and vroom has no way of checking them.
 70 | 
 71 |   > :echomsg "Hello, world!"<CR>
 72 |   ~ Hello, world!
 73 |   > :echomsg exists('x')<CR>
 74 |   ~ 0
 75 | 
 76 | See examples/messages.vroom for more information.
 77 | 
 78 | 
 79 | 
 80 | There are two useful shortcuts that you may appreciate. Firstly, you can use
 81 | lines starting with `  :` to enter vim commands more succinctly:
 82 | 
 83 |   :echomsg "Another message!"
 84 |   ~ Another message!
 85 | 
 86 | This is exactly equivalent to `  > :echomsg "Another message!"<CR>`
 87 | 
 88 | Secondly, you can use lines starting with `  % ` to enter user input.
 89 | 
 90 |   % Goodbye, world.
 91 |   Goodbye, world.
 92 | 
 93 | Which is exactly equivalent to `  > iGoodby, world.<ESC>`: it enters insert
 94 | mode, spits out your text, and exits insert mode.
 95 | 
 96 | Be careful with these shortcuts! They only work from normal mode. If vim isn't in
 97 | normal mode when you use them, things could get a little hairy..
 98 | 
 99 |   :new
100 |   > i
101 |   :LaunchTheNukes
102 |   > <ESC>
103 |   & :LaunchTheNukes
104 |   &
105 | 
106 | Notice how we just tried to match the output line `:LaunchTheNukes`. We couldn't
107 | write it verbatim, because vroom would have thought it was a control line! So we
108 | used `  & ` instead, which explicitly forces output checking. See
109 | examples/escaping.vroom for details.
110 | 
111 | 
112 | 
113 | The currently running file can be found in the $VROOMFILE environment variable.
114 | It is local to the directory where vroom is started.
115 | 
116 |   :echomsg $VROOMFILE
117 |   ~ *basics.vroom (glob)
118 | 
119 | The relative path to the directory containing $VROOMFILE can be found in the
120 | $VROOMDIR environment variable.
121 | 
122 | If vroom was started from the directory containing $VROOMFILE, $VROOMDIR will
123 | be set to '.', and so a file in the same directory as $VROOMFILE can be named
124 | using a path such as $VROOMDIR/foo.vim.
125 | 
126 |   :echomsg $VROOMDIR
127 |   ~ (\.|(.+/)?examples) (regex)
128 | 
129 | 
130 | 
131 | That's all there is to it!
132 | 
133 | In more complicated tests you may need to sandbox vim, preventing it from doing
134 | things like hitting the network for data. To learn how to hijack system calls,
135 | see examples/system.vroom.
136 | 
137 | If you have weird test output that you need to match, you may want to check out
138 | examples/escaping.vroom and examples/continuations.vroom.
139 | 
140 | Then you just run the vroom script (you can use -v for extra output) on your
141 | vroom file, and away you go!
142 | 


--------------------------------------------------------------------------------
/vroom-examples/blocks.vroom:
--------------------------------------------------------------------------------
 1 |   % One<CR>Two<CR>Three<CR><CR>Four
 2 | 
 3 | When you have a block of output commands, vroom checks them against the buffer
 4 | sequentially:
 5 | 
 6 |   One
 7 |   Two
 8 |   Three
 9 | 
10 | When you have a line break between your output checks, you go back to the top.
11 | 
12 |   One
13 | 
14 |   One
15 | 
16 |   One
17 |   Two
18 |   Three
19 | 
20 | Use two spaces instead of a blank line to check for an empty buffer line. (You
21 | may also use `  &` if you dislike trailing whitespace.)
22 | 
23 |   One
24 |   Two
25 |   Three
26 |   &
27 |   Four
28 | 
29 | So if you want to comment during your outputting, comment without blank lines
30 | in-between.
31 | 
32 |   One
33 | Like this.
34 |   Two
35 | 
36 | Finally, three or more blank lines acts like a @clear.
37 | 
38 | 
39 | 
40 |   @end
41 | 


--------------------------------------------------------------------------------
/vroom-examples/buffer.vroom:
--------------------------------------------------------------------------------
 1 | Buffer controls can be placed at the end of any output line. (See
 2 | examples/controls.vroom for more on controls in general.)
 3 | 
 4 |   % Buffer one line one.<CR>
 5 |   % Buffer one line two.
 6 |   :vnew
 7 |   % Buffer two line one.<CR>
 8 |   % Buffer two line two.
 9 | 
10 | If you leave off the buffer control, vroom checks whatever buffer you've loaded
11 | last. If you haven't loaded a buffer before, it checks the active buffer.
12 | 
13 |   Buffer two line one.
14 |   Buffer two line two.
15 | 
16 | Otherwise, it loads the buffer you specify.
17 | 
18 |   Buffer one line one. (1)
19 |   Buffer one line two.
20 | 
21 | Notice how vroom sticks to the (1) buffer after you load it once. That lasts for
22 | continuous output lines. Whenever you start a new output block, vroom goes back
23 | to checking the active buffer.
24 | 
25 |   Buffer two line one.
26 |   Buffer two line two.
27 | 


--------------------------------------------------------------------------------
/vroom-examples/continuations.vroom:
--------------------------------------------------------------------------------
 1 | Sometimes you want lines that are longer that is sightful. For that, you want
 2 | line continuations.
 3 | 
 4 | Vroom line continuations are simple: they are appended to the line prior with no
 5 | whitespace in between.
 6 | 
 7 |   > i
 8 |   |Hello<ESC>
 9 |   Hello
10 | 
11 | 
12 | 
13 | Line continuations can be chained and used anywhere.
14 | 
15 |   > i
16 |   |H
17 |   |e
18 |   |l
19 |   |l
20 |   |o
21 |   |<ESC>
22 | 
23 | 
24 | 
25 | They can't be given controls, so they're useful for outputting literal
26 | parentheses at the end of lines.
27 | 
28 |   > i
29 |   |(regex)<ESC>
30 |   (regex)
31 | 
32 | 
33 | 
34 | You can join output lines:
35 | 
36 |   > iHello<ESC>
37 |   Hel
38 |   |lo
39 | 
40 | 
41 | 
42 | And system hijack lines:
43 | 
44 |   :.!echo "Hello"
45 |   $ Capt
46 |   |ured
47 |   Captured
48 | 
49 | Though remember that you can string system hijack lines together to get
50 | newlines, which is more often what you want with system hijacking:
51 | 
52 |   :.!echo "Hello"
53 |   $ Captured, my friend.
54 |   $ Captured.
55 | 


--------------------------------------------------------------------------------
/vroom-examples/controls.vroom:
--------------------------------------------------------------------------------
 1 | When you end a line with a space and parentheses, you're sending controls to
 2 | vroom. (If you'd rather not, see examples/escaping.vroom.) Different types of
 3 | lines take different types of controls.
 4 | 
 5 | The most important controls are output line controls. There are three different
 6 | controls words that you can use in output lines:
 7 | 
 8 | 
 9 | 
10 | 1. You can choose an output buffer. Buffer controls are just a number.
11 | 
12 |   % Buffer one.
13 |   :vnew
14 |   % Buffer two.
15 |   Buffer one. (1)
16 |   Buffer two. (2)
17 | 
18 | See examples/buffer.vroom for more tricks.
19 | 
20 | 
21 | 
22 | 2. You may select a range of lines to match in the current buffer. You do this
23 | by specifying X,Y  where X is the line to start on and Y is the line to end on.
24 | 
25 |   > 10aHello<CR><ESC>
26 |   > 10aWorld<CR><ESC>
27 |   > dd
28 |   Hello (1,10)
29 |   World (,$)
30 | 
31 | 
32 | 
33 | 2.1. A slight variation on the range control, you may use the `.` control to
34 | check starting at the cursor line instead of starting at the top of the buffer.
35 | 
36 |   % One<CR>Two<CR>Three
37 |   > k
38 |   Two (.)
39 | 
40 | 
41 | 
42 | 3. You may change the match mode of the output line to `regex` or `glob`.
43 | 
44 |   % The quick brown fox jumps over the lazy dog?
45 |   The * * ??? jumps over the * dog[?] (glob)
46 | 
47 | See examples/mode.vroom for more tricks.
48 | 
49 | 
50 | 
51 | Message capture lines can specify a mode, but no other controls.
52 | 
53 |   :echomsg "Hello there!"
54 |   ~ * (glob)
55 |   :echomsg "Hello there!"
56 |   ~ .* (regex)
57 |   :echomsg "Hello there!"
58 |   ~ Hello there!
59 | 
60 | System capture lines are similar: you may specify a mode, but nothing else.
61 | 
62 | 
63 | 
64 | Input lines also have their own special type of control, the delay control. You
65 | use this to have vroom pause after a command that is going to take a long time.
66 | 
67 |   :sleep 1 (1.1s)
68 |   % I'm awake now!
69 |   I'm awake now!
70 | 
71 | The delay control is any number (decimal allowed) followed by an 's'. Vroom
72 | pauses for that many seconds before continuing. The delay must be prefixed with
73 | a leading zero if it's less than one.
74 | 
75 | Note that this pause is in addition to the delay specified by the -d flag.
76 | 


--------------------------------------------------------------------------------
/vroom-examples/directives.vroom:
--------------------------------------------------------------------------------
 1 | Lines that start with `  @` are directives. Some are hard-baked shortcuts,
 2 | others unleash special functionality that can't be achieved otherwise.
 3 | 
 4 | Vroom directives include:
 5 | 
 6 | 1. @end, used to check that all output has been accounted for.
 7 | 
 8 |   > 10aHello<CR><ESC>dd
 9 | 
10 | Normally, vroom checks the lines that you tell it to check and no further. Using
11 | the @end directive, you can verify that the last line checked was the final line
12 | in the buffer.
13 | 
14 |   Hello (,+9)
15 |   @end
16 | 
17 | 
18 | 
19 | 2. @clear, which clears out all the existing buffers. Use it between tests when
20 | you want to start anew.
21 | 
22 |   % Hello
23 |   @clear
24 |   @end
25 | 
26 | 
27 | 
28 | 3. @messages, which can control the message strictness temporarily.
29 | 
30 | Normally, you *must* catch error messages, or vroom complains (unless you've
31 | tweaked the --message-strictness flag).
32 | 
33 |   :set cmdheight=99
34 | 
35 |   :throw 'I broke something!'
36 |   ~ Error detected while processing * (glob)
37 |   ~ E605: Exception not caught: * (glob)
38 | 
39 | But with the @messages directive, you can temporarily change the message
40 | strictness setting:
41 | 
42 |   @messages (RELAXED)
43 |   :throw 'I broke it again.'
44 |   @messages
45 | 
46 | Notice how @messages without a control block resets the message handling back
47 | to its original --message-strictness setting.
48 | 
49 | 
50 | 
51 | You may also use @system to temporarily override --system-strictness.
52 | 
53 |   @system (RELAXED)
54 |   :.!echo "Hello"
55 |   @system
56 | 
57 | This will pass even if you run the test with --system-strictness=STRICT
58 | 


--------------------------------------------------------------------------------
/vroom-examples/escaping.vroom:
--------------------------------------------------------------------------------
 1 | Sometimes, vroom syntax gets in the way of your tests. When you have weird
 2 | tests, there's two escaping rules that you need to remember.
 3 | 
 4 | 
 5 | 
 6 | 1. The ampersand (&) escapes a control block.
 7 | 
 8 |   % Literal line ending in (&1)
 9 |   Literal line ending in (&1)
10 | 
11 | The contents of the buffer will be "Literal line ending in (1)"
12 | 
13 | 
14 | 
15 | 2. Lines starting with `  & ` are also output lines.
16 | 
17 |   % > This looks like an input line.
18 |   & > This looks like an input line.
19 | 
20 | As a special case, you can use the line `  &` to match an empty buffer line.
21 | (two blank spaces will also work, but some editors complain about trailing
22 | whitespace.)
23 | 
24 |   @clear
25 |   % Hello<CR><CR>World
26 |   Hello
27 |   &
28 |   World
29 | 
30 | 
31 | 
32 | Finally, remember that you can escape special characters in glob mode with
33 | square brackets.
34 | 
35 |   % What? An asterisk*
36 |   & ????[?] An *[*] (glob)
37 | 


--------------------------------------------------------------------------------
/vroom-examples/macros.vroom:
--------------------------------------------------------------------------------
  1 | Sometimes you may find yourself repeating similar chunks of vroom code across
  2 | different tests. For example, let's write some tests for the 'cindent' feature:
  3 | 
  4 | Enter a small, unindented function
  5 |   % void func()<cr>
  6 |   % {<cr>
  7 |   % if (true) {<cr>
  8 |   % printf("hello\n!");<cr>
  9 |   % }<cr>
 10 |   % }<cr>
 11 | Enable cindent and set tabstop and shiftwidth to 2
 12 |   :set cin ts=2 sw=2 et
 13 |   > gg=G
 14 | Now function should have a 2-space indentation:
 15 |   void func()
 16 |   {
 17 |     if (true) {
 18 |       printf("hello\n!");
 19 |     }
 20 |   }
 21 |   &
 22 |   @end
 23 |   @clear
 24 | 
 25 | Now let's test cindent again, but with another value for ts/sw. To make sure
 26 | the previous indentation won't affect this one, we start with a clear buffer:
 27 |   % void func()<cr>
 28 |   % {<cr>
 29 |   % if (true) {<cr>
 30 |   % printf("hello\n!");<cr>
 31 |   % }<cr>
 32 |   % }<cr>
 33 |   :set cin ts=4 sw=4 et
 34 |   > gg=G
 35 |   void func()
 36 |   {
 37 |       if (true) {
 38 |           printf("hello\n!");
 39 |       }
 40 |   }
 41 |   &
 42 |   @end
 43 |   @clear
 44 | 
 45 | The above pattern of writing tests can generalized like this:
 46 | 
 47 | - Start with a clear buffer
 48 | - Input some text
 49 | - Call a function or command with some parameters
 50 | - Verify if the buffer is in a expected state
 51 | - Repeat but with a different set of parameters
 52 | 
 53 | Macros can be used to create reusable chunks of vroom code and help reduce
 54 | boilerplate across tests. Let's rewrite the above test using macros:
 55 | 
 56 |   @macro (input_unindented_function)
 57 |   % void func()<cr>
 58 |   % {<cr>
 59 |   % if (true) {<cr>
 60 |   % printf("hello\n!");<cr>
 61 |   % }<cr>
 62 |   % }<cr>
 63 |   @endmacro
 64 | 
 65 | The above defined a macro named 'input_unindented_function' that takes care of
 66 | entering an unindented function in the current buffer.
 67 | 
 68 |   &
 69 |   @end
 70 | 
 71 | As you can see, the buffer wasn't modified. The macro can be "executed" with
 72 | a @do directive:
 73 | 
 74 |   @do (input_unindented_function)
 75 |   void func()
 76 |   {
 77 |   if (true) {
 78 |   printf("hello\n!");
 79 |   }
 80 |   }
 81 |   &
 82 |   @end
 83 | 
 84 | Now indent and verify output
 85 |   :set cin ts=4 sw=4 et
 86 |   > gg=G
 87 |   void func()
 88 |   {
 89 |       if (true) {
 90 |           printf("hello\n!");
 91 |       }
 92 |   }
 93 |   &
 94 |   @end
 95 |   @clear
 96 | 
 97 | A cool thing about macros is that the lines between the @macro/@endmacro
 98 | directives can contain python format string syntax(the same syntax used by
 99 | str.format()). For example:
100 | 
101 |   @macro (greet)
102 |   % hello {subject}<cr>
103 |   @endmacro
104 |   @do (greet, subject='world')
105 |   @do (greet, subject='vroom')
106 |   hello world
107 |   hello vroom
108 |   &
109 |   @end
110 |   @clear
111 | 
112 | That means we can generalize even the cindent verification:
113 | 
114 |   @macro (indent_and_verify)
115 |   :set cin ts={count} sw={count} et
116 |   > gg=G
117 |   void func()
118 |   {{
119 |   {fill:{count}}if (true) {{
120 |   {fill:{count}}{fill:{count}}printf("hello\n!");
121 |   {fill:{count}}}}
122 |   }}
123 | Notice how any braces that are part of the output need to be escaped. This is
124 | only necessary when the macro is executed with arguments.
125 |   &
126 |   @endmacro
127 | 
128 | Let's split into two macros to improve readability:
129 | 
130 |   @macro (verify)
131 |   void func()
132 |   {{
133 |   {indent}if (true) {{
134 |   {indent}{indent}printf("hello\n!");
135 |   {indent}}}
136 |   }}
137 |   &
138 |   @endmacro
139 | 
140 |   @macro (indent_and_verify)
141 | Notice how macros can be redefined at any time
142 |   :set cin ts={count} sw={count} et
143 |   > gg=G
144 |   @do (verify, indent='{fill:{count}}')
145 |   @endmacro
146 | 
147 | After the macro is defined we can easily test cindent for multiple ts/sw
148 | values. The keyword arguments passed to @do can contain simple python
149 | expressions:
150 | 
151 |   @do (input_unindented_function)
152 |   @do (indent_and_verify, fill=' ', count=2)
153 |   @clear
154 |   @do (input_unindented_function)
155 |   @do (indent_and_verify, fill=' ', count=4)
156 |   @clear
157 | 
158 | Since macros can contain `@do` directives, the test can be simplified even
159 | further:
160 | 
161 |   @macro (test_cindent)
162 |   @do (input_unindented_function)
163 |   @do (indent_and_verify, fill=' ', count={width})
164 |   @clear
165 |   @endmacro
166 | 
167 |   @do (test_cindent, width=2)
168 |   @do (test_cindent, width=4)
169 |   @do (test_cindent, width=6)
170 |   @do (test_cindent, width=8)
171 | 
172 | It's important to understand parsing macro contents is delayed until a
173 | corresponding @do directive is found:
174 | 
175 |   @macro (insert_or_verify)
176 |   {prefix}some text
177 |   @endmacro
178 | 
179 | Input the text
180 | 
181 |   @do (insert_or_verify, prefix='% ')
182 |   @do (insert_or_verify, prefix='')
183 |   @clear
184 | 
185 | Finally, macro names can contain spaces for more descriptive names:
186 | 
187 |   @macro (test cindent for arbitrary widths)
188 |   @do (test_cindent, width={width})
189 |   @endmacro
190 | 
191 |   @do (test cindent for arbitrary widths, width=2)
192 |   @do (test cindent for arbitrary widths, width=4)
193 |   @do (test cindent for arbitrary widths, width=8)
194 | 
195 | For more details about python format syntax, see:
196 | https://docs.python.org/2/library/string.html#format-string-syntax
197 | 


--------------------------------------------------------------------------------
/vroom-examples/messages.vroom:
--------------------------------------------------------------------------------
 1 | You can check message output with a `  ~ ` line. You must catch messages after
 2 | the command that causes them if you want it to work.
 3 | 
 4 |   :echomsg "Hello."
 5 |   ~ Hello.
 6 | 
 7 | This mechanism allows vroom to know what lines errors occur on. You can match
 8 | multiple messages on one command.
 9 | 
10 |   :set cmdheight=99
11 | 
12 |   :echomsg "First" | echomsg "Second"
13 |   ~ First
14 |   ~ Second
15 | 
16 | Note sometimes multiple lines of output cause vroom to get stuck at a "Hit ENTER
17 | to continue" prompt (typically in Neovim mode), and increasing cmdheight is a
18 | simple workaround to avoid getting stuck. See
19 | https://github.com/google/vroom/issues/83.
20 | 
21 | By default, vroom doesn't mind if you miss messages. It only minds if you miss
22 | messages that vroom thinks look like error messages.
23 | 
24 | You can tweak this behavior with the --message-strictness flag.
25 | 
26 | For example, the test below will fail with --message-strictness=STRICT, because
27 | the message is not caught.
28 | 
29 |   :echomsg "Third."
30 | 


--------------------------------------------------------------------------------
/vroom-examples/mode.vroom:
--------------------------------------------------------------------------------
 1 | By default, output lines are matched in verbatim mode:
 2 | 
 3 |   % The quick brown fox jumps over the lazy dog?
 4 |   The quick brown fox jumps over the lazy dog?
 5 | 
 6 | You make modes explicit with control blocks:
 7 | 
 8 |   The quick brown fox jumps over the lazy dog? (verbatim)
 9 | 
10 | You may also use `glob` mode and `regex` mode. * and ? are expanded in glob mode
11 | and may be escaped. This works like python's fnmatch.
12 | 
13 |   The * * ??? jumps over the * dog[?] (glob)
14 | 
15 | Regexes are python-style.
16 | 
17 |   \w+ \w+ brown fox .* lazy dog\? (regex)
18 | 
19 | Python regex flags etc. all work:
20 | 
21 |   (?i)\w+ \w+ BROWN FOX .* LAZY DOG. (regex)
22 | 
23 | We suggest you use flags at the beginning of the regex, so as to not confuse
24 | vroom into thinking you're misspelling line controls.
25 | 
26 | 
27 | 
28 | System capture lines are matched in regex mode by default:
29 | 
30 |   :.!echo 'Hello.'
31 |   ! echo .*
32 |   Hello.
33 | 
34 | You may override that.
35 | 
36 |   @clear
37 |   :.!echo '.*'
38 |   ! echo '.*' (verbatim)
39 |   .*
40 | 


--------------------------------------------------------------------------------
/vroom-examples/range.vroom:
--------------------------------------------------------------------------------
 1 | The range syntax is X,Y. Only the comma is required. If X is omitted, vroom
 2 | picks up where it starts off. If Y is omitted, only one line is matched.
 3 | 
 4 | If both are omitted, nothing really happens, but it's technically valid:
 5 | 
 6 |   % Hello,<CR>
 7 |   % World
 8 |   Hello,
 9 |   World (,)
10 | 
11 | 
12 | 
13 | X may also be `.` to start the match at the current cursor position.
14 | 
15 |   % One<CR>Two<CR>Two<CR>Three<CR>Three<CR>Three<CR>
16 |   > 5k
17 |   Two (.,+1)
18 | 
19 | 
20 | 
21 | Y is the end of the range. Y may be absolute:
22 | 
23 |   > 10aHello<CR><ESC>
24 |   > 10aWorld<CR><ESC>
25 |   > dd
26 |   Hello (1,10)
27 |   World (,20)
28 | 
29 | Or relative:
30 | 
31 |   Hello (1,10)
32 |   World (,+9)
33 | 
34 | Y may also be `$` to continue the check until the end of the buffer.
35 | 
36 |   Hello (1,10)
37 |   World (,$)
38 | 


--------------------------------------------------------------------------------
/vroom-examples/system.vroom:
--------------------------------------------------------------------------------
  1 | Sometimes, vim makes calls to the system at large. That could be bad during
  2 | testing if your plugin is hitting a network or launching the nukes.
  3 | 
  4 | Vroom provides you with two tools to handle vim system calls.
  5 | 
  6 | Firstly, you can verify that system calls match a certain expected pattern:
  7 | 
  8 |   :.!echo "Hey system, talk to me."
  9 |   ! echo .*
 10 | 
 11 | System calls are matched in regex mode by default.
 12 | 
 13 | 
 14 | 
 15 | This works with :call as well.
 16 | 
 17 |   :echomsg system('echo hi')
 18 |   ! echo hi (verbatim)
 19 |   ~ hi
 20 | 
 21 | 
 22 | 
 23 | If the system call that vim actually makes doesn't match the one you specify,
 24 | vroom will complain.
 25 | 
 26 | By default, any unexpected system calls will trigger a failure. This strictness
 27 | helps protect you from unknowingly triggering system calls that succeed in your
 28 | environment but fail when others try to run them, and also encourages you to
 29 | document your expectations. But if this gets annoying, you can always turn it
 30 | off with @system (RELAXED).
 31 | 
 32 |   @system (RELAXED)
 33 |   :.!echo "Come at me, bro."
 34 | 
 35 | 
 36 | This is nice, but it doesn't really give you much control over the system. To do
 37 | that, you need to hijack the system and hoodwink vim:
 38 | 
 39 |   :.!echo "Hey system, talk to me."
 40 |   ! echo "Hey system, talk to me\."
 41 |   $ No. I'm not talking.
 42 | 
 43 | Let's check whether or not that worked:
 44 | 
 45 |   No. I'm not talking.
 46 | 
 47 | Good!
 48 | 
 49 | 
 50 | 
 51 | If you need newlines in your dummy output, string hijack commands together.
 52 | 
 53 |   :.!echo "Please?"
 54 |   ! echo "Please\?"
 55 |   $ No!
 56 |   $ Go away.
 57 |   No!
 58 |   Go away.
 59 | 
 60 | 
 61 | 
 62 | You may use system hijack lines to change the exit status using the "status"
 63 | control word:
 64 | 
 65 |   :set cmdheight=99
 66 | 
 67 |   :.!echo "Testing"
 68 |   $ 2 (status)
 69 |   :echomsg v:shell_error
 70 |   ~ 2
 71 | 
 72 | 
 73 | Or even to change the command entirely:
 74 | 
 75 |   :.!rm "Testing."
 76 |   $ echo "Testing." (command)
 77 |   Testing.
 78 | 
 79 | The default output channel is 'stdout'. You may explicitly mark it if you wish.
 80 | 
 81 |   :.!echo "Testing"
 82 |   $ .gnitseT (stdout)
 83 |   .gnitseT
 84 | 
 85 | 
 86 | 
 87 | If you capture a command with a regex, the regex's match groups will be
 88 | available to hijack lines.
 89 | 
 90 |   :.!rm hello
 91 |   ! rm (\w+)
 92 |   $ echo \1 (command)
 93 |   hello
 94 | 
 95 | 
 96 | 
 97 |   :.!rm hello
 98 |   ! rm (\w+)
 99 |   $ \1 \1
100 |   hello hello
101 | 
102 |   @system
103 | 


--------------------------------------------------------------------------------