Move vendor libraries to /vendors folder and exclude from LGTM

src/static/js/vendors/browser.js

@@ -0,0 +1,310 @@
+// WARNING: This file may have been modified from original.
+// TODO: Check requirement of this file, this afaik was to cover weird edge cases
+// that have probably been fixed in browsers.
+
+/*!
+  * Bowser - a browser detector
+  * https://github.com/ded/bowser
+  * MIT License | (c) Dustin Diaz 2015
+  */
+
+!function (name, definition) {
+  if (typeof module != 'undefined' && module.exports) module.exports = definition()
+  else if (typeof define == 'function' && define.amd) define(definition)
+  else this[name] = definition()
+}('bowser', function () {
+  /**
+    * See useragents.js for examples of navigator.userAgent
+    */
+
+  var t = true
+
+  function detect(ua) {
+
+    function getFirstMatch(regex) {
+      var match = ua.match(regex);
+      return (match && match.length > 1 && match[1]) || '';
+    }
+
+    function getSecondMatch(regex) {
+      var match = ua.match(regex);
+      return (match && match.length > 1 && match[2]) || '';
+    }
+
+    var iosdevice = getFirstMatch(/(ipod|iphone|ipad)/i).toLowerCase()
+      , likeAndroid = /like android/i.test(ua)
+      , android = !likeAndroid && /android/i.test(ua)
+      , chromeos = /CrOS/.test(ua)
+      , silk = /silk/i.test(ua)
+      , sailfish = /sailfish/i.test(ua)
+      , tizen = /tizen/i.test(ua)
+      , webos = /(web|hpw)os/i.test(ua)
+      , windowsphone = /windows phone/i.test(ua)
+      , windows = !windowsphone && /windows/i.test(ua)
+      , mac = !iosdevice && !silk && /macintosh/i.test(ua)
+      , linux = !android && !sailfish && !tizen && !webos && /linux/i.test(ua)
+      , edgeVersion = getFirstMatch(/edge\/(\d+(\.\d+)?)/i)
+      , versionIdentifier = getFirstMatch(/version\/(\d+(\.\d+)?)/i)
+      , tablet = /tablet/i.test(ua)
+      , mobile = !tablet && /[^-]mobi/i.test(ua)
+      , result
+
+    if (/opera|opr/i.test(ua)) {
+      result = {
+        name: 'Opera'
+      , opera: t
+      , version: versionIdentifier || getFirstMatch(/(?:opera|opr)[\s\/](\d+(\.\d+)?)/i)
+      }
+    }
+    else if (/yabrowser/i.test(ua)) {
+      result = {
+        name: 'Yandex Browser'
+      , yandexbrowser: t
+      , version: versionIdentifier || getFirstMatch(/(?:yabrowser)[\s\/](\d+(\.\d+)?)/i)
+      }
+    }
+    else if (windowsphone) {
+      result = {
+        name: 'Windows Phone'
+      , windowsphone: t
+      }
+      if (edgeVersion) {
+        result.msedge = t
+        result.version = edgeVersion
+      }
+      else {
+        result.msie = t
+        result.version = getFirstMatch(/iemobile\/(\d+(\.\d+)?)/i)
+      }
+    }
+    else if (/msie|trident/i.test(ua)) {
+      result = {
+        name: 'Internet Explorer'
+      , msie: t
+      , version: getFirstMatch(/(?:msie |rv:)(\d+(\.\d+)?)/i)
+      }
+    } else if (chromeos) {
+      result = {
+        name: 'Chrome'
+      , chromeos: t
+      , chromeBook: t
+      , chrome: t
+      , version: getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.\d+)?)/i)
+      }
+    } else if (/chrome.+? edge/i.test(ua)) {
+      result = {
+        name: 'Microsoft Edge'
+      , msedge: t
+      , version: edgeVersion
+      }
+    }
+    else if (/chrome|crios|crmo/i.test(ua)) {
+      result = {
+        name: 'Chrome'
+      , chrome: t
+      , version: getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.\d+)?)/i)
+      }
+    }
+    else if (iosdevice) {
+      result = {
+        name : iosdevice == 'iphone' ? 'iPhone' : iosdevice == 'ipad' ? 'iPad' : 'iPod'
+      }
+      // WTF: version is not part of user agent in web apps
+      if (versionIdentifier) {
+        result.version = versionIdentifier
+      }
+    }
+    else if (sailfish) {
+      result = {
+        name: 'Sailfish'
+      , sailfish: t
+      , version: getFirstMatch(/sailfish\s?browser\/(\d+(\.\d+)?)/i)
+      }
+    }
+    else if (/seamonkey\//i.test(ua)) {
+      result = {
+        name: 'SeaMonkey'
+      , seamonkey: t
+      , version: getFirstMatch(/seamonkey\/(\d+(\.\d+)?)/i)
+      }
+    }
+    else if (/firefox|iceweasel/i.test(ua)) {
+      result = {
+        name: 'Firefox'
+      , firefox: t
+      , version: getFirstMatch(/(?:firefox|iceweasel)[ \/](\d+(\.\d+)?)/i)
+      }
+      if (/\((mobile|tablet);[^\)]*rv:[\d\.]+\)/i.test(ua)) {
+        result.firefoxos = t
+      }
+    }
+    else if (silk) {
+      result =  {
+        name: 'Amazon Silk'
+      , silk: t
+      , version : getFirstMatch(/silk\/(\d+(\.\d+)?)/i)
+      }
+    }
+    else if (android) {
+      result = {
+        name: 'Android'
+      , version: versionIdentifier
+      }
+    }
+    else if (/phantom/i.test(ua)) {
+      result = {
+        name: 'PhantomJS'
+      , phantom: t
+      , version: getFirstMatch(/phantomjs\/(\d+(\.\d+)?)/i)
+      }
+    }
+    else if (/blackberry|\bbb\d+/i.test(ua) || /rim\stablet/i.test(ua)) {
+      result = {
+        name: 'BlackBerry'
+      , blackberry: t
+      , version: versionIdentifier || getFirstMatch(/blackberry[\d]+\/(\d+(\.\d+)?)/i)
+      }
+    }
+    else if (webos) {
+      result = {
+        name: 'WebOS'
+      , webos: t
+      , version: versionIdentifier || getFirstMatch(/w(?:eb)?osbrowser\/(\d+(\.\d+)?)/i)
+      };
+      /touchpad\//i.test(ua) && (result.touchpad = t)
+    }
+    else if (/bada/i.test(ua)) {
+      result = {
+        name: 'Bada'
+      , bada: t
+      , version: getFirstMatch(/dolfin\/(\d+(\.\d+)?)/i)
+      };
+    }
+    else if (tizen) {
+      result = {
+        name: 'Tizen'
+      , tizen: t
+      , version: getFirstMatch(/(?:tizen\s?)?browser\/(\d+(\.\d+)?)/i) || versionIdentifier
+      };
+    }
+    else if (/safari/i.test(ua)) {
+      result = {
+        name: 'Safari'
+      , safari: t
+      , version: versionIdentifier
+      }
+    }
+    else {
+      result = {
+        name: getFirstMatch(/^(.*)\/(.*) /),
+        version: getSecondMatch(/^(.*)\/(.*) /)
+     };
+   }
+
+    // set webkit or gecko flag for browsers based on these engines
+    if (!result.msedge && /(apple)?webkit/i.test(ua)) {
+      result.name = result.name || "Webkit"
+      result.webkit = t
+      if (!result.version && versionIdentifier) {
+        result.version = versionIdentifier
+      }
+    } else if (!result.opera && /gecko\//i.test(ua)) {
+      result.name = result.name || "Gecko"
+      result.gecko = t
+      result.version = result.version || getFirstMatch(/gecko\/(\d+(\.\d+)?)/i)
+    }
+
+    // set OS flags for platforms that have multiple browsers
+    if (!result.msedge && (android || result.silk)) {
+      result.android = t
+    } else if (iosdevice) {
+      result[iosdevice] = t
+      result.ios = t
+    } else if (windows) {
+      result.windows = t
+    } else if (mac) {
+      result.mac = t
+    } else if (linux) {
+      result.linux = t
+    }
+
+    // OS version extraction
+    var osVersion = '';
+    if (result.windowsphone) {
+      osVersion = getFirstMatch(/windows phone (?:os)?\s?(\d+(\.\d+)*)/i);
+    } else if (iosdevice) {
+      osVersion = getFirstMatch(/os (\d+([_\s]\d+)*) like mac os x/i);
+      osVersion = osVersion.replace(/[_\s]/g, '.');
+    } else if (android) {
+      osVersion = getFirstMatch(/android[ \/-](\d+(\.\d+)*)/i);
+    } else if (result.webos) {
+      osVersion = getFirstMatch(/(?:web|hpw)os\/(\d+(\.\d+)*)/i);
+    } else if (result.blackberry) {
+      osVersion = getFirstMatch(/rim\stablet\sos\s(\d+(\.\d+)*)/i);
+    } else if (result.bada) {
+      osVersion = getFirstMatch(/bada\/(\d+(\.\d+)*)/i);
+    } else if (result.tizen) {
+      osVersion = getFirstMatch(/tizen[\/\s](\d+(\.\d+)*)/i);
+    }
+    if (osVersion) {
+      result.osversion = osVersion;
+    }
+
+    // device type extraction
+    var osMajorVersion = osVersion.split('.')[0];
+    if (tablet || iosdevice == 'ipad' || (android && (osMajorVersion == 3 || (osMajorVersion == 4 && !mobile))) || result.silk) {
+      result.tablet = t
+    } else if (mobile || iosdevice == 'iphone' || iosdevice == 'ipod' || android || result.blackberry || result.webos || result.bada) {
+      result.mobile = t
+    }
+
+    // Graded Browser Support
+    // http://developer.yahoo.com/yui/articles/gbs
+    if (result.msedge ||
+        (result.msie && result.version >= 10) ||
+        (result.yandexbrowser && result.version >= 15) ||
+        (result.chrome && result.version >= 20) ||
+        (result.firefox && result.version >= 20.0) ||
+        (result.safari && result.version >= 6) ||
+        (result.opera && result.version >= 10.0) ||
+        (result.ios && result.osversion && result.osversion.split(".")[0] >= 6) ||
+        (result.blackberry && result.version >= 10.1)
+        ) {
+      result.a = t;
+    }
+    else if ((result.msie && result.version < 10) ||
+        (result.chrome && result.version < 20) ||
+        (result.firefox && result.version < 20.0) ||
+        (result.safari && result.version < 6) ||
+        (result.opera && result.version < 10.0) ||
+        (result.ios && result.osversion && result.osversion.split(".")[0] < 6)
+        ) {
+      result.c = t
+    } else result.x = t
+
+    return result
+  }
+
+  var bowser = detect(typeof navigator !== 'undefined' ? navigator.userAgent : '')
+
+  bowser.test = function (browserList) {
+    for (var i = 0; i < browserList.length; ++i) {
+      var browserItem = browserList[i];
+      if (typeof browserItem=== 'string') {
+        if (browserItem in bowser) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /*
+   * Set our detect method to the main bowser object so we can
+   * reuse it to test other user agents.
+   * This is needed to implement future tests.
+   */
+  bowser._detect = detect;
+
+  return bowser
+});

src/static/js/vendors/farbtastic.js

@@ -0,0 +1,532 @@
+// WARNING: This file has been modified from original.
+// TODO: Replace with https://github.com/Simonwep/pickr
+
+// Farbtastic 2.0 alpha
+// Original can be found at:
+// https://github.com/mattfarina/farbtastic/blob/71ca15f4a09c8e5a08a1b0d1cf37ef028adf22f0/src/farbtastic.js
+// Licensed under the terms of the GNU General Public License v2.0:
+// https://github.com/mattfarina/farbtastic/blob/71ca15f4a09c8e5a08a1b0d1cf37ef028adf22f0/LICENSE.txt
+// edited by Sebastian Castro <sebastian.castro@protonmail.com> on 2020-04-06
+(function ($) {
+
+var __debug = false;
+var __factor = 1;
+
+$.fn.farbtastic = function (options) {
+  $.farbtastic(this, options);
+  return this;
+};
+
+$.farbtastic = function (container, options) {
+  var container = $(container)[0];
+  return container.farbtastic || (container.farbtastic = new $._farbtastic(container, options));
+}
+
+$._farbtastic = function (container, options) {
+  var fb = this;
+
+  /////////////////////////////////////////////////////
+
+  /**
+   * Link to the given element(s) or callback.
+   */
+  fb.linkTo = function (callback) {
+    // Unbind previous nodes
+    if (typeof fb.callback == 'object') {
+      $(fb.callback).unbind('keyup', fb.updateValue);
+    }
+
+    // Reset color
+    fb.color = null;
+
+    // Bind callback or elements
+    if (typeof callback == 'function') {
+      fb.callback = callback;
+    }
+    else if (typeof callback == 'object' || typeof callback == 'string') {
+      fb.callback = $(callback);
+      fb.callback.bind('keyup', fb.updateValue);
+      if (fb.callback[0].value) {
+        fb.setColor(fb.callback[0].value);
+      }
+    }
+    return this;
+  }
+  fb.updateValue = function (event) {
+    if (this.value && this.value != fb.color) {
+      fb.setColor(this.value);
+    }
+  }
+
+  /**
+   * Change color with HTML syntax #123456
+   */
+  fb.setColor = function (color) {
+    var unpack = fb.unpack(color);
+    if (fb.color != color && unpack) {
+      fb.color = color;
+      fb.rgb = unpack;
+      fb.hsl = fb.RGBToHSL(fb.rgb);
+      fb.updateDisplay();
+    }
+    return this;
+  }
+
+  /**
+   * Change color with HSL triplet [0..1, 0..1, 0..1]
+   */
+  fb.setHSL = function (hsl) {
+    fb.hsl = hsl;
+
+    var convertedHSL = [hsl[0]]
+    convertedHSL[1] = hsl[1]*__factor+((1-__factor)/2);
+    convertedHSL[2] = hsl[2]*__factor+((1-__factor)/2);
+
+    fb.rgb = fb.HSLToRGB(convertedHSL);
+    fb.color = fb.pack(fb.rgb);
+    fb.updateDisplay();
+    return this;
+  }
+
+  /////////////////////////////////////////////////////
+
+  /**
+   * Initialize the color picker widget.
+   */
+  fb.initWidget = function () {
+
+    // Insert markup and size accordingly.
+    var dim = {
+      width: options.width,
+      height: options.width
+    };
+    $(container)
+      .html(
+        '<div class="farbtastic" style="position: relative">' +
+          '<div class="farbtastic-solid"></div>' +
+          '<canvas class="farbtastic-mask"></canvas>' +
+          '<canvas class="farbtastic-overlay"></canvas>' +
+        '</div>'
+      )
+      .find('*').attr(dim).css(dim).end()
+      .find('div>*').css('position', 'absolute');
+
+    // IE Fix: Recreate canvas elements with doc.createElement and excanvas.
+    browser.msie && $('canvas', container).each(function () {
+      // Fetch info.
+      var attr = { 'class': $(this).attr('class'), style: this.getAttribute('style') },
+          e = document.createElement('canvas');
+      // Replace element.
+      $(this).before($(e).attr(attr)).remove();
+      // Init with explorerCanvas.
+      G_vmlCanvasManager && G_vmlCanvasManager.initElement(e);
+      // Set explorerCanvas elements dimensions and absolute positioning.
+      $(e).attr(dim).css(dim).css('position', 'absolute')
+        .find('*').attr(dim).css(dim);
+    });
+
+    // Determine layout
+    fb.radius = (options.width - options.wheelWidth) / 2 - 1;
+    fb.square = Math.floor((fb.radius - options.wheelWidth / 2) * 0.7) - 1;
+    fb.mid = Math.floor(options.width / 2);
+    fb.markerSize = options.wheelWidth * 0.3;
+    fb.solidFill = $('.farbtastic-solid', container).css({
+      width: fb.square * 2 - 1,
+      height: fb.square * 2 - 1,
+      left: fb.mid - fb.square,
+      top: fb.mid - fb.square
+    });
+
+    // Set up drawing context.
+    fb.cnvMask = $('.farbtastic-mask', container);
+    fb.ctxMask = fb.cnvMask[0].getContext('2d');
+    fb.cnvOverlay = $('.farbtastic-overlay', container);
+    fb.ctxOverlay = fb.cnvOverlay[0].getContext('2d');
+    fb.ctxMask.translate(fb.mid, fb.mid);
+    fb.ctxOverlay.translate(fb.mid, fb.mid);
+
+    // Draw widget base layers.
+    fb.drawCircle();
+    fb.drawMask();
+  }
+
+  /**
+   * Draw the color wheel.
+   */
+  fb.drawCircle = function () {
+    var tm = +(new Date());
+    // Draw a hue circle with a bunch of gradient-stroked beziers.
+    // Have to use beziers, as gradient-stroked arcs don't work.
+    var n = 24,
+        r = fb.radius,
+        w = options.wheelWidth,
+        nudge = 8 / r / n * Math.PI, // Fudge factor for seams.
+        m = fb.ctxMask,
+        angle1 = 0, color1, d1;
+    m.save();
+    m.lineWidth = w / r;
+    m.scale(r, r);
+    // Each segment goes from angle1 to angle2.
+    for (var i = 0; i <= n; ++i) {
+      var d2 = i / n,
+          angle2 = d2 * Math.PI * 2,
+          // Endpoints
+          x1 = Math.sin(angle1), y1 = -Math.cos(angle1);
+          x2 = Math.sin(angle2), y2 = -Math.cos(angle2),
+          // Midpoint chosen so that the endpoints are tangent to the circle.
+          am = (angle1 + angle2) / 2,
+          tan = 1 / Math.cos((angle2 - angle1) / 2),
+          xm = Math.sin(am) * tan, ym = -Math.cos(am) * tan,
+          // New color
+          color2 = fb.pack(fb.HSLToRGB([d2, 1, 0.5]));
+      if (i > 0) {
+        if (browser.msie) {
+          // IE's gradient calculations mess up the colors. Correct along the diagonals.
+          var corr = (1 + Math.min(Math.abs(Math.tan(angle1)), Math.abs(Math.tan(Math.PI / 2 - angle1)))) / n;
+          color1 = fb.pack(fb.HSLToRGB([d1 - 0.15 * corr, 1, 0.5]));
+          color2 = fb.pack(fb.HSLToRGB([d2 + 0.15 * corr, 1, 0.5]));
+          // Create gradient fill between the endpoints.
+          var grad = m.createLinearGradient(x1, y1, x2, y2);
+          grad.addColorStop(0, color1);
+          grad.addColorStop(1, color2);
+          m.fillStyle = grad;
+          // Draw quadratic curve segment as a fill.
+          var r1 = (r + w / 2) / r, r2 = (r - w / 2) / r; // inner/outer radius.
+          m.beginPath();
+          m.moveTo(x1 * r1, y1 * r1);
+          m.quadraticCurveTo(xm * r1, ym * r1, x2 * r1, y2 * r1);
+          m.lineTo(x2 * r2, y2 * r2);
+          m.quadraticCurveTo(xm * r2, ym * r2, x1 * r2, y1 * r2);
+          m.fill();
+        }
+        else {
+          // Create gradient fill between the endpoints.
+          var grad = m.createLinearGradient(x1, y1, x2, y2);
+          grad.addColorStop(0, color1);
+          grad.addColorStop(1, color2);
+          m.strokeStyle = grad;
+          // Draw quadratic curve segment.
+          m.beginPath();
+          m.moveTo(x1, y1);
+          m.quadraticCurveTo(xm, ym, x2, y2);
+          m.stroke();
+        }
+      }
+      // Prevent seams where curves join.
+      angle1 = angle2 - nudge; color1 = color2; d1 = d2;
+    }
+    m.restore();
+    __debug && $('body').append('<div>drawCircle '+ (+(new Date()) - tm) +'ms');
+  };
+
+  /**
+   * Draw the saturation/luminance mask.
+   */
+  fb.drawMask = function () {
+    var tm = +(new Date());
+
+    // Iterate over sat/lum space and calculate appropriate mask pixel values.
+    var size = fb.square * 2, sq = fb.square;
+    function calculateMask(sizex, sizey, outputPixel) {
+      var isx = 1 / sizex, isy = 1 / sizey;
+      for (var y = 0; y <= sizey; ++y) {
+        var l = 1 - y * isy;
+        for (var x = 0; x <= sizex; ++x) {
+          var s = 1 - x * isx;
+          // From sat/lum to alpha and color (grayscale)
+          var a = 1 - 2 * Math.min(l * s, (1 - l) * s);
+          var c = (a > 0) ? ((2 * l - 1 + a) * .5 / a) : 0;
+
+          a = a*__factor+(1-__factor)/2;
+          c = c*__factor+(1-__factor)/2;
+
+          outputPixel(x, y, c, a);
+        }
+      }
+    }
+
+    // Method #1: direct pixel access (new Canvas).
+    if (fb.ctxMask.getImageData) {
+      // Create half-resolution buffer.
+      var sz = Math.floor(size / 2);
+      var buffer = document.createElement('canvas');
+      buffer.width = buffer.height = sz + 1;
+      var ctx = buffer.getContext('2d');
+      var frame = ctx.getImageData(0, 0, sz + 1, sz + 1);
+
+      var i = 0;
+      calculateMask(sz, sz, function (x, y, c, a) {
+        frame.data[i++] = frame.data[i++] = frame.data[i++] = c * 255;
+        frame.data[i++] = a * 255;
+      });
+
+      ctx.putImageData(frame, 0, 0);
+      fb.ctxMask.drawImage(buffer, 0, 0, sz + 1, sz + 1, -sq, -sq, sq * 2, sq * 2);
+    }
+    // Method #2: drawing commands (old Canvas).
+    else if (!browser.msie) {
+      // Render directly at half-resolution
+      var sz = Math.floor(size / 2);
+      calculateMask(sz, sz, function (x, y, c, a) {
+        c = Math.round(c * 255);
+        fb.ctxMask.fillStyle = 'rgba(' + c + ', ' + c + ', ' + c + ', ' + a +')';
+        fb.ctxMask.fillRect(x * 2 - sq - 1, y * 2 - sq - 1, 2, 2);
+      });
+    }
+    // Method #3: vertical DXImageTransform gradient strips (IE).
+    else {
+      var cache_last, cache, w = 6; // Each strip is 6 pixels wide.
+      var sizex = Math.floor(size / w);
+      // 6 vertical pieces of gradient per strip.
+      calculateMask(sizex, 6, function (x, y, c, a) {
+        if (x == 0) {
+          cache_last = cache;
+          cache = [];
+        }
+        c = Math.round(c * 255);
+        a = Math.round(a * 255);
+        // We can only start outputting gradients once we have two rows of pixels.
+        if (y > 0) {
+          var c_last = cache_last[x][0],
+              a_last = cache_last[x][1],
+              color1 = fb.packDX(c_last, a_last),
+              color2 = fb.packDX(c, a),
+              y1 = Math.round(fb.mid + ((y - 1) * .333 - 1) * sq),
+              y2 = Math.round(fb.mid + (y * .333 - 1) * sq);
+          $('<div>').css({
+            position: 'absolute',
+            filter: "progid:DXImageTransform.Microsoft.Gradient(StartColorStr="+ color1 +", EndColorStr="+ color2 +", GradientType=0)",
+            top: y1,
+            height: y2 - y1,
+            // Avoid right-edge sticking out.
+            left: fb.mid + (x * w - sq - 1),
+            width: w - (x == sizex ? Math.round(w / 2) : 0)
+          }).appendTo(fb.cnvMask);
+        }
+        cache.push([c, a]);
+      });
+    }
+    __debug && $('body').append('<div>drawMask '+ (+(new Date()) - tm) +'ms');
+  }
+
+  /**
+   * Draw the selection markers.
+   */
+  fb.drawMarkers = function () {
+    // Determine marker dimensions
+    var sz = options.width;
+    var angle = fb.hsl[0] * 6.28,
+        x1 =  Math.sin(angle) * fb.radius,
+        y1 = -Math.cos(angle) * fb.radius,
+        x2 = 2 * fb.square * (.5 - fb.hsl[1]),
+        y2 = 2 * fb.square * (.5 - fb.hsl[2]);
+    var circles = [
+      { x: x1, y: y1, r: fb.markerSize + 1, c: 'rgb(0,0,0,.4)', lw: 2 },
+      { x: x1, y: y1, r: fb.markerSize, c: '#fff', lw: 2 },
+      { x: x2, y: y2, r: fb.markerSize + 1, c: 'rgb(0,0,0,.4)', lw: 2 },
+      { x: x2, y: y2, r: fb.markerSize, c: '#fff',     lw: 2 },
+    ];
+
+    // Update the overlay canvas.
+    fb.ctxOverlay.clearRect(-fb.mid, -fb.mid, sz, sz);
+    for (i in circles) {
+      var c = circles[i];
+      fb.ctxOverlay.lineWidth = c.lw;
+      fb.ctxOverlay.strokeStyle = c.c;
+      fb.ctxOverlay.beginPath();
+      fb.ctxOverlay.arc(c.x, c.y, c.r, 0, Math.PI * 2, true);
+      fb.ctxOverlay.stroke();
+    }
+  }
+
+  /**
+   * Update the markers and styles
+   */
+  fb.updateDisplay = function () {
+    // Determine whether labels/markers should invert.
+    fb.invert = (fb.rgb[0] * 0.3 + fb.rgb[1] * .59 + fb.rgb[2] * .11) <= 0.6;
+
+    // Update the solid background fill.
+    fb.solidFill.css('backgroundColor', fb.pack(fb.HSLToRGB([fb.hsl[0], 1, 0.5])));
+
+    // Draw markers
+    fb.drawMarkers();
+
+    // Linked elements or callback
+    if (typeof fb.callback == 'object') {
+      // Set background/foreground color
+      $(fb.callback).css({
+        backgroundColor: fb.color,
+        color: fb.invert ? '#fff' : '#000'
+      });
+
+      // Change linked value
+      $(fb.callback).each(function() {
+        if ((typeof this.value == 'string') && this.value != fb.color) {
+          this.value = fb.color;
+        }
+      });
+    }
+    else if (typeof fb.callback == 'function') {
+      fb.callback.call(fb, fb.color);
+    }
+  }
+
+  /**
+   * Helper for returning coordinates relative to the center.
+   */
+  fb.widgetCoords = function (event) {
+    return {
+      x: event.pageX - fb.offset.left - fb.mid,
+      y: event.pageY - fb.offset.top - fb.mid
+    };
+  }
+
+  /**
+   * Mousedown handler
+   */
+  fb.mousedown = function (event) {
+    // Capture mouse
+    if (!$._farbtastic.dragging) {
+      $(document).bind('mousemove', fb.mousemove).bind('mouseup', fb.mouseup);
+      $._farbtastic.dragging = true;
+    }
+
+    // Update the stored offset for the widget.
+    fb.offset = $(container).offset();
+
+    // Check which area is being dragged
+    var pos = fb.widgetCoords(event);
+    fb.circleDrag = Math.max(Math.abs(pos.x), Math.abs(pos.y)) > (fb.square + 2);
+
+    // Process
+    fb.mousemove(event);
+    return false;
+  }
+
+  /**
+   * Mousemove handler
+   */
+  fb.mousemove = function (event) {
+    // Get coordinates relative to color picker center
+    var pos = fb.widgetCoords(event);
+
+    // Set new HSL parameters
+    if (fb.circleDrag) {
+      var hue = Math.atan2(pos.x, -pos.y) / 6.28;
+      fb.setHSL([(hue + 1) % 1, fb.hsl[1], fb.hsl[2]]);
+    }
+    else {
+      var sat = Math.max(0, Math.min(1, -(pos.x / fb.square / 2) + .5));
+      var lum = Math.max(0, Math.min(1, -(pos.y / fb.square / 2) + .5));
+      fb.setHSL([fb.hsl[0], sat, lum]);
+    }
+    return false;
+  }
+
+  /**
+   * Mouseup handler
+   */
+  fb.mouseup = function () {
+    // Uncapture mouse
+    $(document).unbind('mousemove', fb.mousemove);
+    $(document).unbind('mouseup', fb.mouseup);
+    $._farbtastic.dragging = false;
+  }
+
+  /* Various color utility functions */
+  fb.dec2hex = function (x) {
+    return (x < 16 ? '0' : '') + x.toString(16);
+  }
+
+  fb.packDX = function (c, a) {
+    return '#' + fb.dec2hex(a) + fb.dec2hex(c) + fb.dec2hex(c) + fb.dec2hex(c);
+  };
+
+  fb.pack = function (rgb) {
+    var r = Math.round(rgb[0] * 255);
+    var g = Math.round(rgb[1] * 255);
+    var b = Math.round(rgb[2] * 255);
+    return '#' + fb.dec2hex(r) + fb.dec2hex(g) + fb.dec2hex(b);
+  };
+
+  fb.unpack = function (color) {
+    if (color.length == 7) {
+      function x(i) {
+        return parseInt(color.substring(i, i + 2), 16) / 255;
+      }
+      return [ x(1), x(3), x(5) ];
+    }
+    else if (color.length == 4) {
+      function x(i) {
+        return parseInt(color.substring(i, i + 1), 16) / 15;
+      }
+      return [ x(1), x(2), x(3) ];
+    }
+  };
+
+  fb.HSLToRGB = function (hsl) {
+    var m1, m2, r, g, b;
+    var h = hsl[0], s = hsl[1], l = hsl[2];
+    m2 = (l <= 0.5) ? l * (s + 1) : l + s - l * s;
+    m1 = l * 2 - m2;
+    return [
+      this.hueToRGB(m1, m2, h + 0.33333),
+      this.hueToRGB(m1, m2, h),
+      this.hueToRGB(m1, m2, h - 0.33333)
+    ];
+  };
+
+  fb.hueToRGB = function (m1, m2, h) {
+    h = (h + 1) % 1;
+    if (h * 6 < 1) return m1 + (m2 - m1) * h * 6;
+    if (h * 2 < 1) return m2;
+    if (h * 3 < 2) return m1 + (m2 - m1) * (0.66666 - h) * 6;
+    return m1;
+  };
+
+  fb.RGBToHSL = function (rgb) {
+    var r = rgb[0], g = rgb[1], b = rgb[2],
+        min = Math.min(r, g, b),
+        max = Math.max(r, g, b),
+        delta = max - min,
+        h = 0,
+        s = 0,
+        l = (min + max) / 2;
+    if (l > 0 && l < 1) {
+      s = delta / (l < 0.5 ? (2 * l) : (2 - 2 * l));
+    }
+    if (delta > 0) {
+      if (max == r && max != g) h += (g - b) / delta;
+      if (max == g && max != b) h += (2 + (b - r) / delta);
+      if (max == b && max != r) h += (4 + (r - g) / delta);
+      h /= 6;
+    }
+    return [h, s, l];
+  };
+
+  // Parse options.
+  if (!options.callback) {
+    options = { callback: options };
+  }
+  options = $.extend({
+    width: 300,
+    wheelWidth: (options.width || 300) / 10,
+    callback: null
+  }, options);
+
+  // Initialize.
+  fb.initWidget();
+
+  // Install mousedown handler (the others are set on the document on-demand)
+  $('canvas.farbtastic-overlay', container).mousedown(fb.mousedown);
+
+  // Set linked elements/callback
+  if (options.callback) {
+    fb.linkTo(options.callback);
+  }
+  // Set to gray.
+  fb.setColor('#808080');
+}
+
+})(jQuery);

src/static/js/vendors/gritter.js

@@ -0,0 +1,357 @@
+// WARNING: This file has been modified from the Original
+
+/*
+ * Gritter for jQuery
+ * http://www.boedesign.com/
+ *
+ * Copyright (c) 2012 Jordan Boesch
+ * Dual licensed under the MIT and GPL licenses.
+ *
+ * Date: February 24, 2012
+ * Version: 1.7.4
+ *
+ * Edited by Sebastian Castro <sebastian.castro@protonmail.com> on 2020-03-31
+ *
+ * Edited by Richard Hansen <rhansen@rhansen.org> on 2020-10-19 to accept jQuery or DOM objects for
+ * notification title and text, and to treat plain strings as text instead of HTML (to avoid XSS
+ * vunlerabilities).
+ */
+
+(function($){
+	/**
+	* Set it up as an object under the jQuery namespace
+	*/
+	$.gritter = {};
+
+	/**
+	* Set up global options that the user can over-ride
+	*/
+	$.gritter.options = {
+		position: '',
+		class_name: '', // could be set to 'gritter-light' to use white notifications
+		time: 3000 // hang on the screen for...
+	}
+
+	/**
+	* Add a gritter notification to the screen
+	* @see Gritter#add();
+	*/
+	$.gritter.add = function(params){
+
+		try {
+			return Gritter.add(params || {});
+		} catch(e) {
+
+			var err = 'Gritter Error: ' + e;
+			(typeof(console) != 'undefined' && console.error) ?
+				console.error(err, params) :
+				alert(err);
+
+		}
+
+	}
+
+	/**
+	* Remove a gritter notification from the screen
+	* @see Gritter#removeSpecific();
+	*/
+	$.gritter.remove = function(id, params){
+		Gritter.removeSpecific(id.split('gritter-item-')[1], params || {});
+	}
+
+	/**
+	* Remove all notifications
+	* @see Gritter#stop();
+	*/
+	$.gritter.removeAll = function(params){
+		Gritter.stop(params || {});
+	}
+
+	/**
+	* Big fat Gritter object
+	* @constructor (not really since its object literal)
+	*/
+	var Gritter = {
+
+		// Public - options to over-ride with $.gritter.options in "add"
+		time: '',
+
+		// Private - no touchy the private parts
+		_custom_timer: 0,
+		_item_count: 0,
+		_is_setup: 0,
+		_tpl_wrap_top: '<div id="gritter-container" class="top"></div>',
+		_tpl_wrap_bottom: '<div id="gritter-container" class="bottom"></div>',
+		_tpl_close: '',
+		_tpl_title: $('<h3>').addClass('gritter-title'),
+		_tpl_item: ($('<div>').addClass('popup gritter-item')
+								.append($('<div>').addClass('popup-content')
+												.append($('<div>').addClass('gritter-content'))
+												.append($('<div>').addClass('gritter-close')
+																.append($('<i>').addClass('buttonicon buttonicon-times'))))),
+
+
+		/**
+		* Add a gritter notification to the screen
+		* @param {Object} params The object that contains all the options for drawing the notification
+		* @return {Integer} The specific numeric id to that gritter notification
+		*/
+		add: function(params){
+			// Handle straight text
+			if(typeof(params) == 'string'){
+				params = {text:params};
+			}
+
+			// We might have some issues if we don't have a title or text!
+			if(!params.text){
+				throw 'You must supply "text" parameter.';
+			}
+
+			// Check the options and set them once
+			if(!this._is_setup){
+				this._runSetup();
+			}
+
+			// Basics
+			var title = params.title,
+				text = params.text,
+				image = params.image || '',
+				position = params.position || 'top',
+				sticky = params.sticky || false,
+				item_class = params.class_name || $.gritter.options.class_name,
+				time_alive = params.time || '';
+
+			this._verifyWrapper();
+
+			if (sticky) {
+				item_class += " sticky";
+			}
+
+			this._item_count++;
+			var number = this._item_count;
+
+			// Assign callbacks
+			$(['before_open', 'after_open', 'before_close', 'after_close']).each(function(i, val){
+				Gritter['_' + val + '_' + number] = ($.isFunction(params[val])) ? params[val] : function(){}
+			});
+
+			// Reset
+			this._custom_timer = 0;
+
+			// A custom fade time set
+			if(time_alive){
+				this._custom_timer = time_alive;
+			}
+
+			// String replacements on the template
+			if(title){
+				title = this._tpl_title.clone().append(
+						typeof title === 'string' ? document.createTextNode(title) : title);
+			}else{
+				title = '';
+			}
+
+			const tmp = this._tpl_item.clone();
+			tmp.attr('id', `gritter-item-${number}`);
+			tmp.addClass(item_class);
+			tmp.find('.gritter-content')
+					.append(title)
+					.append(typeof text === 'string' ? $('<p>').text(text) : text);
+
+			// If it's false, don't show another gritter message
+			if(this['_before_open_' + number]() === false){
+				return false;
+			}
+
+			if (['top', 'bottom'].indexOf(position) == -1) {
+				position = 'top';
+			}
+
+			$('#gritter-container.' + position).append(tmp);
+
+			var item = $('#gritter-item-' + this._item_count);
+
+			setTimeout(function() { item.addClass('popup-show'); }, 0);
+			Gritter['_after_open_' + number](item);
+
+			if(!sticky){
+				this._setFadeTimer(item, number);
+				// Bind the hover/unhover states
+				$(item).on('mouseenter', function(event) {
+					Gritter._restoreItemIfFading($(this), number);
+				});
+				$(item).on('mouseleave', function(event) {
+					Gritter._setFadeTimer($(this), number);
+				});
+			}
+
+			// Clicking (X) makes the perdy thing close
+			$(item).find('.gritter-close').click(function(){
+				Gritter.removeSpecific(number, {}, null, true);
+			});
+
+			return number;
+
+		},
+
+		/**
+		* If we don't have any more gritter notifications, get rid of the wrapper using this check
+		* @private
+		* @param {Integer} unique_id The ID of the element that was just deleted, use it for a callback
+		* @param {Object} e The jQuery element that we're going to perform the remove() action on
+		* @param {Boolean} manual_close Did we close the gritter dialog with the (X) button
+		*/
+		_countRemoveWrapper: function(unique_id, e, manual_close){
+
+			// Remove it then run the callback function
+			e.remove();
+			this['_after_close_' + unique_id](e, manual_close);
+
+			// Remove container if empty
+			$('#gritter-container').each(function() {
+				if ($(this).find('.gritter-item').length == 0) {
+					$(this).remove();
+				}
+			})
+		},
+
+		/**
+		* Fade out an element after it's been on the screen for x amount of time
+		* @private
+		* @param {Object} e The jQuery element to get rid of
+		* @param {Integer} unique_id The id of the element to remove
+		* @param {Object} params An optional list of params.
+		* @param {Boolean} unbind_events Unbind the mouseenter/mouseleave events if they click (X)
+		*/
+		_fade: function(e, unique_id, params, unbind_events){
+
+			var params = params || {},
+				fade = (typeof(params.fade) != 'undefined') ? params.fade : true,
+				manual_close = unbind_events;
+
+			this['_before_close_' + unique_id](e, manual_close);
+
+			// If this is true, then we are coming from clicking the (X)
+			if(unbind_events){
+				e.unbind('mouseenter mouseleave');
+			}
+
+			// Fade it out or remove it
+			if(fade){
+				e.removeClass('popup-show');
+				setTimeout(function() {
+					Gritter._countRemoveWrapper(unique_id, e, manual_close);
+				}, 300)
+			}
+			else {
+
+				this._countRemoveWrapper(unique_id, e);
+
+			}
+
+		},
+
+		/**
+		* Remove a specific notification based on an ID
+		* @param {Integer} unique_id The ID used to delete a specific notification
+		* @param {Object} params A set of options passed in to determine how to get rid of it
+		* @param {Object} e The jQuery element that we're "fading" then removing
+		* @param {Boolean} unbind_events If we clicked on the (X) we set this to true to unbind mouseenter/mouseleave
+		*/
+		removeSpecific: function(unique_id, params, e, unbind_events){
+
+			if(!e){
+				var e = $('#gritter-item-' + unique_id);
+			}
+
+			// We set the fourth param to let the _fade function know to
+			// unbind the "mouseleave" event.  Once you click (X) there's no going back!
+			this._fade(e, unique_id, params || {}, unbind_events);
+
+		},
+
+		/**
+		* If the item is fading out and we hover over it, restore it!
+		* @private
+		* @param {Object} e The HTML element to remove
+		* @param {Integer} unique_id The ID of the element
+		*/
+		_restoreItemIfFading: function(e, unique_id){
+
+			clearTimeout(this['_int_id_' + unique_id]);
+			e.stop().css({ opacity: '', height: '' });
+
+		},
+
+		/**
+		* Setup the global options - only once
+		* @private
+		*/
+		_runSetup: function(){
+
+			for(opt in $.gritter.options){
+				this[opt] = $.gritter.options[opt];
+			}
+			this._is_setup = 1;
+
+		},
+
+		/**
+		* Set the notification to fade out after a certain amount of time
+		* @private
+		* @param {Object} item The HTML element we're dealing with
+		* @param {Integer} unique_id The ID of the element
+		*/
+		_setFadeTimer: function(item, unique_id){
+
+			var timer_str = (this._custom_timer) ? this._custom_timer : this.time;
+			this['_int_id_' + unique_id] = setTimeout(function(){
+				Gritter._fade(item, unique_id);
+			}, timer_str);
+
+		},
+
+		/**
+		* Bring everything to a halt
+		* @param {Object} params A list of callback functions to pass when all notifications are removed
+		*/
+		stop: function(params){
+
+			// callbacks (if passed)
+			var before_close = ($.isFunction(params.before_close)) ? params.before_close : function(){};
+			var after_close = ($.isFunction(params.after_close)) ? params.after_close : function(){};
+
+			var wrap = $('#gritter-container');
+			before_close(wrap);
+			wrap.fadeOut(function(){
+				$(this).remove();
+				after_close();
+			});
+
+		},
+
+		/**
+		* A check to make sure we have something to wrap our notices with
+		* @private
+		*/
+		_verifyWrapper: function(){
+			if ($('#gritter-container.top').length === 0) {
+				$('#editorcontainerbox').append(this._tpl_wrap_top);
+			}
+
+			if ($('#gritter-container.bottom').length === 0) {
+				$('#editorcontainerbox').append(this._tpl_wrap_bottom);
+			}
+		}
+
+	}
+
+})(jQuery);
+
+// For Emacs:
+// Local Variables:
+// tab-width: 2
+// indent-tabs-mode: t
+// End:
+
+// vi: ts=2:noet:sw=2

src/static/js/vendors/nice-select.js

@@ -1,3 +1,6 @@
+// WARNING: This file has been modified from the Original
+// TODO: Nice Select seems relatively abandoned, we should consider other options.
+
 /*  jQuery Nice Select - v1.1.0
     https://github.com/hernansartorio/jquery-nice-select
     Made by Hernán Sartorio  */
@@ -60,14 +63,14 @@
         .addClass($select.attr('class') || '')
         .addClass($select.attr('disabled') ? 'disabled' : '')
         .attr('tabindex', $select.attr('disabled') ? null : '0')
-        .html('<span class="current"></span><ul class="list thin-scrollbar"></ul>')
+        .html('<span class="current"></span><ul class="list"></ul>')
       );
 
       var $dropdown = $select.next();
       var $options = $select.find('option');
       var $selected = $select.find('option:selected');
 
