1 files changed, 0 insertions, 1071 deletions
diff --git a/source/prism.js b/source/prism.js
deleted file mode 100644
index 304be1e..0000000
--- a/source/prism.js
+++ /dev/null
@@ -1,1071 +0,0 @@
-/* **********************************************
-     Begin prism-core.js
-********************************************** */
-var _self = (typeof window !== 'undefined')
-  ? window   // if in browser
-  : (
-    (typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope)
-      ? self // if in worker
-      : {}   // if in node js
-  );
-/**
- * Prism: Lightweight, robust, elegant syntax highlighting
- * MIT license http://www.opensource.org/licenses/mit-license.php/
- * @author Lea Verou http://lea.verou.me
- */
-var Prism = (function () {
-  // Private helper vars
-  var lang = /\blang(?:uage)?-([\w-]+)\b/i;
-  var uniqueId = 0;
-  var _ = _self.Prism = {
-    manual: _self.Prism && _self.Prism.manual,
-    disableWorkerMessageHandler: _self.Prism && _self.Prism.disableWorkerMessageHandler,
-    util: {
-      encode: function (tokens) {
-        if (tokens instanceof Token) {
-          return new Token(tokens.type, _.util.encode(tokens.content), tokens.alias);
-        } else if (_.util.type(tokens) === 'Array') {
-          return tokens.map(_.util.encode);
-        } else {
-          return tokens.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/\u00a0/g, ' ');
-        }
-      },
-      type: function (o) {
-        return Object.prototype.toString.call(o).slice(8, -1);
-      },
-      objId: function (obj) {
-        if (!obj['__id']) {
-          Object.defineProperty(obj, '__id', { value: ++uniqueId });
-        }
-        return obj['__id'];
-      },
-      // Deep clone a language definition (e.g. to extend it)
-      clone: function (o, visited) {
-        var type = _.util.type(o);
-        visited = visited || {};
-        switch (type) {
-          case 'Object':
-            if (visited[_.util.objId(o)]) {
-              return visited[_.util.objId(o)];
-            }
-            var clone = {};
-            visited[_.util.objId(o)] = clone;
-            for (var key in o) {
-              if (o.hasOwnProperty(key)) {
-                clone[key] = _.util.clone(o[key], visited);
-              }
-            }
-            return clone;
-          case 'Array':
-            if (visited[_.util.objId(o)]) {
-              return visited[_.util.objId(o)];
-            }
-            var clone = [];
-            visited[_.util.objId(o)] = clone;
-            o.forEach(function (v, i) {
-              clone[i] = _.util.clone(v, visited);
-            });
-            return clone;
-        }
-        return o;
-      }
-    },
-    languages: {
-      extend: function (id, redef) {
-        var lang = _.util.clone(_.languages[id]);
-        for (var key in redef) {
-          lang[key] = redef[key];
-        }
-        return lang;
-      },
-      /**
-       * Insert a token before another token in a language literal
-       * As this needs to recreate the object (we cannot actually insert before keys in object literals),
-       * we cannot just provide an object, we need an object and a key.
-       * @param inside The key (or language id) of the parent
-       * @param before The key to insert before.
-       * @param insert Object with the key/value pairs to insert
-       * @param root The object that contains `inside`. If equal to Prism.languages, it can be omitted.
-       */
-      insertBefore: function (inside, before, insert, root) {
-        root = root || _.languages;
-        var grammar = root[inside];
-        var ret = {};
-        for (var token in grammar) {
-          if (grammar.hasOwnProperty(token)) {
-            if (token == before) {
-              for (var newToken in insert) {
-                if (insert.hasOwnProperty(newToken)) {
-                  ret[newToken] = insert[newToken];
-                }
-              }
-            }
-            // Do not insert token which also occur in insert. See #1525
-            if (!insert.hasOwnProperty(token)) {
-              ret[token] = grammar[token];
-            }
-          }
-        }
-        var old = root[inside];
-        root[inside] = ret;
-        // Update references in other language definitions
-        _.languages.DFS(_.languages, function (key, value) {
-          if (value === old && key != inside) {
-            this[key] = ret;
-          }
-        });
-        return ret;
-      },
-      // Traverse a language definition with Depth First Search
-      DFS: function (o, callback, type, visited) {
-        visited = visited || {};
-        for (var i in o) {
-          if (o.hasOwnProperty(i)) {
-            callback.call(o, i, o[i], type || i);
-            if (_.util.type(o[i]) === 'Object' && !visited[_.util.objId(o[i])]) {
-              visited[_.util.objId(o[i])] = true;
-              _.languages.DFS(o[i], callback, null, visited);
-            }
-            else if (_.util.type(o[i]) === 'Array' && !visited[_.util.objId(o[i])]) {
-              visited[_.util.objId(o[i])] = true;
-              _.languages.DFS(o[i], callback, i, visited);
-            }
-          }
-        }
-      }
-    },
-    plugins: {},
-    highlightAll: function (async, callback) {
-      _.highlightAllUnder(document, async, callback);
-    },
-    highlightAllUnder: function (container, async, callback) {
-      var env = {
-        callback: callback,
-        selector: 'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code'
-      };
-      _.hooks.run("before-highlightall", env);
-      var elements = env.elements || container.querySelectorAll(env.selector);
-      for (var i = 0, element; element = elements[i++];) {
-        _.highlightElement(element, async === true, env.callback);
-      }
-    },
-    highlightElement: function (element, async, callback) {
-      // Find language
-      var language, grammar, parent = element;
-      while (parent && !lang.test(parent.className)) {
-        parent = parent.parentNode;
-      }
-      if (parent) {
-        language = (parent.className.match(lang) || [, ''])[1].toLowerCase();
-        grammar = _.languages[language];
-      }
-      // Set language on the element, if not present
-      element.className = element.className.replace(lang, '').replace(/\s+/g, ' ') + ' language-' + language;
-      if (element.parentNode) {
-        // Set language on the parent, for styling
-        parent = element.parentNode;
-        if (/pre/i.test(parent.nodeName)) {
-          parent.className = parent.className.replace(lang, '').replace(/\s+/g, ' ') + ' language-' + language;
-        }
-      }
-      var code = element.textContent;
-      var env = {
-        element: element,
-        language: language,
-        grammar: grammar,
-        code: code
-      };
-      var insertHighlightedCode = function (highlightedCode) {
-        env.highlightedCode = highlightedCode;
-        _.hooks.run('before-insert', env);
-        env.element.innerHTML = env.highlightedCode;
-        _.hooks.run('after-highlight', env);
-        _.hooks.run('complete', env);
-        callback && callback.call(env.element);
-      }
-      _.hooks.run('before-sanity-check', env);
-      if (!env.code) {
-        _.hooks.run('complete', env);
-        return;
-      }
-      _.hooks.run('before-highlight', env);
-      if (!env.grammar) {
-        insertHighlightedCode(_.util.encode(env.code));
-        return;
-      }
-      if (async && _self.Worker) {
-        var worker = new Worker(_.filename);
-        worker.onmessage = function (evt) {
-          insertHighlightedCode(evt.data);
-        };
-        worker.postMessage(JSON.stringify({
-          language: env.language,
-          code: env.code,
-          immediateClose: true
-        }));
-      }
-      else {
-        insertHighlightedCode(_.highlight(env.code, env.grammar, env.language));
-      }
-    },
-    highlight: function (text, grammar, language) {
-      var env = {
-        code: text,
-        grammar: grammar,
-        language: language
-      };
-      _.hooks.run('before-tokenize', env);
-      env.tokens = _.tokenize(env.code, env.grammar);
-      _.hooks.run('after-tokenize', env);
-      return Token.stringify(_.util.encode(env.tokens), env.language);
-    },
-    matchGrammar: function (text, strarr, grammar, index, startPos, oneshot, target) {
-      var Token = _.Token;
-      for (var token in grammar) {
-        if (!grammar.hasOwnProperty(token) || !grammar[token]) {
-          continue;
-        }
-        if (token == target) {
-          return;
-        }
-        var patterns = grammar[token];
-        patterns = (_.util.type(patterns) === "Array") ? patterns : [patterns];
-        for (var j = 0; j < patterns.length; ++j) {
-          var pattern = patterns[j],
-            inside = pattern.inside,
-            lookbehind = !!pattern.lookbehind,
-            greedy = !!pattern.greedy,
-            lookbehindLength = 0,
-            alias = pattern.alias;
-          if (greedy && !pattern.pattern.global) {
-            // Without the global flag, lastIndex won't work
-            var flags = pattern.pattern.toString().match(/[imuy]*$/)[0];
-            pattern.pattern = RegExp(pattern.pattern.source, flags + "g");
-          }
-          pattern = pattern.pattern || pattern;
-          // Don’t cache length as it changes during the loop
-          for (var i = index, pos = startPos; i < strarr.length; pos += strarr[i].length, ++i) {
-            var str = strarr[i];
-            if (strarr.length > text.length) {
-              // Something went terribly wrong, ABORT, ABORT!
-              return;
-            }
-            if (str instanceof Token) {
-              continue;
-            }
-            if (greedy && i != strarr.length - 1) {
-              pattern.lastIndex = pos;
-              var match = pattern.exec(text);
-              if (!match) {
-                break;
-              }
-              var from = match.index + (lookbehind ? match[1].length : 0),
-                to = match.index + match[0].length,
-                k = i,
-                p = pos;
-              for (var len = strarr.length; k < len && (p < to || (!strarr[k].type && !strarr[k - 1].greedy)); ++k) {
-                p += strarr[k].length;
-                // Move the index i to the element in strarr that is closest to from
-                if (from >= p) {
-                  ++i;
-                  pos = p;
-                }
-              }
-              // If strarr[i] is a Token, then the match starts inside another Token, which is invalid
-              if (strarr[i] instanceof Token) {
-                continue;
-              }
-              // Number of tokens to delete and replace with the new match
-              delNum = k - i;
-              str = text.slice(pos, p);
-              match.index -= pos;
-            } else {
-              pattern.lastIndex = 0;
-              var match = pattern.exec(str),
-                delNum = 1;
-            }
-            if (!match) {
-              if (oneshot) {
-                break;
-              }
-              continue;
-            }
-            if (lookbehind) {
-              lookbehindLength = match[1] ? match[1].length : 0;
-            }
-            var from = match.index + lookbehindLength,
-              match = match[0].slice(lookbehindLength),
-              to = from + match.length,
-              before = str.slice(0, from),
-              after = str.slice(to);
-            var args = [i, delNum];
-            if (before) {
-              ++i;
-              pos += before.length;
-              args.push(before);
-            }
-            var wrapped = new Token(token, inside ? _.tokenize(match, inside) : match, alias, match, greedy);
-            args.push(wrapped);
-            if (after) {
-              args.push(after);
-            }
-            Array.prototype.splice.apply(strarr, args);
-            if (delNum != 1)
-              _.matchGrammar(text, strarr, grammar, i, pos, true, token);
-            if (oneshot)
-              break;
-          }
-        }
-      }
-    },
-    tokenize: function (text, grammar) {
-      var strarr = [text];
-      var rest = grammar.rest;
-      if (rest) {
-        for (var token in rest) {
-          grammar[token] = rest[token];
-        }
-        delete grammar.rest;
-      }
-      _.matchGrammar(text, strarr, grammar, 0, 0, false);
-      return strarr;
-    },
-    hooks: {
-      all: {},
-      add: function (name, callback) {
-        var hooks = _.hooks.all;
-        hooks[name] = hooks[name] || [];
-        hooks[name].push(callback);
-      },
-      run: function (name, env) {
-        var callbacks = _.hooks.all[name];
-        if (!callbacks || !callbacks.length) {
-          return;
-        }
-        for (var i = 0, callback; callback = callbacks[i++];) {
-          callback(env);
-        }
-      }
-    }
-  };
-  var Token = _.Token = function (type, content, alias, matchedStr, greedy) {
-    this.type = type;
-    this.content = content;
-    this.alias = alias;
-    // Copy of the full string this token was created from
-    this.length = (matchedStr || "").length | 0;
-    this.greedy = !!greedy;
-  };
-  Token.stringify = function (o, language, parent) {
-    if (typeof o == 'string') {
-      return o;
-    }
-    if (_.util.type(o) === 'Array') {
-      return o.map(function (element) {
-        return Token.stringify(element, language, o);
-      }).join('');
-    }
-    var env = {
-      type: o.type,
-      content: Token.stringify(o.content, language, parent),
-      tag: 'span',
-      classes: ['token', o.type],
-      attributes: {},
-      language: language,
-      parent: parent
-    };
-    if (o.alias) {
-      var aliases = _.util.type(o.alias) === 'Array' ? o.alias : [o.alias];
-      Array.prototype.push.apply(env.classes, aliases);
-    }
-    _.hooks.run('wrap', env);
-    var attributes = Object.keys(env.attributes).map(function (name) {
-      return name + '="' + (env.attributes[name] || '').replace(/"/g, '&quot;') + '"';
-    }).join(' ');
-    return '<' + env.tag + ' class="' + env.classes.join(' ') + '"' + (attributes ? ' ' + attributes : '') + '>' + env.content + '</' + env.tag + '>';
-  };
-  if (!_self.document) {
-    if (!_self.addEventListener) {
-      // in Node.js
-      return _self.Prism;
-    }
-    if (!_.disableWorkerMessageHandler) {
-      // In worker
-      _self.addEventListener('message', function (evt) {
-        var message = JSON.parse(evt.data),
-          lang = message.language,
-          code = message.code,
-          immediateClose = message.immediateClose;
-        _self.postMessage(_.highlight(code, _.languages[lang], lang));
-        if (immediateClose) {
-          _self.close();
-        }
-      }, false);
-    }
-    return _self.Prism;
-  }
-  //Get current script and highlight
-  var script = document.currentScript || [].slice.call(document.getElementsByTagName("script")).pop();
-  if (script) {
-    _.filename = script.src;
-    if (!_.manual && !script.hasAttribute('data-manual')) {
-      if (document.readyState !== "loading") {
-        if (window.requestAnimationFrame) {
-          window.requestAnimationFrame(_.highlightAll);
-        } else {
-          window.setTimeout(_.highlightAll, 16);
-        }
-      }
-      else {
-        document.addEventListener('DOMContentLoaded', _.highlightAll);
-      }
-    }
-  }
-  return _self.Prism;
-})();
-if (typeof module !== 'undefined' && module.exports) {
-  module.exports = Prism;
-}
-// hack for components to work correctly in node.js
-if (typeof global !== 'undefined') {
-  global.Prism = Prism;
-}
-/* **********************************************
-     Begin prism-markup.js
-********************************************** */
-Prism.languages.markup = {
-  'comment': /<!--[\s\S]*?-->/,
-  'prolog': /<\?[\s\S]+?\?>/,
-  'doctype': /<!DOCTYPE[\s\S]+?>/i,
-  'cdata': /<!\[CDATA\[[\s\S]*?]]>/i,
-  'tag': {
-    pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/i,
-    greedy: true,
-    inside: {
-      'tag': {
-        pattern: /^<\/?[^\s>\/]+/i,
-        inside: {
-          'punctuation': /^<\/?/,
-          'namespace': /^[^\s>\/:]+:/
-        }
-      },
-      'attr-value': {
-        pattern: /=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+)/i,
-        inside: {
-          'punctuation': [
-            /^=/,
-            {
-              pattern: /(^|[^\\])["']/,
-              lookbehind: true
-            }
-          ]
-        }
-      },
-      'punctuation': /\/?>/,
-      'attr-name': {
-        pattern: /[^\s>\/]+/,
-        inside: {
-          'namespace': /^[^\s>\/:]+:/
-        }
-      }
-    }
-  },
-  'entity': /&#?[\da-z]{1,8};/i
-};
-Prism.languages.markup['tag'].inside['attr-value'].inside['entity'] =
-  Prism.languages.markup['entity'];
-// Plugin to make entity title show the real entity, idea by Roman Komarov
-Prism.hooks.add('wrap', function (env) {
-  if (env.type === 'entity') {
-    env.attributes['title'] = env.content.replace(/&amp;/, '&');
-  }
-});
-Prism.languages.xml = Prism.languages.extend('markup', {});
-Prism.languages.html = Prism.languages.markup;
-Prism.languages.mathml = Prism.languages.markup;
-Prism.languages.svg = Prism.languages.markup;
-/* **********************************************
-     Begin prism-css.js
-********************************************** */
-Prism.languages.css = {
-  'comment': /\/\*[\s\S]*?\*\//,
-  'atrule': {
-    pattern: /@[\w-]+?[\s\S]*?(?:;|(?=\s*\{))/i,
-    inside: {
-      'rule': /@[\w-]+/
-      // See rest below
-    }
-  },
-  'url': /url\((?:(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1|.*?)\)/i,
-  'selector': /[^{}\s][^{};]*?(?=\s*\{)/,
-  'string': {
-    pattern: /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
-    greedy: true
-  },
-  'property': /[-_a-z\xA0-\uFFFF][-\w\xA0-\uFFFF]*(?=\s*:)/i,
-  'important': /!important\b/i,
-  'function': /[-a-z0-9]+(?=\()/i,
-  'punctuation': /[(){};:,]/
-};
-Prism.languages.css['atrule'].inside.rest = Prism.languages.css;
-if (Prism.languages.markup) {
-  Prism.languages.insertBefore('markup', 'tag', {
-    'style': {
-      pattern: /(<style[\s\S]*?>)[\s\S]*?(?=<\/style>)/i,
-      lookbehind: true,
-      inside: Prism.languages.css,
-      alias: 'language-css',
-      greedy: true
-    }
-  });
-  Prism.languages.insertBefore('inside', 'attr-value', {
-    'style-attr': {
-      pattern: /\s*style=("|')(?:\\[\s\S]|(?!\1)[^\\])*\1/i,
-      inside: {
-        'attr-name': {
-          pattern: /^\s*style/i,
-          inside: Prism.languages.markup.tag.inside
-        },
-        'punctuation': /^\s*=\s*['"]|['"]\s*$/,
-        'attr-value': {
-          pattern: /.+/i,
-          inside: Prism.languages.css
-        }
-      },
-      alias: 'language-css'
-    }
-  }, Prism.languages.markup.tag);
-}
-/* **********************************************
-     Begin prism-clike.js
-********************************************** */
-Prism.languages.clike = {
-  'comment': [
-    {
-      pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
-      lookbehind: true
-    },
-    {
-      pattern: /(^|[^\\:])\/\/.*/,
-      lookbehind: true,
-      greedy: true
-    }
-  ],
-  'string': {
-    pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
-    greedy: true
-  },
-  'class-name': {
-    pattern: /((?:\b(?:class|interface|extends|implements|trait|instanceof|new)\s+)|(?:catch\s+\())[\w.\\]+/i,
-    lookbehind: true,
-    inside: {
-      punctuation: /[.\\]/
-    }
-  },
-  'keyword': /\b(?:if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/,
-  'boolean': /\b(?:true|false)\b/,
-  'function': /\w+(?=\()/,
-  'number': /\b0x[\da-f]+\b|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?/i,
-  'operator': /--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&?|\|\|?|\?|\*|\/|~|\^|%/,
-  'punctuation': /[{}[\];(),.:]/
-};
-/* **********************************************
-     Begin prism-javascript.js
-********************************************** */
-Prism.languages.javascript = Prism.languages.extend('clike', {
-  'class-name': [
-    Prism.languages.clike['class-name'],
-    {
-      pattern: /(^|[^$\w\xA0-\uFFFF])[_$A-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\.(?:prototype|constructor))/,
-      lookbehind: true
-    }
-  ],
-  'keyword': [
-    {
-      pattern: /((?:^|})\s*)(?:catch|finally)\b/,
-      lookbehind: true
-    },
-    /\b(?:as|async|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/
-  ],
-  'number': /\b(?:(?:0[xX][\dA-Fa-f]+|0[bB][01]+|0[oO][0-7]+)n?|\d+n|NaN|Infinity)\b|(?:\b\d+\.?\d*|\B\.\d+)(?:[Ee][+-]?\d+)?/,
-  // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
-  'function': /[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*\(|\.(?:apply|bind|call)\()/,
-  'operator': /-[-=]?|\+[+=]?|!=?=?|<<?=?|>>?>?=?|=(?:==?|>)?|&[&=]?|\|[|=]?|\*\*?=?|\/=?|~|\^=?|%=?|\?|\.{3}/
-});
-Prism.languages.javascript['class-name'][0].pattern = /(\b(?:class|interface|extends|implements|instanceof|new)\s+)[\w.\\]+/
-Prism.languages.insertBefore('javascript', 'keyword', {
-  'regex': {
-    pattern: /((?:^|[^$\w\xA0-\uFFFF."'\])\s])\s*)\/(\[(?:[^\]\\\r\n]|\\.)*]|\\.|[^/\\\[\r\n])+\/[gimyu]{0,5}(?=\s*($|[\r\n,.;})\]]))/,
-    lookbehind: true,
-    greedy: true
-  },
-  // This must be declared before keyword because we use "function" inside the look-forward
-  'function-variable': {
-    pattern: /[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*)\s*=>))/,
-    alias: 'function'
-  },
-  'parameter': [
-    {
-      pattern: /(function(?:\s+[_$A-Za-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*)?\s*\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\))/,
-      lookbehind: true,
-      inside: Prism.languages.javascript
-    },
-    {
-      pattern: /[_$a-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*=>)/i,
-      inside: Prism.languages.javascript
-    },
-    {
-      pattern: /(\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\)\s*=>)/,
-      lookbehind: true,
-      inside: Prism.languages.javascript
-    },
-    {
-      pattern: /((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:[_$A-Za-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*\s*)\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\)\s*\{)/,
-      lookbehind: true,
-      inside: Prism.languages.javascript
-    }
-  ],
-  'constant': /\b[A-Z][A-Z\d_]*\b/
-});
-Prism.languages.insertBefore('javascript', 'string', {
-  'template-string': {
-    pattern: /`(?:\\[\s\S]|\${[^}]+}|[^\\`])*`/,
-    greedy: true,
-    inside: {
-      'interpolation': {
-        pattern: /\${[^}]+}/,
-        inside: {
-          'interpolation-punctuation': {
-            pattern: /^\${|}$/,
-            alias: 'punctuation'
-          },
-          rest: Prism.languages.javascript
-        }
-      },
-      'string': /[\s\S]+/
-    }
-  }
-});
-if (Prism.languages.markup) {
-  Prism.languages.insertBefore('markup', 'tag', {
-    'script': {
-      pattern: /(<script[\s\S]*?>)[\s\S]*?(?=<\/script>)/i,
-      lookbehind: true,
-      inside: Prism.languages.javascript,
-      alias: 'language-javascript',
-      greedy: true
-    }
-  });
-}
-Prism.languages.js = Prism.languages.javascript;
-/* **********************************************
-     Begin prism-file-highlight.js
-********************************************** */
-(function () {
-  if (typeof self === 'undefined' || !self.Prism || !self.document || !document.querySelector) {
-    return;
-  }
-        /**
-         * @param {Element} [container=document]
-         */
-  self.Prism.fileHighlight = function (container) {
-    container = container || document;
-    var Extensions = {
-      'js': 'javascript',
-      'py': 'python',
-      'rb': 'ruby',
-      'ps1': 'powershell',
-      'psm1': 'powershell',
-      'sh': 'bash',
-      'bat': 'batch',
-      'h': 'c',
-      'tex': 'latex'
-    };
-    Array.prototype.slice.call(container.querySelectorAll('pre[data-src]')).forEach(function (pre) {
-      // ignore if already loaded
-      if (pre.hasAttribute('data-src-loaded')) {
-        return;
-      }
-      // load current
-      var src = pre.getAttribute('data-src');
-      var language, parent = pre;
-      var lang = /\blang(?:uage)?-([\w-]+)\b/i;
-      while (parent && !lang.test(parent.className)) {
-        parent = parent.parentNode;
-      }
-      if (parent) {
-        language = (pre.className.match(lang) || [, ''])[1];
-      }
-      if (!language) {
-        var extension = (src.match(/\.(\w+)$/) || [, ''])[1];
-        language = Extensions[extension] || extension;
-      }
-      var code = document.createElement('code');
-      code.className = 'language-' + language;
-      pre.textContent = '';
-      code.textContent = 'Loading…';
-      pre.appendChild(code);
-      var xhr = new XMLHttpRequest();
-      xhr.open('GET', src, true);
-      xhr.onreadystatechange = function () {
-        if (xhr.readyState == 4) {
-          if (xhr.status < 400 && xhr.responseText) {
-            code.textContent = xhr.responseText;
-            Prism.highlightElement(code);
-            // mark as loaded
-            pre.setAttribute('data-src-loaded', '');
-          }
-          else if (xhr.status >= 400) {
-            code.textContent = '✖ Error ' + xhr.status + ' while fetching file: ' + xhr.statusText;
-          }
-          else {
-            code.textContent = '✖ Error: File does not exist or is empty';
-          }
-        }
-      };
-      xhr.send(null);
-    });
-    if (Prism.plugins.toolbar) {
-      Prism.plugins.toolbar.registerButton('download-file', function (env) {
-        var pre = env.element.parentNode;
-        if (!pre || !/pre/i.test(pre.nodeName) || !pre.hasAttribute('data-src') || !pre.hasAttribute('data-download-link')) {
-          return;
-        }
-        var src = pre.getAttribute('data-src');
-        var a = document.createElement('a');
-        a.textContent = pre.getAttribute('data-download-link-label') || 'Download';
-        a.setAttribute('download', '');
-        a.href = src;
-        return a;
-      });
-    }
-  };
-  document.addEventListener('DOMContentLoaded', function () {
-    // execute inside handler, for dropping Event as argumnet
-    self.Prism.fileHighlight();
-  });
-})();
-(function () {
-  if (typeof self === 'undefined' || !self.Prism || !self.document) {
-    return;
-  }
-        /**
-         * Plugin name which is used as a class name for <pre> which is activating the plugin
-         * @type {String}
-         */
-  var PLUGIN_NAME = 'line-numbers';
-        /**
-         * Regular expression used for determining line breaks
-         * @type {RegExp}
-         */
-  var NEW_LINE_EXP = /\n(?!$)/g;
-        /**
-         * Resizes line numbers spans according to height of line of code
-         * @param {Element} element <pre> element
-         */
-  var _resizeElement = function (element) {
-    var codeStyles = getStyles(element);
-    var whiteSpace = codeStyles['white-space'];
-    if (whiteSpace === 'pre-wrap' || whiteSpace === 'pre-line') {
-      var codeElement = element.querySelector('code');
-      var lineNumbersWrapper = element.querySelector('.line-numbers-rows');
-      var lineNumberSizer = element.querySelector('.line-numbers-sizer');
-      var codeLines = codeElement.textContent.split(NEW_LINE_EXP);
-      if (!lineNumberSizer) {
-        lineNumberSizer = document.createElement('span');
-        lineNumberSizer.className = 'line-numbers-sizer';
-        codeElement.appendChild(lineNumberSizer);
-      }
-      lineNumberSizer.style.display = 'block';
-      codeLines.forEach(function (line, lineNumber) {
-        lineNumberSizer.textContent = line || '\n';
-        var lineSize = lineNumberSizer.getBoundingClientRect().height;
-        lineNumbersWrapper.children[lineNumber].style.height = lineSize + 'px';
-      });
-      lineNumberSizer.textContent = '';
-      lineNumberSizer.style.display = 'none';
-    }
-  };
-        /**
-         * Returns style declarations for the element
-         * @param {Element} element
-         */
-  var getStyles = function (element) {
-    if (!element) {
-      return null;
-    }
-    return window.getComputedStyle ? getComputedStyle(element) : (element.currentStyle || null);
-  };
-  window.addEventListener('resize', function () {
-    Array.prototype.forEach.call(document.querySelectorAll('pre.' + PLUGIN_NAME), _resizeElement);
-  });
-  Prism.hooks.add('complete', function (env) {
-    if (!env.code) {
-      return;
-    }
-    // works only for <code> wrapped inside <pre> (not inline)
-    var pre = env.element.parentNode;
-    var clsReg = /\s*\bline-numbers\b\s*/;
-    if (
-      !pre || !/pre/i.test(pre.nodeName) ||
-      // Abort only if nor the <pre> nor the <code> have the class
-      (!clsReg.test(pre.className) && !clsReg.test(env.element.className))
-    ) {
-      return;
-    }
-    if (env.element.querySelector('.line-numbers-rows')) {
-      // Abort if line numbers already exists
-      return;
-    }
-    if (clsReg.test(env.element.className)) {
-      // Remove the class 'line-numbers' from the <code>
-      env.element.className = env.element.className.replace(clsReg, ' ');
-    }
-    if (!clsReg.test(pre.className)) {
-      // Add the class 'line-numbers' to the <pre>
-      pre.className += ' line-numbers';
-    }
-    var match = env.code.match(NEW_LINE_EXP);
-    var linesNum = match ? match.length + 1 : 1;
-    var lineNumbersWrapper;
-    var lines = new Array(linesNum + 1);
-    lines = lines.join('<span></span>');
-    lineNumbersWrapper = document.createElement('span');
-    lineNumbersWrapper.setAttribute('aria-hidden', 'true');
-    lineNumbersWrapper.className = 'line-numbers-rows';
-    lineNumbersWrapper.innerHTML = lines;
-    if (pre.hasAttribute('data-start')) {
-      pre.style.counterReset = 'linenumber ' + (parseInt(pre.getAttribute('data-start'), 10) - 1);
-    }
-    env.element.appendChild(lineNumbersWrapper);
-    _resizeElement(pre);
-    Prism.hooks.run('line-numbers', env);
-  });
-  Prism.hooks.add('line-numbers', function (env) {
-    env.plugins = env.plugins || {};
-    env.plugins.lineNumbers = true;
-  });
-        /**
-         * Global exports
-         */
-  Prism.plugins.lineNumbers = {
-                /**
-                 * Get node for provided line number
-                 * @param {Element} element pre element
-                 * @param {Number} number line number
-                 * @return {Element|undefined}
-                 */
-    getLine: function (element, number) {
-      if (element.tagName !== 'PRE' || !element.classList.contains(PLUGIN_NAME)) {
-        return;
-      }
-      var lineNumberRows = element.querySelector('.line-numbers-rows');
-      var lineNumberStart = parseInt(element.getAttribute('data-start'), 10) || 1;
-      var lineNumberEnd = lineNumberStart + (lineNumberRows.children.length - 1);
-      if (number < lineNumberStart) {
-        number = lineNumberStart;
-      }
-      if (number > lineNumberEnd) {
-        number = lineNumberEnd;
-      }
-      var lineIndex = number - lineNumberStart;
-      return lineNumberRows.children[lineIndex];
-    }
-  };
-}());