update docsify

Taskfile.yaml

@@ -64,3 +64,7 @@ tasks:
     lint:eslint:
         cmds:
             - npx eslint {{.FILES | default "src/**" }}
+
+    docsify-install:
+        cmds:
+            - cp -r node_modules/docsify/lib docs/docsify

docs/docsify/plugins/disqus.js

@@ -0,0 +1,55 @@
+(function () {
+  /* eslint-disable no-unused-vars */
+  var fixedPath = location.href.replace('/-/', '/#/');
+  if (fixedPath !== location.href) {
+    location.href = fixedPath;
+  }
+
+  function install(hook, vm) {
+    var dom = Docsify.dom;
+    var disqus = vm.config.disqus;
+    if (!disqus) {
+      throw Error('$docsify.disqus is required');
+    }
+
+    hook.init(function (_) {
+      var script = dom.create('script');
+
+      script.async = true;
+      script.src = "https://" + disqus + ".disqus.com/embed.js";
+      script.setAttribute('data-timestamp', Number(new Date()));
+      dom.appendTo(dom.body, script);
+    });
+
+    hook.mounted(function (_) {
+      var div = dom.create('div');
+      div.id = 'disqus_thread';
+      var main = dom.getNode('#main');
+      div.style = "width: " + (main.clientWidth) + "px; margin: 0 auto 20px;";
+      dom.appendTo(dom.find('.content'), div);
+
+      // eslint-disable-next-line
+      window.disqus_config = function() {
+        this.page.url = location.origin + '/-' + vm.route.path;
+        this.page.identifier = vm.route.path;
+        this.page.title = document.title;
+      };
+    });
+
+    hook.doneEach(function (_) {
+      if (typeof window.DISQUS !== 'undefined') {
+        window.DISQUS.reset({
+          reload: true,
+          config: function () {
+            this.page.url = location.origin + '/-' + vm.route.path;
+            this.page.identifier = vm.route.path;
+            this.page.title = document.title;
+          },
+        });
+      }
+    });
+  }
+
+  $docsify.plugins = [].concat(install, $docsify.plugins);
+
+}());

docs/docsify/plugins/disqus.min.js

@@ -0,0 +1 @@
+!function(){var i=location.href.replace("/-/","/#/");i!==location.href&&(location.href=i),$docsify.plugins=[].concat(function(i,o){var n=Docsify.dom,e=o.config.disqus;if(!e)throw Error("$docsify.disqus is required");i.init(function(i){var t=n.create("script");t.async=!0,t.src="https://"+e+".disqus.com/embed.js",t.setAttribute("data-timestamp",Number(new Date)),n.appendTo(n.body,t)}),i.mounted(function(i){var t=n.create("div");t.id="disqus_thread";var e=n.getNode("#main");t.style="width: "+e.clientWidth+"px; margin: 0 auto 20px;",n.appendTo(n.find(".content"),t),window.disqus_config=function(){this.page.url=location.origin+"/-"+o.route.path,this.page.identifier=o.route.path,this.page.title=document.title}}),i.doneEach(function(i){void 0!==window.DISQUS&&window.DISQUS.reset({reload:!0,config:function(){this.page.url=location.origin+"/-"+o.route.path,this.page.identifier=o.route.path,this.page.title=document.title}})})},$docsify.plugins)}();

docs/docsify/plugins/external-script.js

@@ -0,0 +1,28 @@
+(function () {
+  function handleExternalScript() {
+    var container = Docsify.dom.getNode('#main');
+    var scripts = Docsify.dom.findAll(container, 'script');
+
+    for (var i = scripts.length; i--; ) {
+      var script = scripts[i];
+
+      if (script && script.src) {
+        var newScript = document.createElement('script');
+
+        Array.prototype.slice.call(script.attributes).forEach(function (attribute) {
+          newScript[attribute.name] = attribute.value;
+        });
+
+        script.parentNode.insertBefore(newScript, script);
+        script.parentNode.removeChild(script);
+      }
+    }
+  }
+
+  var install = function (hook) {
+    hook.doneEach(handleExternalScript);
+  };
+
+  window.$docsify.plugins = [].concat(install, window.$docsify.plugins);
+
+}());

docs/docsify/plugins/external-script.min.js

@@ -0,0 +1 @@
+!function(){function e(){for(var o=Docsify.dom.getNode("#main"),e=Docsify.dom.findAll(o,"script"),n=e.length;n--;){var i,t=e[n];t&&t.src&&(i=document.createElement("script"),Array.prototype.slice.call(t.attributes).forEach(function(o){i[o.name]=o.value}),t.parentNode.insertBefore(i,t),t.parentNode.removeChild(t))}}window.$docsify.plugins=[].concat(function(o){o.doneEach(e)},window.$docsify.plugins)}();

docs/docsify/plugins/front-matter.js