-      $dropdown.find('.current').html($selected.data('display') || $selected.text());
+      $dropdown.find('.current').html($selected.data('display') || $selected.text());
 
       $options.each(function(i) {
         var $option = $(this);
@@ -94,31 +97,12 @@
       var $dropdown = $(this);
 
       $('.nice-select').not($dropdown).removeClass('open');
-
       $dropdown.toggleClass('open');
 
       if ($dropdown.hasClass('open')) {
         $dropdown.find('.option');
         $dropdown.find('.focus').removeClass('focus');
         $dropdown.find('.selected').addClass('focus');
-        if ($dropdown.closest('.toolbar').length > 0) {
-          $dropdown.find('.list').css('left', $dropdown.offset().left);
-          $dropdown.find('.list').css('top', $dropdown.offset().top + $dropdown.outerHeight());
-          $dropdown.find('.list').css('min-width', $dropdown.outerWidth() + 'px');
-        }
-
-        $listHeight = $dropdown.find('.list').outerHeight();
-        $top = $dropdown.parent().offset().top;
-        $bottom = $('body').height() - $top;
-        $maxListHeight = $bottom - $dropdown.outerHeight() - 20;
-        if ($maxListHeight < 200) {
-          $dropdown.addClass('reverse');
-          $maxListHeight = 250;
-        } else {
-          $dropdown.removeClass('reverse')
-        }
-        $dropdown.find('.list').css('max-height', $maxListHeight + 'px');
-
       } else {
         $dropdown.focus();
       }
@@ -206,4 +190,4 @@
 
   };
 
-}(jQuery));
+}(jQuery));

src/static/js/vendors/underscore.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('underscore');