From 8e9ef5ba62b8bee028428384ad5666e245eb854c Mon Sep 17 00:00:00 2001
From: Mitja Felicijan <mitja.felicijan@gmail.com>
Date: Sun, 17 Feb 2019 21:53:36 +0100
Subject: content update

---
 source/prism.js | 1071 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1071 insertions(+)
 create mode 100644 source/prism.js

(limited to 'source/prism.js')

diff --git a/source/prism.js b/source/prism.js
new file mode 100644
index 0000000..304be1e
--- /dev/null
+++ b/source/prism.js
@@ -0,0 +1,1071 @@
+
+/* **********************************************
+     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];
+    }
+  };
+
+}());
-- 
cgit v1.2.3