ps-toolkit-ui 0.0.207 → 0.0.211

package/src/assets/plugins/highcharts/code/modules/pattern-fill.src.js

@@ -0,0 +1,640 @@
+/**
+ * @license Highcharts JS v9.3.3 (2022-02-01)
+ *
+ * Module for adding patterns and images as point fills.
+ *
+ * (c) 2010-2021 Highsoft AS
+ * Author: Torstein Hønsi, Øystein Moseng
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+(function (factory) {
+    if (typeof module === 'object' && module.exports) {
+        factory['default'] = factory;
+        module.exports = factory;
+    } else if (typeof define === 'function' && define.amd) {
+        define('highcharts/modules/pattern-fill', ['highcharts'], function (Highcharts) {
+            factory(Highcharts);
+            factory.Highcharts = Highcharts;
+            return factory;
+        });
+    } else {
+        factory(typeof Highcharts !== 'undefined' ? Highcharts : undefined);
+    }
+}(function (Highcharts) {
+    var _modules = Highcharts ? Highcharts._modules : {};
+    function _registerModule(obj, path, args, fn) {
+        if (!obj.hasOwnProperty(path)) {
+            obj[path] = fn.apply(null, args);
+        }
+    }
+    _registerModule(_modules, 'Extensions/PatternFill.js', [_modules['Core/Animation/AnimationUtilities.js'], _modules['Core/Chart/Chart.js'], _modules['Core/Globals.js'], _modules['Core/DefaultOptions.js'], _modules['Core/Series/Point.js'], _modules['Core/Series/Series.js'], _modules['Core/Renderer/SVG/SVGRenderer.js'], _modules['Core/Utilities.js']], function (A, Chart, H, D, Point, Series, SVGRenderer, U) {
+        /* *
+         *
+         *  Module for using patterns or images as point fills.
+         *
+         *  (c) 2010-2021 Highsoft AS
+         *  Author: Torstein Hønsi, Øystein Moseng
+         *
+         *  License: www.highcharts.com/license
+         *
+         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+         *
+         * */
+        var animObject = A.animObject;
+        var getOptions = D.getOptions;
+        var addEvent = U.addEvent,
+            erase = U.erase,
+            merge = U.merge,
+            pick = U.pick,
+            removeEvent = U.removeEvent,
+            wrap = U.wrap;
+        // Add the predefined patterns
+        var patterns = H.patterns = (function () {
+                var patterns = [],
+            colors = getOptions().colors;
+            // Start with subtle patterns
+            [
+                'M 0 0 L 5 5 M 4.5 -0.5 L 5.5 0.5 M -0.5 4.5 L 0.5 5.5',
+                'M 0 5 L 5 0 M -0.5 0.5 L 0.5 -0.5 M 4.5 5.5 L 5.5 4.5',
+                'M 2 0 L 2 5 M 4 0 L 4 5',
+                'M 0 2 L 5 2 M 0 4 L 5 4',
+                'M 0 1.5 L 2.5 1.5 L 2.5 0 M 2.5 5 L 2.5 3.5 L 5 3.5'
+            ].forEach(function (pattern, i) {
+                patterns.push({
+                    path: pattern,
+                    color: colors[i],
+                    width: 5,
+                    height: 5,
+                    patternTransform: 'scale(1.4 1.4)'
+                });
+            });
+            // Then add the more drastic ones
+            [
+                'M 0 0 L 5 10 L 10 0',
+                'M 3 3 L 8 3 L 8 8 L 3 8 Z',
+                'M 5 5 m -4 0 a 4 4 0 1 1 8 0 a 4 4 0 1 1 -8 0',
+                'M 0 0 L 10 10 M 9 -1 L 11 1 M -1 9 L 1 11',
+                'M 0 10 L 10 0 M -1 1 L 1 -1 M 9 11 L 11 9'
+            ].forEach(function (pattern, i) {
+                patterns.push({
+                    path: pattern,
+                    color: colors[i + 5],
+                    width: 10,
+                    height: 10
+                });
+            });
+            return patterns;
+        })();
+        /**
+         * Utility function to compute a hash value from an object. Modified Java
+         * String.hashCode implementation in JS. Use the preSeed parameter to add an
+         * additional seeding step.
+         *
+         * @private
+         * @function hashFromObject
+         *
+         * @param {Object} obj
+         *        The javascript object to compute the hash from.
+         *
+         * @param {boolean} [preSeed=false]
+         *        Add an optional preSeed stage.
+         *
+         * @return {string}
+         *         The computed hash.
+         */
+        function hashFromObject(obj, preSeed) {
+            var str = JSON.stringify(obj),
+                strLen = str.length || 0;
+            var hash = 0,
+                i = 0,
+                char,
+                seedStep;
+            if (preSeed) {
+                seedStep = Math.max(Math.floor(strLen / 500), 1);
+                for (var a = 0; a < strLen; a += seedStep) {
+                    hash += str.charCodeAt(a);
+                }
+                hash = hash & hash;
+            }
+            for (; i < strLen; ++i) {
+                char = str.charCodeAt(i);
+                hash = ((hash << 5) - hash) + char;
+                hash = hash & hash;
+            }
+            return hash.toString(16).replace('-', '1');
+        }
+        /**
+         * Set dimensions on pattern from point. This function will set internal
+         * pattern._width/_height properties if width and height are not both already
+         * set. We only do this on image patterns. The _width/_height properties are set
+         * to the size of the bounding box of the point, optionally taking aspect ratio
+         * into account. If only one of width or height are supplied as options, the
+         * undefined option is calculated as above.
+         *
+         * @private
+         * @function Highcharts.Point#calculatePatternDimensions
+         *
+         * @param {Highcharts.PatternOptionsObject} pattern
+         *        The pattern to set dimensions on.
+         *
+         * @return {void}
+         *
+         * @requires modules/pattern-fill
+         */
+        Point.prototype.calculatePatternDimensions = function (pattern) {
+            if (pattern.width && pattern.height) {
+                return;
+            }
+            var bBox = this.graphic && (this.graphic.getBBox &&
+                    this.graphic.getBBox(true) ||
+                    this.graphic.element &&
+                        this.graphic.element.getBBox()) || {},
+                shapeArgs = this.shapeArgs;
+            // Prefer using shapeArgs, as it is animation agnostic
+            if (shapeArgs) {
+                bBox.width = shapeArgs.width || bBox.width;
+                bBox.height = shapeArgs.height || bBox.height;
+                bBox.x = shapeArgs.x || bBox.x;
+                bBox.y = shapeArgs.y || bBox.y;
+            }
+            // For images we stretch to bounding box
+            if (pattern.image) {
+                // If we do not have a bounding box at this point, simply add a defer
+                // key and pick this up in the fillSetter handler, where the bounding
+                // box should exist.
+                if (!bBox.width || !bBox.height) {
+                    pattern._width = 'defer';
+                    pattern._height = 'defer';
+                    return;
+                }
+                // Handle aspect ratio filling
+                if (pattern.aspectRatio) {
+                    bBox.aspectRatio = bBox.width / bBox.height;
+                    if (pattern.aspectRatio > bBox.aspectRatio) {
+                        // Height of bBox will determine width
+                        bBox.aspectWidth = bBox.height * pattern.aspectRatio;
+                    }
+                    else {
+                        // Width of bBox will determine height
+                        bBox.aspectHeight = bBox.width / pattern.aspectRatio;
+                    }
+                }
+                // We set the width/height on internal properties to differentiate
+                // between the options set by a user and by this function.
+                pattern._width = pattern.width ||
+                    Math.ceil(bBox.aspectWidth || bBox.width);
+                pattern._height = pattern.height ||
+                    Math.ceil(bBox.aspectHeight || bBox.height);
+            }
+            // Set x/y accordingly, centering if using aspect ratio, otherwise adjusting
+            // so bounding box corner is 0,0 of pattern.
+            if (!pattern.width) {
+                pattern._x = pattern.x || 0;
+                pattern._x += bBox.x - Math.round(bBox.aspectWidth ?
+                    Math.abs(bBox.aspectWidth - bBox.width) / 2 :
+                    0);
+            }
+            if (!pattern.height) {
+                pattern._y = pattern.y || 0;
+                pattern._y += bBox.y - Math.round(bBox.aspectHeight ?
+                    Math.abs(bBox.aspectHeight - bBox.height) / 2 :
+                    0);
+            }
+        };
+        /* eslint-disable no-invalid-this */
+        /**
+         * Add a pattern to the renderer.
+         *
+         * @private
+         * @function Highcharts.SVGRenderer#addPattern
+         *
+         * @param {Highcharts.PatternObject} options
+         * The pattern options.
+         *
+         * @param {boolean|Partial<Highcharts.AnimationOptionsObject>} [animation]
+         * The animation options.
+         *
+         * @return {Highcharts.SVGElement|undefined}
+         * The added pattern. Undefined if the pattern already exists.
+         *
+         * @requires modules/pattern-fill
+         */
+        SVGRenderer.prototype.addPattern = function (options, animation) {
+            var pattern,
+                animate = pick(animation,
+                true),
+                animationOptions = animObject(animate),
+                path,
+                defaultSize = 32,
+                width = options.width || options._width || defaultSize,
+                height = (options.height || options._height || defaultSize),
+                color = options.color || '#343434',
+                id = options.id,
+                ren = this,
+                rect = function (fill) {
+                    ren.rect(0, 0,
+                width,
+                height)
+                        .attr({ fill: fill })
+                        .add(pattern);
+            }, attribs;
+            if (!id) {
+                this.idCounter = this.idCounter || 0;
+                id = ('highcharts-pattern-' +
+                    this.idCounter +
+                    '-' +
+                    (this.chartIndex || 0));
+                ++this.idCounter;
+            }
+            if (this.forExport) {
+                id += '-export';
+            }
+            // Do nothing if ID already exists
+            this.defIds = this.defIds || [];
+            if (this.defIds.indexOf(id) > -1) {
+                return;
+            }
+            // Store ID in list to avoid duplicates
+            this.defIds.push(id);
+            // Calculate pattern element attributes
+            var attrs = {
+                    id: id,
+                    patternUnits: 'userSpaceOnUse',
+                    patternContentUnits: options.patternContentUnits || 'userSpaceOnUse',
+                    width: width,
+                    height: height,
+                    x: options._x || options.x || 0,
+                    y: options._y || options.y || 0
+                };
+            if (options.patternTransform) {
+                attrs.patternTransform = options.patternTransform;
+            }
+            pattern = this.createElement('pattern').attr(attrs).add(this.defs);
+            // Set id on the SVGRenderer object
+            pattern.id = id;
+            // Use an SVG path for the pattern
+            if (options.path) {
+                path = U.isObject(options.path) ?
+                    options.path :
+                    { d: options.path };
+                // The background
+                if (options.backgroundColor) {
+                    rect(options.backgroundColor);
+                }
+                // The pattern
+                attribs = {
+                    'd': path.d
+                };
+                if (!this.styledMode) {
+                    attribs.stroke = path.stroke || color;
+                    attribs['stroke-width'] = pick(path.strokeWidth, 2);
+                    attribs.fill = path.fill || 'none';
+                }
+                if (path.transform) {
+                    attribs.transform = path.transform;
+                }
+                this.createElement('path').attr(attribs).add(pattern);
+                pattern.color = color;
+                // Image pattern
+            }
+            else if (options.image) {
+                if (animate) {
+                    this.image(options.image, 0, 0, width, height, function () {
+                        // Onload
+                        this.animate({
+                            opacity: pick(options.opacity, 1)
+                        }, animationOptions);
+                        removeEvent(this.element, 'load');
+                    }).attr({ opacity: 0 }).add(pattern);
+                }
+                else {
+                    this.image(options.image, 0, 0, width, height).add(pattern);
+                }
+            }
+            // For non-animated patterns, set opacity now
+            if (!(options.image && animate) && typeof options.opacity !== 'undefined') {
+                [].forEach.call(pattern.element.childNodes, function (child) {
+                    child.setAttribute('opacity', options.opacity);
+                });
+            }
+            // Store for future reference
+            this.patternElements = this.patternElements || {};
+            this.patternElements[id] = pattern;
+            return pattern;
+        };
+        // Make sure we have a series color
+        wrap(Series.prototype, 'getColor', function (proceed) {
+            var oldColor = this.options.color;
+            // Temporarely remove color options to get defaults
+            if (oldColor &&
+                oldColor.pattern &&
+                !oldColor.pattern.color) {
+                delete this.options.color;
+                // Get default
+                proceed.apply(this, Array.prototype.slice.call(arguments, 1));
+                // Replace with old, but add default color
+                oldColor.pattern.color =
+                    this.color;
+                this.color = this.options.color = oldColor;
+            }
+            else {
+                // We have a color, no need to do anything special
+                proceed.apply(this, Array.prototype.slice.call(arguments, 1));
+            }
+        });
+        // Calculate pattern dimensions on points that have their own pattern.
+        addEvent(Series, 'render', function () {
+            var isResizing = this.chart.isResizing;
+            if (this.isDirtyData || isResizing || !this.chart.hasRendered) {
+                (this.points || []).forEach(function (point) {
+                    var colorOptions = point.options && point.options.color;
+                    if (colorOptions &&
+                        colorOptions.pattern) {
+                        // For most points we want to recalculate the dimensions on
+                        // render, where we have the shape args and bbox. But if we
+                        // are resizing and don't have the shape args, defer it, since
+                        // the bounding box is still not resized.
+                        if (isResizing &&
+                            !(point.shapeArgs &&
+                                point.shapeArgs.width &&
+                                point.shapeArgs.height)) {
+                            colorOptions
+                                .pattern._width = 'defer';
+                            colorOptions
+                                .pattern._height = 'defer';
+                        }
+                        else {
+                            point.calculatePatternDimensions(colorOptions.pattern);
+                        }
+                    }
+                });
+            }
+        });
+        // Merge series color options to points
+        addEvent(Point, 'afterInit', function () {
+            var point = this,
+                colorOptions = point.options.color;
+            // Only do this if we have defined a specific color on this point. Otherwise
+            // we will end up trying to re-add the series color for each point.
+            if (colorOptions && colorOptions.pattern) {
+                // Move path definition to object, allows for merge with series path
+                // definition
+                if (typeof colorOptions.pattern.path === 'string') {
+                    colorOptions.pattern.path = {
+                        d: colorOptions.pattern.path
+                    };
+                }
+                // Merge with series options
+                point.color = point.options.color = merge(point.series.options.color, colorOptions);
+            }
+        });
+        // Add functionality to SVG renderer to handle patterns as complex colors
+        addEvent(SVGRenderer, 'complexColor', function (args) {
+            var color = args.args[0],
+                prop = args.args[1],
+                element = args.args[2],
+                chartIndex = (this.chartIndex || 0);
+            var pattern = color.pattern,
+                value = '#343434';
+            // Handle patternIndex
+            if (typeof color.patternIndex !== 'undefined' && patterns) {
+                pattern = patterns[color.patternIndex];
+            }
+            // Skip and call default if there is no pattern
+            if (!pattern) {
+                return true;
+            }
+            // We have a pattern.
+            if (pattern.image ||
+                typeof pattern.path === 'string' ||
+                pattern.path && pattern.path.d) {
+                // Real pattern. Add it and set the color value to be a reference.
+                // Force Hash-based IDs for legend items, as they are drawn before
+                // point render, meaning they are drawn before autocalculated image
+                // width/heights. We don't want them to highjack the width/height for
+                // this ID if it is defined by users.
+                var forceHashId = element.parentNode &&
+                        element.parentNode.getAttribute('class');
+                forceHashId = forceHashId &&
+                    forceHashId.indexOf('highcharts-legend') > -1;
+                // If we don't have a width/height yet, handle it. Try faking a point
+                // and running the algorithm again.
+                if (pattern._width === 'defer' || pattern._height === 'defer') {
+                    Point.prototype.calculatePatternDimensions.call({ graphic: { element: element } }, pattern);
+                }
+                // If we don't have an explicit ID, compute a hash from the
+                // definition and use that as the ID. This ensures that points with
+                // the same pattern definition reuse existing pattern elements by
+                // default. We combine two hashes, the second with an additional
+                // preSeed algorithm, to minimize collision probability.
+                if (forceHashId || !pattern.id) {
+                    // Make a copy so we don't accidentally edit options when setting ID
+                    pattern = merge({}, pattern);
+                    pattern.id = 'highcharts-pattern-' + chartIndex + '-' +
+                        hashFromObject(pattern) + hashFromObject(pattern, true);
+                }
+                // Add it. This function does nothing if an element with this ID
+                // already exists.
+                this.addPattern(pattern, !this.forExport && pick(pattern.animation, this.globalAnimation, { duration: 100 }));
+                value = "url(" + this.url + "#" + (pattern.id + (this.forExport ? '-export' : '')) + ")";
+            }
+            else {
+                // Not a full pattern definition, just add color
+                value = pattern.color || value;
+            }
+            // Set the fill/stroke prop on the element
+            element.setAttribute(prop, value);
+            // Allow the color to be concatenated into tooltips formatters etc.
+            color.toString = function () {
+                return value;
+            };
+            // Skip default handler
+            return false;
+        });
+        // When animation is used, we have to recalculate pattern dimensions after
+        // resize, as the bounding boxes are not available until then.
+        addEvent(Chart, 'endResize', function () {
+            if ((this.renderer && this.renderer.defIds || []).filter(function (id) {
+                return (id &&
+                    id.indexOf &&
+                    id.indexOf('highcharts-pattern-') === 0);
+            }).length) {
+                // We have non-default patterns to fix. Find them by looping through
+                // all points.
+                this.series.forEach(function (series) {
+                    series.points.forEach(function (point) {
+                        var colorOptions = point.options && point.options.color;
+                        if (colorOptions &&
+                            colorOptions.pattern) {
+                            colorOptions.pattern
+                                ._width = 'defer';
+                            colorOptions.pattern
+                                ._height = 'defer';
+                        }
+                    });
+                });
+                // Redraw without animation
+                this.redraw(false);
+            }
+        });
+        // Add a garbage collector to delete old patterns with autogenerated hashes that
+        // are no longer being referenced.
+        addEvent(Chart, 'redraw', function () {
+            var usedIds = {},
+                renderer = this.renderer, 
+                // Get the autocomputed patterns - these are the ones we might delete
+                patterns = (renderer.defIds || []).filter(function (pattern) {
+                    return (pattern.indexOf &&
+                        pattern.indexOf('highcharts-pattern-') === 0);
+            });
+            if (patterns.length) {
+                // Look through the DOM for usage of the patterns. This can be points,
+                // series, tooltips etc.
+                [].forEach.call(this.renderTo.querySelectorAll('[color^="url("], [fill^="url("], [stroke^="url("]'), function (node) {
+                    var id = node.getAttribute('fill') ||
+                            node.getAttribute('color') ||
+                            node.getAttribute('stroke');
+                    if (id) {
+                        var sanitizedId = id
+                                .replace(renderer.url, '')
+                                .replace('url(#', '')
+                                .replace(')', '');
+                        usedIds[sanitizedId] = true;
+                    }
+                });
+                // Loop through the patterns that exist and see if they are used
+                patterns.forEach(function (id) {
+                    if (!usedIds[id]) {
+                        // Remove id from used id list
+                        erase(renderer.defIds, id);
+                        // Remove pattern element
+                        if (renderer.patternElements[id]) {
+                            renderer.patternElements[id].destroy();
+                            delete renderer.patternElements[id];
+                        }
+                    }
+                });
+            }
+        });
+        /* *
+         *
+         *  API Declarations
+         *
+         * */
+        /**
+         * Pattern options
+         *
+         * @interface Highcharts.PatternOptionsObject
+         */ /**
+        * Background color for the pattern if a `path` is set (not images).
+        * @name Highcharts.PatternOptionsObject#backgroundColor
+        * @type {Highcharts.ColorString}
+        */ /**
+        * URL to an image to use as the pattern.
+        * @name Highcharts.PatternOptionsObject#image
+        * @type {string}
+        */ /**
+        * Width of the pattern. For images this is automatically set to the width of
+        * the element bounding box if not supplied. For non-image patterns the default
+        * is 32px. Note that automatic resizing of image patterns to fill a bounding
+        * box dynamically is only supported for patterns with an automatically
+        * calculated ID.
+        * @name Highcharts.PatternOptionsObject#width
+        * @type {number}
+        */ /**
+        * Analogous to pattern.width.
+        * @name Highcharts.PatternOptionsObject#height
+        * @type {number}
+        */ /**
+        * For automatically calculated width and height on images, it is possible to
+        * set an aspect ratio. The image will be zoomed to fill the bounding box,
+        * maintaining the aspect ratio defined.
+        * @name Highcharts.PatternOptionsObject#aspectRatio
+        * @type {number}
+        */ /**
+        * Horizontal offset of the pattern. Defaults to 0.
+        * @name Highcharts.PatternOptionsObject#x
+        * @type {number|undefined}
+        */ /**
+        * Vertical offset of the pattern. Defaults to 0.
+        * @name Highcharts.PatternOptionsObject#y
+        * @type {number|undefined}
+        */ /**
+        * Either an SVG path as string, or an object. As an object, supply the path
+        * string in the `path.d` property. Other supported properties are standard SVG
+        * attributes like `path.stroke` and `path.fill`. If a path is supplied for the
+        * pattern, the `image` property is ignored.
+        * @name Highcharts.PatternOptionsObject#path
+        * @type {string|Highcharts.SVGAttributes}
+        */ /**
+        * SVG `patternTransform` to apply to the entire pattern.
+        * @name Highcharts.PatternOptionsObject#patternTransform
+        * @type {string}
+        * @see [patternTransform demo](https://jsfiddle.net/gh/get/library/pure/highcharts/highcharts/tree/master/samples/highcharts/series/pattern-fill-transform)
+        */ /**
+        * Pattern color, used as default path stroke.
+        * @name Highcharts.PatternOptionsObject#color
+        * @type {Highcharts.ColorString}
+        */ /**
+        * Opacity of the pattern as a float value from 0 to 1.
+        * @name Highcharts.PatternOptionsObject#opacity
+        * @type {number}
+        */ /**
+        * ID to assign to the pattern. This is automatically computed if not added, and
+        * identical patterns are reused. To refer to an existing pattern for a
+        * Highcharts color, use `color: "url(#pattern-id)"`.
+        * @name Highcharts.PatternOptionsObject#id
+        * @type {string|undefined}
+        */
+        /**
+         * Holds a pattern definition.
+         *
+         * @sample highcharts/series/pattern-fill-area/
+         *         Define a custom path pattern
+         * @sample highcharts/series/pattern-fill-pie/
+         *         Default patterns and a custom image pattern
+         * @sample maps/demo/pattern-fill-map/
+         *         Custom images on map
+         *
+         * @example
+         * // Pattern used as a color option
+         * color: {
+         *     pattern: {
+         *            path: {
+         *                 d: 'M 3 3 L 8 3 L 8 8 Z',
+         *                fill: '#102045'
+         *            },
+         *            width: 12,
+         *            height: 12,
+         *            color: '#907000',
+         *            opacity: 0.5
+         *     }
+         * }
+         *
+         * @interface Highcharts.PatternObject
+         */ /**
+        * Pattern options
+        * @name Highcharts.PatternObject#pattern
+        * @type {Highcharts.PatternOptionsObject}
+        */ /**
+        * Animation options for the image pattern loading.
+        * @name Highcharts.PatternObject#animation
+        * @type {boolean|Partial<Highcharts.AnimationOptionsObject>|undefined}
+        */ /**
+        * Optionally an index referencing which pattern to use. Highcharts adds
+        * 10 default patterns to the `Highcharts.patterns` array. Additional
+        * pattern definitions can be pushed to this array if desired. This option
+        * is an index into this array.
+        * @name Highcharts.PatternObject#patternIndex
+        * @type {number|undefined}
+        */
+        ''; // keeps doclets above in transpiled file
+
+    });
+    _registerModule(_modules, 'masters/modules/pattern-fill.src.js', [], function () {
+
+
+    });
+}));