@@ -0,0 +1,505 @@
+(function () {
+  /**
+   * Fork https://github.com/egoist/docute/blob/master/src/utils/yaml.js
+   */
+  /* eslint-disable */
+  /*
+  YAML parser for Javascript
+  Author: Diogo Costa
+  This program is released under the MIT License as follows:
+  Copyright (c) 2011 Diogo Costa (costa.h4evr@gmail.com)
+  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.
+  */
+
+  /**
+   * @name YAML
+   * @namespace
+  */
+
+  var errors = [],
+    reference_blocks = [],
+    processing_time = 0,
+    regex = {
+      regLevel: new RegExp('^([\\s\\-]+)'),
+      invalidLine: new RegExp('^\\-\\-\\-|^\\.\\.\\.|^\\s*#.*|^\\s*$'),
+      dashesString: new RegExp('^\\s*\\"([^\\"]*)\\"\\s*$'),
+      quotesString: new RegExp("^\\s*\\'([^\\']*)\\'\\s*$"),
+      float: new RegExp('^[+-]?[0-9]+\\.[0-9]+(e[+-]?[0-9]+(\\.[0-9]+)?)?$'),
+      integer: new RegExp('^[+-]?[0-9]+$'),
+      array: new RegExp('\\[\\s*(.*)\\s*\\]'),
+      map: new RegExp('\\{\\s*(.*)\\s*\\}'),
+      key_value: new RegExp('([a-z0-9_-][ a-z0-9_-]*):( .+)', 'i'),
+      single_key_value: new RegExp('^([a-z0-9_-][ a-z0-9_-]*):( .+?)$', 'i'),
+      key: new RegExp('([a-z0-9_-][ a-z0-9_-]+):( .+)?', 'i'),
+      item: new RegExp('^-\\s+'),
+      trim: new RegExp('^\\s+|\\s+$'),
+      comment: new RegExp('([^\\\'\\"#]+([\\\'\\"][^\\\'\\"]*[\\\'\\"])*)*(#.*)?')
+    };
+
+  /**
+    * @class A block of lines of a given level.
+    * @param {int} lvl The block's level.
+    * @private
+    */
+  function Block(lvl) {
+    return {
+      /* The block's parent */
+      parent: null,
+      /* Number of children */
+      length: 0,
+      /* Block's level */
+      level: lvl,
+      /* Lines of code to process */
+      lines: [],
+      /* Blocks with greater level */
+      children: [],
+      /* Add a block to the children collection */
+      addChild: function(obj) {
+        this.children.push(obj);
+        obj.parent = this;
+        ++this.length;
+      }
+    }
+  }
+
+  function parser(str) {
+    var regLevel = regex['regLevel'];
+    var invalidLine = regex['invalidLine'];
+    var lines = str.split('\n');
+    var m;
+    var level = 0,
+      curLevel = 0;
+
+    var blocks = [];
+
+    var result = new Block(-1);
+    var currentBlock = new Block(0);
+    result.addChild(currentBlock);
+    var levels = [];
+    var line = '';
+
+    blocks.push(currentBlock);
+    levels.push(level);
+
+    for (var i = 0, len = lines.length; i < len; ++i) {
+      line = lines[i];
+
+      if (line.match(invalidLine)) {
+        continue
+      }
+
+      if ((m = regLevel.exec(line))) {
+        level = m[1].length;
+      } else { level = 0; }
+
+      if (level > curLevel) {
+        var oldBlock = currentBlock;
+        currentBlock = new Block(level);
+        oldBlock.addChild(currentBlock);
+        blocks.push(currentBlock);
+        levels.push(level);
+      } else if (level < curLevel) {
+        var added = false;
+
+        var k = levels.length - 1;
+        for (; k >= 0; --k) {
+          if (levels[k] == level) {
+            currentBlock = new Block(level);
+            blocks.push(currentBlock);
+            levels.push(level);
+            if (blocks[k].parent != null) { blocks[k].parent.addChild(currentBlock); }
+            added = true;
+            break
+          }
+        }
+
+        if (!added) {
+          errors.push('Error: Invalid indentation at line ' + i + ': ' + line);
+          return
+        }
+      }
+
+      currentBlock.lines.push(line.replace(regex['trim'], ''));
+      curLevel = level;
+    }
+
+    return result
+  }
+
+  function processValue(val) {
+    val = val.replace(regex['trim'], '');
+    var m = null;
+
+    if (val == 'true') {
+      return true
+    } else if (val == 'false') {
+      return false
+    } else if (val == '.NaN') {
+      return Number.NaN
+    } else if (val == 'null') {
+      return null
+    } else if (val == '.inf') {
+      return Number.POSITIVE_INFINITY
+    } else if (val == '-.inf') {
+      return Number.NEGATIVE_INFINITY
+    } else if ((m = val.match(regex['dashesString']))) {
+      return m[1]
+    } else if ((m = val.match(regex['quotesString']))) {
+      return m[1]
+    } else if ((m = val.match(regex['float']))) {
+      return parseFloat(m[0])
+    } else if ((m = val.match(regex['integer']))) {
+      return parseInt(m[0])
+    } else if (!isNaN((m = Date.parse(val)))) {
+      return new Date(m)
+    } else if ((m = val.match(regex['single_key_value']))) {
+      var res = {};
+      res[m[1]] = processValue(m[2]);
+      return res
+    } else if ((m = val.match(regex['array']))) {
+      var count = 0,
+        c = ' ';
+      var res = [];
+      var content = '';
+      var str = false;
+      for (var j = 0, lenJ = m[1].length; j < lenJ; ++j) {
+        c = m[1][j];
+        if (c == "'" || c == '"') {
+          if (str === false) {
+            str = c;
+            content += c;
+            continue
+          } else if ((c == "'" && str == "'") || (c == '"' && str == '"')) {
+            str = false;
+            content += c;
+            continue
+          }
+        } else if (str === false && (c == '[' || c == '{')) {
+          ++count;
+        } else if (str === false && (c == ']' || c == '}')) {
+          --count;
+        } else if (str === false && count == 0 && c == ',') {
+          res.push(processValue(content));
+          content = '';
+          continue
+        }
+
+        content += c;
+      }
+
+      if (content.length > 0) { res.push(processValue(content)); }
+      return res
+    } else if ((m = val.match(regex['map']))) {
+      var count = 0,
+        c = ' ';
+      var res = [];
+      var content = '';
+      var str = false;
+      for (var j = 0, lenJ = m[1].length; j < lenJ; ++j) {
+        c = m[1][j];
+        if (c == "'" || c == '"') {
+          if (str === false) {
+            str = c;
+            content += c;
+            continue
+          } else if ((c == "'" && str == "'") || (c == '"' && str == '"')) {
+            str = false;
+            content += c;
+            continue
+          }
+        } else if (str === false && (c == '[' || c == '{')) {
+          ++count;
+        } else if (str === false && (c == ']' || c == '}')) {
+          --count;
+        } else if (str === false && count == 0 && c == ',') {
+          res.push(content);
+          content = '';
+          continue
+        }
+
+        content += c;
+      }
+
+      if (content.length > 0) { res.push(content); }
+
+      var newRes = {};
+      for (var j = 0, lenJ = res.length; j < lenJ; ++j) {
+        if ((m = res[j].match(regex['key_value']))) {
+          newRes[m[1]] = processValue(m[2]);
+        }
+      }
+
+      return newRes
+    } else { return val }
+  }
+
+  function processFoldedBlock(block) {
+    var lines = block.lines;
+    var children = block.children;
+    var str = lines.join(' ');
+    var chunks = [str];
+    for (var i = 0, len = children.length; i < len; ++i) {
+      chunks.push(processFoldedBlock(children[i]));
+    }
+    return chunks.join('\n')
+  }
+
+  function processLiteralBlock(block) {
+    var lines = block.lines;
+    var children = block.children;
+    var str = lines.join('\n');
+    for (var i = 0, len = children.length; i < len; ++i) {
+      str += processLiteralBlock(children[i]);
+    }
+    return str
+  }
+
+  function processBlock(blocks) {
+    var m = null;
+    var res = {};
+    var lines = null;
+    var children = null;
+    var currentObj = null;
+
+    var level = -1;
+
+    var processedBlocks = [];
+
+    var isMap = true;
+
+    for (var j = 0, lenJ = blocks.length; j < lenJ; ++j) {
+      if (level != -1 && level != blocks[j].level) { continue }
+
+      processedBlocks.push(j);
+
+      level = blocks[j].level;
+      lines = blocks[j].lines;
+      children = blocks[j].children;
+      currentObj = null;
+
+      for (var i = 0, len = lines.length; i < len; ++i) {
+        var line = lines[i];
+
+        if ((m = line.match(regex['key']))) {
+          var key = m[1];
+
+          if (key[0] == '-') {
+            key = key.replace(regex['item'], '');
+            if (isMap) {
+              isMap = false;
+              if (typeof res.length === 'undefined') {
+                res = [];
+              }
+            }
+            if (currentObj != null) { res.push(currentObj); }
+            currentObj = {};
+            isMap = true;
+          }
+
+          if (typeof m[2] != 'undefined') {
+            var value = m[2].replace(regex['trim'], '');
+            if (value[0] == '&') {
+              var nb = processBlock(children);
+              if (currentObj != null) { currentObj[key] = nb; }
+              else { res[key] = nb; }
+              reference_blocks[value.substr(1)] = nb;
+            } else if (value[0] == '|') {
+              if (currentObj != null)
+                { currentObj[key] = processLiteralBlock(children.shift()); }
+              else { res[key] = processLiteralBlock(children.shift()); }
+            } else if (value[0] == '*') {
+              var v = value.substr(1);
+              var no = {};
+
+              if (typeof reference_blocks[v] == 'undefined') {
+                errors.push("Reference '" + v + "' not found!");
+              } else {
+                for (var k in reference_blocks[v]) {
+                  no[k] = reference_blocks[v][k];
+                }
+
+                if (currentObj != null) { currentObj[key] = no; }
+                else { res[key] = no; }
+              }
+            } else if (value[0] == '>') {
+              if (currentObj != null)
+                { currentObj[key] = processFoldedBlock(children.shift()); }
+              else { res[key] = processFoldedBlock(children.shift()); }
+            } else {
+              if (currentObj != null) { currentObj[key] = processValue(value); }
+              else { res[key] = processValue(value); }
+            }
+          } else {
+            if (currentObj != null) { currentObj[key] = processBlock(children); }
+            else { res[key] = processBlock(children); }
+          }
+        } else if (line.match(/^-\s*$/)) {
+          if (isMap) {
+            isMap = false;
+            if (typeof res.length === 'undefined') {
+              res = [];
+            }
+          }
+          if (currentObj != null) { res.push(currentObj); }
+          currentObj = {};
+          isMap = true;
+          continue
+        } else if ((m = line.match(/^-\s*(.*)/))) {
+          if (currentObj != null) { currentObj.push(processValue(m[1])); }
+          else {
+            if (isMap) {
+              isMap = false;
+              if (typeof res.length === 'undefined') {
+                res = [];
+              }
+            }
+            res.push(processValue(m[1]));
+          }
+          continue
+        }
+      }
+
+      if (currentObj != null) {
+        if (isMap) {
+          isMap = false;
+          if (typeof res.length === 'undefined') {
+            res = [];
+          }
+        }
+        res.push(currentObj);
+      }
+    }
+
+    for (var j = processedBlocks.length - 1; j >= 0; --j) {
+      blocks.splice.call(blocks, processedBlocks[j], 1);
+    }
+
+    return res
+  }
+
+  function semanticAnalysis(blocks) {
+    var res = processBlock(blocks.children);
+    return res
+  }
+
+  function preProcess(src) {
+    var m;
+    var lines = src.split('\n');
+
+    var r = regex['comment'];
+
+    for (var i in lines) {
+      if ((m = lines[i].match(r))) {
+        /*                var cmt = "";
+              if(typeof m[3] != "undefined")
+                  lines[i] = m[1];
+              else if(typeof m[3] != "undefined")
+                  lines[i] = m[3];
+              else
+                  lines[i] = "";
+                  */
+        if (typeof m[3] !== 'undefined') {
+          lines[i] = m[0].substr(0, m[0].length - m[3].length);
+        }
+      }
+    }
+
+    return lines.join('\n')
+  }
+
+  function load(str) {
+    errors = [];
+    reference_blocks = [];
+    processing_time = new Date().getTime();
+    var pre = preProcess(str);
+    var doc = parser(pre);
+    var res = semanticAnalysis(doc);
+    processing_time = new Date().getTime() - processing_time;
+
+    return res
+  }
+
+  /**
+   * Fork https://github.com/egoist/docute/blob/master/src/utils/front-matter.js
+   */
+
+  var optionalByteOrderMark = '\\ufeff?';
+  var pattern =
+    '^(' +
+    optionalByteOrderMark +
+    '(= yaml =|---)' +
+    '$([\\s\\S]*?)' +
+    '(?:\\2|\\.\\.\\.)' +
+    '$' +
+    '' +
+    '(?:\\n)?)';
+  // NOTE: If this pattern uses the 'g' flag the `regex` variable definition will
+  // need to be moved down into the functions that use it.
+  var regex$1 = new RegExp(pattern, 'm');
+
+  function extractor(string) {
+    string = string || '';
+
+    var lines = string.split(/(\r?\n)/);
+    if (lines[0] && /= yaml =|---/.test(lines[0])) {
+      return parse(string)
+    } else {
+      return { attributes: {}, body: string }
+    }
+  }
+
+  function parse(string) {
+    var match = regex$1.exec(string);
+
+    if (!match) {
+      return {
+        attributes: {},
+        body: string
+      }
+    }
+
+    var yaml = match[match.length - 1].replace(/^\s+|\s+$/g, '');
+    var attributes = load(yaml) || {};
+    var body = string.replace(match[0], '');
+
+    return { attributes: attributes, body: body, frontmatter: yaml }
+  }
+
+  var install = function (hook, vm) {
+    // Used to remove front matter from embedded pages if installed.
+    vm.config.frontMatter = {};
+    vm.config.frontMatter.installed = true;
+    vm.config.frontMatter.parseMarkdown = function (content) {
+      var ref = extractor(content);
+      var body = ref.body;
+      return body;
+    };
+
+    hook.beforeEach(function (content) {
+      var ref = extractor(content);
+      var attributes = ref.attributes;
+      var body = ref.body;
+
+      vm.frontmatter = attributes;
+
+      return body;
+    });
+  };
+
+  $docsify.plugins = [].concat(install, $docsify.plugins);
+
+}());

