hoodcms 5.0.15 → 5.0.16

package/src/js/admin.js

@@ -1,5 +1,5 @@
 /*!
-* hoodcms v5.0.15
+* hoodcms v5.0.16
 * A fully customisable content management system built in ASP.NET Core 5 & Bootstrap 5.
 * Written by George Whysall, 2022
 * Released under the GPL-3.0 License.
@@ -473,7 +473,7 @@
      * For LGPL see License.txt in the project root for license information.
      * For commercial licenses see https://www.tiny.cloud/
      *
-     * Version: 5.10.2 (2021-11-17)
+     * Version: 5.10.3 (2022-02-09)
      */
 
     (function (module) {
@@ -16762,8 +16762,11 @@
             var children = from(node.childNodes);
             if (contentEditable && !hasContentEditableState) {
               var removed = removeNodeFormat(node);
+              var currentNodeMatches = removed || exists(formatList, function (f) {
+                return matchName$1(dom, node, f);
+              });
               var parentNode = node.parentNode;
-              if (!removed && isNonNullable(parentNode) && shouldExpandToSelector(format)) {
+              if (!currentNodeMatches && isNonNullable(parentNode) && shouldExpandToSelector(format)) {
                 removeNodeFormat(parentNode);
               }
             }
@@ -29471,8 +29474,8 @@
           suffix: null,
           $: DomQuery,
           majorVersion: '5',
-          minorVersion: '10.2',
-          releaseDate: '2021-11-17',
+          minorVersion: '10.3',
+          releaseDate: '2022-02-09',
           editors: legacyEditors,
           i18n: I18n,
           activeEditor: null,
@@ -30978,6 +30981,72 @@
             }.bind(this));
         };
         return MediaService;
+    }());
+    var MediaModal = /** @class */ (function () {
+        function MediaModal() {
+            $('body').on('click', '[data-hood-media=attach],[data-hood-media=select],[data-hood-media=gallery]', this.load.bind(this));
+            $('body').on('click', '[data-hood-media=clear]', this.clear.bind(this));
+            $('[data-hood-media=gallery]').each(this.initGallery.bind(this));
+        }
+        MediaModal.prototype.initGallery = function (index, element) {
+            // setup the gallery list also, just a simple list jobby, and attach it to the 
+            var el = document.getElementById(element.dataset.hoodMediaTarget);
+            if (el) {
+                new DataList(el, {
+                    onComplete: function (data, sender) {
+                        Alerts.log('Finished loading gallery media list.', 'info');
+                    }.bind(this)
+                });
+            }
+        };
+        MediaModal.prototype.load = function (e) {
+            e.preventDefault();
+            e.stopPropagation();
+            this.element = e.currentTarget;
+            if (this.modal && this.modal.isOpen) {
+                return;
+            }
+            this.modal = new ModalController({
+                onComplete: function (sender) {
+                    this.list = document.getElementById('media-list');
+                    this.service = new MediaService(this.list, {
+                        action: this.element.dataset.hoodMedia,
+                        url: this.element.dataset.hoodMediaUrl,
+                        refresh: this.element.dataset.hoodMediaRefresh,
+                        target: this.element.dataset.hoodMediaTarget,
+                        size: this.element.dataset.hoodMediaSize,
+                        beforeAction: function (sender, mediaObject) {
+                        }.bind(this),
+                        onAction: function (sender, mediaObject) {
+                            this.modal.close();
+                        }.bind(this),
+                        onListLoad: function (sender) {
+                        },
+                        onListRender: function (data) {
+                            return data;
+                        },
+                        onListComplete: function (data) {
+                        },
+                        onError: function (jqXHR, textStatus, errorThrown) {
+                        },
+                    });
+                }.bind(this)
+            });
+            this.modal.show($(e.currentTarget).data('hood-media-list'), e.currentTarget);
+        };
+        MediaModal.prototype.clear = function (e) {
+            e.preventDefault();
+            e.stopPropagation();
+            Alerts.confirm({}, function (result) {
+                if (result.isConfirmed) {
+                    Inline.post(e.currentTarget.href, e.currentTarget, function (response) {
+                        Response.process(response, 5000);
+                        MediaService.refresh(response.media, e.currentTarget.dataset.hoodMediaRefresh);
+                    }.bind(this));
+                }
+            }.bind(this));
+        };
+        return MediaModal;
     }());
 
     var Editors = /** @class */ (function () {
@@ -31714,9 +31783,9 @@
     };
 
     /*!
-     * Chart.js v3.6.0
+     * Chart.js v3.7.1
      * https://www.chartjs.org
-     * (c) 2021 Chart.js Contributors
+     * (c) 2022 Chart.js Contributors
      * Released under the MIT License
      */
     const requestAnimFrame = (function() {
@@ -31934,6 +32003,9 @@
       }
       return true;
     };
+    function _isClickEvent(e) {
+      return e.type === 'mouseup' || e.type === 'click' || e.type === 'contextmenu';
+    }
 
     const PI = Math.PI;
     const TAU = 2 * PI;
@@ -32046,6 +32118,9 @@
     function _int16Range(value) {
       return _limitValue(value, -32768, 32767);
     }
+    function _isBetween(value, start, end, epsilon = 1e-6) {
+      return value >= Math.min(start, end) - epsilon && value <= Math.max(start, end) + epsilon;
+    }
 
     const atEdge = (t) => t === 0 || t === 1;
     const elasticIn = (t, s, p) => -(Math.pow(2, 10 * (t -= 1)) * Math.sin((t - s) * TAU / p));
@@ -32755,6 +32830,7 @@
         this.scale = undefined;
         this.scales = {};
         this.showLine = true;
+        this.drawActiveElementsOnTop = true;
         this.describe(_descriptors);
       }
       set(scope, values) {
@@ -33105,7 +33181,7 @@
       }
       return size * value;
     }
-    const numberOrZero$1 = v => +v || 0;
+    const numberOrZero = v => +v || 0;
     function _readValueToProps(value, props) {
       const ret = {};
       const objProps = isObject(props);
@@ -33116,7 +33192,7 @@
           : prop => value[prop]
         : () => value;
       for (const prop of keys) {
-        ret[prop] = numberOrZero$1(read(prop));
+        ret[prop] = numberOrZero(read(prop));
       }
       return ret;
     }