package/src/assets/plugins/highcharts/code/modules/price-indicator.js

@@ -0,0 +1,15 @@
+/*
+ Highstock JS v9.3.3 (2022-02-01)
+
+ Advanced Highcharts Stock tools
+
+ (c) 2010-2021 Highsoft AS
+ Author: Torstein Honsi
+
+ License: www.highcharts.com/license
+*/
+'use strict';(function(a){"object"===typeof module&&module.exports?(a["default"]=a,module.exports=a):"function"===typeof define&&define.amd?define("highcharts/modules/price-indicator",["highcharts","highcharts/modules/stock"],function(c){a(c);a.Highcharts=c;return a}):a("undefined"!==typeof Highcharts?Highcharts:void 0)})(function(a){function c(a,d,c,f){a.hasOwnProperty(d)||(a[d]=f.apply(null,c))}a=a?a._modules:{};c(a,"Extensions/PriceIndication.js",[a["Core/Series/Series.js"],a["Core/Utilities.js"]],
+function(a,c){var d=c.addEvent,f=c.isArray,m=c.merge;d(a,"afterRender",function(){var a=this.options,c=a.pointRange,d=a.lastVisiblePrice,e=a.lastPrice;if((d||e)&&"highcharts-navigator-series"!==a.id){var n=this.xAxis,b=this.yAxis,p=b.crosshair,q=b.cross,r=b.crossLabel,g=this.points,h=g.length,k=this.xData[this.xData.length-1],l=this.yData[this.yData.length-1];e&&e.enabled&&(b.crosshair=b.options.crosshair=a.lastPrice,!this.chart.styledMode&&b.crosshair&&b.options.crosshair&&a.lastPrice&&(b.crosshair.color=
+b.options.crosshair.color=a.lastPrice.color||this.color),b.cross=this.lastPrice,e=f(l)?l[3]:l,b.drawCrosshair(null,{x:k,y:e,plotX:n.toPixels(k,!0),plotY:b.toPixels(e,!0)}),this.yAxis.cross&&(this.lastPrice=this.yAxis.cross,this.lastPrice.addClass("highcharts-color-"+this.colorIndex),this.lastPrice.y=e));d&&d.enabled&&0<h&&(c=g[h-1].x===k||null===c?1:2,b.crosshair=b.options.crosshair=m({color:"transparent"},a.lastVisiblePrice),b.cross=this.lastVisiblePrice,a=g[h-c],this.crossLabel&&this.crossLabel.destroy(),
+delete b.crossLabel,b.drawCrosshair(null,a),b.cross&&(this.lastVisiblePrice=b.cross,"number"===typeof a.y&&(this.lastVisiblePrice.y=a.y)),this.crossLabel=b.crossLabel);b.crosshair=b.options.crosshair=p;b.cross=q;b.crossLabel=r}})});c(a,"masters/modules/price-indicator.src.js",[],function(){})});
+//# sourceMappingURL=price-indicator.js.map

package/src/assets/plugins/highcharts/code/modules/price-indicator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"price-indicator.js.map","lineCount":14,"mappings":"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","sources":["price-indicator.src.js"],"names":["factory","module","exports","define","amd","Highcharts","undefined","_registerModule","obj","path","args","fn","hasOwnProperty","apply","_modules","Series","U","addEvent","isArray","merge","seriesOptions","series","options","pointRange","lastVisiblePrice","lastPrice","id","xAxis","yAxis","origOptions","crosshair","origGraphic","cross","origLabel","crossLabel","points","pLength","length","x","xData","y","yData","enabled","chart","styledMode","color","yValue","drawCrosshair","plotX","toPixels","plotY","addClass","colorIndex","crop","lastPoint","destroy"]}