+
+[](https://travis-ci.org/petkaantonov/bluebird)
+[](http://petkaantonov.github.io/bluebird/coverage/debug/index.html)
+
+**Got a question?** Join us on [stackoverflow](http://stackoverflow.com/questions/tagged/bluebird), the [mailing list](https://groups.google.com/forum/#!forum/bluebird-js) or chat on [IRC](https://webchat.freenode.net/?channels=#promises)
+
+# Introduction
+
+Bluebird is a fully featured promise library with focus on innovative features and performance
+
+See the [bluebird website](http://bluebirdjs.com/docs/getting-started.html) for further documentation, references and instructions.
+
+For bluebird 2.x documentation and files, see the [2.x tree](https://github.com/petkaantonov/bluebird/tree/2.x).
+
+# Questions and issues
+
+The [github issue tracker](https://github.com/petkaantonov/bluebird/issues) is **_only_** for bug reports and feature requests. Anything else, such as questions for help in using the library, should be posted in [StackOverflow](http://stackoverflow.com/questions/tagged/bluebird) under tags `promise` and `bluebird`.
+
+# License
+
+The MIT License (MIT)
+
+Copyright (c) 2013-2015 Petka Antonov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/bluebird/changelog.md b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/bluebird/changelog.md
new file mode 100644
index 00000000..73b2eb6c
--- /dev/null
+++ b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/bluebird/changelog.md
@@ -0,0 +1 @@
+[http://bluebirdjs.com/docs/changelog.html](http://bluebirdjs.com/docs/changelog.html)
diff --git a/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/bluebird/js/browser/bluebird.js b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/bluebird/js/browser/bluebird.js
new file mode 100644
index 00000000..8c742cda
--- /dev/null
+++ b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/bluebird/js/browser/bluebird.js
@@ -0,0 +1,5286 @@
+/* @preserve
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2013-2015 Petka Antonov
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+/**
+ * bluebird build version 3.0.6
+ * Features enabled: core, race, call_get, generators, map, nodeify, promisify, props, reduce, settle, some, using, timers, filter, any, each
+*/
+!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.Promise=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof _dereq_=="function"&&_dereq_;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof _dereq_=="function"&&_dereq_;for(var o=0;o
+
+
+
diff --git a/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/instant-markdown-d b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/instant-markdown-d
new file mode 100755
index 00000000..c75208fd
--- /dev/null
+++ b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/instant-markdown-d
@@ -0,0 +1,101 @@
+#!/bin/sh
+':' //; exec "`command -v nodejs || command -v node`" "$0"
+
+var MarkdownIt = require('markdown-it');
+var hljs = require('highlight.js');
+var server = require('http').createServer(httpHandler),
+ exec = require('child_process').exec,
+ io = require('socket.io').listen(server),
+ send = require('send'),
+ server,
+ socket;
+
+server.listen(8090);
+
+var md = new MarkdownIt({
+ html: true,
+ linkify: true,
+ highlight: function(str, lang) {
+ if (lang && hljs.getLanguage(lang)) {
+ try {
+ return hljs.highlight(lang, str).value;
+ } catch (err) {
+ // Do nothing
+ }
+ } else {
+ return str;
+ }
+ }
+});
+
+function writeMarkdown(input, output) {
+ var body = '';
+ input.on('data', function(data) {
+ body += data;
+ if (body.length > 1e6) {
+ throw new Error('The request body is too long.');
+ }
+ });
+ input.on('end', function() {
+ output.emit('newContent', md.render(body));
+ });
+}
+
+function httpHandler(req, res) {
+ switch(req.method)
+ {
+ case 'GET':
+ // Example: /my-repo/raw/master/sub-dir/some.png
+ var githubUrl = req.url.match(/\/[^\/]+\/raw\/[^\/]+\/(.+)/);
+ if (githubUrl) {
+ // Serve the file out of the current working directory
+ send(req, githubUrl[1])
+ .root(process.cwd())
+ .pipe(res);
+ return;
+ }
+
+ // Otherwise serve the file from the directory this module is in
+ send(req, req.url)
+ .root(__dirname)
+ .pipe(res);
+ break;
+
+ // case 'HEAD':
+ // res.writeHead(200);
+ // res.end();
+ // exec('open -g http://localhost:8090', function(error, stdout, stderr){
+ // http.request({port: 8090})
+ // });
+ // break;
+
+ case 'DELETE':
+ socket.emit('die');
+ process.exit();
+ break;
+
+ case 'PUT':
+ writeMarkdown(req, socket);
+ res.writeHead(200);
+ res.end();
+ break;
+
+ default:
+ }
+}
+
+io.set('log level', 1);
+io.sockets.on('connection', function(sock){
+ socket = sock;
+ process.stdout.write('connection established!');
+ writeMarkdown(process.stdin, socket);
+ process.stdin.resume();
+});
+
+
+if (process.platform.toLowerCase().indexOf('darwin') >= 0){
+ exec('open -g http://localhost:8090', function(error, stdout, stderr){});
+}
+else { // assume unix/linux
+ exec('xdg-open http://localhost:8090', function(error, stdout, stderr){});
+}
diff --git a/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/.bin/markdown-it b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/.bin/markdown-it
new file mode 100755
index 00000000..290c3ae1
--- /dev/null
+++ b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/.bin/markdown-it
@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/*eslint no-console:0*/
+
+'use strict';
+
+
+var fs = require('fs');
+var argparse = require('argparse');
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+var cli = new argparse.ArgumentParser({
+ prog: 'markdown-it',
+ version: require('../package.json').version,
+ addHelp: true
+});
+
+cli.addArgument([ '--no-html' ], {
+ help: 'Disable embedded HTML',
+ action: 'storeTrue'
+});
+
+cli.addArgument([ '-l', '--linkify' ], {
+ help: 'Autolink text',
+ action: 'storeTrue'
+});
+
+cli.addArgument([ '-t', '--typographer' ], {
+ help: 'Enable smartquotes and other typographic replacements',
+ action: 'storeTrue'
+});
+
+cli.addArgument([ '--trace' ], {
+ help: 'Show stack trace on error',
+ action: 'storeTrue'
+});
+
+cli.addArgument([ 'file' ], {
+ help: 'File to read',
+ nargs: '?',
+ defaultValue: '-'
+});
+
+var options = cli.parseArgs();
+
+
+function readFile(filename, encoding, callback) {
+ if (options.file === '-') {
+ // read from stdin
+ var chunks = [];
+
+ process.stdin.on('data', function(chunk) { chunks.push(chunk); });
+
+ process.stdin.on('end', function() {
+ return callback(null, Buffer.concat(chunks).toString(encoding));
+ });
+ } else {
+ fs.readFile(filename, encoding, callback);
+ }
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+readFile(options.file, 'utf8', function (err, input) {
+ var output, md;
+
+ if (err) {
+ if (err.code === 'ENOENT') {
+ console.error('File not found: ' + options.file);
+ process.exit(2);
+ }
+
+ console.error(
+ options.trace && err.stack ||
+ err.message ||
+ String(err));
+
+ process.exit(1);
+ }
+
+ md = require('..')({
+ html: !options['no-html'],
+ xhtmlOut: false,
+ typographer: options.typographer,
+ linkify: options.linkify
+ });
+
+ try {
+ output = md.render(input);
+
+ } catch (e) {
+ console.error(
+ options.trace && e.stack ||
+ e.message ||
+ String(e));
+
+ process.exit(1);
+ }
+
+ process.stdout.write(output);
+
+ process.exit(0);
+});
diff --git a/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/LICENSE b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/LICENSE
new file mode 100644
index 00000000..422deb73
--- /dev/null
+++ b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/LICENSE
@@ -0,0 +1,24 @@
+Copyright (c) 2006, Ivan Sagalaev
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of highlight.js nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/README.md b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/README.md
new file mode 100644
index 00000000..e03877bf
--- /dev/null
+++ b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/README.md
@@ -0,0 +1,106 @@
+# Highlight.js
+
+[](https://travis-ci.org/isagalaev/highlight.js)
+
+Highlight.js is a syntax highlighter written in JavaScript. It works in
+the browser as well as on the server. It works with pretty much any
+markup, doesn’t depend on any framework and has automatic language
+detection.
+
+## Getting Started
+
+The bare minimum for using highlight.js on a web page is linking to the
+library along with one of the styles and calling
+[`initHighlightingOnLoad`][1]:
+
+```html
+
+
+
+```
+
+This will find and highlight code inside of `
+
+
+ ` tags; it tries
+to detect the language automatically. If automatic detection doesn’t
+work for you, you can specify the language in the `class` attribute:
+
+```html
+...
+```
+
+The list of supported language classes is available in the [class
+reference][2]. Classes can also be prefixed with either `language-` or
+`lang-`.
+
+To disable highlighting altogether use the `nohighlight` class:
+
+```html
+...
+```
+
+## Custom Initialization
+
+When you need a bit more control over the initialization of
+highlight.js, you can use the [`highlightBlock`][3] and [`configure`][4]
+functions. This allows you to control *what* to highlight and *when*.
+
+Here’s an equivalent way to calling [`initHighlightingOnLoad`][1] using
+jQuery:
+
+```javascript
+$(document).ready(function() {
+ $('pre code').each(function(i, block) {
+ hljs.highlightBlock(block);
+ });
+});
+```
+
+You can use any tags instead of `` to mark up your code. If
+you don't use a container that preserve line breaks you will need to
+configure highlight.js to use the `
` tag:
+
+```javascript
+hljs.configure({useBR: true});
+
+$('div.code').each(function(i, block) {
+ hljs.highlightBlock(block);
+});
+```
+
+For other options refer to the documentation for [`configure`][4].
+
+## Getting the Library
+
+You can get highlight.js as a hosted, or custom-build, browser script or
+as a server module. Right out of the box the browser script supports
+both AMD and CommonJS, so if you wish you can use RequireJS or
+Browserify without having to build from source. The server module also
+works perfectly fine with Browserify, but there is the option to use a
+build specific to browsers rather than something meant for a server.
+Head over to the [download page][5] for all the options.
+
+**Note:** the library is not supposed to work straight from the source
+on GitHub; it requires building. If none of the pre-packaged options
+work for you refer to the [building documentation][6].
+
+## License
+
+Highlight.js is released under the BSD License. See [LICENSE][7] file
+for details.
+
+## Links
+
+The official site for the library is at
`` tags instead of new-line characters. Options are set globally with ``configure``.
+
+Accepts a string with the highlighted markup.
+
+
+``highlightBlock(block)``
+-------------------------
+
+Applies highlighting to a DOM node containing code.
+
+This function is the one to use to apply highlighting dynamically after page load
+or within initialization code of third-party Javascript frameworks.
+
+The function uses language detection by default but you can specify the language
+in the ``class`` attribute of the DOM node. See the :doc:`class reference
+` for all available language names and aliases.
+
+
+``configure(options)``
+----------------------
+
+Configures global options:
+
+* ``tabReplace``: a string used to replace TAB characters in indentation.
+* ``useBR``: a flag to generate ``
`` tags instead of new-line characters in the output, useful when code is marked up using a non-```` container.
+* ``classPrefix``: a string prefix added before class names in the generated markup, used for backwards compatibility with stylesheets.
+* ``languages``: an array of language names and aliases restricting auto detection to only these languages.
+
+Accepts an object representing options with the values to updated. Other options don't change
+::
+
+ hljs.configure({
+ tabReplace: ' ', // 4 spaces
+ classPrefix: '' // don't append class prefix
+ // … other options aren't changed
+ })
+ hljs.initHighlighting();
+
+
+``initHighlighting()``
+----------------------
+
+Applies highlighting to all ``..
`` blocks on a page.
+
+
+
+``initHighlightingOnLoad()``
+----------------------------
+
+Attaches highlighting to the page load event.
+
+
+``registerLanguage(name, language)``
+------------------------------------
+
+Adds new language to the library under the specified name. Used mostly internally.
+
+* ``name``: a string with the name of the language being registered
+* ``language``: a function that returns an object which represents the
+ language definition. The function is passed the ``hljs`` object to be able
+ to use common regular expressions defined within it.
+
+
+``listLanguages()``
+----------------------------
+
+Returns the languages names list.
+
+
+
+.. _getLanguage:
+
+
+``getLanguage(name)``
+---------------------
+
+Looks up a language by name or alias.
+
+Returns the language object if found, ``undefined`` otherwise.
diff --git a/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/building-testing.rst b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/building-testing.rst
new file mode 100644
index 00000000..16292cb8
--- /dev/null
+++ b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/building-testing.rst
@@ -0,0 +1,88 @@
+Building and testing
+====================
+
+To actually run highlight.js it is necessary to build it for the environment
+where you're going to run it: a browser, the node.js server, etc.
+
+
+Building
+--------
+
+The build tool is written in JavaScript using node.js. Before running the
+script, make sure to have node installed and run ``npm install`` to get the
+dependencies.
+
+The tool is located in ``tools/build.js``. A few useful examples:
+
+* Build for a browser using only common languages::
+
+ node tools/build.js :common
+
+* Build for node.js including all available languages::
+
+ node tools/build.js -t node
+
+* Build two specific languages for debugging, skipping compression in this case::
+
+ node tools/build.js -n python ruby
+
+On some systems the node binary is named ``nodejs``; simply replace ``node``
+with ``nodejs`` in the examples above if that is the case.
+
+The full option reference is available with the usual ``--help`` option.
+
+The build result will be in the ``build/`` directory.
+
+.. _basic-testing:
+
+Basic testing
+-------------
+
+The usual approach to debugging and testing a language is first doing it
+visually. You need to build highlight.js with only the language you're working
+on (without compression, to have readable code in browser error messages) and
+then use the Developer tool in ``tools/developer.html`` to see how it highlights
+a test snippet in that language.
+
+A test snippet should be short and give the idea of the overall look of the
+language. It shouldn't include every possible syntactic element and shouldn't
+even make practical sense.
+
+After you satisfied with the result you need to make sure that language
+detection still works with your language definition included in the whole suite.
+
+Testing is done using `Mocha /default.txt``, build the package with all the languages
+for node and run the test suite. If your language breaks auto-detection, it
+should be fixed by :ref:`improving relevance `, which is a black art
+in and of itself. When in doubt, please refer to the discussion group!
+
+
+Testing markup
+--------------
+
+You can also provide additional markup tests for the language to test isolated
+cases of various syntactic construct. If your language has 19 different string
+literals or complicated heuristics for telling division (``/``) apart from
+regexes (``/ .. /``) -- this is the place.
+
+A test case consists of two files:
+
+* ``test/markup//.txt``: test code
+* ``test/markup//.expect.txt``: reference rendering
+
+To generate reference rendering use the Developer tool located at
+``tools/developer.html``. Make sure to explicitly select your language in the
+drop-down menu, as automatic detection is unlikely to work in this case.
+
+
diff --git a/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/css-classes-reference.rst b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/css-classes-reference.rst
new file mode 100644
index 00000000..1b28d36e
--- /dev/null
+++ b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/css-classes-reference.rst
@@ -0,0 +1,1558 @@
+CSS classes reference
+=====================
+
+This is a full list of available classes corresponding to languages'
+syntactic structures. The parentheses after language name contain identifiers
+used as class names in ```` element.
+
+
+Gams ("gms", "gams")
+--------------------
+
+* ``section``: section
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string
+
+
+Python ("python", "py", "gyp")
+------------------------------
+
+* ``keyword``: keyword
+* ``built_in``: built-in objects (None, False, True and Ellipsis)
+* ``number``: number
+* ``string``: string (of any type)
+* ``comment``: comment
+* ``decorator``: @-decorator for functions
+* ``function``: function header "def some_name(...):"
+* ``class``: class header "class SomeName(...):"
+* ``title``: name of a function or a class inside a header
+* ``params``: everything inside parentheses in a function's or class' header
+
+Python profiler results ("profile")
+-----------------------------------
+
+* ``number``: number
+* ``string``: string
+* ``built_in``: built-in function entry
+* ``filename``: filename in an entry
+* ``summary``: profiling summary
+* ``header``: header of table of results
+* ``keyword``: column header
+* ``function``: function name in an entry (including parentheses)
+* ``title``: actual name of a function in an entry (excluding parentheses)
+* ``prompt``: interpreter prompt (>>> or ...)
+
+Ruby ("ruby", "rb", "gemspec", "podspec", "thor", "irb")
+--------------------------------------------------------
+
+* ``keyword``: keyword
+* ``string``: string
+* ``subst``: in-string substitution (#{...})
+* ``comment``: comment
+* ``doctag``: YARD doctag
+* ``function``: function header "def some_name(...):"
+* ``class``: class header "class SomeName(...):"
+* ``title``: name of a function or a class inside a header
+* ``parent``: name of a parent class
+* ``symbol``: symbol
+* ``input``: complete input line (interpreter)
+* ``output``: complete output line (interpreter)
+* ``prompt``: interpreter prompt (>>)
+* ``status``: interpreter response (=>)
+
+Haml ("haml")
+-------------
+
+* ``tag``: any tag starting with "%"
+* ``title``: tag's name
+* ``attribute``: tag's attribute
+* ``keyword``: tag's attribute that is a keyword
+* ``string``: attribute's value that is a string
+* ``value``: attribute's value, shorthand id or class for tag
+* ``comment``: comment
+* ``doctype``: !!! declaration
+* ``bullet``: line defined by variable
+
+Perl ("perl", "pl")
+-------------------
+
+* ``keyword``: keyword
+* ``comment``: comment
+* ``number``: number
+* ``string``: string
+* ``regexp``: regular expression
+* ``sub``: subroutine header (from "sub" till "{")
+* ``variable``: variable starting with "$", "%", "@"
+* ``operator``: operator
+* ``pod``: plain old doc
+
+PHP ("php", "php3", "php4", "php5", "php6")
+-------------------------------------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string (of any type)
+* ``comment``: comment
+* ``doctag``: phpdoc params in comments
+* ``variable``: variable starting with "$"
+* ``preprocessor``: preprocessor marks: ""
+* ``class``: class header
+* ``function``: header of a function
+* ``title``: name of a function inside a header
+* ``params``: parentheses and everything inside them in a function's header
+
+Scala ("scala")
+---------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string
+* ``comment``: comment
+* ``doctag``: @-tag in javadoc comment
+* ``annotation``: annotation
+* ``class``: class header
+* ``title``: class name inside a header
+* ``params``: everything in parentheses inside a class header
+* ``inheritance``: keywords "extends" and "with" inside class header
+
+Groovy ("groovy")
+-----------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string, map string keys and named argument labels
+* ``regex``: regular expression
+* ``comment``: comment
+* ``doctag``: @-tag in javadoc comment
+* ``annotation``: annotation
+* ``class``: class header
+* ``title``: class name inside a header
+* ``label``: label
+* ``shebang``: Groovy shell script header
+
+Go ("go", "golang")
+-------------------
+
+* ``comment``: comment
+* ``string``: string constant
+* ``number``: number
+* ``keyword``: language keywords
+* ``constant``: true false nil iota
+* ``typename``: built-in plain types (int, string etc.)
+* ``built_in``: built-in functions
+
+Golo ("golo", "gololang")
+-------------------
+
+* ``keyword``: language keywords
+* ``literal``: true false null
+* ``typename``: Golo type objects (DynamicObject, struct, ...)
+* ``annotation``: decorator
+
+Gradle ("gradle")
+-----------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string and character
+* ``comment``: comment
+* ``regexp``: regular expression
+
+
+HTML, XML ("xml", "html", "xhtml", "rss", "atom", "xsl", "plist")
+-----------------------------------------------------------------
+
+* ``tag``: any tag from "<" till ">"
+* ``attribute``: tag's attribute with or without value
+* ``value``: attribute's value
+* ``comment``: comment
+* ``pi``: processing instruction ()
+* ``doctype``: declaration
+* ``cdata``: CDATA section
+
+Lasso ("lasso", "ls", "lassoscript")
+------------------------------------
+
+* ``preprocessor``: delimiters and interpreter flags
+* ``shebang``: Lasso 9 shell script header
+* ``comment``: single- or multi-line comment
+* ``keyword``: keyword
+* ``literal``: keyword representing a value
+* ``built_in``: built-in types and variables
+* ``number``: number
+* ``string``: string
+* ``variable``: variable reference starting with "#" or "$"
+* ``tag``: tag literal
+* ``attribute``: named or rest parameter in method signature
+* ``subst``: unary/binary/ternary operator symbols
+* ``class``: type, trait, or method header
+* ``title``: name following "define" inside a header
+
+CSS ("css")
+-----------
+
+* ``tag``: tag in selectors
+* ``id``: #some_name in selectors
+* ``class``: .some_name in selectors
+* ``at_rule``: @-rule till first "{" or ";"
+* ``keyword``: name of @-rule after @ sign
+* ``attr_selector``: attribute selector (square brackets in a[href^=http://])
+* ``pseudo``: pseudo classes and elements (:after, ::after etc.)
+* ``comment``: comment
+* ``rules``: everything from "{" till "}"
+* ``rule``: rule itself — everything inside "{" and "}"
+* ``attribute``: property name inside a rule
+* ``value``: property value inside a rule, from ":" till ";" or till the end of rule block
+* ``number``: number within a value
+* ``string``: string within a value
+* ``hexcolor``: hex color (#FFFFFF) within a value
+* ``function``: CSS function within a value
+* ``important``: "!important" symbol
+
+SCSS ("scss")
+-------------
+
+* ``tag``: tag in selectors
+* ``id``: #some_name in selectors
+* ``class``: .some_name in selectors
+* ``at_rule``: @-rule till first "{" or ";"
+* ``attr_selector``: attribute selector (square brackets in a[href^=http://])
+* ``pseudo``: pseudo classes and elements (:after, ::after etc.)
+* ``comment``: comment
+* ``rules``: everything from "{" till "}"
+* ``attribute``: property name inside a rule
+* ``value``: property value inside a rule, from ":" till ";" or till the end of rule block
+* ``number``: number within a value
+* ``string``: string within a value
+* ``hexcolor``: hex color (#FFFFFF) within a value
+* ``function``: CSS function within a value
+* ``important``: "!important" symbol
+* ``variable``: variable starting with "$"
+* ``preprocessor``: keywords after @
+
+Less ("less")
+-------------
+
+* ``comment``: comment
+* ``number``: number
+* ``string``: string
+* ``attribute``: property name
+* ``variable``: @var, @@var or @{var}
+* ``keyword``: Less keywords (when, extend etc.)
+* ``function``: Less and CSS functions (rgba, unit etc.)
+* ``tag``: tag
+* ``id``: #id
+* ``class``: .class
+* ``at_rule``: at-rule keyword (@media, @keyframes etc.)
+* ``attr_selector``: attribute selector (e.g. [href^=http://])
+* ``pseudo``: pseudo classes and elements (:hover, ::before etc.)
+* ``hexcolor``: hex color (#FFF)
+* ``built_in``: inline javascript (or whatever host language) string
+
+Stylus ("stylus", "styl")
+-------------------------
+
+* ``at_rule``: @-rule till first "{" or ";"
+* ``attribute``: property name inside a rule
+* ``class``: .some_name in selectors
+* ``comment``: comment
+* ``function``: Stylus function
+* ``hexcolor``: hex color (#FFFFFF) within a value
+* ``id``: #some_name in selectors
+* ``number``: number within a value
+* ``pseudo``: pseudo classes and elements (:after, ::after etc.)
+* ``string``: string within a value
+* ``tag``: tag in selectors
+* ``variable``: variable starting with "$"
+
+Markdown ("markdown", "md", "mkdown", "mkd")
+--------------------------------------------
+
+* ``header``: header
+* ``bullet``: list bullet
+* ``emphasis``: emphasis
+* ``strong``: strong emphasis
+* ``blockquote``: blockquote
+* ``code``: code
+* ``horizontal_rule``: horizontal rule
+* ``link_label``: link label
+* ``link_url``: link url
+* ``link_reference``: link reference
+
+AsciiDoc ("asciidoc", "adoc")
+-----------------------------
+
+* ``header``: heading
+* ``bullet``: list or labeled bullet
+* ``emphasis``: emphasis
+* ``strong``: strong emphasis
+* ``blockquote``: blockquote
+* ``code``: inline or block code
+* ``horizontal_rule``: horizontal rule
+* ``link_label``: link or image label
+* ``link_url``: link or image url
+* ``comment``: comment
+* ``attribute``: document attribute, block attributes
+* ``label``: admonition label
+
+Django ("django", "jinja")
+--------------------------
+
+* ``keyword``: HTML tag in HTML, default tags and default filters in templates
+* ``tag``: any tag from "<" till ">"
+* ``comment``: template comment, both {# .. #} and {% comment %}
+* ``doctype``: declaration
+* ``attribute``: tag's attribute with or without value
+* ``value``: attribute's value
+* ``template_tag``: template tag {% .. %}
+* ``variable``: template variable {{ .. }}
+* ``filter``: filter from "|" till the next filter or the end of tag
+* ``argument``: filter argument
+
+
+Twig ("twig", "craftcms")
+-------------------------
+
+* ``keyword``: HTML tag in HTML, default tags and default filters in templates
+* ``tag``: any tag from "<" till ">"
+* ``comment``: template comment {# .. #}
+* ``doctype``: declaration
+* ``attribute``: tag's attribute with or withou value
+* ``value``: attribute's value
+* ``template_tag``: template tag {% .. %}
+* ``variable``: template variable {{ .. }}
+* ``filter``: filter from "|" till the next filter or the end of tag
+* ``argument``: filter argument
+
+
+Handlebars ("handlebars", "hbs", "html.hbs", "html.handlebars")
+---------------------------------------------------------------
+
+* ``expression``: expression to be evaluated
+* ``variable``: variable
+* ``begin-block``: the beginning of a block
+* ``end-block``: the ending of a block
+* ``string``: string
+
+Dust ("dust", "dst")
+--------------------
+
+* ``expression``: expression to be evaluated
+* ``variable``: variable
+* ``begin-block``: the beginning of a block
+* ``end-block``: the ending of a block
+* ``string``: string
+
+JSON ("json")
+-------------
+
+* ``number``: number
+* ``literal``: "true", "false" and "null"
+* ``string``: string value
+* ``attribute``: name of an object property
+* ``value``: value of an object property
+
+Mathematica ("mathematica", "mma")
+----------------------------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``comment``: comment
+* ``string``: string
+* ``list``: a list { .. } - the basic Mma structure
+
+JavaScript ("javascript", "js")
+-------------------------------
+
+* ``keyword``: keyword
+* ``comment``: comment
+* ``number``: number
+* ``literal``: special literal: "true", "false" and "null"
+* ``built_in``: built-in objects and functions ("window", "console", "require", etc...)
+* ``string``: string
+* ``regexp``: regular expression
+* ``function``: header of a function
+* ``title``: name of a function inside a header
+* ``params``: parentheses and everything inside them in a function's header
+* ``pi``: 'use strict' processing instruction
+
+TypeScript ("typescript", "ts")
+-------------------------------
+
+* ``keyword``: keyword
+* ``comment``: comment
+* ``number``: number
+* ``literal``: special literal: "true", "false" and "null"
+* ``built_in``: built-in objects and functions ("window", "console", "require", etc...)
+* ``string``: string
+* ``regexp``: regular expression
+* ``function``: header of a function
+* ``title``: name of a function inside a header
+* ``params``: parentheses and everything inside them in a function's header
+* ``pi``: 'use strict' processing instruction
+
+CoffeeScript ("coffeescript", "coffee", "cson", "iced")
+-------------------------------------------------------
+
+* ``keyword``: keyword
+* ``comment``: comment
+* ``number``: number
+* ``literal``: special literal: "true", "false" and "null"
+* ``built_in``: built-in objects and functions ("window", "console", "require", etc...)
+* ``string``: string
+* ``subst``: #{ ... } interpolation in double-quoted strings
+* ``regexp``: regular expression
+* ``function``: header of a function
+* ``class``: header of a class
+* ``title``: name of a function variable inside a header
+* ``params``: parentheses and everything inside them in a function's header
+* ``property``: @-property within class and functions
+
+Dart ("dart")
+-------------
+
+* ``keyword``: keyword
+* ``literal``: keyword that can be uses as identifier but have special meaning in some cases
+* ``built_in``: some of basic built in classes and function
+* ``number``: number
+* ``string``: string
+* ``subst``: in-string substitution (${...})
+* ``comment``: commment
+* ``annotation``: annotation
+* ``class``: class header from "class" till "{"
+* ``title``: class name
+
+LiveScript ("livescript", "ls")
+-------------------------------
+
+* ``keyword``: keyword
+* ``comment``: comment
+* ``number``: number
+* ``literal``: special literal: "true", "false" and "null"
+* ``built_in``: built-in objects and functions ("window", "console", "require", etc...)
+* ``string``: string
+* ``subst``: #{ ... } interpolation in double-quoted strings
+* ``regexp``: regular expression
+* ``function``: header of a function
+* ``class``: header of a class
+* ``title``: name of a function variable inside a header
+* ``params``: parentheses and everything inside them in a function's header
+* ``property``: @-property within class and functions
+
+ActionScript ("actionscript", "as")
+-----------------------------------
+
+* ``comment``: comment
+* ``string``: string
+* ``number``: number
+* ``keyword``: keywords
+* ``literal``: literal
+* ``reserved``: reserved keyword
+* ``title``: name of declaration (package, class or function)
+* ``preprocessor``: preprocessor directive (import, include)
+* ``type``: type of returned value (for functions)
+* ``package``: package (named or not)
+* ``class``: class/interface
+* ``function``: function
+* ``param``: params of function
+* ``rest_arg``: rest argument of function
+
+Haxe ("haxe", "hx")
+-------------------
+
+* ``comment``: comment
+* ``string``: string
+* ``number``: number
+* ``keyword``: keywords
+* ``literal``: literal
+* ``reserved``: reserved keyword
+* ``title``: name of declaration (package, class or function)
+* ``preprocessor``: preprocessor directive (if, else, elseif, error)
+* ``type``: type of returned value (for functions)
+* ``package``: package (named or not)
+* ``class``: class/interface
+* ``function``: function
+* ``param``: params of function
+* ``rest_arg``: rest argument of function
+
+VBScript ("vbscript", "vbs")
+----------------------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string
+* ``comment``: comment
+* ``built_in``: built-in function
+
+VB.Net ("vbnet", "vb")
+----------------------
+
+* ``keyword``: keyword
+* ``built_in``: built-in types
+* ``literal``: "true", "false" and "nothing"
+* ``string``: string
+* ``comment``: comment
+* ``xmlDocTag``: xmldoc tag ("'''", "", "<..>")
+* ``preprocessor``: preprocessor directive
+
+Protocol Buffers ("protobuf")
+-----------------------------
+
+* ``keyword``: keyword
+* ``built_in``: built-in types (e.g. `int64`, `string`)
+* ``string``: string
+* ``number``: number
+* ``literal``: "true" and "false"
+* ``comment``: comment
+* ``class``: message, service or enum definition header
+* ``title``: message, service or enum identifier
+* ``function``: RPC call identifier
+
+Cap’n Proto ("capnproto", "capnp")
+----------------------------------
+
+* ``shebang``: message identifier
+* ``keyword``: keyword
+* ``built_in``: built-in types (e.g. `Int64`, `Text`)
+* ``string``: string
+* ``number``: number or field number (e.g. @N)
+* ``literal``: "true" and "false"
+* ``comment``: comment
+* ``class``: message, interface or enum definition header
+* ``title``: message, interface or enum identifier
+
+Thrift ("thrift")
+-----------------
+
+* ``keyword``: keyword
+* ``built_in``: built-in types (e.g. `byte`, `i32`)
+* ``string``: string
+* ``number``: number
+* ``literal``: "true" and "false"
+* ``comment``: comment
+* ``class``: struct, enum, service or exception definition header
+* ``title``: struct, enum, service or exception identifier
+
+HTTP ("http", "https")
+----------------------
+
+* ``request``: first line of a request
+* ``status``: first line of a response
+* ``attribute``: header name
+* ``string``: header value or query string in a request line
+* ``number``: status code
+
+Lua ("lua")
+-----------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string
+* ``comment``: comment
+* ``built_in``: built-in operator
+* ``function``: header of a function
+* ``title``: name of a function inside a header
+* ``params``: everything inside parentheses in a function's header
+* ``long_brackets``: multiline string in [=[ .. ]=]
+
+Delphi ("delphi")
+-----------------
+
+* ``keyword``: keyword
+* ``comment``: comment (of any type)
+* ``number``: number
+* ``string``: string
+* ``function``: header of a function, procedure, constructor and destructor
+* ``title``: name of a function, procedure, constructor or destructor inside a header
+* ``params``: everything inside parentheses in a function's header
+* ``class``: class' body from "= class" till "end;"
+
+Oxygene ("oxygene")
+-------------------
+
+* ``keyword``: keyword
+* ``comment``: comment (of any type)
+* ``string``: string/char
+* ``function``: method, destructor, procedure or function
+* ``title``: name of a function (inside function)
+* ``params``: everything inside parentheses in a function's header
+* ``number``: number
+* ``class``: class' body from "= class" till "end;"
+
+Java ("java", "jsp")
+--------------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string
+* ``comment``: comment
+* ``annotaion``: annotation
+* ``class``: class header from "class" till "{"
+* ``function``: method header
+* ``title``: class or method name
+* ``params``: everything in parentheses inside a class header
+* ``inheritance``: keywords "extends" and "implements" inside class header
+
+Processing ("processing")
+-------------------------
+
+* ``constant``: Processing constants
+* ``variable``: Processing special variables
+* ``keyword``: Variable types
+* ``function``: Processing setup and draw functions
+* ``built_in``: Processing built in functions
+
+AspectJ ("aspectj")
+-------------------
+
+* ``comment``: comment
+* ``doctag``: @-tag in javadoc comment
+* ``string``: string
+* ``number``: number
+* ``keyword``: keyword
+* ``annotation``: annotation
+* ``function``: method and intertype method header
+* ``aspect``: aspect header from "aspect" till "{"
+* ``params``: everything in parentheses inside an aspect header
+* ``inheritance``: keywords "extends" and "implements" inside an aspect header
+* ``title``: aspect, (intertype) method name or pointcut name inside an aspect header
+
+Fortran ("fortran", "f90", "f95")
+---------------------------------
+
+* ``comment``: comment
+* ``function``: name of a function or a subroutine
+* ``keyword``: language keywords (function, if)
+* ``number``: number
+* ``string``: string constant (single or double quote)
+
+IRPF90 ("irpf90")
+-----------------
+
+* ``comment``: comment
+* ``function``: name of a function or a subroutine
+* ``keyword``: language keywords (function, if)
+* ``number``: number
+* ``string``: string constant (single or double quote)
+
+C++ ("cpp", "c", "cc", "h", "c++", "h++", "hpp")
+------------------------------------------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string and character
+* ``comment``: comment
+* ``preprocessor``: preprocessor directive
+
+Objective C ("objectivec", "mm", "objc", "obj-c")
+-------------------------------------------------
+
+* ``keyword``: keyword
+* ``built_in``: Cocoa/Cocoa Touch constants and classes
+* ``number``: number
+* ``string``: string
+* ``comment``: comment
+* ``preprocessor``: preprocessor directive
+* ``class``: interface/implementation, protocol and forward class declaration
+* ``title``: title (id) of interface, implementation, protocol, class
+* ``variable``: properties and struct accessors
+
+Vala ("vala")
+-------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string
+* ``comment``: comment
+* ``class``: class definitions
+* ``title``: in class definition
+* ``constant``: ALL_UPPER_CASE
+
+C# ("cs", "csharp")
+-------------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string
+* ``comment``: comment
+* ``xmlDocTag``: xmldoc tag ("///", "", "<..>")
+* ``class``: class header from "class" till "{"
+* ``function``: method header
+* ``title``: title of namespace or class
+
+F# ("fsharp", "fs")
+-------------------
+
+* ``keywords``: keyword
+* ``number``: number
+* ``string``: string
+* ``comment``: comment
+* ``class``: any custom F# type
+* ``title``: the name of a custom F# type
+* ``annotation``: any attribute
+
+OCaml ("ocaml", "ml")
+---------------------
+
+* ``keywords``: keyword
+* ``literal``: true false etc.
+* ``number``: number
+* ``string``: string
+* ``char``: character
+* ``comment``: comment
+* ``built_in``: built-in type (int, list etc.)
+* ``type``: variant constructor, module name
+* ``tag``: polymorphic variant tag
+* ``symbol``: type variable
+
+D ("d")
+-------
+
+* ``comment``: comment
+* ``string``: string constant
+* ``number``: number
+* ``keyword``: language keywords (including @attributes)
+* ``constant``: true false null
+* ``built_in``: built-in plain types (int, string etc.)
+
+RenderMan RSL ("rsl")
+---------------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string (including @"..")
+* ``comment``: comment
+* ``preprocessor``: preprocessor directive
+* ``shader``: shader keywords
+* ``shading``: shading keywords
+* ``built_in``: built-in function
+
+RenderMan RIB ("rib")
+---------------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string
+* ``comment``: comment
+* ``commands``: command
+
+Maya Embedded Language ("mel")
+------------------------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string
+* ``comment``: comment
+* ``variable``: variable
+
+SQL ("sql")
+-----------
+
+* ``keyword``: keyword (mostly SQL'92, SQL'99 and T-SQL)
+* ``literal``: special literal: "true" and "false"
+* ``built_in``: built-in type name
+* ``number``: number
+* ``string``: string (of any type: "..", '..', \`..\`)
+* ``comment``: comment
+* ``variable``: mixed-case names
+
+Smalltalk ("smalltalk", "st")
+-----------------------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string
+* ``comment``: comment
+* ``symbol``: symbol
+* ``array``: array
+* ``class``: name of a class
+* ``char``: char
+* ``localvars``: block of local variables
+
+Lisp ("lisp")
+-------------
+
+* ``number``: number
+* ``string``: string
+* ``comment``: comment
+* ``variable``: variable
+* ``literal``: b, t and nil
+* ``list``: non-quoted list
+* ``keyword``: first symbol in a non-quoted list
+* ``body``: remainder of the non-quoted list
+* ``quoted``: quoted list, both "(quote .. )" and "'(..)"
+
+Clojure ("clojure", "clj")
+--------------------------
+
+* ``comment``: comments and hints
+* ``string``: string
+* ``number``: number
+* ``collection``: collections
+* ``attribute``: :keyword
+* ``list``: non-quoted list
+* ``keyword``: first symbol in a list
+* ``built_in``: built-in function name as the first symbol in a list
+* ``prompt``: REPL prompt
+
+Scheme ("scheme")
+-----------------
+
+* ``shebang``: script interpreter header
+* ``comment``: comment
+* ``string``: string
+* ``number``: number
+* ``regexp``: regexp
+* ``variable``: single-quote 'identifier
+* ``list``: non-quoted list
+* ``keyword``: first symbol in a list
+* ``built_in``: built-in function name as the first symbol in a list
+* ``literal``: #t, #f, #\...\
+
+Ini ("ini")
+-----------
+
+* ``title``: title of a section
+* ``value``: value of a setting of any type
+* ``string``: string
+* ``number``: number
+* ``keyword``: boolean value keyword
+
+Apache ("apache", "apacheconf")
+-------------------------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``comment``: comment
+* ``literal``: On and Off
+* ``sqbracket``: variables in rewrites "%{..}"
+* ``cbracket``: options in rewrites "[..]"
+* ``tag``: begin and end of a configuration section
+
+Nginx ("nginx", "nginxconf")
+----------------------------
+
+* ``title``: directive title
+* ``string``: string
+* ``number``: number
+* ``comment``: comment
+* ``built_in``: built-in constant
+* ``variable``: $-variable
+* ``regexp``: regexp
+
+Diff ("diff", "patch")
+----------------------
+
+* ``header``: file header
+* ``chunk``: chunk header within a file
+* ``addition``: added lines
+* ``deletion``: deleted lines
+* ``change``: changed lines
+
+DOS ("dos", "bat", "cmd")
+-------------------------
+
+* ``keyword``: keyword
+* ``flow``: batch control keyword
+* ``stream``: DOS special files ("con", "prn", ...)
+* ``winutils``: some commands (see dos.js specifically)
+* ``envvar``: environment variables
+
+PowerShell ("powershell", "ps")
+-------------------------------
+
+* ``keyword``: keyword
+* ``string``: string
+* ``number``: number
+* ``comment``: comment
+* ``literal``: special literal: "true" and "false"
+* ``variable``: variable
+
+Bash ("bash", "sh", "zsh")
+--------------------------
+
+* ``keyword``: keyword
+* ``string``: string
+* ``number``: number
+* ``comment``: comment
+* ``literal``: special literal: "true" and "false"
+* ``variable``: variable
+* ``shebang``: script interpreter header
+
+Makefile ("makefile", "mk", "mak")
+----------------------------------
+
+* ``keyword``: keyword ".PHONY" within the phony line
+* ``string``: string
+* ``comment``: comment
+* ``variable``: $(..) variable
+* ``title``: target title
+* ``constant``: constant within the initial definition
+
+CMake ("cmake", "cmake.in")
+---------------------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string
+* ``comment``: comment
+* ``envvar``: $-variable
+* ``operator``: operator (LESS, STREQUAL, MATCHES, etc)
+
+Nix ("nix")
+-----------
+
+* ``keyword``: keyword
+* ``built_in``: built-in constant
+* ``number``: number
+* ``string``: single and double quotes
+* ``subst``: antiquote ${}
+* ``comment``: comment
+* ``variable``: function parameter name
+
+NSIS ("nsis")
+-------------
+
+* ``symbol``: directory constants
+* ``number``: number
+* ``constant``: definitions, language-strings, compiler commands
+* ``variable``: $-variable
+* ``string``: string
+* ``comment``: comment
+* ``params``: parameters
+* ``keyword``: keywords
+* ``literal``: keyword options
+
+Axapta ("axapta")
+-----------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string
+* ``comment``: comment
+* ``class``: class header from "class" till "{"
+* ``title``: class name inside a header
+* ``params``: everything in parentheses inside a class header
+* ``preprocessor``: preprocessor directive
+
+Oracle Rules Language ("ruleslanguage")
+---------------------------------------
+
+* ``comment``: comment
+* ``string``: string constant
+* ``number``: number
+* ``keyword``: language keywords
+* ``built_in``: built-in functions
+* ``array``: array stem
+
+1C ("1c")
+---------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``date``: date
+* ``string``: string
+* ``comment``: comment
+* ``function``: header of function or procedure
+* ``title``: function name inside a header
+* ``params``: everything in parentheses inside a function header
+* ``preprocessor``: preprocessor directive
+
+x86 Assembly ("x86asm")
+-----------------------
+
+* ``keyword``: instruction mnemonic
+* ``literal``: register name
+* ``pseudo``: assembler's pseudo instruction
+* ``preprocessor``: macro
+* ``built_in``: assembler's keyword
+* ``comment``: comment
+* ``number``: number
+* ``string``: string
+* ``label``: jump label
+* ``argument``: macro's argument
+
+AVR assembler ("avrasm")
+------------------------
+
+* ``keyword``: keyword
+* ``built_in``: pre-defined register
+* ``number``: number
+* ``string``: string
+* ``comment``: comment
+* ``label``: label
+* ``preprocessor``: preprocessor directive
+* ``localvars``: substitution in .macro
+
+VHDL ("vhdl")
+-------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string
+* ``comment``: comment
+* ``literal``: signal logical value
+* ``typename``: typename
+* ``attribute``: signal attribute
+
+Parser3 ("parser3")
+-------------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``comment``: comment
+* ``variable``: variable starting with "$"
+* ``preprocessor``: preprocessor directive
+* ``title``: user-defined name starting with "@"
+
+LiveCode Server ("livecodeserver")
+----------------------------------
+
+* ``variable``: variable starting with "g", "t", "p", "s", "$_"
+* ``string``: string
+* ``comment``: comment
+* ``number``: number
+* ``title``: name of a command or a function
+* ``keyword``: keyword
+* ``constant``: constant
+* ``operator``: operator
+* ``built_in``: built_in functions and commands
+* ``function``: header of a function
+* ``command``: header of a command
+* ``preprocessor``: preprocessor marks: ""
+
+TeX ("tex")
+-----------
+
+* ``comment``: comment
+* ``number``: number
+* ``command``: command
+* ``parameter``: parameter
+* ``formula``: formula
+* ``special``: special symbol
+
+Haskell ("haskell", "hs")
+-------------------------
+
+* ``comment``: comment
+* ``pragma``: GHC pragma
+* ``preprocessor``: CPP preprocessor directive
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string
+* ``title``: function or variable name
+* ``type``: value, type or type class constructor name (i.e. capitalized)
+* ``container``: (..., ...) or {...; ...} list in declaration or record
+* ``module``: module declaration
+* ``import``: import declaration
+* ``class``: type class or instance declaration
+* ``typedef``: type declaration (type, newtype, data)
+* ``default``: default declaration
+* ``infix``: infix declaration
+* ``foreign``: FFI declaration
+* ``shebang``: shebang line
+
+Elm ("elm")
+-------------------------
+
+* ``comment``: comment
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string
+* ``title``: function or variable name
+* ``type``: value or type constructor name (i.e. capitalized)
+* ``container``: (..., ...) or {...; ...} list in declaration or record
+* ``module``: module declaration
+* ``import``: import declaration
+* ``typedef``: type declaration (type, type alias)
+* ``infix``: infix declaration
+* ``foreign``: javascript interop declaration
+
+Erlang ("erlang", "erl")
+------------------------
+
+* ``comment``: comment
+* ``string``: string
+* ``number``: number
+* ``keyword``: keyword
+* ``record_name``: record access (#record_name)
+* ``title``: name of declaration function
+* ``variable``: variable (starts with capital letter or with _)
+* ``pp``:.keywords module's attribute (-attribute)
+* ``function_name``: atom or atom:atom in case of function call
+
+Elixir ("elixir")
+-----------------
+
+* ``keyword``: keyword
+* ``string``: string
+* ``subst``: in-string substitution (#{...})
+* ``comment``: comment
+* ``function``: function header "def some_name(...):"
+* ``class``: defmodule and defrecord headers
+* ``title``: name of a function or a module inside a header
+* ``symbol``: atom
+* ``constant``: name of a module
+* ``number``: number
+* ``variable``: variable
+* ``regexp``: regexp
+
+Rust ("rust", "rs")
+-------------------
+
+* ``comment``: comment
+* ``string``: string
+* ``number``: number
+* ``keyword``: keyword
+* ``title``: name of declaration
+* ``preprocessor``: preprocessor directive
+
+Matlab ("matlab")
+-----------------
+
+* ``comment``: comment
+* ``string``: string
+* ``number``: number
+* ``keyword``: keyword
+* ``title``: function name
+* ``function``: function
+* ``param``: params of function
+* ``matrix``: matrix in [ .. ]
+* ``cell``: cell in { .. }
+
+Scilab ("scilab", "sci")
+------------------------
+
+* ``comment``: comment
+* ``string``: string
+* ``number``: number
+* ``keyword``: keyword
+* ``title``: function name
+* ``function``: function
+* ``param``: params of function
+* ``matrix``: matrix in [ .. ]
+
+R ("r")
+-------
+
+* ``comment``: comment
+* ``string``: string constant
+* ``number``: number
+* ``keyword``: language keywords (function, if) plus "structural" functions (attach, require, setClass)
+* ``literal``: special literal: TRUE, FALSE, NULL, NA, etc.
+
+OpenGL Shading Language ("glsl")
+--------------------------------
+
+* ``comment``: comment
+* ``number``: number
+* ``preprocessor``: preprocessor directive
+* ``keyword``: keyword
+* ``built_in``: GLSL built-in functions and variables
+* ``literal``: true false
+
+AppleScript ("applescript", "osascript")
+----------------------------------------
+
+* ``keyword``: keyword
+* ``command``: core AppleScript command
+* ``constant``: AppleScript built in constant
+* ``type``: AppleScript variable type (integer, etc.)
+* ``property``: Applescript built in property (length, etc.)
+* ``number``: number
+* ``string``: string
+* ``comment``: comment
+* ``title``: name of a handler
+
+Vim Script ("vim")
+------------------
+
+* ``keyword``: keyword
+* ``built_in``: built-in functions
+* ``string``: string, comment
+* ``number``: number
+* ``function``: function header "function Foo(...)"
+* ``title``: name of a function
+* ``params``: everything inside parentheses in a function's header
+* ``variable``: vim variables with different visibilities "g:foo, b:bar"
+
+Brainfuck ("brainfuck", "bf")
+-----------------------------
+
+* ``title``: Brainfuck while loop command
+* ``literal``: Brainfuck inc and dec commands
+* ``comment``: comment
+* ``string``: Brainfuck input and output commands
+
+Mizar ("mizar")
+---------------
+
+* ``keyword``: keyword
+* ``comment``: comment
+
+AutoHotkey ("autohotkey")
+-------------------------
+
+* ``keyword``: keyword
+* ``literal``: A (active window), true, false, NOT, AND, OR
+* ``built_in``: built-in variables
+* ``string``: string
+* ``comment``: comment
+* ``number``: number
+* ``var_expand``: variable expansion (enclosed in percent sign)
+* ``label``: label, hotkey label, hotstring label
+
+Monkey ("monkey")
+-----------------
+
+* ``keyword``: keyword
+* ``built_in``: built-in functions, variables and types of variables
+* ``literal``: True, False, Null, And, Or, Shl, Shr, Mod
+* ``string``: string
+* ``comment``: comment
+* ``number``: number
+* ``function``: header of a function, method and constructor
+* ``class``: class header
+* ``title``: name of an alias, class, interface, function or method inside a header
+* ``variable``: self and super keywords
+* ``preprocessor``: import and preprocessor
+* ``pi``: Strict directive
+
+FIX ("fix")
+-----------
+
+* ``attribute``: attribute name
+* ``string``: attribute value
+
+Gherkin ("gherkin")
+-------------------
+
+* ``keyword``: keyword
+* ``number``: number
+* ``comment``: comment
+* ``string``: string
+
+TP ("tp")
+---------
+
+* ``keyword``: keyword
+* ``constant``: ON, OFF, max_speed, LPOS, JPOS, ENABLE, DISABLE, START, STOP, RESET
+* ``number``: number
+* ``comment``: comment
+* ``string``: string
+* ``data``: numeric registers, positions, position registers, etc.
+* ``io``: inputs and outputs
+* ``label``: data and io labels
+* ``variable``: system variables
+* ``units``: units (e.g. mm/sec, sec, deg)
+
+Nimrod ("nimrod", "nim")
+------------------------
+
+* ``decorator`` pragma
+* ``string`` string literal
+* ``type`` variable type
+* ``number`` numeric literal
+* ``comment`` comment
+
+Swift ("swift")
+---------------
+
+* ``keyword``: keyword
+* ``comment``: comment
+* ``number``: number
+* ``string``: string
+* ``literal``: special literal: "true", "false" and "nil"
+* ``built_in``: built-in Swift functions
+* ``func``: header of a function
+* ``class``: class, protocol, enum, struct, or extension declaration
+* ``title``: name of a function or class (or protocol, etc)
+* ``generics``: generic type of a function
+* ``params``: parameters of a function
+* ``type``: a type
+* ``preprocessor``: @attributes
+
+G-Code ("gcode", "nc")
+----------------------
+
+* ``keyword``: G words, looping constructs and conditional operators
+* ``comment``: comment
+* ``number``: number
+* ``built_in``: trigonometric and mathematical functions
+* ``title``: M words and variable registers
+* ``preprocessor``: program number and ending character
+* ``label``: block number
+
+Q ("k", "kdb")
+--------------
+
+* ``comment``: comment
+* ``string``: string constant
+* ``number``: number
+* ``keyword``: language keywords
+* ``constant``: 0/1b
+* ``typename``: built-in plain types (int, symbol etc.)
+* ``built_in``: built-in function
+
+Tcl ("tcl", "tk")
+-----------------
+
+* ``keyword``: keyword
+* ``comment``: comment
+* ``symbol``: function (proc)
+* ``variable``: variable
+* ``string``: string
+* ``number``: number
+
+Puppet ("puppet", "pp")
+-----------------------
+
+* ``comment``: comment
+* ``string``: string
+* ``number``: number
+* ``keyword``: classes and types
+* ``constant``: dependencies
+
+Stata ("stata")
+---------------
+
+* ``keyword``: commands and control flow
+* ``label``: macros (locals and globals)
+* ``string``: string
+* ``comment``: comment
+* ``literal``: built-in functions
+
+XL ("xl", "tao")
+----------------
+
+* ``keyword``: keywords defined in the default syntax file
+* ``literal``: names entered in the compiler (true, false, nil)
+* ``type``: basic types (integer, real, text, name, etc)
+* ``built_in``: built-in functions (sin, exp, mod, etc)
+* ``module``: names of frequently used Tao modules
+* ``id``: names of frequently used Tao functions
+* ``constant``: all-uppercase names such as HELLO
+* ``variable``: Mixed-case names such as Hello (style convention)
+* ``id``: Lower-case names such as hello
+* ``string``: Text between single or double quote, long text << >>
+* ``number``: Number values
+* ``function``: Function or variable definition
+* ``import``: Import clause
+
+Roboconf ("graph", "instances")
+-------------------------------
+
+* ``keyword``: keyword
+* ``string``: names of imported variables
+* ``comment``: comment
+* ``facet``: a **facet** section
+* ``component``: a **component** section
+* ``instance-of``: an **instance** section
+
+STEP Part 21 ("p21", "step", "stp")
+-----------------------------------
+
+* ``preprocessor``: delimiters
+* ``comment``: single- or multi-line comment
+* ``keyword``: keyword
+* ``number``: number
+* ``string``: string
+* ``label``: variable reference starting with "#"
+
+Mercury ("mercury")
+-------------------
+
+* ``keyword``: keyword
+* ``pragma``: compiler directive
+* ``preprocessor``: foreign language interface
+* ``built_in``: control flow, logical, implication, head-body conjunction, purity
+* ``number``: number, numcode of character
+* ``comment``: comment
+* ``label``: TODO label inside comment
+* ``string``: string
+* ``constant``: string format
+
+Smali ("smali")
+---------------
+
+* ``string``: string
+* ``comment``: comment
+* ``keyword``: smali keywords
+* ``instruction``: instruction
+* ``class``: classtypes
+* ``function``: function (call or signature)
+* ``variable``: variable or parameter
+
+Verilog ("verilog", "v")
+------------------------
+
+* ``keyword``: keyword, operator
+* ``comment``: comment
+* ``typename``: types of data, register, and net
+* ``number``: number literals (including X and Z)
+* ``value``: parameters passed to instances
+
+Dockerfile ("dockerfile", "docker")
+-----------------------------------
+
+* ``keyword``: instruction keyword
+* ``comment``: comment
+* ``number``: number
+* ``string``: string
+
+PF ("pf", "pf.conf")
+--------------------
+
+* ``built_in``: top level action, e.g. block/match/pass
+* ``keyword``: some parameter/modifier to an action (in, on, nat-to, most reserved words)
+* ``literal``: words representing special values, e.g. all, egress
+* ``comment``: comment
+* ``number``: number
+* ``string``: string
+* ``variable``: used for both macros and tables
+
+XQuery ("xpath", "xq")
+----------------------
+
+* ``keyword``: instruction keyword
+* ``literal``: words representing special values, e.g. all, egress
+* ``comment``: comment
+* ``number``: number
+* ``string``: string
+* ``variable``: variable
+* ``decorator``: annotations
+* ``function``: function
+
+C/AL ("cal")
+------------
+
+* ``keyword``: keyword
+* ``comment``: comment (of any type)
+* ``number``: number
+* ``string``: string
+* ``date``: date, time, or datetime
+* ``function``: header of a procedure
+* ``title``: name of an object or procedure inside a header
+* ``params``: everything inside parentheses in a function's header
+* ``class``: objects body
+* ``variable``: reference to variables
+
+Inform7 ("I7")
+--------------
+
+* ``string``: string
+* ``comment``: comment
+* ``title``: a section header or table header
+* ``subst``: a substitution inside a string
+* ``kind``: a built-in kind (thing, room, person, etc), for relevance
+* ``characteristic``: a commonly-used characteristic (open, closed, scenery, etc), for relevance
+* ``verb``: a commonly-used verb (is, understand), for relevance.
+* ``misc_keyword``: a word with specific I7 meaning (kind, rule), for relevance.
+
+Prolog ("prolog")
+-----------------
+
+* ``atom``: non-quoted atoms and functor names
+* ``string``: quoted atoms, strings, character code list literals, character code literals
+* ``number``: numbers
+* ``variable``: variables
+* ``comment``: comments
+
+DNS Zone file ("dns", "zone", "bind")
+-------------------------------------
+
+* ``keyword``: DNS resource records as defined in various RFCs
+* ``operator``: operator
+* ``number``: IPv4 and IPv6 addresses
+* ``comment``: comments
+
+Ceylon ("ceylon")
+-----------------
+
+* ``keyword``: keyword
+* ``annotation``: language annotation or compiler annotation
+* ``string``: string literal, part of string template, character literal
+* ``number``: number
+* ``comment``: comment
+
+OpenSCAD ("openscad", "scad")
+-----------------------------
+
+* ``built_in``: built-in functions (cube, sphere, translate, ...)
+* ``comment``: comments
+* ``function``: function or module definition
+* ``keyword``: keywords
+* ``literal``: words representing values (e.g. false, undef, PI)
+* ``number``: numbers
+* ``params``: parameters in function or module header or call
+* ``preprocessor``: file includes (i.e. include, use)
+* ``string``: quoted strings
+* ``title``: names of function or module in a header
+
+ARM assembler ("armasm", "arm")
+-------------------------------
+
+* ``keyword``: keyword (instruction mnemonics)
+* ``literal``: pre-defined register
+* ``number``: number
+* ``built_in``: constants (true, false)
+* ``string``: string
+* ``comment``: comment
+* ``label``: label
+* ``preprocessor``: preprocessor directive
+* ``title``: symbol versions
+
+AutoIt ("autoit")
+-----------------
+
+* ``keyword``: keyword
+* ``literal``: True, False, And, Null, Not, Or
+* ``built_in``: built-in functions and UDF
+* ``constant``: constant, macros
+* ``variable``: variables
+* ``string``: string
+* ``comment``: comment
+* ``number``: number
+* ``preprocessor``: AutoIt3Wrapper directives section
+
+Access log ("accesslog")
+------------------------
+
+* ``keyword``: HTTP method name
+* ``string``: date, request string, user-agent etc
+* ``number``: IP-address, numbers
+
+Crystal ("crystal", "cr")
+-------------------------
+
+* ``keyword``: keyword
+* ``string``: string
+* ``number``: number
+* ``symbol``: symbol
+* ``regexp``: regexp
+* ``literal``: true, false or nil
+* ``constant``: constant
+* ``variable``: global, instance, class and fresh variables
+* ``subst``: in-string substitution (#{...})
+* ``expansion``: macro expansion ({{...}}, {%...%})
+* ``class``: class, module, struct, enum, union or lib header
+* ``function``: method or function header
+* ``title``: a method name or class name
+* ``parent``: name of a parent class
+* ``annotation``: any attribute
+
+Crmsh ("crmsh", "crm", "pcmk")
+------------------------------
+
+* ``keyword``: command name
+* ``title``: resource id
+* ``identifier``: node or property set identifier
+* ``pragma``: resource agent
+* ``string``: string
+* ``number``: number
+* ``literal``: literal
+* ``type``: data type
+* ``variable``: name-value pair variable name
+* ``comment``: comment
+* ``tag``: XML tag
diff --git a/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/index.rst b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/index.rst
new file mode 100644
index 00000000..f80250d7
--- /dev/null
+++ b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/index.rst
@@ -0,0 +1,51 @@
+.. highlight.js documentation master file, created by
+ sphinx-quickstart on Wed Sep 12 23:48:27 2012.
+ You can adapt this file completely to your liking, but it should at least
+ contain the root `toctree` directive.
+
+``highlight.js`` developer documentation
+==========================================
+
+Contents:
+
+.. toctree::
+ :maxdepth: 1
+
+ api
+ language-guide
+ reference
+ css-classes-reference
+ style-guide
+ building-testing
+ release-process
+
+Contribution:
+
+.. toctree::
+ :maxdepth: 1
+
+ language-contribution
+ style-contribution
+
+Miscellaneous:
+
+.. toctree::
+ :maxdepth: 1
+
+ line-numbers
+ language-requests
+
+Links:
+
+- Code: https://github.com/isagalaev/highlight.js
+- Discussion: http://groups.google.com/group/highlightjs
+- Bug tracking: https://github.com/isagalaev/highlight.js/issues
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
+
diff --git a/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/language-contribution.rst b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/language-contribution.rst
new file mode 100644
index 00000000..4deae3f3
--- /dev/null
+++ b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/language-contribution.rst
@@ -0,0 +1,78 @@
+Language contributor checklist
+==============================
+
+1. Put language definition into a .js file
+------------------------------------------
+
+The file defines a function accepting a reference to the library and returning a language object.
+The library parameter is useful to access common modes and regexps. You should not immediately call this function,
+this is done during the build process and details differ for different build targets.
+
+::
+
+ function(hljs) {
+ return {
+ keywords: 'foo bar',
+ contains: [ ..., hljs.NUMBER_MODE, ... ]
+ }
+ }
+
+The name of the file is used as a short language identifier and should be usable as a class name in HTML and CSS.
+
+
+2. Provide meta data
+--------------------
+
+At the top of the file there is a specially formatted comment with meta data processed by a build system.
+Meta data format is simply key-value pairs each occupying its own line:
+
+::
+
+ /*
+ Language: Superlanguage
+ Requires: java.js, sql.js
+ Author: John Smith
+ Contributors: Mike Johnson <...@...>, Matt Wilson <...@...>
+ Description: Some cool language definition
+ */
+
+``Language`` — the only required header giving a human-readable language name.
+
+``Requires`` — a list of other language files required for this language to work.
+This make it possible to describe languages that extend definitions of other ones.
+Required files aren't processed in any special way.
+The build system just makes sure that they will be in the final package in
+``LANGUAGES`` object.
+
+The meaning of the other headers is pretty obvious.
+
+
+3. Create a code example
+------------------------
+
+The code example is used both to test language detection and for the demo page
+on https://highlightjs.org/. Put it in ``test/detect//default.txt``.
+
+Take inspiration from other languages in ``test/detect/`` and read
+:ref:`testing instructions ` for more details.
+
+
+4. Write class reference
+------------------------
+
+Class reference lives in the :doc:`CSS classes reference `..
+Describe shortly names of all meaningful modes used in your language definition.
+
+
+5. Add yourself to AUTHORS.*.txt and CHANGES.md
+-----------------------------------------------
+
+If you're a new contributor add yourself to the authors list. Feel free to use
+either English and/or Russian version.
+Also it will be good to update CHANGES.md.
+
+
+6. Create a pull request
+------------------------
+
+Send your contribution as a pull request on GitHub.
diff --git a/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/language-guide.rst b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/language-guide.rst
new file mode 100644
index 00000000..e5df0f8a
--- /dev/null
+++ b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/language-guide.rst
@@ -0,0 +1,247 @@
+Language definition guide
+=========================
+
+Highlighting overview
+---------------------
+
+Programming language code consists of parts with different rules of parsing: keywords like ``for`` or ``if``
+don't make sense inside strings, strings may contain backslash-escaped symbols like ``\"``
+and comments usually don't contain anything interesting except the end of the comment.
+
+In highlight.js such parts are called "modes".
+
+Each mode consists of:
+
+* starting condition
+* ending condition
+* list of contained sub-modes
+* lexing rules and keywords
+* …exotic stuff like another language inside a language
+
+The parser's work is to look for modes and their keywords.
+Upon finding, it wraps them into the markup ``...``
+and puts the name of the mode ("string", "comment", "number")
+or a keyword group name ("keyword", "literal", "built-in") as the span's class name.
+
+
+General syntax
+--------------
+
+A language definition is a JavaScript object describing the default parsing mode for the language.
+This default mode contains sub-modes which in turn contain other sub-modes, effectively making the language definition a tree of modes.
+
+Here's an example:
+
+::
+
+ {
+ case_insensitive: true, // language is case-insensitive
+ keywords: 'for if while',
+ contains: [
+ {
+ className: 'string',
+ begin: '"', end: '"'
+ },
+ hljs.COMMENT(
+ '/\\*', // begin
+ '\\*/', // end
+ {
+ contains: [
+ {
+ className: 'doc', begin: '@\\w+'
+ }
+ ]
+ }
+ )
+ ]
+ }
+
+Usually the default mode accounts for the majority of the code and describes all language keywords.
+A notable exception here is XML in which a default mode is just a user text that doesn't contain any keywords,
+and most interesting parsing happens inside tags.
+
+
+Keywords
+--------
+
+In the simple case language keywords are defined in a string, separated by space:
+
+::
+
+ {
+ keywords: 'else for if while'
+ }
+
+Some languages have different kinds of "keywords" that might not be called as such by the language spec
+but are very close to them from the point of view of a syntax highlighter. These are all sorts of "literals", "built-ins", "symbols" and such.
+To define such keyword groups the attribute ``keywords`` becomes an object each property of which defines its own group of keywords:
+
+::
+
+ {
+ keywords: {
+ keyword: 'else for if while',
+ literal: 'false true null'
+ }
+ }
+
+The group name becomes then a class name in a generated markup enabling different styling for different kinds of keywords.
+
+To detect keywords highlight.js breaks the processed chunk of code into separate words — a process called lexing.
+The "word" here is defined by the regexp ``[a-zA-Z][a-zA-Z0-9_]*`` that works for keywords in most languages.
+Different lexing rules can be defined by the ``lexemes`` attribute:
+
+::
+
+ {
+ lexemes '-[a-z]+',
+ keywords: '-import -export'
+ }
+
+
+Sub-modes
+---------
+
+Sub-modes are listed in the ``contains`` attribute:
+
+::
+
+ {
+ keywords: '...',
+ contains: [
+ hljs.QUOTE_STRING_MODE,
+ hljs.C_LINE_COMMENT,
+ { ... custom mode definition ... }
+ ]
+ }
+
+A mode can reference itself in the ``contains`` array by using a special keyword ``'self``'.
+This is commonly used to define nested modes:
+
+::
+
+ {
+ className: 'object',
+ begin: '{', end: '}',
+ contains: [hljs.QUOTE_STRING_MODE, 'self']
+ }
+
+
+Markup generation
+-----------------
+
+Modes usually generate actual highlighting markup — ```` elements with specific class names that are defined by the ``className`` attribute:
+
+::
+
+ {
+ contains: [
+ {
+ className: 'string',
+ // ... other attributes
+ },
+ {
+ className: 'number',
+ // ...
+ }
+ ]
+ }
+
+Names are not required to be unique, it's quite common to have several definitions with the same name.
+For example, many languages have various syntaxes for strings, comments, etc…
+
+Sometimes modes are defined only to support specific parsing rules and aren't needed in the final markup.
+A classic example is an escaping sequence inside strings allowing them to contain an ending quote.
+
+::
+
+ {
+ className: 'string',
+ begin: '"', end: '"',
+ contains: [{begin: '\\\\.'}],
+ }
+
+For such modes ``className`` attribute should be omitted so they won't generate excessive markup.
+
+
+Mode attributes
+---------------
+
+Other useful attributes are defined in the :doc:`mode reference `.
+
+
+.. _relevance:
+
+Relevance
+---------
+
+Highlight.js tries to automatically detect the language of a code fragment.
+The heuristics is essentially simple: it tries to highlight a fragment with all the language definitions
+and the one that yields most specific modes and keywords wins. The job of a language definition
+is to help this heuristics by hinting relative relevance (or irrelevance) of modes.
+
+This is best illustrated by example. Python has special kinds of strings defined by prefix letters before the quotes:
+``r"..."``, ``u"..."``. If a code fragment contains such strings there is a good chance that it's in Python.
+So these string modes are given high relevance:
+
+::
+
+ {
+ className: 'string',
+ begin: 'r"', end: '"',
+ relevance: 10
+ }
+
+On the other hand, conventional strings in plain single or double quotes aren't specific to any language
+and it makes sense to bring their relevance to zero to lessen statistical noise:
+
+::
+
+ {
+ className: 'string',
+ begin: '"', end: '"',
+ relevance: 0
+ }
+
+The default value for relevance is 1. When setting an explicit value it's recommended to use either 10 or 0.
+
+Keywords also influence relevance. Each of them usually has a relevance of 1, but there are some unique names
+that aren't likely to be found outside of their languages, even in the form of variable names.
+For example just having ``reinterpret_cast`` somewhere in the code is a good indicator that we're looking at C++.
+It's worth to set relevance of such keywords a bit higher. This is done with a pipe:
+
+::
+
+ {
+ keywords: 'for if reinterpret_cast|10'
+ }
+
+
+Illegal symbols
+---------------
+
+Another way to improve language detection is to define illegal symbols for a mode.
+For example in Python first line of class definition (``class MyClass(object):``) cannot contain symbol "{" or a newline.
+Presence of these symbols clearly shows that the language is not Python and the parser can drop this attempt early.
+
+Illegal symbols are defined as a a single regular expression:
+
+::
+
+ {
+ className: 'class',
+ illegal: '[${]'
+ }
+
+
+Pre-defined modes and regular expressions
+-----------------------------------------
+
+Many languages share common modes and regular expressions. Such expressions are defined in core highlight.js code
+at the end under "Common regexps" and "Common modes" titles. Use them when possible.
+
+
+Contributing
+------------
+
+Follow the :doc:`contributor checklist `.
diff --git a/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/language-requests.rst b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/language-requests.rst
new file mode 100644
index 00000000..4e4c2f0b
--- /dev/null
+++ b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/language-requests.rst
@@ -0,0 +1,17 @@
+On requesting new languages
+===========================
+
+This is a general answer to requests for adding new languages that appear from
+time to time in the highlight.js issue tracker and discussion group.
+
+ Highlight.js doesn't have a fundamental plan for implementing languages,
+ instead the project works by accepting language definitions from
+ interested contributors. There are also no rules at the moment forbidding
+ any languages from being added to the library, no matter how obscure or
+ weird.
+
+ This means that there's no point in requesting a new language without
+ providing an implementation for it. If you want to see a particular language
+ included in highlight.js but cannot implement it, the best way to make it
+ happen is to get another developer interested in doing so. Here's our
+ :doc:`language-guide`.
diff --git a/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/line-numbers.rst b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/line-numbers.rst
new file mode 100644
index 00000000..674542d4
--- /dev/null
+++ b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/line-numbers.rst
@@ -0,0 +1,39 @@
+Line numbers
+============
+
+Highlight.js' notable lack of line numbers support is not an oversight but a
+feature. Following is the explanation of this policy from the current project
+maintainer (hey guys!):
+
+ One of the defining design principles for highlight.js from the start was
+ simplicity. Not the simplicity of code (in fact, it's quite complex) but
+ the simplicity of usage and of the actual look of highlighted snippets on
+ HTML pages. Many highlighters, in my opinion, are overdoing it with such
+ things as separate colors for every single type of lexemes, striped
+ backgrounds, fancy buttons around code blocks and — yes — line numbers.
+ The more fancy stuff resides around the code the more it distracts a
+ reader from understanding it.
+
+ This is why it's not a straightforward decision: this new feature will not
+ just make highlight.js better, it might actually make it worse simply by
+ making it look more bloated in blog posts around the Internet. This is why
+ I'm asking people to show that it's worth it.
+
+ The only real use-case that ever was brought up in support of line numbers
+ is referencing code from the descriptive text around it. On my own blog I
+ was always solving this either with comments within the code itself or by
+ breaking the larger snippets into smaller ones and describing each small
+ part separately. I'm not saying that my solution is better. But I don't
+ see how line numbers are better either. And the only way to show that they
+ are better is to set up some usability research on the subject. I doubt
+ anyone would bother to do it.
+
+ Then there's maintenance. So far the core code of highlight.js is
+ maintained by only one person — yours truly. Inclusion of any new code in
+ highlight.js means that from that moment I will have to fix bugs in it,
+ improve it further, make it work together with the rest of the code,
+ defend its design. And I don't want to do all this for the feature that I
+ consider "evil" and probably will never use myself.
+
+This position is `subject to discuss `_.
+Also it doesn't stop anyone from forking the code and maintaining line-numbers implementation separately.
diff --git a/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/reference.rst b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/reference.rst
new file mode 100644
index 00000000..ff4f2eff
--- /dev/null
+++ b/.vscode/extensions/dbankier.vscode-instant-markdown-0.1.0/node_modules/instant-markdown-d/node_modules/highlight.js/docs/reference.rst
@@ -0,0 +1,298 @@
+Mode reference
+==============
+
+Types
+-----
+
+Types of attributes values in this reference:
+
++------------+-------------------------------------------------------------------------------------+
+| identifier | String suitable to be used as a Javascript variable and CSS class name |
+| | (i.e. mostly ``/[A-Za-z0-9_]+/``) |
++------------+-------------------------------------------------------------------------------------+
+| regexp | String representing a Javascript regexp. |
+| | Note that since it's not a literal regexp all back-slashes should be repeated twice |
++------------+-------------------------------------------------------------------------------------+
+| boolean | Javascript boolean: ``true`` or ``false`` |
++------------+-------------------------------------------------------------------------------------+
+| number | Javascript number |
++------------+-------------------------------------------------------------------------------------+
+| object | Javascript object: ``{ ... }`` |
++------------+-------------------------------------------------------------------------------------+
+| array | Javascript array: ``[ ... ]`` |
++------------+-------------------------------------------------------------------------------------+
+
+
+Attributes
+----------
+
+case_insensitive
+^^^^^^^^^^^^^^^^
+
+**type**: boolean
+
+Case insensitivity of language keywords and regexps. Used only on the top-level mode.
+
+
+aliases
+^^^^^^^
+
+**type**: array
+
+A list of additional names (besides the canonical one given by the filename) that can be used to identify a language in HTML classes and in a call to :ref:`getLanguage `.
+
+
+className
+^^^^^^^^^
+
+**type**: identifier
+
+The name of the mode. It is used as a class name in HTML markup.
+
+Multiple modes can have the same name. This is useful when a language has multiple variants of syntax
+for one thing like string in single or double quotes.
+
+
+begin
+^^^^^
+
+**type**: regexp
+
+Regular expression starting a mode. For example a single quote for strings or two forward slashes for C-style comments.
+If absent, ``begin`` defaults to a regexp that matches anything, so the mode starts immediately.
+
+
+end
+^^^
+
+**type**: regexp
+
+Regular expression ending a mode. For example a single quote for strings or "$" (end of line) for one-line comments.
+
+It's often the case that a beginning regular expression defines the entire mode and doesn't need any special ending.
+For example a number can be defined with ``begin: "\\b\\d+"`` which spans all the digits.
+
+If absent, ``end`` defaults to a regexp that matches anything, so the mode ends immediately.
+
+Sometimes a mode can end not by itself but implicitly with its containing (parent) mode.
+This is achieved with :ref:`endsWithParent ` attribute.
+
+
+beginKeywords
+^^^^^^^^^^^^^^^^
+
+**type**: string
+
+Used instead of ``begin`` for modes starting with keywords to avoid needless repetition:
+
+::
+
+ {
+ begin: '\\b(extends|implements) ',
+ keywords: 'extends implements'
+ }
+
+… becomes:
+
+::
+
+ {
+ beginKeywords: 'extends implements'
+ }
+
+Unlike the :ref:`keywords ` attribute, this one allows only a simple list of space separated keywords.
+If you do need additional features of ``keywords`` or you just need more keywords for this mode you may include ``keywords`` along with ``beginKeywords``.
+
+
+.. _endsWithParent:
+
+endsWithParent
+^^^^^^^^^^^^^^
+
+**type**: boolean
+
+A flag showing that a mode ends when its parent ends.
+
+This is best demonstrated by example. In CSS syntax a selector has a set of rules contained within symbols "{" and "}".
+Individual rules separated by ";" but the last one in a set can omit the terminating semicolon:
+
+::
+
+ p {
+ width: 100%; color: red
+ }
+
+This is when ``endsWithParent`` comes into play:
+
+::
+
+ {
+ className: 'rules', begin: '{', end: '}',
+ contains: [
+ {className: 'rule', /* ... */ end: ';', endsWithParent: true}
+ ]
+ }
+
+.. _endsParent:
+
+endsParent
+^^^^^^^^^^^^^^
+
+**type**: boolean
+
+Forces closing of the parent mode right after the current mode is closed.
+
+This is used for modes that don't have an easily expressible ending lexeme but
+instead could be closed after the last interesting sub-mode is found.
+
+Here's an example with two ways of defining functions in Elixir, one using a
+keyword ``do`` and another using a comma:
+
+::
+
+ def foo :clear, list do
+ :ok
+ end
+
+ def foo, do: IO.puts "hello world"
+
+Note that in the first case the parameter list after the function title may also
+include a comma. And iIf we're only interested in highlighting a title we can
+tell it to end the function definition after itself:
+
+::
+
+ {
+ className: 'function',
+ beginKeywords: 'def', end: /\B\b/,
+ contains: [
+ {
+ className: 'title',
+ begin: hljs.IDENT_RE, endsParent: true
+ }
+ ]
+ }
+
+(The ``end: /\B\b/`` regex tells function to never end by itself.)
+
+.. _lexemes:
+
+lexemes
+^^^^^^^
+
+**type**: regexp
+
+A regular expression that extracts individual lexemes from language text to find :ref:`keywords ` among them.
+Default value is ``hljs.IDENT_RE`` which works for most languages.
+
+
+.. _keywords:
+
+keywords
+^^^^^^^^
+
+**type**: object
+
+Keyword definition comes in two forms:
+
+* ``'for while if else weird_voodoo|10 ... '`` -- a string of space-separated keywords with an optional relevance over a pipe
+* ``{'keyword': ' ... ', 'literal': ' ... '}`` -- an object whose keys are names of different kinds of keywords and values are keyword definition strings in the first form
+
+For detailed explanation see :doc:`Language definition guide `.
+
+
+illegal
+^^^^^^^
+
+**type**: regexp
+
+A regular expression that defines symbols illegal for the mode.
+When the parser finds a match for illegal expression it immediately drops parsing the whole language altogether.
+
+
+excludeBegin, excludeEnd
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+**type**: boolean
+
+Exclude beginning or ending lexemes out of mode's generated markup. For example in CSS syntax a rule ends with a semicolon.
+However visually it's better not to color it as the rule contents. Having ``excludeEnd: true`` forces a ```` element for the rule to close before the semicolon.
+
+
+returnBegin
+^^^^^^^^^^^
+
+**type**: boolean
+
+Returns just found beginning lexeme back into parser. This is used when beginning of a sub-mode is a complex expression
+that should not only be found within a parent mode but also parsed according to the rules of a sub-mode.
+
+Since the parser is effectively goes back it's quite possible to create a infinite loop here so use with caution!
+
+
+returnEnd
+^^^^^^^^^
+
+**type**: boolean
+
+Returns just found ending lexeme back into parser. This is used for example to parse Javascript embedded into HTML.
+A Javascript block ends with the HTML closing tag ```` that cannot be parsed with Javascript rules.
+So it is returned back into its parent HTML mode that knows what to do with it.
+
+Since the parser is effectively goes back it's quite possible to create a infinite loop here so use with caution!
+
+
+contains
+^^^^^^^^
+
+**type**: array
+
+The list of sub-modes that can be found inside the mode. For detailed explanation see :doc:`Language definition guide `.
+
+
+starts
+^^^^^^
+
+**type**: identifier
+
+The name of the mode that will start right after the current mode ends. The new mode won't be contained within the current one.
+
+Currently this attribute is used to highlight Javascript and CSS contained within HTML.
+Tags ``
+
+
+
+
+ {{ "%+010d"|sprintf:-123 }}
+ {{ "%+010d"|vsprintf:[-123] }}
+ {{ "%+010d"|fmt:-123 }}
+ {{ "%+010d"|vfmt:[-123] }}
+ {{ "I've got %2$d apples and %1$d oranges."|fmt:4:2 }}
+ {{ "I've got %(apples)d apples and %(oranges)d oranges."|fmt:{apples: 2, oranges: 4} }}
+
+
+
+