@@ -33323,8 +33399,7 @@
         },
         set(target, prop, value) {
           const storage = target._storage || (target._storage = getTarget());
-          storage[prop] = value;
-          delete target[prop];
+          target[prop] = storage[prop] = value;
           delete target._keys;
           return true;
         }
@@ -33383,7 +33458,8 @@
       };
     }
     const readKey = (prefix, name) => prefix ? prefix + _capitalize(name) : name;
-    const needsSubResolver = (prop, value) => isObject(value) && prop !== 'adapters';
+    const needsSubResolver = (prop, value) => isObject(value) && prop !== 'adapters' &&
+      (Object.getPrototypeOf(value) === null || value.constructor === Object);
     function _cached(target, prop, resolve) {
       if (Object.prototype.hasOwnProperty.call(target, prop)) {
         return target[prop];
@@ -33414,7 +33490,7 @@
       _stack.add(prop);
       value = value(_context, _subProxy || receiver);
       _stack.delete(prop);
-      if (isObject(value)) {
+      if (needsSubResolver(prop, value)) {
         value = createSubResolver(_proxy._scopes, _proxy, prop, value);
       }
       return value;
@@ -33439,12 +33515,12 @@
     }
     const getScope = (key, parent) => key === true ? parent
       : typeof key === 'string' ? resolveObjectKey(parent, key) : undefined;
-    function addScopes(set, parentScopes, key, parentFallback) {
+    function addScopes(set, parentScopes, key, parentFallback, value) {
       for (const parent of parentScopes) {
         const scope = getScope(key, parent);
         if (scope) {
           set.add(scope);
-          const fallback = resolveFallback(scope._fallback, key, scope);
+          const fallback = resolveFallback(scope._fallback, key, value);
           if (defined(fallback) && fallback !== key && fallback !== parentFallback) {
             return fallback;
           }
@@ -33460,12 +33536,12 @@
       const allScopes = [...parentScopes, ...rootScopes];
       const set = new Set();
       set.add(value);
-      let key = addScopesFromKey(set, allScopes, prop, fallback || prop);
+      let key = addScopesFromKey(set, allScopes, prop, fallback || prop, value);
       if (key === null) {
         return false;
       }
       if (defined(fallback) && fallback !== prop) {
-        key = addScopesFromKey(set, allScopes, fallback, key);
+        key = addScopesFromKey(set, allScopes, fallback, key, value);
         if (key === null) {
           return false;
         }
@@ -33473,9 +33549,9 @@
       return _createResolver(Array.from(set), [''], rootScopes, fallback,
         () => subGetTarget(resolver, prop, value));
     }
-    function addScopesFromKey(set, allScopes, key, fallback) {
+    function addScopesFromKey(set, allScopes, key, fallback, item) {
       while (key) {
-        key = addScopes(set, allScopes, key, fallback);
+        key = addScopes(set, allScopes, key, fallback, item);
       }
       return key;
     }
@@ -33966,7 +34042,7 @@
         };
       }
       return {
-        between: (n, s, e) => n >= Math.min(s, e) && n <= Math.max(e, s),
+        between: _isBetween,
         compare: (a, b) => a - b,
         normalize: x => x
       };
@@ -34194,9 +34270,9 @@
     }
 
     /*!
-     * Chart.js v3.6.0
+     * Chart.js v3.7.1
      * https://www.chartjs.org
-     * (c) 2021 Chart.js Contributors
+     * (c) 2022 Chart.js Contributors
      * Released under the MIT License
      */
 
@@ -34919,6 +34995,7 @@
         const scopes = config.getOptionScopes(this.getDataset(), scopeKeys, true);
         this.options = config.createResolver(scopes, this.getContext());
         this._parsing = this.options.parsing;
+        this._cachedDataOpts = {};
       }
       parse(start, count) {
         const {_cachedMeta: meta, _data: data} = this;
@@ -35090,8 +35167,6 @@
       }
       _update(mode) {
         const meta = this._cachedMeta;
-        this.configure();
-        this._cachedDataOpts = {};
         this.update(mode || 'default');
         meta._clip = toClip(valueOrDefault(this.options.clip, defaultClip(meta.xScale, meta.yScale, this.getMaxOverflow())));
       }
@@ -35105,6 +35180,7 @@
         const active = [];
         const start = this._drawStart || 0;
         const count = this._drawCount || (elements.length - start);
+        const drawActiveElementsOnTop = this.options.drawActiveElementsOnTop;
         let i;
         if (meta.dataset) {
           meta.dataset.draw(ctx, area, start, count);
@@ -35114,7 +35190,7 @@
           if (element.hidden) {
             continue;
           }
-          if (element.active) {
+          if (element.active && drawActiveElementsOnTop) {
             active.push(element);
           } else {
             element.draw(ctx, area);
@@ -35305,6 +35381,7 @@
           const [method, arg1, arg2] = args;
           this[method](arg1, arg2);
         }
+        this.chart._dataChanges.push([this.index, ...args]);
       }
       _onDataPush() {
         const count = arguments.length;
@@ -35317,8 +35394,13 @@
         this._sync(['_removeElements', 0, 1]);
       }
       _onDataSplice(start, count) {
-        this._sync(['_removeElements', start, count]);
-        this._sync(['_insertElements', start, arguments.length - 2]);
+        if (count) {
+          this._sync(['_removeElements', start, count]);
+        }
+        const newCount = arguments.length - 2;
+        if (newCount) {
+          this._sync(['_insertElements', start, newCount]);
+        }
       }
       _onDataUnshift() {
         this._sync(['_insertElements', 0, arguments.length]);
@@ -36098,9 +36180,6 @@
               meta = chart.getDatasetMeta(i);
               arcs = meta.data;
               controller = meta.controller;
-              if (controller !== this) {
-                controller.configure();
-              }
               break;
             }
           }
@@ -36705,7 +36784,7 @@
     function binarySearch(metaset, axis, value, intersect) {
       const {controller, data, _sorted} = metaset;
       const iScale = controller._cachedMeta.iScale;
-      if (iScale && axis === iScale.axis && _sorted && data.length) {
+      if (iScale && axis === iScale.axis && axis !== 'r' && _sorted && data.length) {
         const lookupMethod = iScale._reversePixels ? _rlookupByKey : _lookupByKey;
         if (!intersect) {
           return lookupMethod(data, axis, value);
@@ -36757,19 +36836,30 @@
       optimizedEvaluateItems(chart, axis, position, evaluationFunc, true);
       return items;
     }
-    function getNearestItems(chart, position, axis, intersect, useFinalPosition) {
-      const distanceMetric = getDistanceMetricForAxis(axis);
-      let minDistance = Number.POSITIVE_INFINITY;
+    function getNearestRadialItems(chart, position, axis, useFinalPosition) {
       let items = [];
-      if (!_isPointInArea(position, chart.chartArea, chart._minPadding)) {
-        return items;
+      function evaluationFunc(element, datasetIndex, index) {
+        const {startAngle, endAngle} = element.getProps(['startAngle', 'endAngle'], useFinalPosition);
+        const {angle} = getAngleFromPoint(element, {x: position.x, y: position.y});
+        if (_angleBetween(angle, startAngle, endAngle)) {
+          items.push({element, datasetIndex, index});
+        }
       }
-      const evaluationFunc = function(element, datasetIndex, index) {
-        if (intersect && !element.inRange(position.x, position.y, useFinalPosition)) {
+      optimizedEvaluateItems(chart, axis, position, evaluationFunc);
+      return items;
+    }
+    function getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition) {
+      let items = [];
+      const distanceMetric = getDistanceMetricForAxis(axis);
+      let minDistance = Number.POSITIVE_INFINITY;
+      function evaluationFunc(element, datasetIndex, index) {
+        const inRange = element.inRange(position.x, position.y, useFinalPosition);
+        if (intersect && !inRange) {
           return;
         }
         const center = element.getCenterPoint(useFinalPosition);
-        if (!_isPointInArea(center, chart.chartArea, chart._minPadding) && !element.inRange(position.x, position.y, useFinalPosition)) {
+        const pointInArea = _isPointInArea(center, chart.chartArea, chart._minPadding);
+        if (!pointInArea && !inRange) {
           return;
         }
         const distance = distanceMetric(position, center);
@@ -36779,10 +36869,18 @@
         } else if (distance === minDistance) {
           items.push({element, datasetIndex, index});
         }
-      };
+      }
       optimizedEvaluateItems(chart, axis, position, evaluationFunc);
       return items;
     }
+    function getNearestItems(chart, position, axis, intersect, useFinalPosition) {
+      if (!_isPointInArea(position, chart.chartArea, chart._minPadding)) {
+        return [];
+      }
+      return axis === 'r' && !intersect
+        ? getNearestRadialItems(chart, position, axis, useFinalPosition)
+        : getNearestCartesianItems(chart, position, axis, intersect, useFinalPosition);
+    }
     function getAxisItems(chart, e, options, useFinalPosition) {
       const position = getRelativePosition(e, chart);
       const items = [];
@@ -36850,12 +36948,10 @@
           return getNearestItems(chart, position, axis, options.intersect, useFinalPosition);
         },
         x(chart, e, options, useFinalPosition) {
-          options.axis = 'x';
-          return getAxisItems(chart, e, options, useFinalPosition);
+          return getAxisItems(chart, e, {axis: 'x', intersect: options.intersect}, useFinalPosition);
         },
         y(chart, e, options, useFinalPosition) {
-          options.axis = 'y';
-          return getAxisItems(chart, e, options, useFinalPosition);
+          return getAxisItems(chart, e, {axis: 'y', intersect: options.intersect}, useFinalPosition);
         }
       }
     };
@@ -37166,7 +37262,7 @@
         each(boxes.chartArea, (layout) => {
           const box = layout.box;
           Object.assign(box, chart.chartArea);
-          box.update(chartArea.w, chartArea.h);
+          box.update(chartArea.w, chartArea.h, {left: 0, top: 0, right: 0, bottom: 0});
         });
       }
     };
@@ -37271,15 +37367,23 @@
         y: y !== undefined ? y : null,
       };
     }
+    function nodeListContains(nodeList, canvas) {
+      for (const node of nodeList) {
+        if (node === canvas || node.contains(canvas)) {
+          return true;
+        }
+      }
+    }
     function createAttachObserver(chart, type, listener) {
       const canvas = chart.canvas;
       const observer = new MutationObserver(entries => {
+        let trigger = false;
         for (const entry of entries) {
-          for (const node of entry.addedNodes) {
-            if (node === canvas || node.contains(canvas)) {
-              return listener();
-            }
-          }
+          trigger = trigger || nodeListContains(entry.addedNodes, canvas);
+          trigger = trigger && !nodeListContains(entry.removedNodes, canvas);
+        }
+        if (trigger) {
+          listener();
         }
       });
       observer.observe(document, {childList: true, subtree: true});
@@ -37288,12 +37392,13 @@
     function createDetachObserver(chart, type, listener) {
       const canvas = chart.canvas;
       const observer = new MutationObserver(entries => {
+        let trigger = false;
         for (const entry of entries) {
-          for (const node of entry.removedNodes) {
-            if (node === canvas || node.contains(canvas)) {
-              return listener();
-            }
-          }
+          trigger = trigger || nodeListContains(entry.removedNodes, canvas);
+          trigger = trigger && !nodeListContains(entry.addedNodes, canvas);
+        }
+        if (trigger) {
+          listener();
         }
       });
       observer.observe(document, {childList: true, subtree: true});
@@ -39059,7 +39164,7 @@
         }
         const descriptors = filter ? this._descriptors(chart).filter(filter) : this._descriptors(chart);
         const result = this._notify(descriptors, chart, hook, args);
-        if (hook === 'destroy') {
+        if (hook === 'afterDestroy') {
           this._notify(descriptors, chart, 'stop');
           this._notify(this._init, chart, 'uninstall');
         }
@@ -39435,7 +39540,7 @@
       return false;
     }
 
-    var version = "3.6.0";
+    var version = "3.7.1";
 
     const KNOWN_POSITIONS = ['top', 'bottom', 'left', 'right', 'chartArea'];
     function positionIsHorizontal(position, axis) {
@@ -39475,6 +39580,28 @@
       const canvas = getCanvas(key);
       return Object.values(instances).filter((c) => c.canvas === canvas).pop();
     };
+    function moveNumericKeys(obj, start, move) {
+      const keys = Object.keys(obj);
+      for (const key of keys) {
+        const intKey = +key;
+        if (intKey >= start) {
+          const value = obj[key];
+          delete obj[key];
+          if (move > 0 || intKey > start) {
+            obj[intKey + move] = value;
+          }
+        }
+      }
+    }
+    function determineLastEvent(e, lastEvent, inChartArea, isClick) {
+      if (!inChartArea || e.type === 'mouseout') {
+        return null;
+      }
+      if (isClick) {
+        return lastEvent;
+      }
+      return e;
+    }
     class Chart {
       constructor(item, userConfig) {
         const config = this.config = new Config(userConfig);
@@ -39519,6 +39646,7 @@
         this._animationsDisabled = undefined;
         this.$context = undefined;
         this._doResize = debounce(mode => this.update(mode), options.resizeDelay || 0);
+        this._dataChanges = [];
         instances[this.id] = this;
         if (!context || !canvas) {
           console.error("Failed to create chart: can't acquire context from the given item");
@@ -39738,18 +39866,10 @@
         const config = this.config;
         config.update();
         const options = this._options = config.createResolver(config.chartOptionScopes(), this.getContext());
-        each(this.scales, (scale) => {
-          layouts.removeBox(this, scale);
-        });
         const animsDisabled = this._animationsDisabled = !options.animation;
-        this.ensureScalesHaveIDs();
-        this.buildOrUpdateScales();
-        const existingEvents = new Set(Object.keys(this._listeners));
-        const newEvents = new Set(options.events);
-        if (!setsEqual(existingEvents, newEvents) || !!this._responsiveListeners !== options.responsive) {
-          this.unbindEvents();
-          this.bindEvents();
-        }
+        this._updateScales();
+        this._checkEventBindings();
+        this._updateHiddenIndices();
         this._plugins.invalidate();
         if (this.notifyPlugins('beforeUpdate', {mode, cancelable: true}) === false) {
           return;
@@ -39773,11 +39893,60 @@
         this._updateDatasets(mode);
         this.notifyPlugins('afterUpdate', {mode});
         this._layers.sort(compare2Level('z', '_idx'));
-        if (this._lastEvent) {
-          this._eventHandler(this._lastEvent, true);
+        const {_active, _lastEvent} = this;
+        if (_lastEvent) {
+          this._eventHandler(_lastEvent, true);
+        } else if (_active.length) {
+          this._updateHoverStyles(_active, _active, true);
         }
         this.render();
       }
+      _updateScales() {
+        each(this.scales, (scale) => {
+          layouts.removeBox(this, scale);
+        });
+        this.ensureScalesHaveIDs();
+        this.buildOrUpdateScales();
+      }
+      _checkEventBindings() {
+        const options = this.options;
+        const existingEvents = new Set(Object.keys(this._listeners));
+        const newEvents = new Set(options.events);
+        if (!setsEqual(existingEvents, newEvents) || !!this._responsiveListeners !== options.responsive) {
+          this.unbindEvents();
+          this.bindEvents();
+        }
+      }
+      _updateHiddenIndices() {
+        const {_hiddenIndices} = this;
+        const changes = this._getUniformDataChanges() || [];
+        for (const {method, start, count} of changes) {
+          const move = method === '_removeElements' ? -count : count;
+          moveNumericKeys(_hiddenIndices, start, move);
+        }
+      }
+      _getUniformDataChanges() {
+        const _dataChanges = this._dataChanges;
+        if (!_dataChanges || !_dataChanges.length) {
+          return;
+        }
+        this._dataChanges = [];
+        const datasetCount = this.data.datasets.length;
+        const makeSet = (idx) => new Set(
+          _dataChanges
+            .filter(c => c[0] === idx)
+            .map((c, i) => i + ',' + c.splice(1).join(','))
+        );
+        const changeSet = makeSet(0);
+        for (let i = 1; i < datasetCount; i++) {
+          if (!setsEqual(changeSet, makeSet(i))) {
+            return;
+          }
+        }
+        return Array.from(changeSet)
+          .map(c => c.split(','))
+          .map(a => ({method: a[1], start: +a[2], count: +a[3]}));
+      }
       _updateLayout(minPadding) {
         if (this.notifyPlugins('beforeLayout', {cancelable: true}) === false) {
           return;
@@ -39804,6 +39973,9 @@
         if (this.notifyPlugins('beforeDatasetsUpdate', {mode, cancelable: true}) === false) {
           return;
         }
+        for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {
+          this.getDatasetMeta(i).controller.configure();
+        }
         for (let i = 0, ilen = this.data.datasets.length; i < ilen; ++i) {
           this._updateDataset(i, isFunction(mode) ? mode({datasetIndex: i}) : mode);
         }
@@ -39998,6 +40170,7 @@
         }
       }
       destroy() {
+        this.notifyPlugins('beforeDestroy');
         const {canvas, ctx} = this;
         this._stop();
         this.config.clearCache();
@@ -40010,6 +40183,7 @@
         }
         this.notifyPlugins('destroy');
         delete instances[this.id];
+        this.notifyPlugins('afterDestroy');
       }
       toBase64Image(...args) {
         return this.canvas.toDataURL(...args);
@@ -40122,6 +40296,7 @@
         const changed = !_elementsEqual(active, lastActive);
         if (changed) {
           this._active = active;
+          this._lastEvent = null;
           this._updateHoverStyles(active, lastActive);
         }
       }
@@ -40141,12 +40316,17 @@
         }
       }
       _eventHandler(e, replay) {
-        const args = {event: e, replay, cancelable: true};
+        const args = {
+          event: e,
+          replay,
+          cancelable: true,
+          inChartArea: _isPointInArea(e, this.chartArea, this._minPadding)
+        };
         const eventFilter = (plugin) => (plugin.options.events || this.options.events).includes(e.native.type);
         if (this.notifyPlugins('beforeEvent', args, eventFilter) === false) {
           return;
         }
-        const changed = this._handleEvent(e, replay);
+        const changed = this._handleEvent(e, replay, args.inChartArea);
         args.cancelable = false;
         this.notifyPlugins('afterEvent', args, eventFilter);
         if (changed || args.changed) {
@@ -40154,25 +40334,20 @@
         }
         return this;
       }
-      _handleEvent(e, replay) {
+      _handleEvent(e, replay, inChartArea) {
         const {_active: lastActive = [], options} = this;
-        const hoverOptions = options.hover;
         const useFinalPosition = replay;
-        let active = [];
-        let changed = false;
-        let lastEvent = null;
-        if (e.type !== 'mouseout') {
-          active = this.getElementsAtEventForMode(e, hoverOptions.mode, hoverOptions, useFinalPosition);
-          lastEvent = e.type === 'click' ? this._lastEvent : e;
-        }
-        this._lastEvent = null;
-        if (_isPointInArea(e, this.chartArea, this._minPadding)) {
+        const active = this._getActiveElements(e, lastActive, inChartArea, useFinalPosition);
+        const isClick = _isClickEvent(e);
+        const lastEvent = determineLastEvent(e, this._lastEvent, inChartArea, isClick);
+        if (inChartArea) {
+          this._lastEvent = null;
           callback(options.onHover, [e, active, this], this);
-          if (e.type === 'mouseup' || e.type === 'click' || e.type === 'contextmenu') {
+          if (isClick) {
             callback(options.onClick, [e, active, this], this);
           }
         }
-        changed = !_elementsEqual(active, lastActive);
+        const changed = !_elementsEqual(active, lastActive);
         if (changed || replay) {
           this._active = active;
           this._updateHoverStyles(active, lastActive, replay);
@@ -40180,6 +40355,16 @@
         this._lastEvent = lastEvent;
         return changed;
       }
+      _getActiveElements(e, lastActive, inChartArea, useFinalPosition) {
+        if (e.type === 'mouseout') {
+          return [];
+        }
+        if (!inChartArea) {
+          return lastActive;
+        }
+        const hoverOptions = this.options.hover;
+        return this.getElementsAtEventForMode(e, hoverOptions.mode, hoverOptions, useFinalPosition);
+      }
     }
     const invalidatePlugins = () => each(Chart.instances, (chart) => chart._plugins.invalidate());
     const enumerable = true;
@@ -40353,16 +40538,17 @@
     }
     function drawBorder(ctx, element, offset, spacing, endAngle) {
       const {options} = element;
+      const {borderWidth, borderJoinStyle} = options;
       const inner = options.borderAlign === 'inner';
-      if (!options.borderWidth) {
+      if (!borderWidth) {
         return;
       }
       if (inner) {
-        ctx.lineWidth = options.borderWidth * 2;
-        ctx.lineJoin = 'round';
+        ctx.lineWidth = borderWidth * 2;
+        ctx.lineJoin = borderJoinStyle || 'round';
       } else {
-        ctx.lineWidth = options.borderWidth;
-        ctx.lineJoin = 'bevel';
+        ctx.lineWidth = borderWidth;
+        ctx.lineJoin = borderJoinStyle || 'bevel';
       }
       if (element.fullCircles) {
         drawFullCircleBorders(ctx, element, inner);
@@ -40399,8 +40585,9 @@
           'circumference'
         ], useFinalPosition);
         const rAdjust = this.options.spacing / 2;
-        const betweenAngles = circumference >= TAU || _angleBetween(angle, startAngle, endAngle);
-        const withinRadius = (distance >= innerRadius + rAdjust && distance <= outerRadius + rAdjust);
+        const _circumference = valueOrDefault(circumference, endAngle - startAngle);
+        const betweenAngles = _circumference >= TAU || _angleBetween(angle, startAngle, endAngle);
+        const withinRadius = _isBetween(distance, innerRadius + rAdjust, outerRadius + rAdjust);
         return (betweenAngles && withinRadius);
       }
       getCenterPoint(useFinalPosition) {
@@ -40454,6 +40641,7 @@
     ArcElement.defaults = {
       borderAlign: 'center',
       borderColor: '#fff',
+      borderJoinStyle: undefined,
       borderRadius: 0,
       borderWidth: 2,
       offset: 0,
@@ -40888,8 +41076,8 @@
       const skipBoth = skipX && skipY;
       const bounds = bar && !skipBoth && getBarBounds(bar, useFinalPosition);
       return bounds
-    		&& (skipX || x >= bounds.left && x <= bounds.right)
-    		&& (skipY || y >= bounds.top && y <= bounds.bottom);
+    		&& (skipX || _isBetween(x, bounds.left, bounds.right))
+    		&& (skipY || _isBetween(y, bounds.top, bounds.bottom));
     }
     function hasRadius(radius) {
       return radius.topLeft || radius.topRight || radius.bottomLeft || radius.bottomRight;
@@ -41061,7 +41249,7 @@
       };
     }
     function getTooltipSize(tooltip, options) {
-      const ctx = tooltip._chart.ctx;
+      const ctx = tooltip.chart.ctx;
       const {body, footer, title} = tooltip;
       const {boxWidth, boxHeight} = options;
       const bodyFont = toFont(options.bodyFont);
@@ -41149,9 +41337,9 @@
       return xAlign;
     }
     function determineAlignment(chart, options, size) {
-      const yAlign = options.yAlign || determineYAlign(chart, size);
+      const yAlign = size.yAlign || options.yAlign || determineYAlign(chart, size);
       return {
-        xAlign: options.xAlign || determineXAlign(chart, options, size, yAlign),
+        xAlign: size.xAlign || options.xAlign || determineXAlign(chart, options, size, yAlign),
         yAlign
       };
     }
@@ -41189,9 +41377,9 @@
           x -= paddingAndSize;
         }
       } else if (xAlign === 'left') {
-        x -= Math.max(topLeft, bottomLeft) + caretPadding;
+        x -= Math.max(topLeft, bottomLeft) + caretSize;
       } else if (xAlign === 'right') {
-        x += Math.max(topRight, bottomRight) + caretPadding;
+        x += Math.max(topRight, bottomRight) + caretSize;
       }
       return {
         x: _limitValue(x, 0, chart.width - size.width),
@@ -41225,13 +41413,14 @@
         super();
         this.opacity = 0;
         this._active = [];
-        this._chart = config._chart;
         this._eventPosition = undefined;
         this._size = undefined;
         this._cachedAnimations = undefined;
         this._tooltipItems = [];
         this.$animations = undefined;
         this.$context = undefined;
+        this.chart = config.chart || config._chart;
+        this._chart = this.chart;
         this.options = config.options;
         this.dataPoints = undefined;
         this.title = undefined;
@@ -41261,10 +41450,10 @@
         if (cached) {
           return cached;
         }
-        const chart = this._chart;
+        const chart = this.chart;
         const options = this.options.setContext(this.getContext());
         const opts = options.enabled && chart.options.animation && options.animations;
-        const animations = new Animations(this._chart, opts);
+        const animations = new Animations(this.chart, opts);
         if (opts._cacheable) {
           this._cachedAnimations = Object.freeze(animations);
         }
@@ -41272,7 +41461,7 @@
       }
       getContext() {
         return this.$context ||
-    			(this.$context = createTooltipContext(this._chart.getContext(), this, this._tooltipItems));
+    			(this.$context = createTooltipContext(this.chart.getContext(), this, this._tooltipItems));
       }
       getTitle(context, options) {
         const {callbacks} = options;
@@ -41321,14 +41510,14 @@
       }
       _createItems(options) {
         const active = this._active;
-        const data = this._chart.data;
+        const data = this.chart.data;
         const labelColors = [];
         const labelPointStyles = [];
         const labelTextColors = [];
         let tooltipItems = [];
         let i, len;
         for (i = 0, len = active.length; i < len; ++i) {
-          tooltipItems.push(createTooltipItem(this._chart, active[i]));
+          tooltipItems.push(createTooltipItem(this.chart, active[i]));
         }
         if (options.filter) {
           tooltipItems = tooltipItems.filter((element, index, array) => options.filter(element, index, array, data));
@@ -41369,8 +41558,8 @@
           this.footer = this.getFooter(tooltipItems, options);
           const size = this._size = getTooltipSize(this, options);
           const positionAndSize = Object.assign({}, position, size);
-          const alignment = determineAlignment(this._chart, options, positionAndSize);
-          const backgroundPoint = getBackgroundPoint(options, positionAndSize, alignment, this._chart);
+          const alignment = determineAlignment(this.chart, options, positionAndSize);
+          const backgroundPoint = getBackgroundPoint(options, positionAndSize, alignment, this.chart);
           this.xAlign = alignment.xAlign;
           this.yAlign = alignment.yAlign;
           properties = {
@@ -41389,7 +41578,7 @@
           this._resolveAnimations().update(this, properties);
         }
         if (changed && options.external) {
-          options.external.call(this, {chart: this._chart, tooltip: this, replay});
+          options.external.call(this, {chart: this.chart, tooltip: this, replay});
         }
       }
       drawCaret(tooltipPoint, ctx, size, options) {
@@ -41627,7 +41816,7 @@
         }
       }
       _updateAnimationTarget(options) {
-        const chart = this._chart;
+        const chart = this.chart;
         const anims = this.$animations;
         const animX = anims && anims.x;
         const animY = anims && anims.y;
@@ -41688,7 +41877,7 @@
       setActiveElements(activeElements, eventPosition) {
         const lastActive = this._active;
         const active = activeElements.map(({datasetIndex, index}) => {
-          const meta = this._chart.getDatasetMeta(datasetIndex);
+          const meta = this.chart.getDatasetMeta(datasetIndex);
           if (!meta) {
             throw new Error('Cannot find a dataset at index ' + datasetIndex);
           }
@@ -41703,22 +41892,20 @@
         if (changed || positionChanged) {
           this._active = active;
           this._eventPosition = eventPosition;
+          this._ignoreReplayEvents = true;
           this.update(true);
         }
       }
-      handleEvent(e, replay) {
+      handleEvent(e, replay, inChartArea = true) {
+        if (replay && this._ignoreReplayEvents) {
+          return false;
+        }
+        this._ignoreReplayEvents = false;
         const options = this.options;
         const lastActive = this._active || [];
-        let changed = false;
-        let active = [];
-        if (e.type !== 'mouseout') {
-          active = this._chart.getElementsAtEventForMode(e, options.mode, options, replay);
-          if (options.reverse) {
-            active.reverse();
-          }
-        }
+        const active = this._getActiveElements(e, lastActive, replay, inChartArea);
         const positionChanged = this._positionChanged(active, e);
-        changed = replay || !_elementsEqual(active, lastActive) || positionChanged;
+        const changed = replay || !_elementsEqual(active, lastActive) || positionChanged;
         if (changed) {
           this._active = active;
           if (options.enabled || options.external) {
@@ -41731,6 +41918,20 @@
         }
         return changed;
       }
+      _getActiveElements(e, lastActive, replay, inChartArea) {
+        const options = this.options;
+        if (e.type === 'mouseout') {
+          return [];
+        }
+        if (!inChartArea) {
+          return lastActive;
+        }
+        const active = this.chart.getElementsAtEventForMode(e, options.mode, options, replay);
+        if (options.reverse) {
+          active.reverse();
+        }
+        return active;
+      }
       _positionChanged(active, e) {
         const {caretX, caretY, options} = this;
         const position = positioners[options.position].call(this, active, e);
@@ -41739,13 +41940,19 @@
     }
     Tooltip.positioners = positioners;
 
-    const addIfString = (labels, raw, index) => typeof raw === 'string'
-      ? labels.push(raw) - 1
-      : isNaN(raw) ? null : index;
-    function findOrAddLabel(labels, raw, index) {
+    const addIfString = (labels, raw, index, addedLabels) => {
+      if (typeof raw === 'string') {
+        index = labels.push(raw) - 1;
+        addedLabels.unshift({index, label: raw});
+      } else if (isNaN(raw)) {
+        index = null;
+      }
+      return index;
+    };
+    function findOrAddLabel(labels, raw, index, addedLabels) {
       const first = labels.indexOf(raw);
       if (first === -1) {
-        return addIfString(labels, raw, index);
+        return addIfString(labels, raw, index, addedLabels);
       }
       const last = labels.lastIndexOf(raw);
       return first !== last ? index : first;
@@ -41756,6 +41963,20 @@
         super(cfg);
         this._startValue = undefined;
         this._valueRange = 0;
+        this._addedLabels = [];
+      }
+      init(scaleOptions) {
+        const added = this._addedLabels;
+        if (added.length) {
+          const labels = this.getLabels();
+          for (const {index, label} of added) {
+            if (labels[index] === label) {
+              labels.splice(index, 1);
+            }
+          }
+          this._addedLabels = [];
+        }
+        super.init(scaleOptions);
       }
       parse(raw, index) {
         if (isNullOrUndef(raw)) {
@@ -41763,7 +41984,7 @@
         }
         const labels = this.getLabels();
         index = isFinite(index) && labels[index] === raw ? index
-          : findOrAddLabel(labels, raw, valueOrDefault(index, raw));
+          : findOrAddLabel(labels, raw, valueOrDefault(index, raw), this._addedLabels);
         return validIndex(index, labels.length - 1);
       }
       determineDataLimits() {
@@ -42040,7 +42261,7 @@
         this._valueRange = end - start;
       }
       getLabelForValue(value) {
-        return formatNumber(value, this.chart.options.locale);
+        return formatNumber(value, this.chart.options.locale, this.options.ticks.format);
       }
     }
 
@@ -42173,7 +42394,9 @@
         return ticks;
       }
       getLabelForValue(value) {
-        return value === undefined ? '0' : formatNumber(value, this.chart.options.locale);
+        return value === undefined
+          ? '0'
+          : formatNumber(value, this.chart.options.locale, this.options.ticks.format);
       }
       configure() {
         const start = this.min;
@@ -42240,57 +42463,69 @@
       };
     }
     function fitWithPointLabels(scale) {
-      const furthestLimits = {
-        l: 0,
-        r: scale.width,
-        t: 0,
-        b: scale.height - scale.paddingTop
+      const orig = {
+        l: scale.left + scale._padding.left,
+        r: scale.right - scale._padding.right,
+        t: scale.top + scale._padding.top,
+        b: scale.bottom - scale._padding.bottom
       };
-      const furthestAngles = {};
+      const limits = Object.assign({}, orig);
       const labelSizes = [];
       const padding = [];
-      const valueCount = scale.getLabels().length;
+      const valueCount = scale._pointLabels.length;
+      const pointLabelOpts = scale.options.pointLabels;
+      const additionalAngle = pointLabelOpts.centerPointLabels ? PI / valueCount : 0;
       for (let i = 0; i < valueCount; i++) {
-        const opts = scale.options.pointLabels.setContext(scale.getPointLabelContext(i));
+        const opts = pointLabelOpts.setContext(scale.getPointLabelContext(i));
         padding[i] = opts.padding;
-        const pointPosition = scale.getPointPosition(i, scale.drawingArea + padding[i]);
+        const pointPosition = scale.getPointPosition(i, scale.drawingArea + padding[i], additionalAngle);
         const plFont = toFont(opts.font);
         const textSize = measureLabelSize(scale.ctx, plFont, scale._pointLabels[i]);
         labelSizes[i] = textSize;
-        const angleRadians = scale.getIndexAngle(i);
-        const angle = toDegrees(angleRadians);
+        const angleRadians = _normalizeAngle(scale.getIndexAngle(i) + additionalAngle);
+        const angle = Math.round(toDegrees(angleRadians));
         const hLimits = determineLimits(angle, pointPosition.x, textSize.w, 0, 180);
         const vLimits = determineLimits(angle, pointPosition.y, textSize.h, 90, 270);
-        if (hLimits.start < furthestLimits.l) {
-          furthestLimits.l = hLimits.start;
-          furthestAngles.l = angleRadians;
-        }
-        if (hLimits.end > furthestLimits.r) {
-          furthestLimits.r = hLimits.end;
-          furthestAngles.r = angleRadians;
-        }
-        if (vLimits.start < furthestLimits.t) {
-          furthestLimits.t = vLimits.start;
-          furthestAngles.t = angleRadians;
-        }
-        if (vLimits.end > furthestLimits.b) {
-          furthestLimits.b = vLimits.end;
-          furthestAngles.b = angleRadians;
-        }
+        updateLimits(limits, orig, angleRadians, hLimits, vLimits);
       }
-      scale._setReductions(scale.drawingArea, furthestLimits, furthestAngles);
+      scale.setCenterPoint(
+        orig.l - limits.l,
+        limits.r - orig.r,
+        orig.t - limits.t,
+        limits.b - orig.b
+      );
       scale._pointLabelItems = buildPointLabelItems(scale, labelSizes, padding);
     }
+    function updateLimits(limits, orig, angle, hLimits, vLimits) {
+      const sin = Math.abs(Math.sin(angle));
+      const cos = Math.abs(Math.cos(angle));
+      let x = 0;
+      let y = 0;
+      if (hLimits.start < orig.l) {
+        x = (orig.l - hLimits.start) / sin;
+        limits.l = Math.min(limits.l, orig.l - x);
+      } else if (hLimits.end > orig.r) {
+        x = (hLimits.end - orig.r) / sin;
+        limits.r = Math.max(limits.r, orig.r + x);
+      }
+      if (vLimits.start < orig.t) {
+        y = (orig.t - vLimits.start) / cos;
+        limits.t = Math.min(limits.t, orig.t - y);
+      } else if (vLimits.end > orig.b) {
+        y = (vLimits.end - orig.b) / cos;
+        limits.b = Math.max(limits.b, orig.b + y);
+      }
+    }
     function buildPointLabelItems(scale, labelSizes, padding) {
       const items = [];
-      const valueCount = scale.getLabels().length;
+      const valueCount = scale._pointLabels.length;
       const opts = scale.options;
-      const tickBackdropHeight = getTickBackdropHeight(opts);
-      const outerDistance = scale.getDistanceFromCenterForValue(opts.ticks.reverse ? scale.min : scale.max);
+      const extra = getTickBackdropHeight(opts) / 2;
+      const outerDistance = scale.drawingArea;
+      const additionalAngle = opts.pointLabels.centerPointLabels ? PI / valueCount : 0;
       for (let i = 0; i < valueCount; i++) {
-        const extra = (i === 0 ? tickBackdropHeight / 2 : 0);
-        const pointLabelPosition = scale.getPointPosition(i, outerDistance + extra + padding[i]);
-        const angle = toDegrees(scale.getIndexAngle(i));
+        const pointLabelPosition = scale.getPointPosition(i, outerDistance + extra + padding[i], additionalAngle);
+        const angle = Math.round(toDegrees(_normalizeAngle(pointLabelPosition.angle + HALF_PI)));
         const size = labelSizes[i];
         const y = yForAngle(pointLabelPosition.y, size.h, angle);
         const textAlign = getTextAlignForAngle(angle);
@@ -42388,9 +42623,6 @@
       ctx.stroke();
       ctx.restore();
     }
-    function numberOrZero(param) {
-      return isNumber(param) ? param : 0;
-    }
     function createPointLabelContext(parent, index, label) {
       return createContext(parent, {
         label,
@@ -42408,12 +42640,12 @@
         this._pointLabelItems = [];
       }
       setDimensions() {
-        this.width = this.maxWidth;
-        this.height = this.maxHeight;
-        this.paddingTop = getTickBackdropHeight(this.options) / 2;
-        this.xCenter = Math.floor(this.width / 2);
-        this.yCenter = Math.floor((this.height - this.paddingTop) / 2);
-        this.drawingArea = Math.min(this.height - this.paddingTop, this.width) / 2;
+        const padding = this._padding = toPadding(getTickBackdropHeight(this.options) / 2);
+        const w = this.width = this.maxWidth - padding.width;
+        const h = this.height = this.maxHeight - padding.height;
+        this.xCenter = Math.floor(this.left + w / 2 + padding.left);
+        this.yCenter = Math.floor(this.top + h / 2 + padding.top);
+        this.drawingArea = Math.floor(Math.min(w, h) / 2);
       }
       determineDataLimits() {
         const {min, max} = this.getMinMax(false);
@@ -42426,10 +42658,12 @@
       }
       generateTickLabels(ticks) {
         LinearScaleBase.prototype.generateTickLabels.call(this, ticks);
-        this._pointLabels = this.getLabels().map((value, index) => {
-          const label = callback(this.options.pointLabels.callback, [value, index], this);
-          return label || label === 0 ? label : '';
-        });
+        this._pointLabels = this.getLabels()
+          .map((value, index) => {
+            const label = callback(this.options.pointLabels.callback, [value, index], this);
+            return label || label === 0 ? label : '';
+          })
+          .filter((v, i) => this.chart.getDataVisibility(i));
       }
       fit() {
         const opts = this.options;
@@ -42439,30 +42673,13 @@
           this.setCenterPoint(0, 0, 0, 0);
         }
       }
-      _setReductions(largestPossibleRadius, furthestLimits, furthestAngles) {
-        let radiusReductionLeft = furthestLimits.l / Math.sin(furthestAngles.l);
-        let radiusReductionRight = Math.max(furthestLimits.r - this.width, 0) / Math.sin(furthestAngles.r);
-        let radiusReductionTop = -furthestLimits.t / Math.cos(furthestAngles.t);
-        let radiusReductionBottom = -Math.max(furthestLimits.b - (this.height - this.paddingTop), 0) / Math.cos(furthestAngles.b);
-        radiusReductionLeft = numberOrZero(radiusReductionLeft);
-        radiusReductionRight = numberOrZero(radiusReductionRight);
-        radiusReductionTop = numberOrZero(radiusReductionTop);
-        radiusReductionBottom = numberOrZero(radiusReductionBottom);
-        this.drawingArea = Math.max(largestPossibleRadius / 2, Math.min(
-          Math.floor(largestPossibleRadius - (radiusReductionLeft + radiusReductionRight) / 2),
-          Math.floor(largestPossibleRadius - (radiusReductionTop + radiusReductionBottom) / 2)));
-        this.setCenterPoint(radiusReductionLeft, radiusReductionRight, radiusReductionTop, radiusReductionBottom);
-      }
       setCenterPoint(leftMovement, rightMovement, topMovement, bottomMovement) {
-        const maxRight = this.width - rightMovement - this.drawingArea;
-        const maxLeft = leftMovement + this.drawingArea;
-        const maxTop = topMovement + this.drawingArea;
-        const maxBottom = (this.height - this.paddingTop) - bottomMovement - this.drawingArea;
-        this.xCenter = Math.floor(((maxLeft + maxRight) / 2) + this.left);
-        this.yCenter = Math.floor(((maxTop + maxBottom) / 2) + this.top + this.paddingTop);
+        this.xCenter += Math.floor((leftMovement - rightMovement) / 2);
+        this.yCenter += Math.floor((topMovement - bottomMovement) / 2);
+        this.drawingArea -= Math.min(this.drawingArea / 2, Math.max(leftMovement, rightMovement, topMovement, bottomMovement));
       }
       getIndexAngle(index) {
-        const angleMultiplier = TAU / this.getLabels().length;
+        const angleMultiplier = TAU / (this._pointLabels.length || 1);
         const startAngle = this.options.startAngle || 0;
         return _normalizeAngle(index * angleMultiplier + toRadians(startAngle));
       }
@@ -42490,8 +42707,8 @@
           return createPointLabelContext(this.getContext(), index, pointLabel);
         }
       }
-      getPointPosition(index, distanceFromCenter) {
-        const angle = this.getIndexAngle(index) - HALF_PI;
+      getPointPosition(index, distanceFromCenter, additionalAngle = 0) {
+        const angle = this.getIndexAngle(index) - HALF_PI + additionalAngle;
         return {
           x: Math.cos(angle) * distanceFromCenter + this.xCenter,
           y: Math.sin(angle) * distanceFromCenter + this.yCenter,
@@ -42519,7 +42736,7 @@
           const ctx = this.ctx;
           ctx.save();
           ctx.beginPath();
-          pathRadiusLine(this, this.getDistanceFromCenterForValue(this._endValue), circular, this.getLabels().length);
+          pathRadiusLine(this, this.getDistanceFromCenterForValue(this._endValue), circular, this._pointLabels.length);
           ctx.closePath();
           ctx.fillStyle = backgroundColor;
           ctx.fill();
@@ -42530,7 +42747,7 @@
         const ctx = this.ctx;
         const opts = this.options;
         const {angleLines, grid} = opts;
-        const labelCount = this.getLabels().length;
+        const labelCount = this._pointLabels.length;
         let i, offset, position;
         if (opts.pointLabels.display) {
           drawPointLabels(this, labelCount);
@@ -42546,7 +42763,7 @@
         }
         if (angleLines.display) {
           ctx.save();
-          for (i = this.getLabels().length - 1; i >= 0; i--) {
+          for (i = labelCount - 1; i >= 0; i--) {
             const optsAtIndex = angleLines.setContext(this.getPointLabelContext(i));
             const {color, lineWidth} = optsAtIndex;
             if (!lineWidth || !color) {
@@ -42637,7 +42854,8 @@
         callback(label) {
           return label;
         },
-        padding: 5
+        padding: 5,
+        centerPointLabels: false
       }
     };
     RadialLinearScale.defaultRoutes = {
@@ -43998,6 +44216,7 @@
             var _this = _super.call(this) || this;
             _this.editors = new Editors();
             _this.colorPickers = new ColorPickers();
+            _this.mediaModal = new MediaModal();
             // Hook up default handlers.
             _this.handlers.initDefaultHandlers();
             // Admin Controllers