ngx-hana-nameserver-history-viewer 1.1.1 → 1.1.90

package/esm2020/src/nameserver-history-viewer/utils/chartjs-zoom/chart.zoom.mjs

@@ -0,0 +1,527 @@
+/**
+ * this plugin is adapted from: https://github.com/chartjs/chartjs-plugin-zoom
+ * for following two open issues:
+ * https://github.com/chartjs/chartjs-plugin-zoom/pull/155
+ * https://github.com/chartjs/chartjs-plugin-zoom/pull/150
+ *
+ * The MIT License (MIT) Copyright (c) 2013-2016 Nick Downie
+ * 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.
+ */
+/*jslint browser:true, devel:true, white:true, vars:true */
+/*global require*/
+// hammer JS for touch support
+import * as hammerjs from 'hammerjs';
+const Hammer = window && window.Hammer ? window.Hammer : hammerjs.Hammer;
+// Get the chart variable
+import * as chartjs from 'chart.js';
+const Chart = window && window.Chart ? window.Chart : chartjs.Chart;
+const helpers = Chart.helpers;
+// Take the zoom namespace of Chart
+const zoomNS = Chart.Zoom = Chart.Zoom || {};
+// Where we store functions to handle different scale types
+const zoomFunctions = zoomNS.zoomFunctions = zoomNS.zoomFunctions || {};
+const panFunctions = zoomNS.panFunctions = zoomNS.panFunctions || {};
+// Default options if none are provided
+const defaultOptions = zoomNS.defaults = {
+    pan: {
+        enabled: true,
+        mode: 'xy',
+        speed: 20,
+        threshold: 10
+    },
+    zoom: {
+        enabled: true,
+        mode: 'xy',
+        sensitivity: 3
+    }
+};
+function directionEnabled(mode, dir) {
+    if (mode === undefined) {
+        return true;
+    }
+    else if (typeof mode === 'string') {
+        return mode.indexOf(dir) !== -1;
+    }
+    return false;
+}
+function rangeMaxLimiter(zoomPanOptions, newMax) {
+    if (zoomPanOptions.scaleAxes && zoomPanOptions.rangeMax &&
+        !helpers.isNullOrUndef(zoomPanOptions.rangeMax[zoomPanOptions.scaleAxes])) {
+        const rangeMax = zoomPanOptions.rangeMax[zoomPanOptions.scaleAxes];
+        if (newMax > rangeMax) {
+            newMax = rangeMax;
+        }
+    }
+    return newMax;
+}
+function rangeMinLimiter(zoomPanOptions, newMin) {
+    if (zoomPanOptions.scaleAxes && zoomPanOptions.rangeMin &&
+        !helpers.isNullOrUndef(zoomPanOptions.rangeMin[zoomPanOptions.scaleAxes])) {
+        const rangeMin = zoomPanOptions.rangeMin[zoomPanOptions.scaleAxes];
+        if (newMin < rangeMin) {
+            newMin = rangeMin;
+        }
+    }
+    return newMin;
+}
+function zoomIndexScale(scale, zoom, center, zoomOptions) {
+    const labels = scale.chart.data.labels;
+    let minIndex = scale.minIndex;
+    const lastLabelIndex = labels.length - 1;
+    let maxIndex = scale.maxIndex;
+    const sensitivity = zoomOptions.sensitivity;
+    const chartCenter = scale.isHorizontal() ? scale.left + (scale.width / 2) : scale.top + (scale.height / 2);
+    const centerPointer = scale.isHorizontal() ? center.x : center.y;
+    zoomNS.zoomCumulativeDelta = zoom > 1 ? zoomNS.zoomCumulativeDelta + 1 : zoomNS.zoomCumulativeDelta - 1;
+    if (Math.abs(zoomNS.zoomCumulativeDelta) > sensitivity) {
+        if (zoomNS.zoomCumulativeDelta < 0) {
+            if (centerPointer >= chartCenter) {
+                if (minIndex <= 0) {
+                    maxIndex = Math.min(lastLabelIndex, maxIndex + 1);
+                }
+                else {
+                    minIndex = Math.max(0, minIndex - 1);
+                }
+            }
+            else if (centerPointer < chartCenter) {
+                if (maxIndex >= lastLabelIndex) {
+                    minIndex = Math.max(0, minIndex - 1);
+                }
+                else {
+                    maxIndex = Math.min(lastLabelIndex, maxIndex + 1);
+                }
+            }
+            zoomNS.zoomCumulativeDelta = 0;
+        }
+        else if (zoomNS.zoomCumulativeDelta > 0) {
+            if (centerPointer >= chartCenter) {
+                minIndex = minIndex < maxIndex ? minIndex = Math.min(maxIndex, minIndex + 1) : minIndex;
+            }
+            else if (centerPointer < chartCenter) {
+                maxIndex = maxIndex > minIndex ? maxIndex = Math.max(minIndex, maxIndex - 1) : maxIndex;
+            }
+            zoomNS.zoomCumulativeDelta = 0;
+        }
+        scale.options.ticks.min = rangeMinLimiter(zoomOptions, labels[minIndex]);
+        scale.options.ticks.max = rangeMaxLimiter(zoomOptions, labels[maxIndex]);
+    }
+}
+function zoomTimeScale(scale, zoom, center, zoomOptions) {
+    const options = scale.options;
+    // var range;
+    // var min_percent;
+    // if (scale.isHorizontal()) {
+    //   range = scale.right - scale.left;
+    //   min_percent = (center.x - scale.left) / range;
+    // } else {
+    //   range = scale.bottom - scale.top;
+    //   min_percent = (center.y - scale.top) / range;
+    // }
+    //
+    // var max_percent = 1 - min_percent;
+    const range = scale.max - scale.min;
+    const newDiff = range * (zoom - 1);
+    const cursorPixel = scale.isHorizontal() ? center.x : center.y;
+    const min_percent = (scale.getValueForPixel(cursorPixel) - scale.min) / range;
+    const max_percent = 1 - min_percent;
+    const minDelta = newDiff * min_percent;
+    const maxDelta = newDiff * max_percent;
+    const newMin = scale.min + minDelta;
+    const newMax = scale.max - maxDelta;
+    const diffMinMax = newMax - newMin;
+    const minLimitExceeded = rangeMinLimiter(zoomOptions, diffMinMax) !== diffMinMax;
+    const maxLimitExceeded = rangeMaxLimiter(zoomOptions, diffMinMax) !== diffMinMax;
+    if (!minLimitExceeded && !maxLimitExceeded) {
+        options.time.min = newMin;
+        options.time.max = newMax;
+    }
+}
+function zoomNumericalScale(scale, zoom, center, zoomOptions) {
+    const range = scale.max - scale.min;
+    const newDiff = range * (zoom - 1);
+    const cursorPixel = scale.isHorizontal() ? center.x : center.y;
+    const min_percent = (scale.getValueForPixel(cursorPixel) - scale.min) / range;
+    const max_percent = 1 - min_percent;
+    const minDelta = newDiff * min_percent;
+    const maxDelta = newDiff * max_percent;
+    scale.options.ticks.min = rangeMinLimiter(zoomOptions, scale.min + minDelta);
+    scale.options.ticks.max = rangeMaxLimiter(zoomOptions, scale.max - maxDelta);
+}
+function zoomScale(scale, zoom, center, zoomOptions) {
+    const fn = zoomFunctions[scale.options.type];
+    if (fn) {
+        fn(scale, zoom, center, zoomOptions);
+    }
+}
+function doZoom(chartInstance, zoom, center, whichAxes) {
+    const ca = chartInstance.chartArea;
+    if (!center) {
+        center = {
+            x: (ca.left + ca.right) / 2,
+            y: (ca.top + ca.bottom) / 2,
+        };
+    }
+    const zoomOptions = chartInstance.options.zoom;
+    if (zoomOptions && helpers.getValueOrDefault(zoomOptions.enabled, defaultOptions.zoom.enabled)) {
+        // Do the zoom here
+        const zoomMode = helpers.getValueOrDefault(chartInstance.options.zoom.mode, defaultOptions.zoom.mode);
+        zoomOptions.sensitivity = helpers.getValueOrDefault(chartInstance.options.zoom.sensitivity, defaultOptions.zoom.sensitivity);
+        // Which axe should be modified when figers were used.
+        let _whichAxes;
+        if (zoomMode === 'xy' && whichAxes !== undefined) {
+            // based on fingers positions
+            _whichAxes = whichAxes;
+        }
+        else {
+            // no effect
+            _whichAxes = 'xy';
+        }
+        helpers.each(chartInstance.scales, function (scale, id) {
+            if (scale.isHorizontal() && directionEnabled(zoomMode, 'x') && directionEnabled(_whichAxes, 'x')) {
+                zoomOptions.scaleAxes = 'x';
+                zoomScale(scale, zoom, center, zoomOptions);
+            }
+            else if (!scale.isHorizontal() && directionEnabled(zoomMode, 'y') && directionEnabled(_whichAxes, 'y')) {
+                // Do Y zoom
+                zoomOptions.scaleAxes = 'y';
+                zoomScale(scale, zoom, center, zoomOptions);
+            }
+        });
+        chartInstance.update(0);
+        if (typeof zoomOptions.onZoom === 'function') {
+            zoomOptions.onZoom();
+        }
+    }
+}
+function panIndexScale(scale, delta, panOptions) {
+    const labels = scale.chart.data.labels;
+    const lastLabelIndex = labels.length - 1;
+    const offsetAmt = Math.max((scale.ticks.length - ((scale.options.gridLines.offsetGridLines) ? 0 : 1)), 1);
+    const panSpeed = panOptions.speed;
+    let minIndex = scale.minIndex;
+    const step = Math.round(scale.width / (offsetAmt * panSpeed));
+    let maxIndex;
+    zoomNS.panCumulativeDelta += delta;
+    minIndex = zoomNS.panCumulativeDelta > step ? Math.max(0, minIndex - 1) : zoomNS.panCumulativeDelta < -step ? Math.min(lastLabelIndex - offsetAmt + 1, minIndex + 1) : minIndex;
+    zoomNS.panCumulativeDelta = minIndex !== scale.minIndex ? 0 : zoomNS.panCumulativeDelta;
+    maxIndex = Math.min(lastLabelIndex, minIndex + offsetAmt - 1);
+    scale.options.ticks.min = rangeMinLimiter(panOptions, labels[minIndex]);
+    scale.options.ticks.max = rangeMaxLimiter(panOptions, labels[maxIndex]);
+}
+function panTimeScale(scale, delta, panOptions) {
+    const options = scale.options;
+    const limitedMax = rangeMaxLimiter(panOptions, scale.getValueForPixel(scale.getPixelForValue(scale.max) - delta));
+    const limitedMin = rangeMinLimiter(panOptions, scale.getValueForPixel(scale.getPixelForValue(scale.min) - delta));
+    const limitedTimeDelta = delta < 0 ? limitedMax - scale.max : limitedMin - scale.min;
+    options.time.max = scale.max + limitedTimeDelta;
+    options.time.min = scale.min + limitedTimeDelta;
+}
+function panNumericalScale(scale, delta, panOptions) {
+    const tickOpts = scale.options.ticks;
+    const start = scale.start, end = scale.end;
+    if (tickOpts.reverse) {
+        tickOpts.max = scale.getValueForPixel(scale.getPixelForValue(start) - delta);
+        tickOpts.min = scale.getValueForPixel(scale.getPixelForValue(end) - delta);
+    }
+    else {
+        tickOpts.min = scale.getValueForPixel(scale.getPixelForValue(start) - delta);
+        tickOpts.max = scale.getValueForPixel(scale.getPixelForValue(end) - delta);
+    }
+    tickOpts.min = rangeMinLimiter(panOptions, tickOpts.min);
+    tickOpts.max = rangeMaxLimiter(panOptions, tickOpts.max);
+}
+function panScale(scale, delta, panOptions) {
+    const fn = panFunctions[scale.options.type];
+    if (fn) {
+        fn(scale, delta, panOptions);
+    }
+}
+function doPan(chartInstance, deltaX, deltaY) {
+    const panOptions = chartInstance.options.pan;
+    if (panOptions && helpers.getValueOrDefault(panOptions.enabled, defaultOptions.pan.enabled)) {
+        const panMode = helpers.getValueOrDefault(chartInstance.options.pan.mode, defaultOptions.pan.mode);
+        panOptions.speed = helpers.getValueOrDefault(chartInstance.options.pan.speed, defaultOptions.pan.speed);
+        helpers.each(chartInstance.scales, function (scale, id) {
+            if (scale.isHorizontal() && directionEnabled(panMode, 'x') && deltaX !== 0) {
+                panOptions.scaleAxes = 'x';
+                panScale(scale, deltaX, panOptions);
+            }
+            else if (!scale.isHorizontal() && directionEnabled(panMode, 'y') && deltaY !== 0) {
+                panOptions.scaleAxes = 'y';
+                panScale(scale, deltaY, panOptions);
+            }
+        });
+        chartInstance.update(0);
+        if (typeof panOptions.onPan === 'function') {
+            panOptions.onPan();
+        }
+    }
+}
+function positionInChartArea(chartInstance, position) {
+    return (position.x >= chartInstance.chartArea.left && position.x <= chartInstance.chartArea.right) &&
+        (position.y >= chartInstance.chartArea.top && position.y <= chartInstance.chartArea.bottom);
+}
+function getYAxis(chartInstance) {
+    const scales = chartInstance.scales;
+    for (const scaleId in scales) {
+        if (scales.hasOwnProperty(scaleId)) {
+            const scale = scales[scaleId];
+            if (!scale.isHorizontal()) {
+                return scale;
+            }
+        }
+    }
+}
+// Store these for later
+zoomNS.zoomFunctions.category = zoomIndexScale;
+zoomNS.zoomFunctions.time = zoomTimeScale;
+zoomNS.zoomFunctions.linear = zoomNumericalScale;
+zoomNS.zoomFunctions.logarithmic = zoomNumericalScale;
+zoomNS.panFunctions.category = panIndexScale;
+zoomNS.panFunctions.time = panTimeScale;
+zoomNS.panFunctions.linear = panNumericalScale;
+zoomNS.panFunctions.logarithmic = panNumericalScale;
+// Globals for catergory pan and zoom
+zoomNS.panCumulativeDelta = 0;
+zoomNS.zoomCumulativeDelta = 0;
+// Chartjs Zoom Plugin
+export const zoomPlugin = {
+    afterInit: function (chartInstance) {
+        helpers.each(chartInstance.scales, function (scale) {
+            scale.originalOptions = helpers.clone(scale.options);
+        });
+        chartInstance.resetZoom = function () {
+            helpers.each(chartInstance.scales, function (scale, id) {
+                const timeOptions = scale.options.time;
+                const tickOptions = scale.options.ticks;
+                if (timeOptions) {
+                    timeOptions.min = scale.originalOptions.time.min;
+                    timeOptions.max = scale.originalOptions.time.max;
+                }
+                if (tickOptions) {
+                    tickOptions.min = scale.originalOptions.ticks.min;
+                    tickOptions.max = scale.originalOptions.ticks.max;
+                }
+            });
+            helpers.each(chartInstance.data.datasets, function (dataset, id) {
+                dataset._meta = null;
+            });
+            chartInstance.update();
+        };
+    },
+    beforeInit: function (chartInstance) {
+        chartInstance.zoom = {};
+        const node = chartInstance.zoom.node = chartInstance.chart.ctx.canvas;
+        const options = chartInstance.options;
+        const panThreshold = helpers.getValueOrDefault(options.pan ? options.pan.threshold : undefined, zoomNS.defaults.pan.threshold);
+        if (!options.zoom || !options.zoom.enabled) {
+            return;
+        }
+        if (options.zoom.drag) {
+            // Only want to zoom horizontal axis
+            options.zoom.mode = 'x';
+            chartInstance.zoom._mouseDownHandler = function (event) {
+                chartInstance.zoom._dragZoomStart = event;
+            };
+            node.addEventListener('mousedown', chartInstance.zoom._mouseDownHandler);
+            chartInstance.zoom._mouseMoveHandler = function (event) {
+                if (chartInstance.zoom._dragZoomStart) {
+                    chartInstance.zoom._dragZoomEnd = event;
+                    chartInstance.update(0);
+                }
+            };
+            node.addEventListener('mousemove', chartInstance.zoom._mouseMoveHandler);
+            chartInstance.zoom._mouseUpHandler = function (event) {
+                if (chartInstance.zoom._dragZoomStart) {
+                    const chartArea = chartInstance.chartArea;
+                    const yAxis = getYAxis(chartInstance);
+                    const beginPoint = chartInstance.zoom._dragZoomStart;
+                    const offsetX = beginPoint.target.getBoundingClientRect().left;
+                    const startX = Math.max(Math.min(beginPoint.clientX, event.clientX) - offsetX, chartArea.left);
+                    const endX = Math.min(Math.max(beginPoint.clientX, event.clientX) - offsetX, chartArea.right);
+                    const dragDistance = endX - startX;
+                    const chartDistance = chartArea.right - chartArea.left;
+                    const zoom = 1 + (chartDistance - dragDistance) / chartDistance;
+                    const centerX = chartArea.left + (startX - chartArea.left) / (zoom - 1);
+                    // Remove drag start and end before chart update to stop drawing selected area
+                    chartInstance.zoom._dragZoomStart = null;
+                    chartInstance.zoom._dragZoomEnd = null;
+                    if (dragDistance > 0) {
+                        doZoom(chartInstance, zoom, {
+                            x: centerX,
+                            y: (yAxis.bottom - yAxis.top) / 2,
+                        });
+                    }
+                }
+            };
+            // node.addEventListener('mouseup', chartInstance.zoom._mouseUpHandler);
+            node.ownerDocument.addEventListener('mouseup', chartInstance.zoom._mouseUpHandler);
+        }
+        else {
+            chartInstance.zoom._wheelHandler = function (event) {
+                const rect = event.target.getBoundingClientRect();
+                const offsetX = event.clientX - rect.left;
+                const offsetY = event.clientY - rect.top;
+                const center = {
+                    x: offsetX,
+                    y: offsetY
+                };
+                if (event.deltaY < 0) {
+                    doZoom(chartInstance, 1.1, center);
+                }
+                else {
+                    doZoom(chartInstance, 0.909, center);
+                }
+                // Prevent the event from triggering the default behavior (eg. Content scrolling).
+                event.preventDefault();
+            };
+            node.addEventListener('wheel', chartInstance.zoom._wheelHandler);
+        }
+        if (Hammer) {
+            const mc = new Hammer.Manager(node);
+            mc.add(new Hammer.Pinch());
+            mc.add(new Hammer.Pan({
+                threshold: panThreshold
+            }));
+            // Hammer reports the total scaling. We need the incremental amount
+            let currentPinchScaling;
+            const handlePinch = function (e) {
+                const diff = 1 / (currentPinchScaling) * e.scale;
+                const rect = e.target.getBoundingClientRect();
+                const offsetX = e.center.x - rect.left;
+                const offsetY = e.center.y - rect.top;
+                const center = {
+                    x: offsetX,
+                    y: offsetY
+                };
+                // fingers position difference
+                const x = Math.abs(e.pointers[0].clientX - e.pointers[1].clientX);
+                const y = Math.abs(e.pointers[0].clientY - e.pointers[1].clientY);
+                // diagonal fingers will change both (xy) axes
+                const p = x / y;
+                let xy;
+                if (p > 0.3 && p < 1.7) {
+                    xy = 'xy';
+                }
+                else if (x > y) {
+                    // x axis
+                    xy = 'x';
+                }
+                else {
+                    // y axis
+                    xy = 'y';
+                }
+                doZoom(chartInstance, diff, center, xy);
+                // Keep track of overall scale
+                currentPinchScaling = e.scale;
+            };
+            mc.on('pinchstart', function (e) {
+                currentPinchScaling = 1; // reset tracker
+            });
+            mc.on('pinch', handlePinch);
+            mc.on('pinchend', function (e) {
+                handlePinch(e);
+                currentPinchScaling = null; // reset
+                zoomNS.zoomCumulativeDelta = 0;
+            });
+            let currentDeltaX = null, currentDeltaY = null, panning = false;
+            const handlePan = function (e) {
+                if (currentDeltaX !== null && currentDeltaY !== null) {
+                    panning = true;
+                    const deltaX = e.deltaX - currentDeltaX;
+                    const deltaY = e.deltaY - currentDeltaY;
+                    currentDeltaX = e.deltaX;
+                    currentDeltaY = e.deltaY;
+                    doPan(chartInstance, deltaX, deltaY);
+                }
+            };
+            mc.on('panstart', function (e) {
+                currentDeltaX = 0;
+                currentDeltaY = 0;
+                handlePan(e);
+            });
+            mc.on('panmove', handlePan);
+            mc.on('panend', function (e) {
+                currentDeltaX = null;
+                currentDeltaY = null;
+                zoomNS.panCumulativeDelta = 0;
+                setTimeout(function () { panning = false; }, 500);
+            });
+            chartInstance.zoom._ghostClickHandler = function (e) {
+                if (panning) {
+                    e.stopImmediatePropagation();
+                    e.preventDefault();
+                }
+            };
+            node.addEventListener('click', chartInstance.zoom._ghostClickHandler);
+            chartInstance._mc = mc;
+        }
+    },
+    beforeDatasetsDraw: function (chartInstance) {
+        const ctx = chartInstance.chart.ctx;
+        const chartArea = chartInstance.chartArea;
+        ctx.save();
+        ctx.beginPath();
+        if (chartInstance.zoom._dragZoomEnd) {
+            const yAxis = getYAxis(chartInstance);
+            const beginPoint = chartInstance.zoom._dragZoomStart;
+            const endPoint = chartInstance.zoom._dragZoomEnd;
+            const offsetX = beginPoint.target.getBoundingClientRect().left;
+            const startX = Math.min(beginPoint.clientX, endPoint.clientX) - offsetX;
+            const endX = Math.max(beginPoint.clientX, endPoint.clientX) - offsetX;
+            const rectWidth = endX - startX;
+            ctx.fillStyle = 'rgba(225,225,225,0.5)';
+            ctx.lineWidth = 5;
+            ctx.fillRect(startX, yAxis.top, rectWidth, yAxis.bottom - yAxis.top);
+        }
+        ctx.rect(chartArea.left, chartArea.top, chartArea.right - chartArea.left, chartArea.bottom - chartArea.top);
+        ctx.clip();
+    },
+    afterDatasetsDraw: function (chartInstance) {
+        chartInstance.chart.ctx.restore();
+    },
+    destroy: function (chartInstance) {
+        if (chartInstance.zoom) {
+            const options = chartInstance.options;
+            const node = chartInstance.zoom.node;
+            if (options.zoom && options.zoom.drag) {
+                node.removeEventListener('mousedown', chartInstance.zoom._mouseDownHandler);
+                node.removeEventListener('mousemove', chartInstance.zoom._mouseMoveHandler);
+                // node.removeEventListener('mouseup', chartInstance.zoom._mouseUpHandler);
+                node.ownerDocument.removeEventListener('mouseup', chartInstance.zoom._mouseUpHandler);
+            }
+            else {
+                node.removeEventListener('wheel', chartInstance.zoom._wheelHandler);
+            }
+            if (Hammer) {
+                node.removeEventListener('click', chartInstance.zoom._ghostClickHandler);
+            }
+            delete chartInstance.zoom;
+            const mc = chartInstance._mc;
+            if (mc) {
+                mc.remove('pinchstart');
+                mc.remove('pinch');
+                mc.remove('pinchend');
+                mc.remove('panstart');
+                mc.remove('pan');
+                mc.remove('panend');
+            }
+        }
+    }
+};
+Chart.pluginService.register(zoomPlugin);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart.zoom.js","sourceRoot":"","sources":["../../../../../../src/nameserver-history-viewer/utils/chartjs-zoom/chart.zoom.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,2DAA2D;AAC3D,kBAAkB;AAElB,8BAA8B;AAC9B,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,MAAM,MAAM,GAAG,MAAM,IAAK,MAAc,CAAC,MAAM,CAAC,CAAC,CAAE,MAAc,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;AAE3F,yBAAyB;AACzB,OAAO,KAAK,OAAO,MAAM,UAAU,CAAC;AACpC,MAAM,KAAK,GAAG,MAAM,IAAK,MAAc,CAAC,KAAK,CAAC,CAAC,CAAE,MAAc,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC;AAEtF,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;AAE9B,mCAAmC;AACnC,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC;AAE7C,2DAA2D;AAC3D,MAAM,aAAa,GAAG,MAAM,CAAC,aAAa,GAAG,MAAM,CAAC,aAAa,IAAI,EAAE,CAAC;AACxE,MAAM,YAAY,GAAG,MAAM,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,IAAI,EAAE,CAAC;AAErE,uCAAuC;AACvC,MAAM,cAAc,GAAG,MAAM,CAAC,QAAQ,GAAG;IACvC,GAAG,EAAE;QACH,OAAO,EAAE,IAAI;QACb,IAAI,EAAE,IAAI;QACV,KAAK,EAAE,EAAE;QACT,SAAS,EAAE,EAAE;KACd;IACD,IAAI,EAAE;QACJ,OAAO,EAAE,IAAI;QACb,IAAI,EAAE,IAAI;QACV,WAAW,EAAE,CAAC;KACf;CACF,CAAC;AAEF,SAAS,gBAAgB,CAAC,IAAI,EAAE,GAAG;IACjC,IAAI,IAAI,KAAK,SAAS,EAAE;QACtB,OAAO,IAAI,CAAC;KACb;SAAM,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;QACnC,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;KACjC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,eAAe,CAAC,cAAc,EAAE,MAAM;IAC7C,IAAI,cAAc,CAAC,SAAS,IAAI,cAAc,CAAC,QAAQ;QACrD,CAAC,OAAO,CAAC,aAAa,CAAC,cAAc,CAAC,QAAQ,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,EAAE;QAC3E,MAAM,QAAQ,GAAG,cAAc,CAAC,QAAQ,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;QACnE,IAAI,MAAM,GAAG,QAAQ,EAAE;YACrB,MAAM,GAAG,QAAQ,CAAC;SACnB;KACF;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,eAAe,CAAC,cAAc,EAAE,MAAM;IAC7C,IAAI,cAAc,CAAC,SAAS,IAAI,cAAc,CAAC,QAAQ;QACrD,CAAC,OAAO,CAAC,aAAa,CAAC,cAAc,CAAC,QAAQ,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,EAAE;QAC3E,MAAM,QAAQ,GAAG,cAAc,CAAC,QAAQ,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;QACnE,IAAI,MAAM,GAAG,QAAQ,EAAE;YACrB,MAAM,GAAG,QAAQ,CAAC;SACnB;KACF;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW;IACtD,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;IACvC,IAAI,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;IAC9B,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;IACzC,IAAI,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;IAC9B,MAAM,WAAW,GAAG,WAAW,CAAC,WAAW,CAAC;IAC5C,MAAM,WAAW,GAAI,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC5G,MAAM,aAAa,GAAG,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAEjE,MAAM,CAAC,mBAAmB,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,mBAAmB,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,mBAAmB,GAAG,CAAC,CAAC;IAExG,IAAI,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,mBAAmB,CAAC,GAAG,WAAW,EAAE;QACtD,IAAI,MAAM,CAAC,mBAAmB,GAAG,CAAC,EAAE;YAClC,IAAI,aAAa,IAAI,WAAW,EAAE;gBAChC,IAAI,QAAQ,IAAI,CAAC,EAAE;oBACjB,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAC;iBACnD;qBAAM;oBACL,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAC;iBACtC;aACF;iBAAM,IAAI,aAAa,GAAG,WAAW,EAAE;gBACtC,IAAI,QAAQ,IAAI,cAAc,EAAE;oBAC9B,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAC;iBACtC;qBAAM;oBACL,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAC;iBACnD;aACF;YACD,MAAM,CAAC,mBAAmB,GAAG,CAAC,CAAC;SAChC;aAAM,IAAI,MAAM,CAAC,mBAAmB,GAAG,CAAC,EAAE;YACzC,IAAI,aAAa,IAAI,WAAW,EAAE;gBAChC,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;aACzF;iBAAM,IAAI,aAAa,GAAG,WAAW,EAAE;gBACtC,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;aACzF;YACD,MAAM,CAAC,mBAAmB,GAAG,CAAC,CAAC;SAChC;QACD,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,GAAG,eAAe,CAAC,WAAW,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;QACzE,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,GAAG,eAAe,CAAC,WAAW,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;KAC1E;AACH,CAAC;AAED,SAAS,aAAa,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW;IACrD,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;IAE9B,aAAa;IACb,mBAAmB;IACnB,8BAA8B;IAC9B,sCAAsC;IACtC,mDAAmD;IACnD,WAAW;IACX,sCAAsC;IACtC,kDAAkD;IAClD,IAAI;IACJ,EAAE;IACF,qCAAqC;IACrC,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;IACpC,MAAM,OAAO,GAAG,KAAK,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;IAEnC,MAAM,WAAW,GAAG,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/D,MAAM,WAAW,GAAG,CAAC,KAAK,CAAC,gBAAgB,CAAC,WAAW,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IAC9E,MAAM,WAAW,GAAG,CAAC,GAAG,WAAW,CAAC;IAEpC,MAAM,QAAQ,GAAG,OAAO,GAAG,WAAW,CAAC;IACvC,MAAM,QAAQ,GAAG,OAAO,GAAG,WAAW,CAAC;IAEvC,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,GAAG,QAAQ,CAAC;IACpC,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,GAAG,QAAQ,CAAC;IAEpC,MAAM,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC;IACnC,MAAM,gBAAgB,GAAG,eAAe,CAAC,WAAW,EAAE,UAAU,CAAC,KAAK,UAAU,CAAC;IACjF,MAAM,gBAAgB,GAAG,eAAe,CAAC,WAAW,EAAE,UAAU,CAAC,KAAK,UAAU,CAAC;IAEjF,IAAI,CAAC,gBAAgB,IAAI,CAAC,gBAAgB,EAAE;QAC1C,OAAO,CAAC,IAAI,CAAC,GAAG,GAAG,MAAM,CAAC;QAC1B,OAAO,CAAC,IAAI,CAAC,GAAG,GAAG,MAAM,CAAC;KAC3B;AACH,CAAC;AAED,SAAS,kBAAkB,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW;IAC1D,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;IACpC,MAAM,OAAO,GAAG,KAAK,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;IAEnC,MAAM,WAAW,GAAG,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/D,MAAM,WAAW,GAAG,CAAC,KAAK,CAAC,gBAAgB,CAAC,WAAW,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IAC9E,MAAM,WAAW,GAAG,CAAC,GAAG,WAAW,CAAC;IAEpC,MAAM,QAAQ,GAAG,OAAO,GAAG,WAAW,CAAC;IACvC,MAAM,QAAQ,GAAG,OAAO,GAAG,WAAW,CAAC;IAEvC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,GAAG,eAAe,CAAC,WAAW,EAAE,KAAK,CAAC,GAAG,GAAG,QAAQ,CAAC,CAAC;IAC7E,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,GAAG,eAAe,CAAC,WAAW,EAAE,KAAK,CAAC,GAAG,GAAG,QAAQ,CAAC,CAAC;AAC/E,CAAC;AAED,SAAS,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW;IACjD,MAAM,EAAE,GAAG,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,IAAI,EAAE,EAAE;QACN,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;KACtC;AACH,CAAC;AAED,SAAS,MAAM,CAAC,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,SAAU;IACrD,MAAM,EAAE,GAAG,aAAa,CAAC,SAAS,CAAC;IACnC,IAAI,CAAC,MAAM,EAAE;QACX,MAAM,GAAG;YACP,CAAC,EAAE,CAAC,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC;YAC3B,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC;SAC5B,CAAC;KACH;IAED,MAAM,WAAW,GAAG,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC;IAE/C,IAAI,WAAW,IAAI,OAAO,CAAC,iBAAiB,CAAC,WAAW,CAAC,OAAO,EAAE,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;QAC9F,mBAAmB;QACnB,MAAM,QAAQ,GAAG,OAAO,CAAC,iBAAiB,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtG,WAAW,CAAC,WAAW,GAAG,OAAO,CAAC,iBAAiB,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAE7H,sDAAsD;QACtD,IAAI,UAAU,CAAC;QACf,IAAI,QAAQ,KAAK,IAAI,IAAI,SAAS,KAAK,SAAS,EAAE;YAChD,6BAA6B;YAC7B,UAAU,GAAG,SAAS,CAAC;SACxB;aAAM;YACL,YAAY;YACZ,UAAU,GAAG,IAAI,CAAC;SACnB;QAED,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,UAAS,KAAK,EAAE,EAAE;YACnD,IAAI,KAAK,CAAC,YAAY,EAAE,IAAI,gBAAgB,CAAC,QAAQ,EAAE,GAAG,CAAC,IAAI,gBAAgB,CAAC,UAAU,EAAE,GAAG,CAAC,EAAE;gBAChG,WAAW,CAAC,SAAS,GAAG,GAAG,CAAC;gBAC5B,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;aAC7C;iBAAM,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,IAAI,gBAAgB,CAAC,QAAQ,EAAE,GAAG,CAAC,IAAI,gBAAgB,CAAC,UAAU,EAAE,GAAG,CAAC,EAAE;gBACxG,YAAY;gBACZ,WAAW,CAAC,SAAS,GAAG,GAAG,CAAC;gBAC5B,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;aAC7C;QACH,CAAC,CAAC,CAAC;QAEH,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACxB,IAAI,OAAO,WAAW,CAAC,MAAM,KAAK,UAAU,EAAE;YAC5C,WAAW,CAAC,MAAM,EAAE,CAAC;SACtB;KACF;AACH,CAAC;AAED,SAAS,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU;IAC7C,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;IACvC,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;IACzC,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1G,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC;IAClC,IAAI,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;IAC9B,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,SAAS,GAAG,QAAQ,CAAC,CAAC,CAAC;IAC9D,IAAI,QAAQ,CAAC;IAEb,MAAM,CAAC,kBAAkB,IAAI,KAAK,CAAC;IAEnC,QAAQ,GAAG,MAAM,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,kBAAkB,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,GAAG,SAAS,GAAG,CAAC,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IAChL,MAAM,CAAC,kBAAkB,GAAG,QAAQ,KAAK,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,kBAAkB,CAAC;IAExF,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,QAAQ,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC;IAE9D,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,GAAG,eAAe,CAAC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;IACxE,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,GAAG,eAAe,CAAC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;AAC1E,CAAC;AAED,SAAS,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU;IAC5C,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;IAC9B,MAAM,UAAU,GAAG,eAAe,CAAC,UAAU,EAAE,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;IAClH,MAAM,UAAU,GAAG,eAAe,CAAC,UAAU,EAAE,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;IAElH,MAAM,gBAAgB,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,GAAG,KAAK,CAAC,GAAG,CAAC;IAErF,OAAO,CAAC,IAAI,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,GAAG,gBAAgB,CAAC;IAChD,OAAO,CAAC,IAAI,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,GAAG,gBAAgB,CAAC;AAClD,CAAC;AAED,SAAS,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU;IACjD,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;IACrC,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,EACvB,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;IAElB,IAAI,QAAQ,CAAC,OAAO,EAAE;QACpB,QAAQ,CAAC,GAAG,GAAG,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC;QAC7E,QAAQ,CAAC,GAAG,GAAG,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;KAC5E;SAAM;QACL,QAAQ,CAAC,GAAG,GAAG,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC;QAC7E,QAAQ,CAAC,GAAG,GAAG,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;KAC5E;IACD,QAAQ,CAAC,GAAG,GAAG,eAAe,CAAC,UAAU,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;IACzD,QAAQ,CAAC,GAAG,GAAG,eAAe,CAAC,UAAU,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;AAC3D,CAAC;AAED,SAAS,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU;IACxC,MAAM,EAAE,GAAG,YAAY,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,IAAI,EAAE,EAAE;QACN,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;KAC9B;AACH,CAAC;AAED,SAAS,KAAK,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM;IAC1C,MAAM,UAAU,GAAG,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC;IAC7C,IAAI,UAAU,IAAI,OAAO,CAAC,iBAAiB,CAAC,UAAU,CAAC,OAAO,EAAE,cAAc,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE;QAC3F,MAAM,OAAO,GAAG,OAAO,CAAC,iBAAiB,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACnG,UAAU,CAAC,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAExG,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,UAAS,KAAK,EAAE,EAAE;YACnD,IAAI,KAAK,CAAC,YAAY,EAAE,IAAI,gBAAgB,CAAC,OAAO,EAAE,GAAG,CAAC,IAAI,MAAM,KAAK,CAAC,EAAE;gBAC1E,UAAU,CAAC,SAAS,GAAG,GAAG,CAAC;gBAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;aACrC;iBAAM,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,IAAI,gBAAgB,CAAC,OAAO,EAAE,GAAG,CAAC,IAAI,MAAM,KAAK,CAAC,EAAE;gBAClF,UAAU,CAAC,SAAS,GAAG,GAAG,CAAC;gBAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;aACrC;QACH,CAAC,CAAC,CAAC;QAEH,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACxB,IAAI,OAAO,UAAU,CAAC,KAAK,KAAK,UAAU,EAAE;YAC1C,UAAU,CAAC,KAAK,EAAE,CAAC;SACpB;KACF;AACH,CAAC;AAED,SAAS,mBAAmB,CAAC,aAAa,EAAE,QAAQ;IAClD,OAAS,CAAC,QAAQ,CAAC,CAAC,IAAI,aAAa,CAAC,SAAS,CAAC,IAAI,IAAI,QAAQ,CAAC,CAAC,IAAI,aAAa,CAAC,SAAS,CAAC,KAAK,CAAC;QAClG,CAAC,QAAQ,CAAC,CAAC,IAAI,aAAa,CAAC,SAAS,CAAC,GAAG,IAAI,QAAQ,CAAC,CAAC,IAAI,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;AAChG,CAAC;AAED,SAAS,QAAQ,CAAC,aAAa;IAC7B,MAAM,MAAM,GAAG,aAAa,CAAC,MAAM,CAAC;IAEpC,KAAK,MAAM,OAAO,IAAI,MAAM,EAAE;QAC5B,IAAI,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE;YAClC,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;YAC9B,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,EAAE;gBACzB,OAAO,KAAK,CAAC;aACd;SACF;KACF;AACH,CAAC;AAED,wBAAwB;AACxB,MAAM,CAAC,aAAa,CAAC,QAAQ,GAAG,cAAc,CAAC;AAC/C,MAAM,CAAC,aAAa,CAAC,IAAI,GAAG,aAAa,CAAC;AAC1C,MAAM,CAAC,aAAa,CAAC,MAAM,GAAG,kBAAkB,CAAC;AACjD,MAAM,CAAC,aAAa,CAAC,WAAW,GAAG,kBAAkB,CAAC;AACtD,MAAM,CAAC,YAAY,CAAC,QAAQ,GAAG,aAAa,CAAC;AAC7C,MAAM,CAAC,YAAY,CAAC,IAAI,GAAG,YAAY,CAAC;AACxC,MAAM,CAAC,YAAY,CAAC,MAAM,GAAG,iBAAiB,CAAC;AAC/C,MAAM,CAAC,YAAY,CAAC,WAAW,GAAG,iBAAiB,CAAC;AACpD,qCAAqC;AACrC,MAAM,CAAC,kBAAkB,GAAG,CAAC,CAAC;AAC9B,MAAM,CAAC,mBAAmB,GAAG,CAAC,CAAC;AAE/B,sBAAsB;AACtB,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,SAAS,EAAE,UAAS,aAAa;QAC/B,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,UAAS,KAAK;YAC/C,KAAK,CAAC,eAAe,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACvD,CAAC,CAAC,CAAC;QAEH,aAAa,CAAC,SAAS,GAAG;YACxB,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,UAAS,KAAK,EAAE,EAAE;gBACnD,MAAM,WAAW,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;gBACvC,MAAM,WAAW,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;gBAExC,IAAI,WAAW,EAAE;oBACf,WAAW,CAAC,GAAG,GAAG,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,GAAG,CAAC;oBACjD,WAAW,CAAC,GAAG,GAAG,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,GAAG,CAAC;iBAClD;gBAED,IAAI,WAAW,EAAE;oBACf,WAAW,CAAC,GAAG,GAAG,KAAK,CAAC,eAAe,CAAC,KAAK,CAAC,GAAG,CAAC;oBAClD,WAAW,CAAC,GAAG,GAAG,KAAK,CAAC,eAAe,CAAC,KAAK,CAAC,GAAG,CAAC;iBACnD;YACH,CAAC,CAAC,CAAC;YAEH,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAS,OAAO,EAAE,EAAE;gBAC5D,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;YACvB,CAAC,CAAC,CAAC;YAEH,aAAa,CAAC,MAAM,EAAE,CAAC;QACzB,CAAC,CAAC;IAEJ,CAAC;IACD,UAAU,EAAE,UAAS,aAAa;QAChC,aAAa,CAAC,IAAI,GAAG,EAAE,CAAC;QAExB,MAAM,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,GAAG,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC;QAEtE,MAAM,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC;QACtC,MAAM,YAAY,GAAG,OAAO,CAAC,iBAAiB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,EAAE,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAC/H,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE;YAC1C,OAAO;SACR;QACD,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE;YACrB,oCAAoC;YACpC,OAAO,CAAC,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;YAExB,aAAa,CAAC,IAAI,CAAC,iBAAiB,GAAG,UAAS,KAAK;gBACnD,aAAa,CAAC,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;YAC5C,CAAC,CAAC;YACF,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,aAAa,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;YAEzE,aAAa,CAAC,IAAI,CAAC,iBAAiB,GAAG,UAAS,KAAK;gBACnD,IAAI,aAAa,CAAC,IAAI,CAAC,cAAc,EAAE;oBACrC,aAAa,CAAC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;oBACxC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;iBACzB;YACH,CAAC,CAAC;YACF,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,aAAa,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;YAEzE,aAAa,CAAC,IAAI,CAAC,eAAe,GAAG,UAAS,KAAK;gBACjD,IAAI,aAAa,CAAC,IAAI,CAAC,cAAc,EAAE;oBACrC,MAAM,SAAS,GAAG,aAAa,CAAC,SAAS,CAAC;oBAC1C,MAAM,KAAK,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAC;oBACtC,MAAM,UAAU,GAAG,aAAa,CAAC,IAAI,CAAC,cAAc,CAAC;oBACrD,MAAM,OAAO,GAAG,UAAU,CAAC,MAAM,CAAC,qBAAqB,EAAE,CAAC,IAAI,CAAC;oBAC/D,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;oBAC/F,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,OAAO,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;oBAC9F,MAAM,YAAY,GAAG,IAAI,GAAG,MAAM,CAAC;oBACnC,MAAM,aAAa,GAAG,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC;oBACvD,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,aAAa,GAAG,YAAY,CAAC,GAAG,aAAa,CAAC;oBAChE,MAAM,OAAO,GAAG,SAAS,CAAC,IAAI,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;oBAExE,8EAA8E;oBAC9E,aAAa,CAAC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;oBACzC,aAAa,CAAC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;oBAEvC,IAAI,YAAY,GAAG,CAAC,EAAE;wBACpB,MAAM,CAAC,aAAa,EAAE,IAAI,EAAE;4BAC1B,CAAC,EAAE,OAAO;4BACV,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC;yBAClC,CAAC,CAAC;qBACJ;iBACF;YACH,CAAC,CAAC;YACF,wEAAwE;YACxE,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,SAAS,EAAE,aAAa,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;SACpF;aAAM;YACL,aAAa,CAAC,IAAI,CAAC,aAAa,GAAG,UAAS,KAAK;gBAC/C,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,qBAAqB,EAAE,CAAC;gBAClD,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC;gBAC1C,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC;gBAEzC,MAAM,MAAM,GAAG;oBACb,CAAC,EAAG,OAAO;oBACX,CAAC,EAAG,OAAO;iBACZ,CAAC;gBAEF,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;oBACpB,MAAM,CAAC,aAAa,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;iBACpC;qBAAM;oBACL,MAAM,CAAC,aAAa,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;iBACtC;gBACD,kFAAkF;gBAClF,KAAK,CAAC,cAAc,EAAE,CAAC;YACzB,CAAC,CAAC;YAEF,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;SAClE;QAED,IAAI,MAAM,EAAE;YACV,MAAM,EAAE,GAAG,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YACpC,EAAE,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;YAC3B,EAAE,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC;gBACpB,SAAS,EAAE,YAAY;aACxB,CAAC,CAAC,CAAC;YAEJ,mEAAmE;YACnE,IAAI,mBAAmB,CAAC;YACxB,MAAM,WAAW,GAAG,UAAU,CAAC;gBAC7B,MAAM,IAAI,GAAG,CAAC,GAAG,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC;gBACjD,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,qBAAqB,EAAE,CAAC;gBAC9C,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC;gBACvC,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC;gBACtC,MAAM,MAAM,GAAG;oBACb,CAAC,EAAG,OAAO;oBACX,CAAC,EAAG,OAAO;iBACZ,CAAC;gBAEF,8BAA8B;gBAC9B,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;gBAClE,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;gBAElE,8CAA8C;gBAC9C,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBAChB,IAAI,EAAE,CAAC;gBACP,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,GAAG,EAAE;oBACtB,EAAE,GAAG,IAAI,CAAC;iBACX;qBAAM,IAAI,CAAC,GAAG,CAAC,EAAE;oBAChB,SAAS;oBACT,EAAE,GAAG,GAAG,CAAC;iBACV;qBAAM;oBACL,SAAS;oBACT,EAAE,GAAG,GAAG,CAAC;iBACV;gBAED,MAAM,CAAC,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC;gBAExC,8BAA8B;gBAC9B,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC;YAChC,CAAC,CAAC;YAEF,EAAE,CAAC,EAAE,CAAC,YAAY,EAAE,UAAS,CAAC;gBAC5B,mBAAmB,GAAG,CAAC,CAAC,CAAC,gBAAgB;YAC3C,CAAC,CAAC,CAAC;YACH,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;YAC5B,EAAE,CAAC,EAAE,CAAC,UAAU,EAAE,UAAS,CAAC;gBAC1B,WAAW,CAAC,CAAC,CAAC,CAAC;gBACf,mBAAmB,GAAG,IAAI,CAAC,CAAC,QAAQ;gBACpC,MAAM,CAAC,mBAAmB,GAAG,CAAC,CAAC;YACjC,CAAC,CAAC,CAAC;YAEH,IAAI,aAAa,GAAG,IAAI,EAAE,aAAa,GAAG,IAAI,EAAE,OAAO,GAAG,KAAK,CAAC;YAChE,MAAM,SAAS,GAAG,UAAU,CAAC;gBAC3B,IAAI,aAAa,KAAK,IAAI,IAAI,aAAa,KAAK,IAAI,EAAE;oBACpD,OAAO,GAAG,IAAI,CAAC;oBACf,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,GAAG,aAAa,CAAC;oBACxC,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,GAAG,aAAa,CAAC;oBACxC,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC;oBACzB,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC;oBACzB,KAAK,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;iBACtC;YACH,CAAC,CAAC;YAEF,EAAE,CAAC,EAAE,CAAC,UAAU,EAAE,UAAS,CAAC;gBAC1B,aAAa,GAAG,CAAC,CAAC;gBAClB,aAAa,GAAG,CAAC,CAAC;gBAClB,SAAS,CAAC,CAAC,CAAC,CAAC;YACf,CAAC,CAAC,CAAC;YACH,EAAE,CAAC,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;YAC5B,EAAE,CAAC,EAAE,CAAC,QAAQ,EAAE,UAAS,CAAC;gBACxB,aAAa,GAAG,IAAI,CAAC;gBACrB,aAAa,GAAG,IAAI,CAAC;gBACrB,MAAM,CAAC,kBAAkB,GAAG,CAAC,CAAC;gBAC9B,UAAU,CAAC,cAAa,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;YACnD,CAAC,CAAC,CAAC;YAEH,aAAa,CAAC,IAAI,CAAC,kBAAkB,GAAG,UAAS,CAAC;gBAChD,IAAI,OAAO,EAAE;oBACX,CAAC,CAAC,wBAAwB,EAAE,CAAC;oBAC7B,CAAC,CAAC,cAAc,EAAE,CAAC;iBACpB;YACH,CAAC,CAAC;YACF,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;YAEtE,aAAa,CAAC,GAAG,GAAG,EAAE,CAAC;SACxB;IACH,CAAC;IAED,kBAAkB,EAAE,UAAS,aAAa;QACxC,MAAM,GAAG,GAAG,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC;QACpC,MAAM,SAAS,GAAG,aAAa,CAAC,SAAS,CAAC;QAC1C,GAAG,CAAC,IAAI,EAAE,CAAC;QACX,GAAG,CAAC,SAAS,EAAE,CAAC;QAEhB,IAAI,aAAa,CAAC,IAAI,CAAC,YAAY,EAAE;YACnC,MAAM,KAAK,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAC;YACtC,MAAM,UAAU,GAAG,aAAa,CAAC,IAAI,CAAC,cAAc,CAAC;YACrD,MAAM,QAAQ,GAAG,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC;YACjD,MAAM,OAAO,GAAG,UAAU,CAAC,MAAM,CAAC,qBAAqB,EAAE,CAAC,IAAI,CAAC;YAC/D,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,OAAO,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;YACxE,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,OAAO,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;YACtE,MAAM,SAAS,GAAG,IAAI,GAAG,MAAM,CAAC;YAGhC,GAAG,CAAC,SAAS,GAAG,uBAAuB,CAAC;YACxC,GAAG,CAAC,SAAS,GAAG,CAAC,CAAC;YAClB,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,EAAE,SAAS,EAAE,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;SACtE;QAED,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,GAAG,EAAE,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;QAC5G,GAAG,CAAC,IAAI,EAAE,CAAC;IACb,CAAC;IAED,iBAAiB,EAAE,UAAS,aAAa;QACvC,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;IACpC,CAAC;IAED,OAAO,EAAE,UAAS,aAAa;QAC7B,IAAI,aAAa,CAAC,IAAI,EAAE;YACtB,MAAM,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC;YACtC,MAAM,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC;YAErC,IAAI,OAAO,CAAC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE;gBACrC,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,aAAa,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;gBAC5E,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,aAAa,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;gBAC5E,2EAA2E;gBAC3E,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,SAAS,EAAE,aAAa,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;aACvF;iBAAM;gBACL,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;aACrE;YAED,IAAI,MAAM,EAAE;gBACV,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,aAAa,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;aAC1E;YAED,OAAO,aAAa,CAAC,IAAI,CAAC;YAE1B,MAAM,EAAE,GAAG,aAAa,CAAC,GAAG,CAAC;YAC7B,IAAI,EAAE,EAAE;gBACN,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;gBACxB,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;gBACnB,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;gBACtB,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;gBACtB,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBACjB,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;aACrB;SACF;IACH,CAAC;CACF,CAAC;AAEF,KAAK,CAAC,aAAa,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC","sourcesContent":["/**\r\n * this plugin is adapted from: https://github.com/chartjs/chartjs-plugin-zoom\r\n * for following two open issues:\r\n * https://github.com/chartjs/chartjs-plugin-zoom/pull/155\r\n * https://github.com/chartjs/chartjs-plugin-zoom/pull/150\r\n *\r\n * The MIT License (MIT) Copyright (c) 2013-2016 Nick Downie\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy of this\r\n * software and associated documentation files (the \"Software\"), to deal in the Software\r\n * without restriction, including without limitation the rights to use, copy, modify, merge,\r\n * publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons\r\n * to whom the Software is furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in all copies or\r\n * substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING\r\n * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE\r\n * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\r\n * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,\r\n * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r\n * THE SOFTWARE.\r\n */\r\n\r\n/*jslint browser:true, devel:true, white:true, vars:true */\r\n/*global require*/\r\n\r\n// hammer JS for touch support\r\nimport * as hammerjs from 'hammerjs';\r\nconst Hammer = window && (window as any).Hammer ? (window as any).Hammer : hammerjs.Hammer;\r\n\r\n// Get the chart variable\r\nimport * as chartjs from 'chart.js';\r\nconst Chart = window && (window as any).Chart ? (window as any).Chart : chartjs.Chart;\r\n\r\nconst helpers = Chart.helpers;\r\n\r\n// Take the zoom namespace of Chart\r\nconst zoomNS = Chart.Zoom = Chart.Zoom || {};\r\n\r\n// Where we store functions to handle different scale types\r\nconst zoomFunctions = zoomNS.zoomFunctions = zoomNS.zoomFunctions || {};\r\nconst panFunctions = zoomNS.panFunctions = zoomNS.panFunctions || {};\r\n\r\n// Default options if none are provided\r\nconst defaultOptions = zoomNS.defaults = {\r\n  pan: {\r\n    enabled: true,\r\n    mode: 'xy',\r\n    speed: 20,\r\n    threshold: 10\r\n  },\r\n  zoom: {\r\n    enabled: true,\r\n    mode: 'xy',\r\n    sensitivity: 3\r\n  }\r\n};\r\n\r\nfunction directionEnabled(mode, dir) {\r\n  if (mode === undefined) {\r\n    return true;\r\n  } else if (typeof mode === 'string') {\r\n    return mode.indexOf(dir) !== -1;\r\n  }\r\n\r\n  return false;\r\n}\r\n\r\nfunction rangeMaxLimiter(zoomPanOptions, newMax) {\r\n  if (zoomPanOptions.scaleAxes && zoomPanOptions.rangeMax &&\r\n    !helpers.isNullOrUndef(zoomPanOptions.rangeMax[zoomPanOptions.scaleAxes])) {\r\n    const rangeMax = zoomPanOptions.rangeMax[zoomPanOptions.scaleAxes];\r\n    if (newMax > rangeMax) {\r\n      newMax = rangeMax;\r\n    }\r\n  }\r\n  return newMax;\r\n}\r\n\r\nfunction rangeMinLimiter(zoomPanOptions, newMin) {\r\n  if (zoomPanOptions.scaleAxes && zoomPanOptions.rangeMin &&\r\n    !helpers.isNullOrUndef(zoomPanOptions.rangeMin[zoomPanOptions.scaleAxes])) {\r\n    const rangeMin = zoomPanOptions.rangeMin[zoomPanOptions.scaleAxes];\r\n    if (newMin < rangeMin) {\r\n      newMin = rangeMin;\r\n    }\r\n  }\r\n  return newMin;\r\n}\r\n\r\nfunction zoomIndexScale(scale, zoom, center, zoomOptions) {\r\n  const labels = scale.chart.data.labels;\r\n  let minIndex = scale.minIndex;\r\n  const lastLabelIndex = labels.length - 1;\r\n  let maxIndex = scale.maxIndex;\r\n  const sensitivity = zoomOptions.sensitivity;\r\n  const chartCenter =  scale.isHorizontal() ? scale.left + (scale.width / 2) : scale.top + (scale.height / 2);\r\n  const centerPointer = scale.isHorizontal() ? center.x : center.y;\r\n\r\n  zoomNS.zoomCumulativeDelta = zoom > 1 ? zoomNS.zoomCumulativeDelta + 1 : zoomNS.zoomCumulativeDelta - 1;\r\n\r\n  if (Math.abs(zoomNS.zoomCumulativeDelta) > sensitivity) {\r\n    if (zoomNS.zoomCumulativeDelta < 0) {\r\n      if (centerPointer >= chartCenter) {\r\n        if (minIndex <= 0) {\r\n          maxIndex = Math.min(lastLabelIndex, maxIndex + 1);\r\n        } else {\r\n          minIndex = Math.max(0, minIndex - 1);\r\n        }\r\n      } else if (centerPointer < chartCenter) {\r\n        if (maxIndex >= lastLabelIndex) {\r\n          minIndex = Math.max(0, minIndex - 1);\r\n        } else {\r\n          maxIndex = Math.min(lastLabelIndex, maxIndex + 1);\r\n        }\r\n      }\r\n      zoomNS.zoomCumulativeDelta = 0;\r\n    } else if (zoomNS.zoomCumulativeDelta > 0) {\r\n      if (centerPointer >= chartCenter) {\r\n        minIndex = minIndex < maxIndex ? minIndex = Math.min(maxIndex, minIndex + 1) : minIndex;\r\n      } else if (centerPointer < chartCenter) {\r\n        maxIndex = maxIndex > minIndex ? maxIndex = Math.max(minIndex, maxIndex - 1) : maxIndex;\r\n      }\r\n      zoomNS.zoomCumulativeDelta = 0;\r\n    }\r\n    scale.options.ticks.min = rangeMinLimiter(zoomOptions, labels[minIndex]);\r\n    scale.options.ticks.max = rangeMaxLimiter(zoomOptions, labels[maxIndex]);\r\n  }\r\n}\r\n\r\nfunction zoomTimeScale(scale, zoom, center, zoomOptions) {\r\n  const options = scale.options;\r\n\r\n  // var range;\r\n  // var min_percent;\r\n  // if (scale.isHorizontal()) {\r\n  //   range = scale.right - scale.left;\r\n  //   min_percent = (center.x - scale.left) / range;\r\n  // } else {\r\n  //   range = scale.bottom - scale.top;\r\n  //   min_percent = (center.y - scale.top) / range;\r\n  // }\r\n  //\r\n  // var max_percent = 1 - min_percent;\r\n  const range = scale.max - scale.min;\r\n  const newDiff = range * (zoom - 1);\r\n\r\n  const cursorPixel = scale.isHorizontal() ? center.x : center.y;\r\n  const min_percent = (scale.getValueForPixel(cursorPixel) - scale.min) / range;\r\n  const max_percent = 1 - min_percent;\r\n\r\n  const minDelta = newDiff * min_percent;\r\n  const maxDelta = newDiff * max_percent;\r\n\r\n  const newMin = scale.min + minDelta;\r\n  const newMax = scale.max - maxDelta;\r\n\r\n  const diffMinMax = newMax - newMin;\r\n  const minLimitExceeded = rangeMinLimiter(zoomOptions, diffMinMax) !== diffMinMax;\r\n  const maxLimitExceeded = rangeMaxLimiter(zoomOptions, diffMinMax) !== diffMinMax;\r\n\r\n  if (!minLimitExceeded && !maxLimitExceeded) {\r\n    options.time.min = newMin;\r\n    options.time.max = newMax;\r\n  }\r\n}\r\n\r\nfunction zoomNumericalScale(scale, zoom, center, zoomOptions) {\r\n  const range = scale.max - scale.min;\r\n  const newDiff = range * (zoom - 1);\r\n\r\n  const cursorPixel = scale.isHorizontal() ? center.x : center.y;\r\n  const min_percent = (scale.getValueForPixel(cursorPixel) - scale.min) / range;\r\n  const max_percent = 1 - min_percent;\r\n\r\n  const minDelta = newDiff * min_percent;\r\n  const maxDelta = newDiff * max_percent;\r\n\r\n  scale.options.ticks.min = rangeMinLimiter(zoomOptions, scale.min + minDelta);\r\n  scale.options.ticks.max = rangeMaxLimiter(zoomOptions, scale.max - maxDelta);\r\n}\r\n\r\nfunction zoomScale(scale, zoom, center, zoomOptions) {\r\n  const fn = zoomFunctions[scale.options.type];\r\n  if (fn) {\r\n    fn(scale, zoom, center, zoomOptions);\r\n  }\r\n}\r\n\r\nfunction doZoom(chartInstance, zoom, center, whichAxes?) {\r\n  const ca = chartInstance.chartArea;\r\n  if (!center) {\r\n    center = {\r\n      x: (ca.left + ca.right) / 2,\r\n      y: (ca.top + ca.bottom) / 2,\r\n    };\r\n  }\r\n\r\n  const zoomOptions = chartInstance.options.zoom;\r\n\r\n  if (zoomOptions && helpers.getValueOrDefault(zoomOptions.enabled, defaultOptions.zoom.enabled)) {\r\n    // Do the zoom here\r\n    const zoomMode = helpers.getValueOrDefault(chartInstance.options.zoom.mode, defaultOptions.zoom.mode);\r\n    zoomOptions.sensitivity = helpers.getValueOrDefault(chartInstance.options.zoom.sensitivity, defaultOptions.zoom.sensitivity);\r\n\r\n    // Which axe should be modified when figers were used.\r\n    let _whichAxes;\r\n    if (zoomMode === 'xy' && whichAxes !== undefined) {\r\n      // based on fingers positions\r\n      _whichAxes = whichAxes;\r\n    } else {\r\n      // no effect\r\n      _whichAxes = 'xy';\r\n    }\r\n\r\n    helpers.each(chartInstance.scales, function(scale, id) {\r\n      if (scale.isHorizontal() && directionEnabled(zoomMode, 'x') && directionEnabled(_whichAxes, 'x')) {\r\n        zoomOptions.scaleAxes = 'x';\r\n        zoomScale(scale, zoom, center, zoomOptions);\r\n      } else if (!scale.isHorizontal() && directionEnabled(zoomMode, 'y') && directionEnabled(_whichAxes, 'y')) {\r\n        // Do Y zoom\r\n        zoomOptions.scaleAxes = 'y';\r\n        zoomScale(scale, zoom, center, zoomOptions);\r\n      }\r\n    });\r\n\r\n    chartInstance.update(0);\r\n    if (typeof zoomOptions.onZoom === 'function') {\r\n      zoomOptions.onZoom();\r\n    }\r\n  }\r\n}\r\n\r\nfunction panIndexScale(scale, delta, panOptions) {\r\n  const labels = scale.chart.data.labels;\r\n  const lastLabelIndex = labels.length - 1;\r\n  const offsetAmt = Math.max((scale.ticks.length - ((scale.options.gridLines.offsetGridLines) ? 0 : 1)), 1);\r\n  const panSpeed = panOptions.speed;\r\n  let minIndex = scale.minIndex;\r\n  const step = Math.round(scale.width / (offsetAmt * panSpeed));\r\n  let maxIndex;\r\n\r\n  zoomNS.panCumulativeDelta += delta;\r\n\r\n  minIndex = zoomNS.panCumulativeDelta > step ? Math.max(0, minIndex - 1) : zoomNS.panCumulativeDelta < -step ? Math.min(lastLabelIndex - offsetAmt + 1, minIndex + 1) : minIndex;\r\n  zoomNS.panCumulativeDelta = minIndex !== scale.minIndex ? 0 : zoomNS.panCumulativeDelta;\r\n\r\n  maxIndex = Math.min(lastLabelIndex, minIndex + offsetAmt - 1);\r\n\r\n  scale.options.ticks.min = rangeMinLimiter(panOptions, labels[minIndex]);\r\n  scale.options.ticks.max = rangeMaxLimiter(panOptions, labels[maxIndex]);\r\n}\r\n\r\nfunction panTimeScale(scale, delta, panOptions) {\r\n  const options = scale.options;\r\n  const limitedMax = rangeMaxLimiter(panOptions, scale.getValueForPixel(scale.getPixelForValue(scale.max) - delta));\r\n  const limitedMin = rangeMinLimiter(panOptions, scale.getValueForPixel(scale.getPixelForValue(scale.min) - delta));\r\n\r\n  const limitedTimeDelta = delta < 0 ? limitedMax - scale.max : limitedMin - scale.min;\r\n\r\n  options.time.max = scale.max + limitedTimeDelta;\r\n  options.time.min = scale.min + limitedTimeDelta;\r\n}\r\n\r\nfunction panNumericalScale(scale, delta, panOptions) {\r\n  const tickOpts = scale.options.ticks;\r\n  const start = scale.start,\r\n    end = scale.end;\r\n\r\n  if (tickOpts.reverse) {\r\n    tickOpts.max = scale.getValueForPixel(scale.getPixelForValue(start) - delta);\r\n    tickOpts.min = scale.getValueForPixel(scale.getPixelForValue(end) - delta);\r\n  } else {\r\n    tickOpts.min = scale.getValueForPixel(scale.getPixelForValue(start) - delta);\r\n    tickOpts.max = scale.getValueForPixel(scale.getPixelForValue(end) - delta);\r\n  }\r\n  tickOpts.min = rangeMinLimiter(panOptions, tickOpts.min);\r\n  tickOpts.max = rangeMaxLimiter(panOptions, tickOpts.max);\r\n}\r\n\r\nfunction panScale(scale, delta, panOptions) {\r\n  const fn = panFunctions[scale.options.type];\r\n  if (fn) {\r\n    fn(scale, delta, panOptions);\r\n  }\r\n}\r\n\r\nfunction doPan(chartInstance, deltaX, deltaY) {\r\n  const panOptions = chartInstance.options.pan;\r\n  if (panOptions && helpers.getValueOrDefault(panOptions.enabled, defaultOptions.pan.enabled)) {\r\n    const panMode = helpers.getValueOrDefault(chartInstance.options.pan.mode, defaultOptions.pan.mode);\r\n    panOptions.speed = helpers.getValueOrDefault(chartInstance.options.pan.speed, defaultOptions.pan.speed);\r\n\r\n    helpers.each(chartInstance.scales, function(scale, id) {\r\n      if (scale.isHorizontal() && directionEnabled(panMode, 'x') && deltaX !== 0) {\r\n        panOptions.scaleAxes = 'x';\r\n        panScale(scale, deltaX, panOptions);\r\n      } else if (!scale.isHorizontal() && directionEnabled(panMode, 'y') && deltaY !== 0) {\r\n        panOptions.scaleAxes = 'y';\r\n        panScale(scale, deltaY, panOptions);\r\n      }\r\n    });\r\n\r\n    chartInstance.update(0);\r\n    if (typeof panOptions.onPan === 'function') {\r\n      panOptions.onPan();\r\n    }\r\n  }\r\n}\r\n\r\nfunction positionInChartArea(chartInstance, position) {\r\n  return   (position.x >= chartInstance.chartArea.left && position.x <= chartInstance.chartArea.right) &&\r\n    (position.y >= chartInstance.chartArea.top && position.y <= chartInstance.chartArea.bottom);\r\n}\r\n\r\nfunction getYAxis(chartInstance) {\r\n  const scales = chartInstance.scales;\r\n\r\n  for (const scaleId in scales) {\r\n    if (scales.hasOwnProperty(scaleId)) {\r\n      const scale = scales[scaleId];\r\n      if (!scale.isHorizontal()) {\r\n        return scale;\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n// Store these for later\r\nzoomNS.zoomFunctions.category = zoomIndexScale;\r\nzoomNS.zoomFunctions.time = zoomTimeScale;\r\nzoomNS.zoomFunctions.linear = zoomNumericalScale;\r\nzoomNS.zoomFunctions.logarithmic = zoomNumericalScale;\r\nzoomNS.panFunctions.category = panIndexScale;\r\nzoomNS.panFunctions.time = panTimeScale;\r\nzoomNS.panFunctions.linear = panNumericalScale;\r\nzoomNS.panFunctions.logarithmic = panNumericalScale;\r\n// Globals for catergory pan and zoom\r\nzoomNS.panCumulativeDelta = 0;\r\nzoomNS.zoomCumulativeDelta = 0;\r\n\r\n// Chartjs Zoom Plugin\r\nexport const zoomPlugin = {\r\n  afterInit: function(chartInstance) {\r\n    helpers.each(chartInstance.scales, function(scale) {\r\n      scale.originalOptions = helpers.clone(scale.options);\r\n    });\r\n\r\n    chartInstance.resetZoom = function() {\r\n      helpers.each(chartInstance.scales, function(scale, id) {\r\n        const timeOptions = scale.options.time;\r\n        const tickOptions = scale.options.ticks;\r\n\r\n        if (timeOptions) {\r\n          timeOptions.min = scale.originalOptions.time.min;\r\n          timeOptions.max = scale.originalOptions.time.max;\r\n        }\r\n\r\n        if (tickOptions) {\r\n          tickOptions.min = scale.originalOptions.ticks.min;\r\n          tickOptions.max = scale.originalOptions.ticks.max;\r\n        }\r\n      });\r\n\r\n      helpers.each(chartInstance.data.datasets, function(dataset, id) {\r\n        dataset._meta = null;\r\n      });\r\n\r\n      chartInstance.update();\r\n    };\r\n\r\n  },\r\n  beforeInit: function(chartInstance) {\r\n    chartInstance.zoom = {};\r\n\r\n    const node = chartInstance.zoom.node = chartInstance.chart.ctx.canvas;\r\n\r\n    const options = chartInstance.options;\r\n    const panThreshold = helpers.getValueOrDefault(options.pan ? options.pan.threshold : undefined, zoomNS.defaults.pan.threshold);\r\n    if (!options.zoom || !options.zoom.enabled) {\r\n      return;\r\n    }\r\n    if (options.zoom.drag) {\r\n      // Only want to zoom horizontal axis\r\n      options.zoom.mode = 'x';\r\n\r\n      chartInstance.zoom._mouseDownHandler = function(event) {\r\n        chartInstance.zoom._dragZoomStart = event;\r\n      };\r\n      node.addEventListener('mousedown', chartInstance.zoom._mouseDownHandler);\r\n\r\n      chartInstance.zoom._mouseMoveHandler = function(event) {\r\n        if (chartInstance.zoom._dragZoomStart) {\r\n          chartInstance.zoom._dragZoomEnd = event;\r\n          chartInstance.update(0);\r\n        }\r\n      };\r\n      node.addEventListener('mousemove', chartInstance.zoom._mouseMoveHandler);\r\n\r\n      chartInstance.zoom._mouseUpHandler = function(event) {\r\n        if (chartInstance.zoom._dragZoomStart) {\r\n          const chartArea = chartInstance.chartArea;\r\n          const yAxis = getYAxis(chartInstance);\r\n          const beginPoint = chartInstance.zoom._dragZoomStart;\r\n          const offsetX = beginPoint.target.getBoundingClientRect().left;\r\n          const startX = Math.max(Math.min(beginPoint.clientX, event.clientX) - offsetX, chartArea.left);\r\n          const endX = Math.min(Math.max(beginPoint.clientX, event.clientX) - offsetX, chartArea.right);\r\n          const dragDistance = endX - startX;\r\n          const chartDistance = chartArea.right - chartArea.left;\r\n          const zoom = 1 + (chartDistance - dragDistance) / chartDistance;\r\n          const centerX = chartArea.left + (startX - chartArea.left) / (zoom - 1);\r\n\r\n          // Remove drag start and end before chart update to stop drawing selected area\r\n          chartInstance.zoom._dragZoomStart = null;\r\n          chartInstance.zoom._dragZoomEnd = null;\r\n\r\n          if (dragDistance > 0) {\r\n            doZoom(chartInstance, zoom, {\r\n              x: centerX,\r\n              y: (yAxis.bottom - yAxis.top) / 2,\r\n            });\r\n          }\r\n        }\r\n      };\r\n      // node.addEventListener('mouseup', chartInstance.zoom._mouseUpHandler);\r\n      node.ownerDocument.addEventListener('mouseup', chartInstance.zoom._mouseUpHandler);\r\n    } else {\r\n      chartInstance.zoom._wheelHandler = function(event) {\r\n        const rect = event.target.getBoundingClientRect();\r\n        const offsetX = event.clientX - rect.left;\r\n        const offsetY = event.clientY - rect.top;\r\n\r\n        const center = {\r\n          x : offsetX,\r\n          y : offsetY\r\n        };\r\n\r\n        if (event.deltaY < 0) {\r\n          doZoom(chartInstance, 1.1, center);\r\n        } else {\r\n          doZoom(chartInstance, 0.909, center);\r\n        }\r\n        // Prevent the event from triggering the default behavior (eg. Content scrolling).\r\n        event.preventDefault();\r\n      };\r\n\r\n      node.addEventListener('wheel', chartInstance.zoom._wheelHandler);\r\n    }\r\n\r\n    if (Hammer) {\r\n      const mc = new Hammer.Manager(node);\r\n      mc.add(new Hammer.Pinch());\r\n      mc.add(new Hammer.Pan({\r\n        threshold: panThreshold\r\n      }));\r\n\r\n      // Hammer reports the total scaling. We need the incremental amount\r\n      let currentPinchScaling;\r\n      const handlePinch = function (e) {\r\n        const diff = 1 / (currentPinchScaling) * e.scale;\r\n        const rect = e.target.getBoundingClientRect();\r\n        const offsetX = e.center.x - rect.left;\r\n        const offsetY = e.center.y - rect.top;\r\n        const center = {\r\n          x : offsetX,\r\n          y : offsetY\r\n        };\r\n\r\n        // fingers position difference\r\n        const x = Math.abs(e.pointers[0].clientX - e.pointers[1].clientX);\r\n        const y = Math.abs(e.pointers[0].clientY - e.pointers[1].clientY);\r\n\r\n        // diagonal fingers will change both (xy) axes\r\n        const p = x / y;\r\n        let xy;\r\n        if (p > 0.3 && p < 1.7) {\r\n          xy = 'xy';\r\n        } else if (x > y) {\r\n          // x axis\r\n          xy = 'x';\r\n        } else {\r\n          // y axis\r\n          xy = 'y';\r\n        }\r\n\r\n        doZoom(chartInstance, diff, center, xy);\r\n\r\n        // Keep track of overall scale\r\n        currentPinchScaling = e.scale;\r\n      };\r\n\r\n      mc.on('pinchstart', function(e) {\r\n        currentPinchScaling = 1; // reset tracker\r\n      });\r\n      mc.on('pinch', handlePinch);\r\n      mc.on('pinchend', function(e) {\r\n        handlePinch(e);\r\n        currentPinchScaling = null; // reset\r\n        zoomNS.zoomCumulativeDelta = 0;\r\n      });\r\n\r\n      let currentDeltaX = null, currentDeltaY = null, panning = false;\r\n      const handlePan = function (e) {\r\n        if (currentDeltaX !== null && currentDeltaY !== null) {\r\n          panning = true;\r\n          const deltaX = e.deltaX - currentDeltaX;\r\n          const deltaY = e.deltaY - currentDeltaY;\r\n          currentDeltaX = e.deltaX;\r\n          currentDeltaY = e.deltaY;\r\n          doPan(chartInstance, deltaX, deltaY);\r\n        }\r\n      };\r\n\r\n      mc.on('panstart', function(e) {\r\n        currentDeltaX = 0;\r\n        currentDeltaY = 0;\r\n        handlePan(e);\r\n      });\r\n      mc.on('panmove', handlePan);\r\n      mc.on('panend', function(e) {\r\n        currentDeltaX = null;\r\n        currentDeltaY = null;\r\n        zoomNS.panCumulativeDelta = 0;\r\n        setTimeout(function() { panning = false; }, 500);\r\n      });\r\n\r\n      chartInstance.zoom._ghostClickHandler = function(e) {\r\n        if (panning) {\r\n          e.stopImmediatePropagation();\r\n          e.preventDefault();\r\n        }\r\n      };\r\n      node.addEventListener('click', chartInstance.zoom._ghostClickHandler);\r\n\r\n      chartInstance._mc = mc;\r\n    }\r\n  },\r\n\r\n  beforeDatasetsDraw: function(chartInstance) {\r\n    const ctx = chartInstance.chart.ctx;\r\n    const chartArea = chartInstance.chartArea;\r\n    ctx.save();\r\n    ctx.beginPath();\r\n\r\n    if (chartInstance.zoom._dragZoomEnd) {\r\n      const yAxis = getYAxis(chartInstance);\r\n      const beginPoint = chartInstance.zoom._dragZoomStart;\r\n      const endPoint = chartInstance.zoom._dragZoomEnd;\r\n      const offsetX = beginPoint.target.getBoundingClientRect().left;\r\n      const startX = Math.min(beginPoint.clientX, endPoint.clientX) - offsetX;\r\n      const endX = Math.max(beginPoint.clientX, endPoint.clientX) - offsetX;\r\n      const rectWidth = endX - startX;\r\n\r\n\r\n      ctx.fillStyle = 'rgba(225,225,225,0.5)';\r\n      ctx.lineWidth = 5;\r\n      ctx.fillRect(startX, yAxis.top, rectWidth, yAxis.bottom - yAxis.top);\r\n    }\r\n\r\n    ctx.rect(chartArea.left, chartArea.top, chartArea.right - chartArea.left, chartArea.bottom - chartArea.top);\r\n    ctx.clip();\r\n  },\r\n\r\n  afterDatasetsDraw: function(chartInstance) {\r\n    chartInstance.chart.ctx.restore();\r\n  },\r\n\r\n  destroy: function(chartInstance) {\r\n    if (chartInstance.zoom) {\r\n      const options = chartInstance.options;\r\n      const node = chartInstance.zoom.node;\r\n\r\n      if (options.zoom && options.zoom.drag) {\r\n        node.removeEventListener('mousedown', chartInstance.zoom._mouseDownHandler);\r\n        node.removeEventListener('mousemove', chartInstance.zoom._mouseMoveHandler);\r\n        // node.removeEventListener('mouseup', chartInstance.zoom._mouseUpHandler);\r\n        node.ownerDocument.removeEventListener('mouseup', chartInstance.zoom._mouseUpHandler);\r\n      } else {\r\n        node.removeEventListener('wheel', chartInstance.zoom._wheelHandler);\r\n      }\r\n\r\n      if (Hammer) {\r\n        node.removeEventListener('click', chartInstance.zoom._ghostClickHandler);\r\n      }\r\n\r\n      delete chartInstance.zoom;\r\n\r\n      const mc = chartInstance._mc;\r\n      if (mc) {\r\n        mc.remove('pinchstart');\r\n        mc.remove('pinch');\r\n        mc.remove('pinchend');\r\n        mc.remove('panstart');\r\n        mc.remove('pan');\r\n        mc.remove('panend');\r\n      }\r\n    }\r\n  }\r\n};\r\n\r\nChart.pluginService.register(zoomPlugin);\r\n"]}

package/esm2020/src/nameserver-history-viewer/utils/chartjs-zoom/index.mjs

@@ -0,0 +1,2 @@
+export * from './chart.zoom';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbmFtZXNlcnZlci1oaXN0b3J5LXZpZXdlci91dGlscy9jaGFydGpzLXpvb20vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NoYXJ0Lnpvb20nO1xyXG4iXX0=