docs/docsify/plugins/ga.js

@@ -0,0 +1,43 @@
+(function () {
+  /* eslint-disable no-console */
+  // From https://github.com/egoist/vue-ga/blob/master/src/index.js
+  function appendScript() {
+    var script = document.createElement('script');
+    script.async = true;
+    script.src = 'https://www.google-analytics.com/analytics.js';
+    document.body.appendChild(script);
+  }
+
+  function init(id) {
+    appendScript();
+    window.ga =
+      window.ga ||
+      function () {
+        (window.ga.q = window.ga.q || []).push(arguments);
+      };
+
+    window.ga.l = Number(new Date());
+    window.ga('create', id, 'auto');
+  }
+
+  function collect() {
+    if (!window.ga) {
+      init($docsify.ga);
+    }
+
+    window.ga('set', 'page', location.hash);
+    window.ga('send', 'pageview');
+  }
+
+  var install = function (hook) {
+    if (!$docsify.ga) {
+      console.error('[Docsify] ga is required.');
+      return;
+    }
+
+    hook.beforeEach(collect);
+  };
+
+  $docsify.plugins = [].concat(install, $docsify.plugins);
+
+}());

docs/docsify/plugins/ga.min.js

@@ -0,0 +1 @@
+!function(){function n(n){var o;(o=document.createElement("script")).async=!0,o.src="https://www.google-analytics.com/analytics.js",document.body.appendChild(o),window.ga=window.ga||function(){(window.ga.q=window.ga.q||[]).push(arguments)},window.ga.l=Number(new Date),window.ga("create",n,"auto")}function o(){window.ga||n($docsify.ga),window.ga("set","page",location.hash),window.ga("send","pageview")}$docsify.plugins=[].concat(function(n){$docsify.ga?n.beforeEach(o):console.error("[Docsify] ga is required.")},$docsify.plugins)}();

docs/docsify/plugins/gitalk.js

@@ -0,0 +1,27 @@
+(function () {
+  /* eslint-disable no-unused-vars */
+  function install(hook) {
+    var dom = Docsify.dom;
+
+    hook.mounted(function (_) {
+      var div = dom.create('div');
+      div.id = 'gitalk-container';
+      var main = dom.getNode('#main');
+      div.style = "width: " + (main.clientWidth) + "px; margin: 0 auto 20px;";
+      dom.appendTo(dom.find('.content'), div);
+    });
+
+    hook.doneEach(function (_) {
+      var el = document.getElementById('gitalk-container');
+      while (el.hasChildNodes()) {
+        el.removeChild(el.firstChild);
+      }
+
+      // eslint-disable-next-line
+      gitalk.render('gitalk-container');
+    });
+  }
+
+  $docsify.plugins = [].concat(install, $docsify.plugins);
+
+}());

docs/docsify/plugins/gitalk.min.js

@@ -0,0 +1 @@
+$docsify.plugins=[].concat(function(i){var e=Docsify.dom;i.mounted(function(i){var n=e.create("div");n.id="gitalk-container";var t=e.getNode("#main");n.style="width: "+t.clientWidth+"px; margin: 0 auto 20px;",e.appendTo(e.find(".content"),n)}),i.doneEach(function(i){for(var n=document.getElementById("gitalk-container");n.hasChildNodes();)n.removeChild(n.firstChild);gitalk.render("gitalk-container")})},$docsify.plugins);

docs/docsify/plugins/matomo.js

@@ -0,0 +1,42 @@
+(function () {
+  function appendScript(options) {
+    var script = document.createElement('script');
+    script.async = true;
+    script.src = options.host + '/matomo.js';
+    document.body.appendChild(script);
+  }
+
+  function init(options) {
+    window._paq = window._paq || [];
+    window._paq.push(['trackPageView']);
+    window._paq.push(['enableLinkTracking']);
+    setTimeout(function () {
+      appendScript(options);
+      window._paq.push(['setTrackerUrl', options.host + '/matomo.php']);
+      window._paq.push(['setSiteId', String(options.id)]);
+    }, 0);
+  }
+
+  function collect() {
+    if (!window._paq) {
+      init($docsify.matomo);
+    }
+
+    window._paq.push(['setCustomUrl', window.location.hash.substr(1)]);
+    window._paq.push(['setDocumentTitle', document.title]);
+    window._paq.push(['trackPageView']);
+  }
+
+  var install = function (hook) {
+    if (!$docsify.matomo) {
+      // eslint-disable-next-line no-console
+      console.error('[Docsify] matomo is required.');
+      return;
+    }
+
+    hook.beforeEach(collect);
+  };
+
+  $docsify.plugins = [].concat(install, $docsify.plugins);
+
+}());

docs/docsify/plugins/matomo.min.js

@@ -0,0 +1 @@
+!function(){function o(n){window._paq=window._paq||[],window._paq.push(["trackPageView"]),window._paq.push(["enableLinkTracking"]),setTimeout(function(){var o,i;o=n,(i=document.createElement("script")).async=!0,i.src=o.host+"/matomo.js",document.body.appendChild(i),window._paq.push(["setTrackerUrl",n.host+"/matomo.php"]),window._paq.push(["setSiteId",String(n.id)])},0)}function i(){window._paq||o($docsify.matomo),window._paq.push(["setCustomUrl",window.location.hash.substr(1)]),window._paq.push(["setDocumentTitle",document.title]),window._paq.push(["trackPageView"])}$docsify.plugins=[].concat(function(o){$docsify.matomo?o.beforeEach(i):console.error("[Docsify] matomo is required.")},$docsify.plugins)}();

docs/docsify/plugins/search.js

@@ -0,0 +1,540 @@
+(function () {
+  /**
+   * Converts a colon formatted string to a object with properties.
+   *
+   * This is process a provided string and look for any tokens in the format
+   * of `:name[=value]` and then convert it to a object and return.
+   * An example of this is ':include :type=code :fragment=demo' is taken and
+   * then converted to:
+   *
+   * ```
+   * {
+   *  include: '',
+   *  type: 'code',
+   *  fragment: 'demo'
+   * }
+   * ```
+   *
+   * @param {string}   str   The string to parse.
+   *
+   * @return {object}  The original string and parsed object, { str, config }.
+   */
+  function getAndRemoveConfig(str) {
+    if ( str === void 0 ) str = '';
+
+    var config = {};
+
+    if (str) {
+      str = str
+        .replace(/^('|")/, '')
+        .replace(/('|")$/, '')
+        .replace(/(?:^|\s):([\w-]+:?)=?([\w-%]+)?/g, function (m, key, value) {
+          if (key.indexOf(':') === -1) {
+            config[key] = (value && value.replace(/"/g, '')) || true;
+            return '';
+          }
+
+          return m;
+        })
+        .trim();
+    }
+
+    return { str: str, config: config };
+  }
+
+  function removeDocsifyIgnoreTag(str) {
+    return str
+      .replace(/<!-- {docsify-ignore} -->/, '')
+      .replace(/{docsify-ignore}/, '')
+      .replace(/<!-- {docsify-ignore-all} -->/, '')
+      .replace(/{docsify-ignore-all}/, '')
+      .trim();
+  }
+
+  /* eslint-disable no-unused-vars */
+
+  var INDEXS = {};
+
+  var LOCAL_STORAGE = {
+    EXPIRE_KEY: 'docsify.search.expires',
+    INDEX_KEY: 'docsify.search.index',
+  };
+
+  function resolveExpireKey(namespace) {
+    return namespace
+      ? ((LOCAL_STORAGE.EXPIRE_KEY) + "/" + namespace)
+      : LOCAL_STORAGE.EXPIRE_KEY;
+  }
+
+  function resolveIndexKey(namespace) {
+    return namespace
+      ? ((LOCAL_STORAGE.INDEX_KEY) + "/" + namespace)
+      : LOCAL_STORAGE.INDEX_KEY;
+  }
+
+  function escapeHtml(string) {
+    var entityMap = {
+      '&': '&amp;',
+      '<': '&lt;',
+      '>': '&gt;',
+      '"': '&quot;',
+      "'": '&#39;',
+    };
+
+    return String(string).replace(/[&<>"']/g, function (s) { return entityMap[s]; });
+  }
+
+  function getAllPaths(router) {
+    var paths = [];
+
+    Docsify.dom
+      .findAll('.sidebar-nav a:not(.section-link):not([data-nosearch])')
+      .forEach(function (node) {
+        var href = node.href;
+        var originHref = node.getAttribute('href');
+        var path = router.parse(href).path;
+
+        if (
+          path &&
+          paths.indexOf(path) === -1 &&
+          !Docsify.util.isAbsolutePath(originHref)
+        ) {
+          paths.push(path);
+        }
+      });
+
+    return paths;
+  }
+
+  function getTableData(token) {
+    if (!token.text && token.type === 'table') {
+      token.cells.unshift(token.header);
+      token.text = token.cells
+        .map(function (rows) {
+          return rows.join(' | ');
+        })
+        .join(' |\n ');
+    }
+    return token.text;
+  }
+
+  function getListData(token) {
+    if (!token.text && token.type === 'list') {
+      token.text = token.raw;
+    }
+    return token.text;
+  }
+
+  function saveData(maxAge, expireKey, indexKey) {
+    localStorage.setItem(expireKey, Date.now() + maxAge);
+    localStorage.setItem(indexKey, JSON.stringify(INDEXS));
+  }
+
+  function genIndex(path, content, router, depth) {
+    if ( content === void 0 ) content = '';
+
+    var tokens = window.marked.lexer(content);
+    var slugify = window.Docsify.slugify;
+    var index = {};
+    var slug;
+    var title = '';
+
+    tokens.forEach(function (token, tokenIndex) {
+      if (token.type === 'heading' && token.depth <= depth) {
+        var ref = getAndRemoveConfig(token.text);
+        var str = ref.str;
+        var config = ref.config;
+
+        var text = removeDocsifyIgnoreTag(token.text);
+
+        if (config.id) {
+          slug = router.toURL(path, { id: slugify(config.id) });
+        } else {
+          slug = router.toURL(path, { id: slugify(escapeHtml(text)) });
+        }
+
+        if (str) {
+          title = removeDocsifyIgnoreTag(str);
+        }
+
+        index[slug] = { slug: slug, title: title, body: '' };
+      } else {
+        if (tokenIndex === 0) {
+          slug = router.toURL(path);
+          index[slug] = {
+            slug: slug,
+            title: path !== '/' ? path.slice(1) : 'Home Page',
+            body: token.text || '',
+          };
+        }
+
+        if (!slug) {
+          return;
+        }
+
+        if (!index[slug]) {
+          index[slug] = { slug: slug, title: '', body: '' };
+        } else if (index[slug].body) {
+          token.text = getTableData(token);
+          token.text = getListData(token);
+
+          index[slug].body += '\n' + (token.text || '');
+        } else {
+          token.text = getTableData(token);
+          token.text = getListData(token);
+
+          index[slug].body = token.text || '';
+        }
+      }
+    });
+    slugify.clear();
+    return index;
+  }
+
+  function ignoreDiacriticalMarks(keyword) {
+    if (keyword && keyword.normalize) {
+      return keyword.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+    }
+    return keyword;
+  }
+
+  /**
+   * @param {String} query Search query
+   * @returns {Array} Array of results
+   */
+  function search(query) {
+    var matchingResults = [];
+    var data = [];
+    Object.keys(INDEXS).forEach(function (key) {
+      data = data.concat(Object.keys(INDEXS[key]).map(function (page) { return INDEXS[key][page]; }));
+    });
+
+    query = query.trim();
+    var keywords = query.split(/[\s\-，\\/]+/);
+    if (keywords.length !== 1) {
+      keywords = [].concat(query, keywords);
+    }
+
+    var loop = function ( i ) {
+      var post = data[i];
+      var matchesScore = 0;
+      var resultStr = '';
+      var handlePostTitle = '';
+      var handlePostContent = '';
+      var postTitle = post.title && post.title.trim();
+      var postContent = post.body && post.body.trim();
+      var postUrl = post.slug || '';
+
+      if (postTitle) {
+        keywords.forEach(function (keyword) {
+          // From https://github.com/sindresorhus/escape-string-regexp
+          var regEx = new RegExp(
+            escapeHtml(ignoreDiacriticalMarks(keyword)).replace(
+              /[|\\{}()[\]^$+*?.]/g,
+              '\\$&'
+            ),
+            'gi'
+          );
+          var indexTitle = -1;
+          var indexContent = -1;
+          handlePostTitle = postTitle
+            ? escapeHtml(ignoreDiacriticalMarks(postTitle))
+            : postTitle;
+          handlePostContent = postContent
+            ? escapeHtml(ignoreDiacriticalMarks(postContent))
+            : postContent;
+
+          indexTitle = postTitle ? handlePostTitle.search(regEx) : -1;
+          indexContent = postContent ? handlePostContent.search(regEx) : -1;
+
+          if (indexTitle >= 0 || indexContent >= 0) {
+            matchesScore += indexTitle >= 0 ? 3 : indexContent >= 0 ? 2 : 0;
+            if (indexContent < 0) {
+              indexContent = 0;
+            }
+
+            var start = 0;
+            var end = 0;
+
+            start = indexContent < 11 ? 0 : indexContent - 10;
+            end = start === 0 ? 70 : indexContent + keyword.length + 60;
+
+            if (postContent && end > postContent.length) {
+              end = postContent.length;
+            }
+
+            var matchContent =
+              handlePostContent &&
+              '...' +
+                handlePostContent
+                  .substring(start, end)
+                  .replace(
+                    regEx,
+                    function (word) { return ("<em class=\"search-keyword\">" + word + "</em>"); }
+                  ) +
+                '...';
+
+            resultStr += matchContent;
+          }
+        });
+
+        if (matchesScore > 0) {
+          var matchingPost = {
+            title: handlePostTitle,
+            content: postContent ? resultStr : '',
+            url: postUrl,
+            score: matchesScore,
+          };
+
+          matchingResults.push(matchingPost);
+        }
+      }
+    };
+
+    for (var i = 0; i < data.length; i++) loop( i );
+
+    return matchingResults.sort(function (r1, r2) { return r2.score - r1.score; });
+  }
+
+  function init(config, vm) {
+    var isAuto = config.paths === 'auto';
+    var paths = isAuto ? getAllPaths(vm.router) : config.paths;
+
+    var namespaceSuffix = '';
+
+    // only in auto mode
+    if (paths.length && isAuto && config.pathNamespaces) {
+      var path = paths[0];
+
+      if (Array.isArray(config.pathNamespaces)) {
+        namespaceSuffix =
+          config.pathNamespaces.filter(
+            function (prefix) { return path.slice(0, prefix.length) === prefix; }
+          )[0] || namespaceSuffix;
+      } else if (config.pathNamespaces instanceof RegExp) {
+        var matches = path.match(config.pathNamespaces);
+
+        if (matches) {
+          namespaceSuffix = matches[0];
+        }
+      }
+      var isExistHome = paths.indexOf(namespaceSuffix + '/') === -1;
+      var isExistReadme = paths.indexOf(namespaceSuffix + '/README') === -1;
+      if (isExistHome && isExistReadme) {
+        paths.unshift(namespaceSuffix + '/');
+      }
+    } else if (paths.indexOf('/') === -1 && paths.indexOf('/README') === -1) {
+      paths.unshift('/');
+    }
+
+    var expireKey = resolveExpireKey(config.namespace) + namespaceSuffix;
+    var indexKey = resolveIndexKey(config.namespace) + namespaceSuffix;
+
+    var isExpired = localStorage.getItem(expireKey) < Date.now();
+
+    INDEXS = JSON.parse(localStorage.getItem(indexKey));
+
+    if (isExpired) {
+      INDEXS = {};
+    } else if (!isAuto) {
+      return;
+    }
+
+    var len = paths.length;
+    var count = 0;
+
+    paths.forEach(function (path) {
+      if (INDEXS[path]) {
+        return count++;
+      }
+
+      Docsify.get(vm.router.getFile(path), false, vm.config.requestHeaders).then(
+        function (result) {
+          INDEXS[path] = genIndex(path, result, vm.router, config.depth);
+          len === ++count && saveData(config.maxAge, expireKey, indexKey);
+        }
+      );
+    });
+  }
+
+  /* eslint-disable no-unused-vars */
+
+  var NO_DATA_TEXT = '';
+  var options;
+
+  function style() {
+    var code = "\n.sidebar {\n  padding-top: 0;\n}\n\n.search {\n  margin-bottom: 20px;\n  padding: 6px;\n  border-bottom: 1px solid #eee;\n}\n\n.search .input-wrap {\n  display: flex;\n  align-items: center;\n}\n\n.search .results-panel {\n  display: none;\n}\n\n.search .results-panel.show {\n  display: block;\n}\n\n.search input {\n  outline: none;\n  border: none;\n  width: 100%;\n  padding: 0.6em 7px;\n  font-size: inherit;\n  border: 1px solid transparent;\n}\n\n.search input:focus {\n  box-shadow: 0 0 5px var(--theme-color, #42b983);\n  border: 1px solid var(--theme-color, #42b983);\n}\n\n.search input::-webkit-search-decoration,\n.search input::-webkit-search-cancel-button,\n.search input {\n  -webkit-appearance: none;\n  -moz-appearance: none;\n  appearance: none;\n}\n\n.search input::-ms-clear {\n  display: none;\n  height: 0;\n  width: 0;\n}\n\n.search .clear-button {\n  cursor: pointer;\n  width: 36px;\n  text-align: right;\n  display: none;\n}\n\n.search .clear-button.show {\n  display: block;\n}\n\n.search .clear-button svg {\n  transform: scale(.5);\n}\n\n.search h2 {\n  font-size: 17px;\n  margin: 10px 0;\n}\n\n.search a {\n  text-decoration: none;\n  color: inherit;\n}\n\n.search .matching-post {\n  border-bottom: 1px solid #eee;\n}\n\n.search .matching-post:last-child {\n  border-bottom: 0;\n}\n\n.search p {\n  font-size: 14px;\n  overflow: hidden;\n  text-overflow: ellipsis;\n  display: -webkit-box;\n  -webkit-line-clamp: 2;\n  -webkit-box-orient: vertical;\n}\n\n.search p.empty {\n  text-align: center;\n}\n\n.app-name.hide, .sidebar-nav.hide {\n  display: none;\n}";
+
+    Docsify.dom.style(code);
+  }
+
+  function tpl(defaultValue) {
+    if ( defaultValue === void 0 ) defaultValue = '';
+
+    var html = "<div class=\"input-wrap\">\n      <input type=\"search\" value=\"" + defaultValue + "\" aria-label=\"Search text\" />\n      <div class=\"clear-button\">\n        <svg width=\"26\" height=\"24\">\n          <circle cx=\"12\" cy=\"12\" r=\"11\" fill=\"#ccc\" />\n          <path stroke=\"white\" stroke-width=\"2\" d=\"M8.25,8.25,15.75,15.75\" />\n          <path stroke=\"white\" stroke-width=\"2\"d=\"M8.25,15.75,15.75,8.25\" />\n        </svg>\n      </div>\n    </div>\n    <div class=\"results-panel\"></div>\n    </div>";
+    var el = Docsify.dom.create('div', html);
+    var aside = Docsify.dom.find('aside');
+
+    Docsify.dom.toggleClass(el, 'search');
+    Docsify.dom.before(aside, el);
+  }
+
+  function doSearch(value) {
+    var $search = Docsify.dom.find('div.search');
+    var $panel = Docsify.dom.find($search, '.results-panel');
+    var $clearBtn = Docsify.dom.find($search, '.clear-button');
+    var $sidebarNav = Docsify.dom.find('.sidebar-nav');
+    var $appName = Docsify.dom.find('.app-name');
+
+    if (!value) {
+      $panel.classList.remove('show');
+      $clearBtn.classList.remove('show');
+      $panel.innerHTML = '';
+
+      if (options.hideOtherSidebarContent) {
+        $sidebarNav && $sidebarNav.classList.remove('hide');
+        $appName && $appName.classList.remove('hide');
+      }
+
+      return;
+    }
+
+    var matchs = search(value);
+
+    var html = '';
+    matchs.forEach(function (post) {
+      html += "<div class=\"matching-post\">\n<a href=\"" + (post.url) + "\">\n<h2>" + (post.title) + "</h2>\n<p>" + (post.content) + "</p>\n</a>\n</div>";
+    });
+
+    $panel.classList.add('show');
+    $clearBtn.classList.add('show');
+    $panel.innerHTML = html || ("<p class=\"empty\">" + NO_DATA_TEXT + "</p>");
+    if (options.hideOtherSidebarContent) {
+      $sidebarNav && $sidebarNav.classList.add('hide');
+      $appName && $appName.classList.add('hide');
+    }
+  }
+
+  function bindEvents() {
+    var $search = Docsify.dom.find('div.search');
+    var $input = Docsify.dom.find($search, 'input');
+    var $inputWrap = Docsify.dom.find($search, '.input-wrap');
+
+    var timeId;
+
+    /**
+      Prevent to Fold sidebar.
+
+      When searching on the mobile end,
+      the sidebar is collapsed when you click the INPUT box,
+      making it impossible to search.
+     */
+    Docsify.dom.on(
+      $search,
+      'click',
+      function (e) { return ['A', 'H2', 'P', 'EM'].indexOf(e.target.tagName) === -1 &&
+        e.stopPropagation(); }
+    );
+    Docsify.dom.on($input, 'input', function (e) {
+      clearTimeout(timeId);
+      timeId = setTimeout(function (_) { return doSearch(e.target.value.trim()); }, 100);
+    });
+    Docsify.dom.on($inputWrap, 'click', function (e) {
+      // Click input outside
+      if (e.target.tagName !== 'INPUT') {
+        $input.value = '';
+        doSearch();
+      }
+    });
+  }
+
+  function updatePlaceholder(text, path) {
+    var $input = Docsify.dom.getNode('.search input[type="search"]');
+
+    if (!$input) {
+      return;
+    }
+
+    if (typeof text === 'string') {
+      $input.placeholder = text;
+    } else {
+      var match = Object.keys(text).filter(function (key) { return path.indexOf(key) > -1; })[0];
+      $input.placeholder = text[match];
+    }
+  }
+
+  function updateNoData(text, path) {
+    if (typeof text === 'string') {
+      NO_DATA_TEXT = text;
+    } else {
+      var match = Object.keys(text).filter(function (key) { return path.indexOf(key) > -1; })[0];
+      NO_DATA_TEXT = text[match];
+    }
+  }
+
+  function updateOptions(opts) {
+    options = opts;
+  }
+
+  function init$1(opts, vm) {
+    var keywords = vm.router.parse().query.s;
+
+    updateOptions(opts);
+    style();
+    tpl(keywords);
+    bindEvents();
+    keywords && setTimeout(function (_) { return doSearch(keywords); }, 500);
+  }
+
+  function update(opts, vm) {
+    updateOptions(opts);
+    updatePlaceholder(opts.placeholder, vm.route.path);
+    updateNoData(opts.noData, vm.route.path);
+  }
+
+  /* eslint-disable no-unused-vars */
+
+  var CONFIG = {
+    placeholder: 'Type to search',
+    noData: 'No Results!',
+    paths: 'auto',
+    depth: 2,
+    maxAge: 86400000, // 1 day
+    hideOtherSidebarContent: false,
+    namespace: undefined,
+    pathNamespaces: undefined,
+  };
+
+  var install = function (hook, vm) {
+    var util = Docsify.util;
+    var opts = vm.config.search || CONFIG;
+
+    if (Array.isArray(opts)) {
+      CONFIG.paths = opts;
+    } else if (typeof opts === 'object') {
+      CONFIG.paths = Array.isArray(opts.paths) ? opts.paths : 'auto';
+      CONFIG.maxAge = util.isPrimitive(opts.maxAge) ? opts.maxAge : CONFIG.maxAge;
+      CONFIG.placeholder = opts.placeholder || CONFIG.placeholder;
+      CONFIG.noData = opts.noData || CONFIG.noData;
+      CONFIG.depth = opts.depth || CONFIG.depth;
+      CONFIG.hideOtherSidebarContent =
+        opts.hideOtherSidebarContent || CONFIG.hideOtherSidebarContent;
+      CONFIG.namespace = opts.namespace || CONFIG.namespace;
+      CONFIG.pathNamespaces = opts.pathNamespaces || CONFIG.pathNamespaces;
+    }
+
+    var isAuto = CONFIG.paths === 'auto';
+
+    hook.mounted(function (_) {
+      init$1(CONFIG, vm);
+      !isAuto && init(CONFIG, vm);
+    });
+    hook.doneEach(function (_) {
+      update(CONFIG, vm);
+      isAuto && init(CONFIG, vm);
+    });
+  };
+
+  $docsify.plugins = [].concat(install, $docsify.plugins);
+
+}());

docs/docsify/plugins/zoom-image.js

@@ -0,0 +1,668 @@
+(function () {
+  /*! medium-zoom 1.0.8 | MIT License | https://github.com/francoischalifour/medium-zoom */
+  var _extends = Object.assign || function (target) {
+    var arguments$1 = arguments;
+
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments$1[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  var isSupported = function isSupported(node) {
+    return node.tagName === 'IMG';
+  };
+
+  /* eslint-disable-next-line no-prototype-builtins */
+  var isNodeList = function isNodeList(selector) {
+    return NodeList.prototype.isPrototypeOf(selector);
+  };
+
+  var isNode = function isNode(selector) {
+    return selector && selector.nodeType === 1;
+  };
+
+  var isSvg = function isSvg(image) {
+    var source = image.currentSrc || image.src;
+    return source.substr(-4).toLowerCase() === '.svg';
+  };
+
+  var getImagesFromSelector = function getImagesFromSelector(selector) {
+    try {
+      if (Array.isArray(selector)) {
+        return selector.filter(isSupported);
+      }
+
+      if (isNodeList(selector)) {
+        // Do not use spread operator or Array.from() for IE support
+        return [].slice.call(selector).filter(isSupported);
+      }
+
+      if (isNode(selector)) {
+        return [selector].filter(isSupported);
+      }
+
+      if (typeof selector === 'string') {
+        // Do not use spread operator or Array.from() for IE support
+        return [].slice.call(document.querySelectorAll(selector)).filter(isSupported);
+      }
+
+      return [];
+    } catch (err) {
+      throw new TypeError('The provided selector is invalid.\n' + 'Expects a CSS selector, a Node element, a NodeList or an array.\n' + 'See: https://github.com/francoischalifour/medium-zoom');
+    }
+  };
+
+  var createOverlay = function createOverlay(background) {
+    var overlay = document.createElement('div');
+    overlay.classList.add('medium-zoom-overlay');
+    overlay.style.background = background;
+
+    return overlay;
+  };
+
+  var cloneTarget = function cloneTarget(template) {
+    var _template$getBounding = template.getBoundingClientRect(),
+        top = _template$getBounding.top,
+        left = _template$getBounding.left,
+        width = _template$getBounding.width,
+        height = _template$getBounding.height;
+
+    var clone = template.cloneNode();
+    var scrollTop = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
+    var scrollLeft = window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft || 0;
+
+    clone.removeAttribute('id');
+    clone.style.position = 'absolute';
+    clone.style.top = top + scrollTop + 'px';
+    clone.style.left = left + scrollLeft + 'px';
+    clone.style.width = width + 'px';
+    clone.style.height = height + 'px';
+    clone.style.transform = '';
+
+    return clone;
+  };
+
+  var createCustomEvent = function createCustomEvent(type, params) {
+    var eventParams = _extends({
+      bubbles: false,
+      cancelable: false,
+      detail: undefined
+    }, params);
+
+    if (typeof window.CustomEvent === 'function') {
+      return new CustomEvent(type, eventParams);
+    }
+
+    var customEvent = document.createEvent('CustomEvent');
+    customEvent.initCustomEvent(type, eventParams.bubbles, eventParams.cancelable, eventParams.detail);
+
+    return customEvent;
+  };
+
+  var mediumZoom = function mediumZoom(selector) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+    /**
+     * Ensure the compatibility with IE11 if no Promise polyfill are used.
+     */
+    var Promise = window.Promise || function Promise(fn) {
+      function noop() {}
+      fn(noop, noop);
+    };
+
+    var _handleClick = function _handleClick(event) {
+      var target = event.target;
+
+
+      if (target === overlay) {
+        close();
+        return;
+      }
+
+      if (images.indexOf(target) === -1) {
+        return;
+      }
+
+      toggle({ target: target });
+    };
+
+    var _handleScroll = function _handleScroll() {
+      if (isAnimating || !active.original) {
+        return;
+      }
+
+      var currentScroll = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
+
+      if (Math.abs(scrollTop - currentScroll) > zoomOptions.scrollOffset) {
+        setTimeout(close, 150);
+      }
+    };
+
+    var _handleKeyUp = function _handleKeyUp(event) {
+      var key = event.key || event.keyCode;
+
+      // Close if escape key is pressed
+      if (key === 'Escape' || key === 'Esc' || key === 27) {
+        close();
+      }
+    };
+
+    var update = function update() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+      var newOptions = options;
+
+      if (options.background) {
+        overlay.style.background = options.background;
+      }
+
+      if (options.container && options.container instanceof Object) {
+        newOptions.container = _extends({}, zoomOptions.container, options.container);
+      }
+
+      if (options.template) {
+        var template = isNode(options.template) ? options.template : document.querySelector(options.template);
+
+        newOptions.template = template;
+      }
+
+      zoomOptions = _extends({}, zoomOptions, newOptions);
+
+      images.forEach(function (image) {
+        image.dispatchEvent(createCustomEvent('medium-zoom:update', {
+          detail: { zoom: zoom }
+        }));
+      });
+
+      return zoom;
+    };
+
+    var clone = function clone() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return mediumZoom(_extends({}, zoomOptions, options));
+    };
+
+    var attach = function attach() {
+      var arguments$1 = arguments;
+
+      for (var _len = arguments.length, selectors = Array(_len), _key = 0; _key < _len; _key++) {
+        selectors[_key] = arguments$1[_key];
+      }
+
+      var newImages = selectors.reduce(function (imagesAccumulator, currentSelector) {
+        return [].concat(imagesAccumulator, getImagesFromSelector(currentSelector));
+      }, []);
+
+      newImages.filter(function (newImage) {
+        return images.indexOf(newImage) === -1;
+      }).forEach(function (newImage) {
+        images.push(newImage);
+        newImage.classList.add('medium-zoom-image');
+      });
+
+      eventListeners.forEach(function (_ref) {
+        var type = _ref.type,
+            listener = _ref.listener,
+            options = _ref.options;
+
+        newImages.forEach(function (image) {
+          image.addEventListener(type, listener, options);
+        });
+      });
+
+      return zoom;
+    };
+
+    var detach = function detach() {
+      var arguments$1 = arguments;
+
+      for (var _len2 = arguments.length, selectors = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        selectors[_key2] = arguments$1[_key2];
+      }
+
+      if (active.zoomed) {
+        close();
+      }
+
+      var imagesToDetach = selectors.length > 0 ? selectors.reduce(function (imagesAccumulator, currentSelector) {
+        return [].concat(imagesAccumulator, getImagesFromSelector(currentSelector));
+      }, []) : images;
+
+      imagesToDetach.forEach(function (image) {
+        image.classList.remove('medium-zoom-image');
+        image.dispatchEvent(createCustomEvent('medium-zoom:detach', {
+          detail: { zoom: zoom }
+        }));
+      });
+
+      images = images.filter(function (image) {
+        return imagesToDetach.indexOf(image) === -1;
+      });
+
+      return zoom;
+    };
+
+    var on = function on(type, listener) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+      images.forEach(function (image) {
+        image.addEventListener('medium-zoom:' + type, listener, options);
+      });
+
+      eventListeners.push({ type: 'medium-zoom:' + type, listener: listener, options: options });
+
+      return zoom;
+    };
+
+    var off = function off(type, listener) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+      images.forEach(function (image) {
+        image.removeEventListener('medium-zoom:' + type, listener, options);
+      });
+
+      eventListeners = eventListeners.filter(function (eventListener) {
+        return !(eventListener.type === 'medium-zoom:' + type && eventListener.listener.toString() === listener.toString());
+      });
+
+      return zoom;
+    };
+
+    var open = function open() {
+      var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+          target = _ref2.target;
+
+      var _animate = function _animate() {
+        var container = {
+          width: document.documentElement.clientWidth,
+          height: document.documentElement.clientHeight,
+          left: 0,
+          top: 0,
+          right: 0,
+          bottom: 0
+        };
+        var viewportWidth = void 0;
+        var viewportHeight = void 0;
+
+        if (zoomOptions.container) {
+          if (zoomOptions.container instanceof Object) {
+            // The container is given as an object with properties like width, height, left, top
+            container = _extends({}, container, zoomOptions.container);
+
+            // We need to adjust custom options like container.right or container.bottom
+            viewportWidth = container.width - container.left - container.right - zoomOptions.margin * 2;
+            viewportHeight = container.height - container.top - container.bottom - zoomOptions.margin * 2;
+          } else {
+            // The container is given as an element
+            var zoomContainer = isNode(zoomOptions.container) ? zoomOptions.container : document.querySelector(zoomOptions.container);
+
+            var _zoomContainer$getBou = zoomContainer.getBoundingClientRect(),
+                _width = _zoomContainer$getBou.width,
+                _height = _zoomContainer$getBou.height,
+                _left = _zoomContainer$getBou.left,
+                _top = _zoomContainer$getBou.top;
+
+            container = _extends({}, container, {
+              width: _width,
+              height: _height,
+              left: _left,
+              top: _top
+            });
+          }
+        }
+
+        viewportWidth = viewportWidth || container.width - zoomOptions.margin * 2;
+        viewportHeight = viewportHeight || container.height - zoomOptions.margin * 2;
+
+        var zoomTarget = active.zoomedHd || active.original;
+        var naturalWidth = isSvg(zoomTarget) ? viewportWidth : zoomTarget.naturalWidth || viewportWidth;
+        var naturalHeight = isSvg(zoomTarget) ? viewportHeight : zoomTarget.naturalHeight || viewportHeight;
+
+        var _zoomTarget$getBoundi = zoomTarget.getBoundingClientRect(),
+            top = _zoomTarget$getBoundi.top,
+            left = _zoomTarget$getBoundi.left,
+            width = _zoomTarget$getBoundi.width,
+            height = _zoomTarget$getBoundi.height;
+
+        var scaleX = Math.min(Math.max(width, naturalWidth), viewportWidth) / width;
+        var scaleY = Math.min(Math.max(height, naturalHeight), viewportHeight) / height;
+        var scale = Math.min(scaleX, scaleY);
+        var translateX = (-left + (viewportWidth - width) / 2 + zoomOptions.margin + container.left) / scale;
+        var translateY = (-top + (viewportHeight - height) / 2 + zoomOptions.margin + container.top) / scale;
+        var transform = 'scale(' + scale + ') translate3d(' + translateX + 'px, ' + translateY + 'px, 0)';
+
+        active.zoomed.style.transform = transform;
+
+        if (active.zoomedHd) {
+          active.zoomedHd.style.transform = transform;
+        }
+      };
+
+      return new Promise(function (resolve) {
+        if (target && images.indexOf(target) === -1) {
+          resolve(zoom);
+          return;
+        }
+
+        var _handleOpenEnd = function _handleOpenEnd() {
+          isAnimating = false;
+          active.zoomed.removeEventListener('transitionend', _handleOpenEnd);
+          active.original.dispatchEvent(createCustomEvent('medium-zoom:opened', {
+            detail: { zoom: zoom }
+          }));
+
+          resolve(zoom);
+        };
+
+        if (active.zoomed) {
+          resolve(zoom);
+          return;
+        }
+
+        if (target) {
+          // The zoom was triggered manually via a click
+          active.original = target;
+        } else if (images.length > 0) {
+  var _images = images;
+          active.original = _images[0];
+        } else {
+          resolve(zoom);
+          return;
+        }
+
+        active.original.dispatchEvent(createCustomEvent('medium-zoom:open', {
+          detail: { zoom: zoom }
+        }));
+
+        scrollTop = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
+        isAnimating = true;
+        active.zoomed = cloneTarget(active.original);
+
+        document.body.appendChild(overlay);
+
+        if (zoomOptions.template) {
+          var template = isNode(zoomOptions.template) ? zoomOptions.template : document.querySelector(zoomOptions.template);
+          active.template = document.createElement('div');
+          active.template.appendChild(template.content.cloneNode(true));
+
+          document.body.appendChild(active.template);
+        }
+
+        // If the selected <img> tag is inside a <picture> tag, set the
+        // currently-applied source as the cloned `src=` attribute.
+        // (as these might differ, or src= might be unset in some cases)
+        if (active.original.parentElement && active.original.parentElement.tagName === 'PICTURE' && active.original.currentSrc) {
+          active.zoomed.src = active.original.currentSrc;
+        }
+
+        document.body.appendChild(active.zoomed);
+
+        window.requestAnimationFrame(function () {
+          document.body.classList.add('medium-zoom--opened');
+        });
+
+        active.original.classList.add('medium-zoom-image--hidden');
+        active.zoomed.classList.add('medium-zoom-image--opened');
+
+        active.zoomed.addEventListener('click', close);
+        active.zoomed.addEventListener('transitionend', _handleOpenEnd);
+
+        if (active.original.getAttribute('data-zoom-src')) {
+          active.zoomedHd = active.zoomed.cloneNode();
+
+          // Reset the `scrset` property or the HD image won't load.
+          active.zoomedHd.removeAttribute('srcset');
+          active.zoomedHd.removeAttribute('sizes');
+          // Remove loading attribute so the browser can load the image normally
+          active.zoomedHd.removeAttribute('loading');
+
+          active.zoomedHd.src = active.zoomed.getAttribute('data-zoom-src');
+
+          active.zoomedHd.onerror = function () {
+            clearInterval(getZoomTargetSize);
+            console.warn('Unable to reach the zoom image target ' + active.zoomedHd.src);
+            active.zoomedHd = null;
+            _animate();
+          };
+
+          // We need to access the natural size of the full HD
+          // target as fast as possible to compute the animation.
+          var getZoomTargetSize = setInterval(function () {
+            if ( active.zoomedHd.complete) {
+              clearInterval(getZoomTargetSize);
+              active.zoomedHd.classList.add('medium-zoom-image--opened');
+              active.zoomedHd.addEventListener('click', close);
+              document.body.appendChild(active.zoomedHd);
+              _animate();
+            }
+          }, 10);
+        } else if (active.original.hasAttribute('srcset')) {
+          // If an image has a `srcset` attribuet, we don't know the dimensions of the
+          // zoomed (HD) image (like when `data-zoom-src` is specified).
+          // Therefore the approach is quite similar.
+          active.zoomedHd = active.zoomed.cloneNode();
+
+          // Resetting the sizes attribute tells the browser to load the
+          // image best fitting the current viewport size, respecting the `srcset`.
+          active.zoomedHd.removeAttribute('sizes');
+
+          // In Firefox, the `loading` attribute needs to be set to `eager` (default
+          // value) for the load event to be fired.
+          active.zoomedHd.removeAttribute('loading');
+
+          // Wait for the load event of the hd image. This will fire if the image
+          // is already cached.
+          var loadEventListener = active.zoomedHd.addEventListener('load', function () {
+            active.zoomedHd.removeEventListener('load', loadEventListener);
+            active.zoomedHd.classList.add('medium-zoom-image--opened');
+            active.zoomedHd.addEventListener('click', close);
+            document.body.appendChild(active.zoomedHd);
+            _animate();
+          });
+        } else {
+          _animate();
+        }
+      });
+    };
+
+    var close = function close() {
+      return new Promise(function (resolve) {
+        if (isAnimating || !active.original) {
+          resolve(zoom);
+          return;
+        }
+
+        var _handleCloseEnd = function _handleCloseEnd() {
+          active.original.classList.remove('medium-zoom-image--hidden');
+          document.body.removeChild(active.zoomed);
+          if (active.zoomedHd) {
+            document.body.removeChild(active.zoomedHd);
+          }
+          document.body.removeChild(overlay);
+          active.zoomed.classList.remove('medium-zoom-image--opened');
+          if (active.template) {
+            document.body.removeChild(active.template);
+          }
+
+          isAnimating = false;
+          active.zoomed.removeEventListener('transitionend', _handleCloseEnd);
+
+          active.original.dispatchEvent(createCustomEvent('medium-zoom:closed', {
+            detail: { zoom: zoom }
+          }));
+
+          active.original = null;
+          active.zoomed = null;
+          active.zoomedHd = null;
+          active.template = null;
+
+          resolve(zoom);
+        };
+
+        isAnimating = true;
+        document.body.classList.remove('medium-zoom--opened');
+        active.zoomed.style.transform = '';
+
+        if (active.zoomedHd) {
+          active.zoomedHd.style.transform = '';
+        }
+
+        // Fade out the template so it's not too abrupt
+        if (active.template) {
+          active.template.style.transition = 'opacity 150ms';
+          active.template.style.opacity = 0;
+        }
+
+        active.original.dispatchEvent(createCustomEvent('medium-zoom:close', {
+          detail: { zoom: zoom }
+        }));
+
+        active.zoomed.addEventListener('transitionend', _handleCloseEnd);
+      });
+    };
+
+    var toggle = function toggle() {
+      var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+          target = _ref3.target;
+
+      if (active.original) {
+        return close();
+      }
+
+      return open({ target: target });
+    };
+
+    var getOptions = function getOptions() {
+      return zoomOptions;
+    };
+
+    var getImages = function getImages() {
+      return images;
+    };
+
+    var getZoomedImage = function getZoomedImage() {
+      return active.original;
+    };
+
+    var images = [];
+    var eventListeners = [];
+    var isAnimating = false;
+    var scrollTop = 0;
+    var zoomOptions = options;
+    var active = {
+      original: null,
+      zoomed: null,
+      zoomedHd: null,
+      template: null
+
+      // If the selector is omitted, it's replaced by the options
+    };if (Object.prototype.toString.call(selector) === '[object Object]') {
+      zoomOptions = selector;
+    } else if (selector || typeof selector === 'string' // to process empty string as a selector
+    ) {
+        attach(selector);
+      }
+
+    // Apply the default option values
+    zoomOptions = _extends({
+      margin: 0,
+      background: '#fff',
+      scrollOffset: 40,
+      container: null,
+      template: null
+    }, zoomOptions);
+
+    var overlay = createOverlay(zoomOptions.background);
+
+    document.addEventListener('click', _handleClick);
+    document.addEventListener('keyup', _handleKeyUp);
+    document.addEventListener('scroll', _handleScroll);
+    window.addEventListener('resize', close);
+
+    var zoom = {
+      open: open,
+      close: close,
+      toggle: toggle,
+      update: update,
+      clone: clone,
+      attach: attach,
+      detach: detach,
+      on: on,
+      off: off,
+      getOptions: getOptions,
+      getImages: getImages,
+      getZoomedImage: getZoomedImage
+    };
+
+    return zoom;
+  };
+
+  function styleInject(css, ref) {
+    if ( ref === void 0 ) { ref = {}; }
+    var insertAt = ref.insertAt;
+
+    if (!css || typeof document === 'undefined') { return; }
+
+    var head = document.head || document.getElementsByTagName('head')[0];
+    var style = document.createElement('style');
+    style.type = 'text/css';
+
+    if (insertAt === 'top') {
+      if (head.firstChild) {
+        head.insertBefore(style, head.firstChild);
+      } else {
+        head.appendChild(style);
+      }
+    } else {
+      head.appendChild(style);
+    }
+
+    if (style.styleSheet) {
+      style.styleSheet.cssText = css;
+    } else {
+      style.appendChild(document.createTextNode(css));
+    }
+  }
+
+  var css = ".medium-zoom-overlay{position:fixed;top:0;right:0;bottom:0;left:0;opacity:0;transition:opacity .3s;will-change:opacity}.medium-zoom--opened .medium-zoom-overlay{cursor:pointer;cursor:zoom-out;opacity:1}.medium-zoom-image{cursor:pointer;cursor:zoom-in;transition:transform .3s cubic-bezier(.2,0,.2,1)!important}.medium-zoom-image--hidden{visibility:hidden}.medium-zoom-image--opened{position:relative;cursor:pointer;cursor:zoom-out;will-change:transform}";
+  styleInject(css);
+
+  /* eslint-disable no-unused-vars */
+
+  var matchesSelector =
+    Element.prototype.matches ||
+    Element.prototype.webkitMatchesSelector ||
+    Element.prototype.msMatchesSelector;
+
+  function install(hook) {
+    var zoom;
+
+    hook.doneEach(function (_) {
+      var elms = Array.apply(
+        null,
+        document.querySelectorAll(
+          '.markdown-section img:not(.emoji):not([data-no-zoom])'
+        )
+      );
+
+      elms = elms.filter(function (elm) { return matchesSelector.call(elm, 'a img') === false; });
+
+      if (zoom) {
+        zoom.detach();
+      }
+
+      zoom = mediumZoom(elms);
+    });
+  }
+
+  $docsify.plugins = [].concat(install, $docsify.plugins);
+
+}());

docs/index.html

@@ -6,7 +6,7 @@
   <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
   <meta name="description" content="Description">
   <meta name="viewport" content="width=device-width, initial-scale=1.0, minimum-scale=1.0">
-  <link rel="stylesheet" href="//cdn.jsdelivr.net/npm/docsify@4/lib/themes/vue.css">
+  <link rel="stylesheet" href="docsify/themes/buble.css">
 </head>
 <body>
   <div id="app"></div>
@@ -19,6 +19,6 @@
     }
   </script>
   <!-- Docsify v4 -->
-  <script src="docsify.js"></script>
+  <script src="docsify/docsify.js"></script>
 </body>
 </html>

package.json

@@ -38,6 +38,7 @@
         "@reduxjs/toolkit": "==2.0.0-alpha.5 ",
         "@vitest/browser": "^0.23.1",
         "@vitest/ui": "^0.23.1",
+        "docsify": "^4.13.1",
         "eslint": "^8.22.0",
         "eslint-plugin-no-only-tests": "^3.0.0",
         "eslint-plugin-todo-plz": "^1.2.1",