{"version":3,"file":"static/js/3710.c500ab3a.js","mappings":"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","sources":["../node_modules/plotly.js/src/locale-en.js","../node_modules/plotly.js/src/lib/svg_text_utils.js","../node_modules/plotly.js/src/lib/noop.js","../node_modules/plotly.js/src/lib/preserve_drawing_buffer.js","../node_modules/plotly.js/src/lib/setcursor.js","../node_modules/plotly.js/src/lib/polygon.js","../node_modules/plotly.js/src/lib/search.js","../node_modules/plotly.js/src/locale-en-us.js","../node_modules/plotly.js/src/lib/queue.js","../node_modules/plotly.js/src/lib/nested_property.js","../node_modules/plotly.js/src/lib/to_log_range.js","../node_modules/plotly.js/src/lib/stats.js","../node_modules/plotly.js/src/lib/regex.js","../node_modules/plotly.js/src/lib/push_unique.js","../node_modules/plotly.js/src/lib/override_cursor.js","../node_modules/plotly.js/src/lib/notifier.js","../node_modules/plotly.js/src/lib/relink_private.js","../node_modules/plotly.js/src/lib/sort_object_keys.js","../node_modules/plotly.js/src/lib/supports_pixelated_image.js","../node_modules/plotly.js/src/lib/throttle.js","../node_modules/plotly.js/src/lib/relative_attr.js"],"sourcesContent":["'use strict';\n\nmodule.exports = {\n    moduleType: 'locale',\n    name: 'en',\n    dictionary: {\n        'Click to enter Colorscale title': 'Click to enter Colourscale title'\n    },\n    format: {\n        days: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],\n        shortDays: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],\n        months: [\n            'January', 'February', 'March', 'April', 'May', 'June',\n            'July', 'August', 'September', 'October', 'November', 'December'\n        ],\n        shortMonths: [\n            'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',\n            'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'\n        ],\n        periods: ['AM', 'PM'],\n        dateTime: '%a %b %e %X %Y',\n        date: '%d/%m/%Y',\n        time: '%H:%M:%S',\n        decimal: '.',\n        thousands: ',',\n        grouping: [3],\n        currency: ['$', ''],\n        year: '%Y',\n        month: '%b %Y',\n        dayMonth: '%b %-d',\n        dayMonthYear: '%b %-d, %Y'\n    }\n};\n","'use strict';\n\n/* global MathJax:false */\n\nvar d3 = require('@plotly/d3');\n\nvar Lib = require('../lib');\nvar strTranslate = Lib.strTranslate;\nvar xmlnsNamespaces = require('../constants/xmlns_namespaces');\nvar LINE_SPACING = require('../constants/alignment').LINE_SPACING;\n\n// text converter\n\nvar FIND_TEX = /([^$]*)([$]+[^$]*[$]+)([^$]*)/;\n\nexports.convertToTspans = function(_context, gd, _callback) {\n    var str = _context.text();\n\n    // Until we get tex integrated more fully (so it can be used along with non-tex)\n    // allow some elements to prohibit it by attaching 'data-notex' to the original\n    var tex = (!_context.attr('data-notex')) &&\n        gd && gd._context.typesetMath &&\n        (typeof MathJax !== 'undefined') &&\n        str.match(FIND_TEX);\n\n    var parent = d3.select(_context.node().parentNode);\n    if(parent.empty()) return;\n    var svgClass = (_context.attr('class')) ? _context.attr('class').split(' ')[0] : 'text';\n    svgClass += '-math';\n    parent.selectAll('svg.' + svgClass).remove();\n    parent.selectAll('g.' + svgClass + '-group').remove();\n    _context.style('display', null)\n        .attr({\n            // some callers use data-unformatted *from the <text> element* in 'cancel'\n            // so we need it here even if we're going to turn it into math\n            // these two (plus style and text-anchor attributes) form the key we're\n            // going to use for Drawing.bBox\n            'data-unformatted': str,\n            'data-math': 'N'\n        });\n\n    function showText() {\n        if(!parent.empty()) {\n            svgClass = _context.attr('class') + '-math';\n            parent.select('svg.' + svgClass).remove();\n        }\n        _context.text('')\n            .style('white-space', 'pre');\n\n        var hasLink = buildSVGText(_context.node(), str);\n\n        if(hasLink) {\n            // at least in Chrome, pointer-events does not seem\n            // to be honored in children of <text> elements\n            // so if we have an anchor, we have to make the\n            // whole element respond\n            _context.style('pointer-events', 'all');\n        }\n\n        exports.positionText(_context);\n\n        if(_callback) _callback.call(_context);\n    }\n\n    if(tex) {\n        ((gd && gd._promises) || []).push(new Promise(function(resolve) {\n            _context.style('display', 'none');\n            var fontSize = parseInt(_context.node().style.fontSize, 10);\n            var config = {fontSize: fontSize};\n\n            texToSVG(tex[2], config, function(_svgEl, _glyphDefs, _svgBBox) {\n                parent.selectAll('svg.' + svgClass).remove();\n                parent.selectAll('g.' + svgClass + '-group').remove();\n\n                var newSvg = _svgEl && _svgEl.select('svg');\n                if(!newSvg || !newSvg.node()) {\n                    showText();\n                    resolve();\n                    return;\n                }\n\n                var mathjaxGroup = parent.append('g')\n                    .classed(svgClass + '-group', true)\n                    .attr({\n                        'pointer-events': 'none',\n                        'data-unformatted': str,\n                        'data-math': 'Y'\n                    });\n\n                mathjaxGroup.node().appendChild(newSvg.node());\n\n                // stitch the glyph defs\n                if(_glyphDefs && _glyphDefs.node()) {\n                    newSvg.node().insertBefore(_glyphDefs.node().cloneNode(true),\n                                               newSvg.node().firstChild);\n                }\n\n                var w0 = _svgBBox.width;\n                var h0 = _svgBBox.height;\n\n                newSvg.attr({\n                    class: svgClass,\n                    height: h0,\n                    preserveAspectRatio: 'xMinYMin meet'\n                })\n                .style({overflow: 'visible', 'pointer-events': 'none'});\n\n                var fill = _context.node().style.fill || 'black';\n                var g = newSvg.select('g');\n                g.attr({fill: fill, stroke: fill});\n\n                var bb = g.node().getBoundingClientRect();\n                var w = bb.width;\n                var h = bb.height;\n\n                if(w > w0 || h > h0) {\n                    // this happen in firefox v82+ | see https://bugzilla.mozilla.org/show_bug.cgi?id=1709251 addressed\n                    // temporary fix:\n                    newSvg.style('overflow', 'hidden');\n                    bb = newSvg.node().getBoundingClientRect();\n                    w = bb.width;\n                    h = bb.height;\n                }\n\n                var x = +_context.attr('x');\n                var y = +_context.attr('y');\n\n                // font baseline is about 1/4 fontSize below centerline\n                var textHeight = fontSize || _context.node().getBoundingClientRect().height;\n                var dy = -textHeight / 4;\n\n                if(svgClass[0] === 'y') {\n                    mathjaxGroup.attr({\n                        transform: 'rotate(' + [-90, x, y] +\n                        ')' + strTranslate(-w / 2, dy - h / 2)\n                    });\n                } else if(svgClass[0] === 'l') {\n                    y = dy - h / 2;\n                } else if(svgClass[0] === 'a' && svgClass.indexOf('atitle') !== 0) {\n                    x = 0;\n                    y = dy;\n                } else {\n                    var anchor = _context.attr('text-anchor');\n\n                    x = x - w * (\n                        anchor === 'middle' ? 0.5 :\n                        anchor === 'end' ? 1 : 0\n                    );\n                    y = y + dy - h / 2;\n                }\n\n                newSvg.attr({\n                    x: x,\n                    y: y\n                });\n\n                if(_callback) _callback.call(_context, mathjaxGroup);\n                resolve(mathjaxGroup);\n            });\n        }));\n    } else showText();\n\n    return _context;\n};\n\n\n// MathJax\n\nvar LT_MATCH = /(<|&lt;|&#60;)/g;\nvar GT_MATCH = /(>|&gt;|&#62;)/g;\n\nfunction cleanEscapesForTex(s) {\n    return s.replace(LT_MATCH, '\\\\lt ')\n        .replace(GT_MATCH, '\\\\gt ');\n}\n\nvar inlineMath = [['$', '$'], ['\\\\(', '\\\\)']];\n\nfunction texToSVG(_texString, _config, _callback) {\n    var MathJaxVersion = parseInt(\n        (MathJax.version || '').split('.')[0]\n    );\n\n    if(\n        MathJaxVersion !== 2 &&\n        MathJaxVersion !== 3\n    ) {\n        Lib.warn('No MathJax version:', MathJax.version);\n        return;\n    }\n\n    var originalRenderer,\n        originalConfig,\n        originalProcessSectionDelay,\n        tmpDiv;\n\n    var setConfig2 = function() {\n        originalConfig = Lib.extendDeepAll({}, MathJax.Hub.config);\n\n        originalProcessSectionDelay = MathJax.Hub.processSectionDelay;\n        if(MathJax.Hub.processSectionDelay !== undefined) {\n            // MathJax 2.5+ but not 3+\n            MathJax.Hub.processSectionDelay = 0;\n        }\n\n        return MathJax.Hub.Config({\n            messageStyle: 'none',\n            tex2jax: {\n                inlineMath: inlineMath\n            },\n            displayAlign: 'left',\n        });\n    };\n\n    var setConfig3 = function() {\n        originalConfig = Lib.extendDeepAll({}, MathJax.config);\n\n        if(!MathJax.config.tex) {\n            MathJax.config.tex = {};\n        }\n\n        MathJax.config.tex.inlineMath = inlineMath;\n    };\n\n    var setRenderer2 = function() {\n        originalRenderer = MathJax.Hub.config.menuSettings.renderer;\n        if(originalRenderer !== 'SVG') {\n            return MathJax.Hub.setRenderer('SVG');\n        }\n    };\n\n    var setRenderer3 = function() {\n        originalRenderer = MathJax.config.startup.output;\n        if(originalRenderer !== 'svg') {\n            MathJax.config.startup.output = 'svg';\n        }\n    };\n\n    var initiateMathJax = function() {\n        var randomID = 'math-output-' + Lib.randstr({}, 64);\n        tmpDiv = d3.select('body').append('div')\n            .attr({id: randomID})\n            .style({\n                visibility: 'hidden',\n                position: 'absolute',\n                'font-size': _config.fontSize + 'px'\n            })\n            .text(cleanEscapesForTex(_texString));\n\n        var tmpNode = tmpDiv.node();\n\n        return MathJaxVersion === 2 ?\n            MathJax.Hub.Typeset(tmpNode) :\n            MathJax.typeset([tmpNode]);\n    };\n\n    var finalizeMathJax = function() {\n        var sel = tmpDiv.select(\n            MathJaxVersion === 2 ? '.MathJax_SVG' : '.MathJax'\n        );\n\n        var node = !sel.empty() && tmpDiv.select('svg').node();\n        if(!node) {\n            Lib.log('There was an error in the tex syntax.', _texString);\n            _callback();\n        } else {\n            var nodeBBox = node.getBoundingClientRect();\n            var glyphDefs;\n            if(MathJaxVersion === 2) {\n                glyphDefs = d3.select('body').select('#MathJax_SVG_glyphs');\n            } else {\n                glyphDefs = sel.select('defs');\n            }\n            _callback(sel, glyphDefs, nodeBBox);\n        }\n\n        tmpDiv.remove();\n    };\n\n    var resetRenderer2 = function() {\n        if(originalRenderer !== 'SVG') {\n            return MathJax.Hub.setRenderer(originalRenderer);\n        }\n    };\n\n    var resetRenderer3 = function() {\n        if(originalRenderer !== 'svg') {\n            MathJax.config.startup.output = originalRenderer;\n        }\n    };\n\n    var resetConfig2 = function() {\n        if(originalProcessSectionDelay !== undefined) {\n            MathJax.Hub.processSectionDelay = originalProcessSectionDelay;\n        }\n        return MathJax.Hub.Config(originalConfig);\n    };\n\n    var resetConfig3 = function() {\n        MathJax.config = originalConfig;\n    };\n\n    if(MathJaxVersion === 2) {\n        MathJax.Hub.Queue(\n            setConfig2,\n            setRenderer2,\n            initiateMathJax,\n            finalizeMathJax,\n            resetRenderer2,\n            resetConfig2\n        );\n    } else if(MathJaxVersion === 3) {\n        setConfig3();\n        setRenderer3();\n        MathJax.startup.defaultReady();\n\n        MathJax.startup.promise.then(function() {\n            initiateMathJax();\n            finalizeMathJax();\n\n            resetRenderer3();\n            resetConfig3();\n        });\n    }\n}\n\nvar TAG_STYLES = {\n    // would like to use baseline-shift for sub/sup but FF doesn't support it\n    // so we need to use dy along with the uber hacky shift-back-to\n    // baseline below\n    sup: 'font-size:70%',\n    sub: 'font-size:70%',\n    b: 'font-weight:bold',\n    i: 'font-style:italic',\n    a: 'cursor:pointer',\n    span: '',\n    em: 'font-style:italic;font-weight:bold'\n};\n\n// baseline shifts for sub and sup\nvar SHIFT_DY = {\n    sub: '0.3em',\n    sup: '-0.6em'\n};\n// reset baseline by adding a tspan (empty except for a zero-width space)\n// with dy of -70% * SHIFT_DY (because font-size=70%)\nvar RESET_DY = {\n    sub: '-0.21em',\n    sup: '0.42em'\n};\nvar ZERO_WIDTH_SPACE = '\\u200b';\n\n/*\n * Whitelist of protocols in user-supplied urls. Mostly we want to avoid javascript\n * and related attack vectors. The empty items are there for IE, that in various\n * versions treats relative paths as having different flavors of no protocol, while\n * other browsers have these explicitly inherit the protocol of the page they're in.\n */\nvar PROTOCOLS = ['http:', 'https:', 'mailto:', '', undefined, ':'];\n\nvar NEWLINES = exports.NEWLINES = /(\\r\\n?|\\n)/g;\n\nvar SPLIT_TAGS = /(<[^<>]*>)/;\n\nvar ONE_TAG = /<(\\/?)([^ >]*)(\\s+(.*))?>/i;\n\nvar BR_TAG = /<br(\\s+.*)?>/i;\nexports.BR_TAG_ALL = /<br(\\s+.*)?>/gi;\n\n/*\n * style and href: pull them out of either single or double quotes. Also\n * - target: (_blank|_self|_parent|_top|framename)\n *     note that you can't use target to get a popup but if you use popup,\n *     a `framename` will be passed along as the name of the popup window.\n *     per the spec, cannot contain whitespace.\n *     for backward compatibility we default to '_blank'\n * - popup: a custom one for us to enable popup (new window) links. String\n *     for window.open -> strWindowFeatures, like 'menubar=yes,width=500,height=550'\n *     note that at least in Chrome, you need to give at least one property\n *     in this string or the page will open in a new tab anyway. We follow this\n *     convention and will not make a popup if this string is empty.\n *     per the spec, cannot contain whitespace.\n *\n * Because we hack in other attributes with style (sub & sup), drop any trailing\n * semicolon in user-supplied styles so we can consistently append the tag-dependent style\n *\n * These are for tag attributes; Chrome anyway will convert entities in\n * attribute values, but not in attribute names\n * you can test this by for example:\n * > p = document.createElement('p')\n * > p.innerHTML = '<span styl&#x65;=\"font-color:r&#x65;d;\">Hi</span>'\n * > p.innerHTML\n * <- '<span styl&#x65;=\"font-color:red;\">Hi</span>'\n */\nvar STYLEMATCH = /(^|[\\s\"'])style\\s*=\\s*(\"([^\"]*);?\"|'([^']*);?')/i;\nvar HREFMATCH = /(^|[\\s\"'])href\\s*=\\s*(\"([^\"]*)\"|'([^']*)')/i;\nvar TARGETMATCH = /(^|[\\s\"'])target\\s*=\\s*(\"([^\"\\s]*)\"|'([^'\\s]*)')/i;\nvar POPUPMATCH = /(^|[\\s\"'])popup\\s*=\\s*(\"([\\w=,]*)\"|'([\\w=,]*)')/i;\n\n// dedicated matcher for these quoted regexes, that can return their results\n// in two different places\nfunction getQuotedMatch(_str, re) {\n    if(!_str) return null;\n    var match = _str.match(re);\n    var result = match && (match[3] || match[4]);\n    return result && convertEntities(result);\n}\n\nvar COLORMATCH = /(^|;)\\s*color:/;\n\n/**\n * Strip string of tags\n *\n * @param {string} _str : input string\n * @param {object} opts :\n * - len {number} max length of output string\n * - allowedTags {array} list of pseudo-html tags to NOT strip\n * @return {string}\n */\nexports.plainText = function(_str, opts) {\n    opts = opts || {};\n\n    var len = (opts.len !== undefined && opts.len !== -1) ? opts.len : Infinity;\n    var allowedTags = opts.allowedTags !== undefined ? opts.allowedTags : ['br'];\n\n    var ellipsis = '...';\n    var eLen = ellipsis.length;\n\n    var oldParts = _str.split(SPLIT_TAGS);\n    var newParts = [];\n    var prevTag = '';\n    var l = 0;\n\n    for(var i = 0; i < oldParts.length; i++) {\n        var p = oldParts[i];\n        var match = p.match(ONE_TAG);\n        var tagType = match && match[2].toLowerCase();\n\n        if(tagType) {\n            // N.B. tags do not count towards string length\n            if(allowedTags.indexOf(tagType) !== -1) {\n                newParts.push(p);\n                prevTag = tagType;\n            }\n        } else {\n            var pLen = p.length;\n\n            if((l + pLen) < len) {\n                newParts.push(p);\n                l += pLen;\n            } else if(l < len) {\n                var pLen2 = len - l;\n\n                if(prevTag && (prevTag !== 'br' || pLen2 <= eLen || pLen <= eLen)) {\n                    newParts.pop();\n                }\n\n                if(len > eLen) {\n                    newParts.push(p.substr(0, pLen2 - eLen) + ellipsis);\n                } else {\n                    newParts.push(p.substr(0, pLen2));\n                }\n                break;\n            }\n\n            prevTag = '';\n        }\n    }\n\n    return newParts.join('');\n};\n\n/*\n * N.B. HTML entities are listed without the leading '&' and trailing ';'\n * https://www.freeformatter.com/html-entities.html\n *\n * FWIW if we wanted to support the full set, it has 2261 entries:\n * https://www.w3.org/TR/html5/entities.json\n * though I notice that some of these are duplicates and/or are missing \";\"\n * eg: \"&amp;\", \"&amp\", \"&AMP;\", and \"&AMP\" all map to \"&\"\n * We no longer need to include numeric entities here, these are now handled\n * by String.fromCodePoint/fromCharCode\n *\n * Anyway the only ones that are really important to allow are the HTML special\n * chars <, >, and &, because these ones can trigger special processing if not\n * replaced by the corresponding entity.\n */\nvar entityToUnicode = {\n    mu: 'μ',\n    amp: '&',\n    lt: '<',\n    gt: '>',\n    nbsp: ' ',\n    times: '×',\n    plusmn: '±',\n    deg: '°'\n};\n\n// NOTE: in general entities can contain uppercase too (so [a-zA-Z]) but all the\n// ones we support use only lowercase. If we ever change that, update the regex.\nvar ENTITY_MATCH = /&(#\\d+|#x[\\da-fA-F]+|[a-z]+);/g;\nfunction convertEntities(_str) {\n    return _str.replace(ENTITY_MATCH, function(fullMatch, innerMatch) {\n        var outChar;\n        if(innerMatch.charAt(0) === '#') {\n            // cannot use String.fromCodePoint in IE\n            outChar = fromCodePoint(\n                innerMatch.charAt(1) === 'x' ?\n                    parseInt(innerMatch.substr(2), 16) :\n                    parseInt(innerMatch.substr(1), 10)\n            );\n        } else outChar = entityToUnicode[innerMatch];\n\n        // as in regular HTML, if we didn't decode the entity just\n        // leave the raw text in place.\n        return outChar || fullMatch;\n    });\n}\nexports.convertEntities = convertEntities;\n\nfunction fromCodePoint(code) {\n    // Don't allow overflow. In Chrome this turns into � but I feel like it's\n    // more useful to just not convert it at all.\n    if(code > 0x10FFFF) return;\n    var stringFromCodePoint = String.fromCodePoint;\n    if(stringFromCodePoint) return stringFromCodePoint(code);\n\n    // IE doesn't have String.fromCodePoint\n    // see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint\n    var stringFromCharCode = String.fromCharCode;\n    if(code <= 0xFFFF) return stringFromCharCode(code);\n    return stringFromCharCode(\n        (code >> 10) + 0xD7C0,\n        (code % 0x400) + 0xDC00\n    );\n}\n\n/*\n * buildSVGText: convert our pseudo-html into SVG tspan elements, and attach these\n * to containerNode\n *\n * @param {svg text element} containerNode: the <text> node to insert this text into\n * @param {string} str: the pseudo-html string to convert to svg\n *\n * @returns {bool}: does the result contain any links? We need to handle the text element\n *   somewhat differently if it does, so just keep track of this when it happens.\n */\nfunction buildSVGText(containerNode, str) {\n    /*\n     * Normalize behavior between IE and others wrt newlines and whitespace:pre\n     * this combination makes IE barf https://github.com/plotly/plotly.js/issues/746\n     * Chrome and FF display \\n, \\r, or \\r\\n as a space in this mode.\n     * I feel like at some point we turned these into <br> but currently we don't so\n     * I'm just going to cement what we do now in Chrome and FF\n     */\n    str = str.replace(NEWLINES, ' ');\n\n    var hasLink = false;\n\n    // as we're building the text, keep track of what elements we're nested inside\n    // nodeStack will be an array of {node, type, style, href, target, popup}\n    // where only type: 'a' gets the last 3 and node is only added when it's created\n    var nodeStack = [];\n    var currentNode;\n    var currentLine = -1;\n\n    function newLine() {\n        currentLine++;\n\n        var lineNode = document.createElementNS(xmlnsNamespaces.svg, 'tspan');\n        d3.select(lineNode).attr({\n            class: 'line',\n            dy: (currentLine * LINE_SPACING) + 'em'\n        });\n        containerNode.appendChild(lineNode);\n\n        currentNode = lineNode;\n\n        var oldNodeStack = nodeStack;\n        nodeStack = [{node: lineNode}];\n\n        if(oldNodeStack.length > 1) {\n            for(var i = 1; i < oldNodeStack.length; i++) {\n                enterNode(oldNodeStack[i]);\n            }\n        }\n    }\n\n    function enterNode(nodeSpec) {\n        var type = nodeSpec.type;\n        var nodeAttrs = {};\n        var nodeType;\n\n        if(type === 'a') {\n            nodeType = 'a';\n            var target = nodeSpec.target;\n            var href = nodeSpec.href;\n            var popup = nodeSpec.popup;\n            if(href) {\n                nodeAttrs = {\n                    'xlink:xlink:show': (target === '_blank' || target.charAt(0) !== '_') ? 'new' : 'replace',\n                    target: target,\n                    'xlink:xlink:href': href\n                };\n                if(popup) {\n                    // security: href and target are not inserted as code but\n                    // as attributes. popup is, but limited to /[A-Za-z0-9_=,]/\n                    nodeAttrs.onclick = 'window.open(this.href.baseVal,this.target.baseVal,\"' +\n                        popup + '\");return false;';\n                }\n            }\n        } else nodeType = 'tspan';\n\n        if(nodeSpec.style) nodeAttrs.style = nodeSpec.style;\n\n        var newNode = document.createElementNS(xmlnsNamespaces.svg, nodeType);\n\n        if(type === 'sup' || type === 'sub') {\n            addTextNode(currentNode, ZERO_WIDTH_SPACE);\n            currentNode.appendChild(newNode);\n\n            var resetter = document.createElementNS(xmlnsNamespaces.svg, 'tspan');\n            addTextNode(resetter, ZERO_WIDTH_SPACE);\n            d3.select(resetter).attr('dy', RESET_DY[type]);\n            nodeAttrs.dy = SHIFT_DY[type];\n\n            currentNode.appendChild(newNode);\n            currentNode.appendChild(resetter);\n        } else {\n            currentNode.appendChild(newNode);\n        }\n\n        d3.select(newNode).attr(nodeAttrs);\n\n        currentNode = nodeSpec.node = newNode;\n        nodeStack.push(nodeSpec);\n    }\n\n    function addTextNode(node, text) {\n        node.appendChild(document.createTextNode(text));\n    }\n\n    function exitNode(type) {\n        // A bare closing tag can't close the root node. If we encounter this it\n        // means there's an extra closing tag that can just be ignored:\n        if(nodeStack.length === 1) {\n            Lib.log('Ignoring unexpected end tag </' + type + '>.', str);\n            return;\n        }\n\n        var innerNode = nodeStack.pop();\n\n        if(type !== innerNode.type) {\n            Lib.log('Start tag <' + innerNode.type + '> doesnt match end tag <' +\n                type + '>. Pretending it did match.', str);\n        }\n        currentNode = nodeStack[nodeStack.length - 1].node;\n    }\n\n    var hasLines = BR_TAG.test(str);\n\n    if(hasLines) newLine();\n    else {\n        currentNode = containerNode;\n        nodeStack = [{node: containerNode}];\n    }\n\n    var parts = str.split(SPLIT_TAGS);\n    for(var i = 0; i < parts.length; i++) {\n        var parti = parts[i];\n        var match = parti.match(ONE_TAG);\n        var tagType = match && match[2].toLowerCase();\n        var tagStyle = TAG_STYLES[tagType];\n\n        if(tagType === 'br') {\n            newLine();\n        } else if(tagStyle === undefined) {\n            addTextNode(currentNode, convertEntities(parti));\n        } else {\n            // tag - open or close\n            if(match[1]) {\n                exitNode(tagType);\n            } else {\n                var extra = match[4];\n\n                var nodeSpec = {type: tagType};\n\n                // now add style, from both the tag name and any extra css\n                // Most of the svg css that users will care about is just like html,\n                // but font color is different (uses fill). Let our users ignore this.\n                var css = getQuotedMatch(extra, STYLEMATCH);\n                if(css) {\n                    css = css.replace(COLORMATCH, '$1 fill:');\n                    if(tagStyle) css += ';' + tagStyle;\n                } else if(tagStyle) css = tagStyle;\n\n                if(css) nodeSpec.style = css;\n\n                if(tagType === 'a') {\n                    hasLink = true;\n\n                    var href = getQuotedMatch(extra, HREFMATCH);\n\n                    if(href) {\n                        var safeHref = sanitizeHref(href);\n                        if(safeHref) {\n                            nodeSpec.href = safeHref;\n                            nodeSpec.target = getQuotedMatch(extra, TARGETMATCH) || '_blank';\n                            nodeSpec.popup = getQuotedMatch(extra, POPUPMATCH);\n                        }\n                    }\n                }\n\n                enterNode(nodeSpec);\n            }\n        }\n    }\n\n    return hasLink;\n}\n\nfunction sanitizeHref(href) {\n    var decodedHref = encodeURI(decodeURI(href));\n    var dummyAnchor1 = document.createElement('a');\n    var dummyAnchor2 = document.createElement('a');\n    dummyAnchor1.href = href;\n    dummyAnchor2.href = decodedHref;\n\n    var p1 = dummyAnchor1.protocol;\n    var p2 = dummyAnchor2.protocol;\n\n    // check safe protocols\n    if(\n        PROTOCOLS.indexOf(p1) !== -1 &&\n        PROTOCOLS.indexOf(p2) !== -1\n    ) {\n        return decodedHref;\n    } else {\n        return '';\n    }\n}\n\n/*\n * sanitizeHTML: port of buildSVGText aimed at providing a clean subset of HTML\n * @param {string} str: the html string to clean\n * @returns {string}: a cleaned and normalized version of the input,\n *     supporting only a small subset of html\n */\nexports.sanitizeHTML = function sanitizeHTML(str) {\n    str = str.replace(NEWLINES, ' ');\n\n    var rootNode = document.createElement('p');\n    var currentNode = rootNode;\n    var nodeStack = [];\n\n    var parts = str.split(SPLIT_TAGS);\n    for(var i = 0; i < parts.length; i++) {\n        var parti = parts[i];\n        var match = parti.match(ONE_TAG);\n        var tagType = match && match[2].toLowerCase();\n\n        if(tagType in TAG_STYLES) {\n            if(match[1]) {\n                if(nodeStack.length) {\n                    currentNode = nodeStack.pop();\n                }\n            } else {\n                var extra = match[4];\n\n                var css = getQuotedMatch(extra, STYLEMATCH);\n                var nodeAttrs = css ? {style: css} : {};\n\n                if(tagType === 'a') {\n                    var href = getQuotedMatch(extra, HREFMATCH);\n\n                    if(href) {\n                        var safeHref = sanitizeHref(href);\n                        if(safeHref) {\n                            nodeAttrs.href = safeHref;\n                            var target = getQuotedMatch(extra, TARGETMATCH);\n                            if(target) {\n                                nodeAttrs.target = target;\n                            }\n                        }\n                    }\n                }\n\n                var newNode = document.createElement(tagType);\n                currentNode.appendChild(newNode);\n                d3.select(newNode).attr(nodeAttrs);\n\n                currentNode = newNode;\n                nodeStack.push(newNode);\n            }\n        } else {\n            currentNode.appendChild(\n                document.createTextNode(convertEntities(parti))\n            );\n        }\n    }\n    var key = 'innerHTML'; // i.e. to avoid pass test-syntax\n    return rootNode[key];\n};\n\nexports.lineCount = function lineCount(s) {\n    return s.selectAll('tspan.line').size() || 1;\n};\n\nexports.positionText = function positionText(s, x, y) {\n    return s.each(function() {\n        var text = d3.select(this);\n\n        function setOrGet(attr, val) {\n            if(val === undefined) {\n                val = text.attr(attr);\n                if(val === null) {\n                    text.attr(attr, 0);\n                    val = 0;\n                }\n            } else text.attr(attr, val);\n            return val;\n        }\n\n        var thisX = setOrGet('x', x);\n        var thisY = setOrGet('y', y);\n\n        if(this.nodeName === 'text') {\n            text.selectAll('tspan.line').attr({x: thisX, y: thisY});\n        }\n    });\n};\n\nfunction alignHTMLWith(_base, container, options) {\n    var alignH = options.horizontalAlign;\n    var alignV = options.verticalAlign || 'top';\n    var bRect = _base.node().getBoundingClientRect();\n    var cRect = container.node().getBoundingClientRect();\n    var thisRect;\n    var getTop;\n    var getLeft;\n\n    if(alignV === 'bottom') {\n        getTop = function() { return bRect.bottom - thisRect.height; };\n    } else if(alignV === 'middle') {\n        getTop = function() { return bRect.top + (bRect.height - thisRect.height) / 2; };\n    } else { // default: top\n        getTop = function() { return bRect.top; };\n    }\n\n    if(alignH === 'right') {\n        getLeft = function() { return bRect.right - thisRect.width; };\n    } else if(alignH === 'center') {\n        getLeft = function() { return bRect.left + (bRect.width - thisRect.width) / 2; };\n    } else { // default: left\n        getLeft = function() { return bRect.left; };\n    }\n\n    return function() {\n        thisRect = this.node().getBoundingClientRect();\n\n        var x0 = getLeft() - cRect.left;\n        var y0 = getTop() - cRect.top;\n        var gd = options.gd || {};\n        if(options.gd) {\n            gd._fullLayout._calcInverseTransform(gd);\n            var transformedCoords = Lib.apply3DTransform(gd._fullLayout._invTransform)(x0, y0);\n            x0 = transformedCoords[0];\n            y0 = transformedCoords[1];\n        }\n\n        this.style({\n            top: y0 + 'px',\n            left: x0 + 'px',\n            'z-index': 1000\n        });\n        return this;\n    };\n}\n\nvar onePx = '1px ';\n\nexports.makeTextShadow = function(color) {\n    var x = onePx;\n    var y = onePx;\n    var b = onePx;\n    return x + y + b + color + ', ' +\n        '-' + x + '-' + y + b + color + ', ' +\n        x + '-' + y + b + color + ', ' +\n        '-' + x + y + b + color;\n};\n\n/*\n * Editable title\n * @param {d3.selection} context: the element being edited. Normally text,\n *   but if it isn't, you should provide the styling options\n * @param {object} options:\n *   @param {div} options.gd: graphDiv\n *   @param {d3.selection} options.delegate: item to bind events to if not this\n *   @param {boolean} options.immediate: start editing now (true) or on click (false, default)\n *   @param {string} options.fill: font color if not as shown\n *   @param {string} options.background: background color if not as shown\n *   @param {string} options.text: initial text, if not as shown\n *   @param {string} options.horizontalAlign: alignment of the edit box wrt. the bound element\n *   @param {string} options.verticalAlign: alignment of the edit box wrt. the bound element\n */\n\nexports.makeEditable = function(context, options) {\n    var gd = options.gd;\n    var _delegate = options.delegate;\n    var dispatch = d3.dispatch('edit', 'input', 'cancel');\n    var handlerElement = _delegate || context;\n\n    context.style({'pointer-events': _delegate ? 'none' : 'all'});\n\n    if(context.size() !== 1) throw new Error('boo');\n\n    function handleClick() {\n        appendEditable();\n        context.style({opacity: 0});\n        // also hide any mathjax svg\n        var svgClass = handlerElement.attr('class');\n        var mathjaxClass;\n        if(svgClass) mathjaxClass = '.' + svgClass.split(' ')[0] + '-math-group';\n        else mathjaxClass = '[class*=-math-group]';\n        if(mathjaxClass) {\n            d3.select(context.node().parentNode).select(mathjaxClass).style({opacity: 0});\n        }\n    }\n\n    function selectElementContents(_el) {\n        var el = _el.node();\n        var range = document.createRange();\n        range.selectNodeContents(el);\n        var sel = window.getSelection();\n        sel.removeAllRanges();\n        sel.addRange(range);\n        el.focus();\n    }\n\n    function appendEditable() {\n        var plotDiv = d3.select(gd);\n        var container = plotDiv.select('.svg-container');\n        var div = container.append('div');\n        var cStyle = context.node().style;\n        var fontSize = parseFloat(cStyle.fontSize || 12);\n\n        var initialText = options.text;\n        if(initialText === undefined) initialText = context.attr('data-unformatted');\n\n        div.classed('plugin-editable editable', true)\n            .style({\n                position: 'absolute',\n                'font-family': cStyle.fontFamily || 'Arial',\n                'font-size': fontSize,\n                color: options.fill || cStyle.fill || 'black',\n                opacity: 1,\n                'background-color': options.background || 'transparent',\n                outline: '#ffffff33 1px solid',\n                margin: [-fontSize / 8 + 1, 0, 0, -1].join('px ') + 'px',\n                padding: '0',\n                'box-sizing': 'border-box'\n            })\n            .attr({contenteditable: true})\n            .text(initialText)\n            .call(alignHTMLWith(context, container, options))\n            .on('blur', function() {\n                gd._editing = false;\n                context.text(this.textContent)\n                    .style({opacity: 1});\n                var svgClass = d3.select(this).attr('class');\n                var mathjaxClass;\n                if(svgClass) mathjaxClass = '.' + svgClass.split(' ')[0] + '-math-group';\n                else mathjaxClass = '[class*=-math-group]';\n                if(mathjaxClass) {\n                    d3.select(context.node().parentNode).select(mathjaxClass).style({opacity: 0});\n                }\n                var text = this.textContent;\n                d3.select(this).transition().duration(0).remove();\n                d3.select(document).on('mouseup', null);\n                dispatch.edit.call(context, text);\n            })\n            .on('focus', function() {\n                var editDiv = this;\n                gd._editing = true;\n                d3.select(document).on('mouseup', function() {\n                    if(d3.event.target === editDiv) return false;\n                    if(document.activeElement === div.node()) div.node().blur();\n                });\n            })\n            .on('keyup', function() {\n                if(d3.event.which === 27) {\n                    gd._editing = false;\n                    context.style({opacity: 1});\n                    d3.select(this)\n                        .style({opacity: 0})\n                        .on('blur', function() { return false; })\n                        .transition().remove();\n                    dispatch.cancel.call(context, this.textContent);\n                } else {\n                    dispatch.input.call(context, this.textContent);\n                    d3.select(this).call(alignHTMLWith(context, container, options));\n                }\n            })\n            .on('keydown', function() {\n                if(d3.event.which === 13) this.blur();\n            })\n            .call(selectElementContents);\n    }\n\n    if(options.immediate) handleClick();\n    else handlerElement.on('click', handleClick);\n\n    return d3.rebind(context, dispatch, 'on');\n};\n","'use strict';\n\n// Simple helper functions\n// none of these need any external deps\n\nmodule.exports = function noop() {};\n","'use strict';\n\nvar isNumeric = require('fast-isnumeric');\nvar isMobileOrTablet = require('is-mobile');\n\nmodule.exports = function preserveDrawingBuffer(opts) {\n    var ua;\n\n    if(opts && opts.hasOwnProperty('userAgent')) {\n        ua = opts.userAgent;\n    } else {\n        ua = getUserAgent();\n    }\n\n    if(typeof ua !== 'string') return true;\n\n    var enable = isMobileOrTablet({\n        ua: { headers: {'user-agent': ua }},\n        tablet: true,\n        featureDetect: false\n    });\n\n    if(!enable) {\n        var allParts = ua.split(' ');\n        for(var i = 1; i < allParts.length; i++) {\n            var part = allParts[i];\n            if(part.indexOf('Safari') !== -1) {\n                // find Safari version\n                for(var k = i - 1; k > -1; k--) {\n                    var prevPart = allParts[k];\n                    if(prevPart.substr(0, 8) === 'Version/') {\n                        var v = prevPart.substr(8).split('.')[0];\n                        if(isNumeric(v)) v = +v;\n                        if(v >= 13) return true;\n                    }\n                }\n            }\n        }\n    }\n\n    return enable;\n};\n\nfunction getUserAgent() {\n    // similar to https://github.com/juliangruber/is-mobile/blob/91ca39ccdd4cfc5edfb5391e2515b923a730fbea/index.js#L14-L17\n    var ua;\n    if(typeof navigator !== 'undefined') {\n        ua = navigator.userAgent;\n    }\n\n    if(\n        ua &&\n        ua.headers &&\n        typeof ua.headers['user-agent'] === 'string'\n    ) {\n        ua = ua.headers['user-agent'];\n    }\n\n    return ua;\n}\n","'use strict';\n\n// works with our CSS cursor classes (see css/_cursor.scss)\n// to apply cursors to d3 single-element selections.\n// omit cursor to revert to the default.\nmodule.exports = function setCursor(el3, csr) {\n    (el3.attr('class') || '').split(' ').forEach(function(cls) {\n        if(cls.indexOf('cursor-') === 0) el3.classed(cls, false);\n    });\n\n    if(csr) el3.classed('cursor-' + csr, true);\n};\n","'use strict';\n\nvar dot = require('./matrix').dot;\nvar BADNUM = require('../constants/numerical').BADNUM;\n\nvar polygon = module.exports = {};\n\n/**\n * Turn an array of [x, y] pairs into a polygon object\n * that can test if points are inside it\n *\n * @param ptsIn Array of [x, y] pairs\n *\n * @returns polygon Object {xmin, xmax, ymin, ymax, pts, contains}\n *      (x|y)(min|max) are the bounding rect of the polygon\n *      pts is the original array, with the first pair repeated at the end\n *      contains is a function: (pt, omitFirstEdge)\n *          pt is the [x, y] pair to test\n *          omitFirstEdge truthy means points exactly on the first edge don't\n *              count. This is for use adding one polygon to another so we\n *              don't double-count the edge where they meet.\n *          returns boolean: is pt inside the polygon (including on its edges)\n */\npolygon.tester = function tester(ptsIn) {\n    var pts = ptsIn.slice();\n    var xmin = pts[0][0];\n    var xmax = xmin;\n    var ymin = pts[0][1];\n    var ymax = ymin;\n    var i;\n\n    if(\n        pts[pts.length - 1][0] !== pts[0][0] ||\n        pts[pts.length - 1][1] !== pts[0][1]\n    ) {\n        // close the polygon\n        pts.push(pts[0]);\n    }\n\n    for(i = 1; i < pts.length; i++) {\n        xmin = Math.min(xmin, pts[i][0]);\n        xmax = Math.max(xmax, pts[i][0]);\n        ymin = Math.min(ymin, pts[i][1]);\n        ymax = Math.max(ymax, pts[i][1]);\n    }\n\n    // do we have a rectangle? Handle this here, so we can use the same\n    // tester for the rectangular case without sacrificing speed\n\n    var isRect = false;\n    var rectFirstEdgeTest;\n\n    if(pts.length === 5) {\n        if(pts[0][0] === pts[1][0]) { // vert, horz, vert, horz\n            if(pts[2][0] === pts[3][0] &&\n                    pts[0][1] === pts[3][1] &&\n                    pts[1][1] === pts[2][1]) {\n                isRect = true;\n                rectFirstEdgeTest = function(pt) { return pt[0] === pts[0][0]; };\n            }\n        } else if(pts[0][1] === pts[1][1]) { // horz, vert, horz, vert\n            if(pts[2][1] === pts[3][1] &&\n                    pts[0][0] === pts[3][0] &&\n                    pts[1][0] === pts[2][0]) {\n                isRect = true;\n                rectFirstEdgeTest = function(pt) { return pt[1] === pts[0][1]; };\n            }\n        }\n    }\n\n    function rectContains(pt, omitFirstEdge) {\n        var x = pt[0];\n        var y = pt[1];\n\n        if(x === BADNUM || x < xmin || x > xmax || y === BADNUM || y < ymin || y > ymax) {\n            // pt is outside the bounding box of polygon\n            return false;\n        }\n        if(omitFirstEdge && rectFirstEdgeTest(pt)) return false;\n\n        return true;\n    }\n\n    function contains(pt, omitFirstEdge) {\n        var x = pt[0];\n        var y = pt[1];\n\n        if(x === BADNUM || x < xmin || x > xmax || y === BADNUM || y < ymin || y > ymax) {\n            // pt is outside the bounding box of polygon\n            return false;\n        }\n\n        var imax = pts.length;\n        var x1 = pts[0][0];\n        var y1 = pts[0][1];\n        var crossings = 0;\n        var i;\n        var x0;\n        var y0;\n        var xmini;\n        var ycross;\n\n        for(i = 1; i < imax; i++) {\n            // find all crossings of a vertical line upward from pt with\n            // polygon segments\n            // crossings exactly at xmax don't count, unless the point is\n            // exactly on the segment, then it counts as inside.\n            x0 = x1;\n            y0 = y1;\n            x1 = pts[i][0];\n            y1 = pts[i][1];\n            xmini = Math.min(x0, x1);\n\n            if(x < xmini || x > Math.max(x0, x1) || y > Math.max(y0, y1)) {\n                // outside the bounding box of this segment, it's only a crossing\n                // if it's below the box.\n\n                continue;\n            } else if(y < Math.min(y0, y1)) {\n                // don't count the left-most point of the segment as a crossing\n                // because we don't want to double-count adjacent crossings\n                // UNLESS the polygon turns past vertical at exactly this x\n                // Note that this is repeated below, but we can't factor it out\n                // because\n                if(x !== xmini) crossings++;\n            } else {\n                // inside the bounding box, check the actual line intercept\n\n                // vertical segment - we know already that the point is exactly\n                // on the segment, so mark the crossing as exactly at the point.\n                if(x1 === x0) ycross = y;\n                // any other angle\n                else ycross = y0 + (x - x0) * (y1 - y0) / (x1 - x0);\n\n                // exactly on the edge: counts as inside the polygon, unless it's the\n                // first edge and we're omitting it.\n                if(y === ycross) {\n                    if(i === 1 && omitFirstEdge) return false;\n                    return true;\n                }\n\n                if(y <= ycross && x !== xmini) crossings++;\n            }\n        }\n\n        // if we've gotten this far, odd crossings means inside, even is outside\n        return crossings % 2 === 1;\n    }\n\n    // detect if poly is degenerate\n    var degenerate = true;\n    var lastPt = pts[0];\n    for(i = 1; i < pts.length; i++) {\n        if(lastPt[0] !== pts[i][0] || lastPt[1] !== pts[i][1]) {\n            degenerate = false;\n            break;\n        }\n    }\n\n    return {\n        xmin: xmin,\n        xmax: xmax,\n        ymin: ymin,\n        ymax: ymax,\n        pts: pts,\n        contains: isRect ? rectContains : contains,\n        isRect: isRect,\n        degenerate: degenerate\n    };\n};\n\n/**\n * Test if a segment of a points array is bent or straight\n *\n * @param pts Array of [x, y] pairs\n * @param start the index of the proposed start of the straight section\n * @param end the index of the proposed end point\n * @param tolerance the max distance off the line connecting start and end\n *      before the line counts as bent\n * @returns boolean: true means this segment is bent, false means straight\n */\npolygon.isSegmentBent = function isSegmentBent(pts, start, end, tolerance) {\n    var startPt = pts[start];\n    var segment = [pts[end][0] - startPt[0], pts[end][1] - startPt[1]];\n    var segmentSquared = dot(segment, segment);\n    var segmentLen = Math.sqrt(segmentSquared);\n    var unitPerp = [-segment[1] / segmentLen, segment[0] / segmentLen];\n    var i;\n    var part;\n    var partParallel;\n\n    for(i = start + 1; i < end; i++) {\n        part = [pts[i][0] - startPt[0], pts[i][1] - startPt[1]];\n        partParallel = dot(part, segment);\n\n        if(partParallel < 0 || partParallel > segmentSquared ||\n            Math.abs(dot(part, unitPerp)) > tolerance) return true;\n    }\n    return false;\n};\n\n/**\n * Make a filtering polygon, to minimize the number of segments\n *\n * @param pts Array of [x, y] pairs (must start with at least 1 pair)\n * @param tolerance the maximum deviation from straight allowed for\n *      removing points to simplify the polygon\n *\n * @returns Object {addPt, raw, filtered}\n *      addPt is a function(pt: [x, y] pair) to add a raw point and\n *          continue filtering\n *      raw is all the input points\n *      filtered is the resulting filtered Array of [x, y] pairs\n */\npolygon.filter = function filter(pts, tolerance) {\n    var ptsFiltered = [pts[0]];\n    var doneRawIndex = 0;\n    var doneFilteredIndex = 0;\n\n    function addPt(pt) {\n        pts.push(pt);\n        var prevFilterLen = ptsFiltered.length;\n        var iLast = doneRawIndex;\n        ptsFiltered.splice(doneFilteredIndex + 1);\n\n        for(var i = iLast + 1; i < pts.length; i++) {\n            if(i === pts.length - 1 || polygon.isSegmentBent(pts, iLast, i + 1, tolerance)) {\n                ptsFiltered.push(pts[i]);\n                if(ptsFiltered.length < prevFilterLen - 2) {\n                    doneRawIndex = i;\n                    doneFilteredIndex = ptsFiltered.length - 1;\n                }\n                iLast = i;\n            }\n        }\n    }\n\n    if(pts.length > 1) {\n        var lastPt = pts.pop();\n        addPt(lastPt);\n    }\n\n    return {\n        addPt: addPt,\n        raw: pts,\n        filtered: ptsFiltered\n    };\n};\n","'use strict';\n\nvar isNumeric = require('fast-isnumeric');\nvar loggers = require('./loggers');\nvar identity = require('./identity');\nvar BADNUM = require('../constants/numerical').BADNUM;\n\n// don't trust floating point equality - fraction of bin size to call\n// \"on the line\" and ensure that they go the right way specified by\n// linelow\nvar roundingError = 1e-9;\n\n\n/**\n * findBin - find the bin for val - note that it can return outside the\n * bin range any pos. or neg. integer for linear bins, or -1 or\n * bins.length-1 for explicit.\n * bins is either an object {start,size,end} or an array length #bins+1\n * bins can be either increasing or decreasing but must be monotonic\n * for linear bins, we can just calculate. For listed bins, run a binary\n * search linelow (truthy) says the bin boundary should be attributed to\n * the lower bin rather than the default upper bin\n */\nexports.findBin = function(val, bins, linelow) {\n    if(isNumeric(bins.start)) {\n        return linelow ?\n            Math.ceil((val - bins.start) / bins.size - roundingError) - 1 :\n            Math.floor((val - bins.start) / bins.size + roundingError);\n    } else {\n        var n1 = 0;\n        var n2 = bins.length;\n        var c = 0;\n        var binSize = (n2 > 1) ? (bins[n2 - 1] - bins[0]) / (n2 - 1) : 1;\n        var n, test;\n        if(binSize >= 0) {\n            test = linelow ? lessThan : lessOrEqual;\n        } else {\n            test = linelow ? greaterOrEqual : greaterThan;\n        }\n        val += binSize * roundingError * (linelow ? -1 : 1) * (binSize >= 0 ? 1 : -1);\n        // c is just to avoid infinite loops if there's an error\n        while(n1 < n2 && c++ < 100) {\n            n = Math.floor((n1 + n2) / 2);\n            if(test(bins[n], val)) n1 = n + 1;\n            else n2 = n;\n        }\n        if(c > 90) loggers.log('Long binary search...');\n        return n1 - 1;\n    }\n};\n\nfunction lessThan(a, b) { return a < b; }\nfunction lessOrEqual(a, b) { return a <= b; }\nfunction greaterThan(a, b) { return a > b; }\nfunction greaterOrEqual(a, b) { return a >= b; }\n\nexports.sorterAsc = function(a, b) { return a - b; };\nexports.sorterDes = function(a, b) { return b - a; };\n\n/**\n * find distinct values in an array, lumping together ones that appear to\n * just be off by a rounding error\n * return the distinct values and the minimum difference between any two\n */\nexports.distinctVals = function(valsIn) {\n    var vals = valsIn.slice();  // otherwise we sort the original array...\n    vals.sort(exports.sorterAsc); // undefined listed in the end - also works on IE11\n\n    var last;\n    for(last = vals.length - 1; last > -1; last--) {\n        if(vals[last] !== BADNUM) break;\n    }\n\n    var minDiff = (vals[last] - vals[0]) || 1;\n    var errDiff = minDiff / (last || 1) / 10000;\n    var newVals = [];\n    var preV;\n    for(var i = 0; i <= last; i++) {\n        var v = vals[i];\n\n        // make sure values aren't just off by a rounding error\n        var diff = v - preV;\n\n        if(preV === undefined) {\n            newVals.push(v);\n            preV = v;\n        } else if(diff > errDiff) {\n            minDiff = Math.min(minDiff, diff);\n\n            newVals.push(v);\n            preV = v;\n        }\n    }\n\n    return {vals: newVals, minDiff: minDiff};\n};\n\n/**\n * return the smallest element from (sorted) array arrayIn that's bigger than val,\n * or (reverse) the largest element smaller than val\n * used to find the best tick given the minimum (non-rounded) tick\n * particularly useful for date/time where things are not powers of 10\n * binary search is probably overkill here...\n */\nexports.roundUp = function(val, arrayIn, reverse) {\n    var low = 0;\n    var high = arrayIn.length - 1;\n    var mid;\n    var c = 0;\n    var dlow = reverse ? 0 : 1;\n    var dhigh = reverse ? 1 : 0;\n    var rounded = reverse ? Math.ceil : Math.floor;\n    // c is just to avoid infinite loops if there's an error\n    while(low < high && c++ < 100) {\n        mid = rounded((low + high) / 2);\n        if(arrayIn[mid] <= val) low = mid + dlow;\n        else high = mid - dhigh;\n    }\n    return arrayIn[low];\n};\n\n/**\n * Tweak to Array.sort(sortFn) that improves performance for pre-sorted arrays\n *\n * Note that newer browsers (such as Chrome v70+) are starting to pick up\n * on pre-sorted arrays which may render the following optimization unnecessary\n * in the future.\n *\n * Motivation: sometimes we need to sort arrays but the input is likely to\n * already be sorted. Browsers don't seem to pick up on pre-sorted arrays,\n * and in fact Chrome is actually *slower* sorting pre-sorted arrays than purely\n * random arrays. FF is at least faster if the array is pre-sorted, but still\n * not as fast as it could be.\n * Here's how this plays out sorting a length-1e6 array:\n *\n * Calls to Sort FN  |  Chrome bare  |  FF bare  |  Chrome tweak  |  FF tweak\n *                   |  v68.0 Mac    |  v61.0 Mac|                |\n * ------------------+---------------+-----------+----------------+------------\n * ordered           |  30.4e6       |  10.1e6   |  1e6           |  1e6\n * reversed          |  29.4e6       |  9.9e6    |  1e6 + reverse |  1e6 + reverse\n * random            |  ~21e6        |  ~18.7e6  |  ~21e6         |  ~18.7e6\n *\n * So this is a substantial win for pre-sorted (ordered or exactly reversed)\n * arrays. Including this wrapper on an unsorted array adds a penalty that will\n * in general be only a few calls to the sort function. The only case this\n * penalty will be significant is if the array is mostly sorted but there are\n * a few unsorted items near the end, but the penalty is still at most N calls\n * out of (for N=1e6) ~20N total calls\n *\n * @param {Array} array: the array, to be sorted in place\n * @param {function} sortFn: As in Array.sort, function(a, b) that puts\n *     item a before item b if the return is negative, a after b if positive,\n *     and no change if zero.\n * @return {Array}: the original array, sorted in place.\n */\nexports.sort = function(array, sortFn) {\n    var notOrdered = 0;\n    var notReversed = 0;\n    for(var i = 1; i < array.length; i++) {\n        var pairOrder = sortFn(array[i], array[i - 1]);\n        if(pairOrder < 0) notOrdered = 1;\n        else if(pairOrder > 0) notReversed = 1;\n        if(notOrdered && notReversed) return array.sort(sortFn);\n    }\n    return notReversed ? array : array.reverse();\n};\n\n/**\n * find index in array 'arr' that minimizes 'fn'\n *\n * @param {array} arr : array where to search\n * @param {fn (optional)} fn : function to minimize,\n *   if not given, fn is the identity function\n * @return {integer}\n */\nexports.findIndexOfMin = function(arr, fn) {\n    fn = fn || identity;\n\n    var min = Infinity;\n    var ind;\n\n    for(var i = 0; i < arr.length; i++) {\n        var v = fn(arr[i]);\n        if(v < min) {\n            min = v;\n            ind = i;\n        }\n    }\n    return ind;\n};\n","'use strict';\n\nmodule.exports = {\n    moduleType: 'locale',\n    name: 'en-US',\n    dictionary: {\n        'Click to enter Colorscale title': 'Click to enter Colorscale title'\n    },\n    format: {\n        date: '%m/%d/%Y'\n    }\n};\n","'use strict';\n\nvar Lib = require('../lib');\nvar dfltConfig = require('../plot_api/plot_config').dfltConfig;\n\n/**\n * Copy arg array *without* removing `undefined` values from objects.\n *\n * @param gd\n * @param args\n * @returns {Array}\n */\nfunction copyArgArray(gd, args) {\n    var copy = [];\n    var arg;\n\n    for(var i = 0; i < args.length; i++) {\n        arg = args[i];\n\n        if(arg === gd) copy[i] = arg;\n        else if(typeof arg === 'object') {\n            copy[i] = Array.isArray(arg) ?\n                Lib.extendDeep([], arg) :\n                Lib.extendDeepAll({}, arg);\n        } else copy[i] = arg;\n    }\n\n    return copy;\n}\n\n\n// -----------------------------------------------------\n// Undo/Redo queue for plots\n// -----------------------------------------------------\n\n\nvar queue = {};\n\n// TODO: disable/enable undo and redo buttons appropriately\n\n/**\n * Add an item to the undoQueue for a graphDiv\n *\n * @param gd\n * @param undoFunc Function undo this operation\n * @param undoArgs Args to supply undoFunc with\n * @param redoFunc Function to redo this operation\n * @param redoArgs Args to supply redoFunc with\n */\nqueue.add = function(gd, undoFunc, undoArgs, redoFunc, redoArgs) {\n    var queueObj,\n        queueIndex;\n\n    // make sure we have the queue and our position in it\n    gd.undoQueue = gd.undoQueue || {index: 0, queue: [], sequence: false};\n    queueIndex = gd.undoQueue.index;\n\n    // if we're already playing an undo or redo, or if this is an auto operation\n    // (like pane resize... any others?) then we don't save this to the undo queue\n    if(gd.autoplay) {\n        if(!gd.undoQueue.inSequence) gd.autoplay = false;\n        return;\n    }\n\n    // if we're not in a sequence or are just starting, we need a new queue item\n    if(!gd.undoQueue.sequence || gd.undoQueue.beginSequence) {\n        queueObj = {undo: {calls: [], args: []}, redo: {calls: [], args: []}};\n        gd.undoQueue.queue.splice(queueIndex, gd.undoQueue.queue.length - queueIndex, queueObj);\n        gd.undoQueue.index += 1;\n    } else {\n        queueObj = gd.undoQueue.queue[queueIndex - 1];\n    }\n    gd.undoQueue.beginSequence = false;\n\n    // we unshift to handle calls for undo in a forward for loop later\n    if(queueObj) {\n        queueObj.undo.calls.unshift(undoFunc);\n        queueObj.undo.args.unshift(undoArgs);\n        queueObj.redo.calls.push(redoFunc);\n        queueObj.redo.args.push(redoArgs);\n    }\n\n    if(gd.undoQueue.queue.length > dfltConfig.queueLength) {\n        gd.undoQueue.queue.shift();\n        gd.undoQueue.index--;\n    }\n};\n\n/**\n * Begin a sequence of undoQueue changes\n *\n * @param gd\n */\nqueue.startSequence = function(gd) {\n    gd.undoQueue = gd.undoQueue || {index: 0, queue: [], sequence: false};\n    gd.undoQueue.sequence = true;\n    gd.undoQueue.beginSequence = true;\n};\n\n/**\n * Stop a sequence of undoQueue changes\n *\n * Call this *after* you're sure your undo chain has ended\n *\n * @param gd\n */\nqueue.stopSequence = function(gd) {\n    gd.undoQueue = gd.undoQueue || {index: 0, queue: [], sequence: false};\n    gd.undoQueue.sequence = false;\n    gd.undoQueue.beginSequence = false;\n};\n\n/**\n * Move one step back in the undo queue, and undo the object there.\n *\n * @param gd\n */\nqueue.undo = function undo(gd) {\n    var queueObj, i;\n\n    if(gd.undoQueue === undefined ||\n            isNaN(gd.undoQueue.index) ||\n            gd.undoQueue.index <= 0) {\n        return;\n    }\n\n    // index is pointing to next *forward* queueObj, point to the one we're undoing\n    gd.undoQueue.index--;\n\n    // get the queueObj for instructions on how to undo\n    queueObj = gd.undoQueue.queue[gd.undoQueue.index];\n\n    // this sequence keeps things from adding to the queue during undo/redo\n    gd.undoQueue.inSequence = true;\n    for(i = 0; i < queueObj.undo.calls.length; i++) {\n        queue.plotDo(gd, queueObj.undo.calls[i], queueObj.undo.args[i]);\n    }\n    gd.undoQueue.inSequence = false;\n    gd.autoplay = false;\n};\n\n/**\n * Redo the current object in the undo, then move forward in the queue.\n *\n * @param gd\n */\nqueue.redo = function redo(gd) {\n    var queueObj, i;\n\n    if(gd.undoQueue === undefined ||\n            isNaN(gd.undoQueue.index) ||\n            gd.undoQueue.index >= gd.undoQueue.queue.length) {\n        return;\n    }\n\n    // get the queueObj for instructions on how to undo\n    queueObj = gd.undoQueue.queue[gd.undoQueue.index];\n\n    // this sequence keeps things from adding to the queue during undo/redo\n    gd.undoQueue.inSequence = true;\n    for(i = 0; i < queueObj.redo.calls.length; i++) {\n        queue.plotDo(gd, queueObj.redo.calls[i], queueObj.redo.args[i]);\n    }\n    gd.undoQueue.inSequence = false;\n    gd.autoplay = false;\n\n    // index is pointing to the thing we just redid, move it\n    gd.undoQueue.index++;\n};\n\n/**\n * Called by undo/redo to make the actual changes.\n *\n * Not meant to be called publically, but included for mocking out in tests.\n *\n * @param gd\n * @param func\n * @param args\n */\nqueue.plotDo = function(gd, func, args) {\n    gd.autoplay = true;\n\n    // this *won't* copy gd and it preserves `undefined` properties!\n    args = copyArgArray(gd, args);\n\n    // call the supplied function\n    func.apply(null, args);\n};\n\nmodule.exports = queue;\n","'use strict';\n\nvar isNumeric = require('fast-isnumeric');\nvar isArrayOrTypedArray = require('./array').isArrayOrTypedArray;\n\n/**\n * convert a string s (such as 'xaxis.range[0]')\n * representing a property of nested object into set and get methods\n * also return the string and object so we don't have to keep track of them\n * allows [-1] for an array index, to set a property inside all elements\n * of an array\n * eg if obj = {arr: [{a: 1}, {a: 2}]}\n * you can do p = nestedProperty(obj, 'arr[-1].a')\n * but you cannot set the array itself this way, to do that\n * just set the whole array.\n * eg if obj = {arr: [1, 2, 3]}\n * you can't do nestedProperty(obj, 'arr[-1]').set(5)\n * but you can do nestedProperty(obj, 'arr').set([5, 5, 5])\n */\nmodule.exports = function nestedProperty(container, propStr) {\n    if(isNumeric(propStr)) propStr = String(propStr);\n    else if(typeof propStr !== 'string' ||\n            propStr.substr(propStr.length - 4) === '[-1]') {\n        throw 'bad property string';\n    }\n\n    var propParts = propStr.split('.');\n    var indexed;\n    var indices;\n    var i, j;\n\n    for(j = 0; j < propParts.length; j++) {\n        // guard against polluting __proto__ and other internals\n        if(String(propParts[j]).slice(0, 2) === '__') {\n            throw 'bad property string';\n        }\n    }\n\n    // check for parts of the nesting hierarchy that are numbers (ie array elements)\n    j = 0;\n    while(j < propParts.length) {\n        // look for non-bracket chars, then any number of [##] blocks\n        indexed = String(propParts[j]).match(/^([^\\[\\]]*)((\\[\\-?[0-9]*\\])+)$/);\n        if(indexed) {\n            if(indexed[1]) propParts[j] = indexed[1];\n            // allow propStr to start with bracketed array indices\n            else if(j === 0) propParts.splice(0, 1);\n            else throw 'bad property string';\n\n            indices = indexed[2]\n                .substr(1, indexed[2].length - 2)\n                .split('][');\n\n            for(i = 0; i < indices.length; i++) {\n                j++;\n                propParts.splice(j, 0, Number(indices[i]));\n            }\n        }\n        j++;\n    }\n\n    if(typeof container !== 'object') {\n        return badContainer(container, propStr, propParts);\n    }\n\n    return {\n        set: npSet(container, propParts, propStr),\n        get: npGet(container, propParts),\n        astr: propStr,\n        parts: propParts,\n        obj: container\n    };\n};\n\nfunction npGet(cont, parts) {\n    return function() {\n        var curCont = cont;\n        var curPart;\n        var allSame;\n        var out;\n        var i;\n        var j;\n\n        for(i = 0; i < parts.length - 1; i++) {\n            curPart = parts[i];\n            if(curPart === -1) {\n                allSame = true;\n                out = [];\n                for(j = 0; j < curCont.length; j++) {\n                    out[j] = npGet(curCont[j], parts.slice(i + 1))();\n                    if(out[j] !== out[0]) allSame = false;\n                }\n                return allSame ? out[0] : out;\n            }\n            if(typeof curPart === 'number' && !isArrayOrTypedArray(curCont)) {\n                return undefined;\n            }\n            curCont = curCont[curPart];\n            if(typeof curCont !== 'object' || curCont === null) {\n                return undefined;\n            }\n        }\n\n        // only hit this if parts.length === 1\n        if(typeof curCont !== 'object' || curCont === null) return undefined;\n\n        out = curCont[parts[i]];\n        if(out === null) return undefined;\n        return out;\n    };\n}\n\n/*\n * Can this value be deleted? We can delete `undefined`, and `null` except INSIDE an\n * *args* array.\n *\n * Previously we also deleted some `{}` and `[]`, in order to try and make set/unset\n * a net noop; but this causes far more complication than it's worth, and still had\n * lots of exceptions. See https://github.com/plotly/plotly.js/issues/1410\n *\n * *args* arrays get passed directly to API methods and we should respect null if\n * the user put it there, but otherwise null is deleted as we use it as code\n * in restyle/relayout/update for \"delete this value\" whereas undefined means\n * \"ignore this edit\"\n */\nvar ARGS_PATTERN = /(^|\\.)args\\[/;\nfunction isDeletable(val, propStr) {\n    return (val === undefined) || (val === null && !propStr.match(ARGS_PATTERN));\n}\n\nfunction npSet(cont, parts, propStr) {\n    return function(val) {\n        var curCont = cont;\n        var propPart = '';\n        var containerLevels = [[cont, propPart]];\n        var toDelete = isDeletable(val, propStr);\n        var curPart;\n        var i;\n\n        for(i = 0; i < parts.length - 1; i++) {\n            curPart = parts[i];\n\n            if(typeof curPart === 'number' && !isArrayOrTypedArray(curCont)) {\n                throw 'array index but container is not an array';\n            }\n\n            // handle special -1 array index\n            if(curPart === -1) {\n                toDelete = !setArrayAll(curCont, parts.slice(i + 1), val, propStr);\n                if(toDelete) break;\n                else return;\n            }\n\n            if(!checkNewContainer(curCont, curPart, parts[i + 1], toDelete)) {\n                break;\n            }\n\n            curCont = curCont[curPart];\n\n            if(typeof curCont !== 'object' || curCont === null) {\n                throw 'container is not an object';\n            }\n\n            propPart = joinPropStr(propPart, curPart);\n\n            containerLevels.push([curCont, propPart]);\n        }\n\n        if(toDelete) {\n            if(i === parts.length - 1) {\n                delete curCont[parts[i]];\n\n                // The one bit of pruning we still do: drop `undefined` from the end of arrays.\n                // In case someone has already unset previous items, continue until we hit a\n                // non-undefined value.\n                if(Array.isArray(curCont) && +parts[i] === curCont.length - 1) {\n                    while(curCont.length && curCont[curCont.length - 1] === undefined) {\n                        curCont.pop();\n                    }\n                }\n            }\n        } else curCont[parts[i]] = val;\n    };\n}\n\nfunction joinPropStr(propStr, newPart) {\n    var toAdd = newPart;\n    if(isNumeric(newPart)) toAdd = '[' + newPart + ']';\n    else if(propStr) toAdd = '.' + newPart;\n\n    return propStr + toAdd;\n}\n\n// handle special -1 array index\nfunction setArrayAll(containerArray, innerParts, val, propStr) {\n    var arrayVal = isArrayOrTypedArray(val);\n    var allSet = true;\n    var thisVal = val;\n    var thisPropStr = propStr.replace('-1', 0);\n    var deleteThis = arrayVal ? false : isDeletable(val, thisPropStr);\n    var firstPart = innerParts[0];\n    var i;\n\n    for(i = 0; i < containerArray.length; i++) {\n        thisPropStr = propStr.replace('-1', i);\n        if(arrayVal) {\n            thisVal = val[i % val.length];\n            deleteThis = isDeletable(thisVal, thisPropStr);\n        }\n        if(deleteThis) allSet = false;\n        if(!checkNewContainer(containerArray, i, firstPart, deleteThis)) {\n            continue;\n        }\n        npSet(containerArray[i], innerParts, propStr.replace('-1', i))(thisVal);\n    }\n    return allSet;\n}\n\n/**\n * make new sub-container as needed.\n * returns false if there's no container and none is needed\n * because we're only deleting an attribute\n */\nfunction checkNewContainer(container, part, nextPart, toDelete) {\n    if(container[part] === undefined) {\n        if(toDelete) return false;\n\n        if(typeof nextPart === 'number') container[part] = [];\n        else container[part] = {};\n    }\n    return true;\n}\n\nfunction badContainer(container, propStr, propParts) {\n    return {\n        set: function() { throw 'bad container'; },\n        get: function() {},\n        astr: propStr,\n        parts: propParts,\n        obj: container\n    };\n}\n","'use strict';\n\nvar isNumeric = require('fast-isnumeric');\n\n/**\n * convert a linear value into a logged value, folding negative numbers into\n * the given range\n */\nmodule.exports = function toLogRange(val, range) {\n    if(val > 0) return Math.log(val) / Math.LN10;\n\n    // move a negative value reference to a log axis - just put the\n    // result at the lowest range value on the plot (or if the range also went negative,\n    // one millionth of the top of the range)\n    var newVal = Math.log(Math.min(range[0], range[1])) / Math.LN10;\n    if(!isNumeric(newVal)) newVal = Math.log(Math.max(range[0], range[1])) / Math.LN10 - 6;\n    return newVal;\n};\n","'use strict';\n\nvar isNumeric = require('fast-isnumeric');\nvar isArrayOrTypedArray = require('./array').isArrayOrTypedArray;\n\n/**\n * aggNums() returns the result of an aggregate function applied to an array of\n * values, where non-numerical values have been tossed out.\n *\n * @param {function} f - aggregation function (e.g., Math.min)\n * @param {Number} v - initial value (continuing from previous calls)\n *      if there's no continuing value, use null for selector-type\n *      functions (max,min), or 0 for summations\n * @param {Array} a - array to aggregate (may be nested, we will recurse,\n *                    but all elements must have the same dimension)\n * @param {Number} len - maximum length of a to aggregate\n * @return {Number} - result of f applied to a starting from v\n */\nexports.aggNums = function(f, v, a, len) {\n    var i,\n        b;\n    if(!len || len > a.length) len = a.length;\n    if(!isNumeric(v)) v = false;\n    if(isArrayOrTypedArray(a[0])) {\n        b = new Array(len);\n        for(i = 0; i < len; i++) b[i] = exports.aggNums(f, v, a[i]);\n        a = b;\n    }\n\n    for(i = 0; i < len; i++) {\n        if(!isNumeric(v)) v = a[i];\n        else if(isNumeric(a[i])) v = f(+v, +a[i]);\n    }\n    return v;\n};\n\n/**\n * mean & std dev functions using aggNums, so it handles non-numerics nicely\n * even need to use aggNums instead of .length, to toss out non-numerics\n */\nexports.len = function(data) {\n    return exports.aggNums(function(a) { return a + 1; }, 0, data);\n};\n\nexports.mean = function(data, len) {\n    if(!len) len = exports.len(data);\n    return exports.aggNums(function(a, b) { return a + b; }, 0, data) / len;\n};\n\nexports.midRange = function(numArr) {\n    if(numArr === undefined || numArr.length === 0) return undefined;\n    return (exports.aggNums(Math.max, null, numArr) + exports.aggNums(Math.min, null, numArr)) / 2;\n};\n\nexports.variance = function(data, len, mean) {\n    if(!len) len = exports.len(data);\n    if(!isNumeric(mean)) mean = exports.mean(data, len);\n\n    return exports.aggNums(function(a, b) {\n        return a + Math.pow(b - mean, 2);\n    }, 0, data) / len;\n};\n\nexports.stdev = function(data, len, mean) {\n    return Math.sqrt(exports.variance(data, len, mean));\n};\n\n/**\n * median of a finite set of numbers\n * reference page: https://en.wikipedia.org/wiki/Median#Finite_set_of_numbers\n**/\nexports.median = function(data) {\n    var b = data.slice().sort();\n    return exports.interp(b, 0.5);\n};\n\n/**\n * interp() computes a percentile (quantile) for a given distribution.\n * We interpolate the distribution (to compute quantiles, we follow method #10 here:\n * http://jse.amstat.org/v14n3/langford.html).\n * Typically the index or rank (n * arr.length) may be non-integer.\n * For reference: ends are clipped to the extreme values in the array;\n * For box plots: index you get is half a point too high (see\n * http://en.wikipedia.org/wiki/Percentile#Nearest_rank) but note that this definition\n * indexes from 1 rather than 0, so we subtract 1/2 (instead of add).\n *\n * @param {Array} arr - This array contains the values that make up the distribution.\n * @param {Number} n - Between 0 and 1, n = p/100 is such that we compute the p^th percentile.\n * For example, the 50th percentile (or median) corresponds to n = 0.5\n * @return {Number} - percentile\n */\nexports.interp = function(arr, n) {\n    if(!isNumeric(n)) throw 'n should be a finite number';\n    n = n * arr.length - 0.5;\n    if(n < 0) return arr[0];\n    if(n > arr.length - 1) return arr[arr.length - 1];\n    var frac = n % 1;\n    return frac * arr[Math.ceil(n)] + (1 - frac) * arr[Math.floor(n)];\n};\n","'use strict';\n\n/*\n * make a regex for matching counter ids/names ie xaxis, xaxis2, xaxis10...\n *\n * @param {string} head: the head of the pattern, eg 'x' matches 'x', 'x2', 'x10' etc.\n *      'xy' is a special case for cartesian subplots: it matches 'x2y3' etc\n * @param {Optional(string)} tail: a fixed piece after the id\n *      eg counterRegex('scene', '.annotations') for scene2.annotations etc.\n * @param {boolean} openEnded: if true, the string may continue past the match.\n * @param {boolean} matchBeginning: if false, the string may start before the match.\n */\nexports.counter = function(head, tail, openEnded, matchBeginning) {\n    var fullTail = (tail || '') + (openEnded ? '' : '$');\n    var startWithPrefix = matchBeginning === false ? '' : '^';\n    if(head === 'xy') {\n        return new RegExp(startWithPrefix + 'x([2-9]|[1-9][0-9]+)?y([2-9]|[1-9][0-9]+)?' + fullTail);\n    }\n    return new RegExp(startWithPrefix + head + '([2-9]|[1-9][0-9]+)?' + fullTail);\n};\n","'use strict';\n\n/**\n * Push array with unique items\n *\n * Ignores falsy items, except 0 so we can use it to construct arrays of indices.\n *\n * @param {array} array\n *  array to be filled\n * @param {any} item\n *  item to be or not to be inserted\n * @return {array}\n *  ref to array (now possibly containing one more item)\n *\n */\nmodule.exports = function pushUnique(array, item) {\n    if(item instanceof RegExp) {\n        var itemStr = item.toString();\n        for(var i = 0; i < array.length; i++) {\n            if(array[i] instanceof RegExp && array[i].toString() === itemStr) {\n                return array;\n            }\n        }\n        array.push(item);\n    } else if((item || item === 0) && array.indexOf(item) === -1) array.push(item);\n\n    return array;\n};\n","'use strict';\n\nvar setCursor = require('./setcursor');\n\nvar STASHATTR = 'data-savedcursor';\nvar NO_CURSOR = '!!';\n\n/*\n * works with our CSS cursor classes (see css/_cursor.scss)\n * to override a previous cursor set on d3 single-element selections,\n * by moving the name of the original cursor to the data-savedcursor attr.\n * omit cursor to revert to the previously set value.\n */\nmodule.exports = function overrideCursor(el3, csr) {\n    var savedCursor = el3.attr(STASHATTR);\n    if(csr) {\n        if(!savedCursor) {\n            var classes = (el3.attr('class') || '').split(' ');\n            for(var i = 0; i < classes.length; i++) {\n                var cls = classes[i];\n                if(cls.indexOf('cursor-') === 0) {\n                    el3.attr(STASHATTR, cls.substr(7))\n                        .classed(cls, false);\n                }\n            }\n            if(!el3.attr(STASHATTR)) {\n                el3.attr(STASHATTR, NO_CURSOR);\n            }\n        }\n        setCursor(el3, csr);\n    } else if(savedCursor) {\n        el3.attr(STASHATTR, null);\n\n        if(savedCursor === NO_CURSOR) setCursor(el3);\n        else setCursor(el3, savedCursor);\n    }\n};\n","'use strict';\n\nvar d3 = require('@plotly/d3');\nvar isNumeric = require('fast-isnumeric');\n\nvar NOTEDATA = [];\n\n/**\n * notifier\n * @param {String} text The person's user name\n * @param {Number} [delay=1000] The delay time in milliseconds\n *          or 'long' which provides 2000 ms delay time.\n * @return {undefined} this function does not return a value\n */\nmodule.exports = function(text, displayLength) {\n    if(NOTEDATA.indexOf(text) !== -1) return;\n\n    NOTEDATA.push(text);\n\n    var ts = 1000;\n    if(isNumeric(displayLength)) ts = displayLength;\n    else if(displayLength === 'long') ts = 3000;\n\n    var notifierContainer = d3.select('body')\n        .selectAll('.plotly-notifier')\n        .data([0]);\n    notifierContainer.enter()\n        .append('div')\n        .classed('plotly-notifier', true);\n\n    var notes = notifierContainer.selectAll('.notifier-note').data(NOTEDATA);\n\n    function killNote(transition) {\n        transition\n            .duration(700)\n            .style('opacity', 0)\n            .each('end', function(thisText) {\n                var thisIndex = NOTEDATA.indexOf(thisText);\n                if(thisIndex !== -1) NOTEDATA.splice(thisIndex, 1);\n                d3.select(this).remove();\n            });\n    }\n\n    notes.enter().append('div')\n        .classed('notifier-note', true)\n        .style('opacity', 0)\n        .each(function(thisText) {\n            var note = d3.select(this);\n\n            note.append('button')\n                .classed('notifier-close', true)\n                .html('&times;')\n                .on('click', function() {\n                    note.transition().call(killNote);\n                });\n\n            var p = note.append('p');\n            var lines = thisText.split(/<br\\s*\\/?>/g);\n            for(var i = 0; i < lines.length; i++) {\n                if(i) p.append('br');\n                p.append('span').text(lines[i]);\n            }\n\n            if(displayLength === 'stick') {\n                note.transition()\n                        .duration(350)\n                        .style('opacity', 1);\n            } else {\n                note.transition()\n                        .duration(700)\n                        .style('opacity', 1)\n                    .transition()\n                        .delay(ts)\n                        .call(killNote);\n            }\n        });\n};\n","'use strict';\n\nvar isArrayOrTypedArray = require('./array').isArrayOrTypedArray;\nvar isPlainObject = require('./is_plain_object');\n\n/**\n * Relink private _keys and keys with a function value from one container\n * to the new container.\n * Relink means copying if object is pass-by-value and adding a reference\n * if object is pass-by-ref.\n * This prevents deepCopying massive structures like a webgl context.\n */\nmodule.exports = function relinkPrivateKeys(toContainer, fromContainer) {\n    for(var k in fromContainer) {\n        var fromVal = fromContainer[k];\n        var toVal = toContainer[k];\n\n        if(toVal === fromVal) continue;\n\n        if(k.charAt(0) === '_' || typeof fromVal === 'function') {\n            // if it already exists at this point, it's something\n            // that we recreate each time around, so ignore it\n            if(k in toContainer) continue;\n\n            toContainer[k] = fromVal;\n        } else if(isArrayOrTypedArray(fromVal) && isArrayOrTypedArray(toVal) && isPlainObject(fromVal[0])) {\n            // filter out data_array items that can contain user objects\n            // most of the time the toVal === fromVal check will catch these early\n            // but if the user makes new ones we also don't want to recurse in.\n            if(k === 'customdata' || k === 'ids') continue;\n\n            // recurse into arrays containers\n            var minLen = Math.min(fromVal.length, toVal.length);\n            for(var j = 0; j < minLen; j++) {\n                if((toVal[j] !== fromVal[j]) && isPlainObject(fromVal[j]) && isPlainObject(toVal[j])) {\n                    relinkPrivateKeys(toVal[j], fromVal[j]);\n                }\n            }\n        } else if(isPlainObject(fromVal) && isPlainObject(toVal)) {\n            // recurse into objects, but only if they still exist\n            relinkPrivateKeys(toVal, fromVal);\n\n            if(!Object.keys(toVal).length) delete toContainer[k];\n        }\n    }\n};\n","'use strict';\n\nmodule.exports = function sortObjectKeys(obj) {\n    return Object.keys(obj).sort();\n};\n","'use strict';\n\nvar constants = require('../constants/pixelated_image');\nvar Drawing = require('../components/drawing');\nvar Lib = require('../lib');\n\nvar _supportsPixelated = null;\n\n/**\n * Check browser support for pixelated image rendering\n *\n * @return {boolean}\n */\nfunction supportsPixelatedImage() {\n    if(_supportsPixelated !== null) { // only run the feature detection once\n        return _supportsPixelated;\n    }\n\n    _supportsPixelated = false;\n\n    // @see https://github.com/plotly/plotly.js/issues/6604\n    var unsupportedBrowser = Lib.isIE() || Lib.isSafari() || Lib.isIOS();\n\n    if(window.navigator.userAgent && !unsupportedBrowser) {\n        var declarations = Array.from(constants.CSS_DECLARATIONS).reverse();\n\n        var supports = (window.CSS && window.CSS.supports) || window.supportsCSS;\n        if(typeof supports === 'function') {\n            _supportsPixelated = declarations.some(function(d) {\n                return supports.apply(null, d);\n            });\n        } else {\n            var image3 = Drawing.tester.append('image')\n                .attr('style', constants.STYLE);\n\n            var cStyles = window.getComputedStyle(image3.node());\n            var imageRendering = cStyles.imageRendering;\n\n            _supportsPixelated = declarations.some(function(d) {\n                var value = d[1];\n                return (\n                    imageRendering === value ||\n                    imageRendering === value.toLowerCase()\n                );\n            });\n\n            image3.remove();\n        }\n    }\n\n    return _supportsPixelated;\n}\n\nmodule.exports = supportsPixelatedImage;\n","'use strict';\n\nvar timerCache = {};\n\n/**\n * Throttle a callback. `callback` executes synchronously only if\n * more than `minInterval` milliseconds have already elapsed since the latest\n * call (if any). Otherwise we wait until `minInterval` is over and execute the\n * last callback received while waiting.\n * So the first and last events in a train are always executed (eventually)\n * but some of the events in the middle can be dropped.\n *\n * @param {string} id: an identifier to mark events to throttle together\n * @param {number} minInterval: minimum time, in milliseconds, between\n *   invocations of `callback`\n * @param {function} callback: the function to throttle. `callback` itself\n *   should be a purely synchronous function.\n */\nexports.throttle = function throttle(id, minInterval, callback) {\n    var cache = timerCache[id];\n    var now = Date.now();\n\n    if(!cache) {\n        /*\n         * Throw out old items before making a new one, to prevent the cache\n         * getting overgrown, for example from old plots that have been replaced.\n         * 1 minute age is arbitrary.\n         */\n        for(var idi in timerCache) {\n            if(timerCache[idi].ts < now - 60000) {\n                delete timerCache[idi];\n            }\n        }\n        cache = timerCache[id] = {ts: 0, timer: null};\n    }\n\n    _clearTimeout(cache);\n\n    function exec() {\n        callback();\n        cache.ts = Date.now();\n        if(cache.onDone) {\n            cache.onDone();\n            cache.onDone = null;\n        }\n    }\n\n    if(now > cache.ts + minInterval) {\n        exec();\n        return;\n    }\n\n    cache.timer = setTimeout(function() {\n        exec();\n        cache.timer = null;\n    }, minInterval);\n};\n\nexports.done = function(id) {\n    var cache = timerCache[id];\n    if(!cache || !cache.timer) return Promise.resolve();\n\n    return new Promise(function(resolve) {\n        var previousOnDone = cache.onDone;\n        cache.onDone = function onDone() {\n            if(previousOnDone) previousOnDone();\n            resolve();\n            cache.onDone = null;\n        };\n    });\n};\n\n/**\n * Clear the throttle cache for one or all timers\n * @param {optional string} id:\n *   if provided, clear just this timer\n *   if omitted, clear all timers (mainly useful for testing)\n */\nexports.clear = function(id) {\n    if(id) {\n        _clearTimeout(timerCache[id]);\n        delete timerCache[id];\n    } else {\n        for(var idi in timerCache) exports.clear(idi);\n    }\n};\n\nfunction _clearTimeout(cache) {\n    if(cache && cache.timer !== null) {\n        clearTimeout(cache.timer);\n        cache.timer = null;\n    }\n}\n","'use strict';\n\n// ASCEND: chop off the last nesting level - either [<n>] or .<key> - to ascend\n// the attribute tree. the remaining attrString is in match[1]\nvar ASCEND = /^(.*)(\\.[^\\.\\[\\]]+|\\[\\d\\])$/;\n\n// SIMPLEATTR: is this an un-nested attribute? (no dots or brackets)\nvar SIMPLEATTR = /^[^\\.\\[\\]]+$/;\n\n/*\n * calculate a relative attribute string, similar to a relative path\n *\n * @param {string} baseAttr:\n *   an attribute string, such as 'annotations[3].x'. The \"current location\"\n *   is the attribute string minus the last component ('annotations[3]')\n * @param {string} relativeAttr:\n *   a route to the desired attribute string, using '^' to ascend\n *\n * @return {string} attrString:\n *   for example:\n *     relativeAttr('annotations[3].x', 'y') = 'annotations[3].y'\n *     relativeAttr('annotations[3].x', '^[2].z') = 'annotations[2].z'\n *     relativeAttr('annotations[3].x', '^^margin') = 'margin'\n *     relativeAttr('annotations[3].x', '^^margin.r') = 'margin.r'\n */\nmodule.exports = function(baseAttr, relativeAttr) {\n    while(relativeAttr) {\n        var match = baseAttr.match(ASCEND);\n\n        if(match) baseAttr = match[1];\n        else if(baseAttr.match(SIMPLEATTR)) baseAttr = '';\n        else throw new Error('bad relativeAttr call:' + [baseAttr, relativeAttr]);\n\n        if(relativeAttr.charAt(0) === '^') relativeAttr = relativeAttr.slice(1);\n        else break;\n    }\n\n    if(baseAttr && relativeAttr.charAt(0) !== '[') {\n        return baseAttr + '.' + relativeAttr;\n    }\n    return baseAttr + relativeAttr;\n};\n"],"names":["module","exports","moduleType","name","dictionary","format","days","shortDays","months","shortMonths","periods","dateTime","date","time","decimal","thousands","grouping","currency","year","month","dayMonth","dayMonthYear","d3","require","Lib","strTranslate","xmlnsNamespaces","LINE_SPACING","FIND_TEX","convertToTspans","_context","gd","_callback","str","text","tex","attr","typesetMath","MathJax","match","parent","select","node","parentNode","empty","svgClass","split","selectAll","remove","style","_promises","push","Promise","resolve","fontSize","parseInt","config","_texString","_config","originalRenderer","originalConfig","originalProcessSectionDelay","tmpDiv","MathJaxVersion","version","warn","setConfig2","extendDeepAll","Hub","processSectionDelay","undefined","Config","messageStyle","tex2jax","inlineMath","displayAlign","setConfig3","setRenderer2","menuSettings","renderer","setRenderer","setRenderer3","startup","output","initiateMathJax","randomID","randstr","tmpNode","append","id","visibility","position","replace","LT_MATCH","GT_MATCH","Typeset","typeset","finalizeMathJax","sel","glyphDefs","nodeBBox","getBoundingClientRect","log","resetRenderer2","resetRenderer3","resetConfig2","resetConfig3","Queue","defaultReady","promise","then","texToSVG","_svgEl","_glyphDefs","_svgBBox","newSvg","showText","mathjaxGroup","classed","appendChild","insertBefore","cloneNode","firstChild","w0","width","h0","height","class","preserveAspectRatio","overflow","fill","g","stroke","bb","w","h","x","y","dy","transform","indexOf","anchor","call","hasLink","containerNode","NEWLINES","currentNode","nodeStack","currentLine","newLine","lineNode","document","createElementNS","svg","oldNodeStack","length","i","enterNode","nodeSpec","nodeType","type","nodeAttrs","target","href","popup","charAt","onclick","newNode","addTextNode","ZERO_WIDTH_SPACE","resetter","RESET_DY","SHIFT_DY","createTextNode","exitNode","innerNode","pop","hasLines","BR_TAG","test","parts","SPLIT_TAGS","parti","ONE_TAG","tagType","toLowerCase","tagStyle","TAG_STYLES","convertEntities","extra","css","getQuotedMatch","STYLEMATCH","COLORMATCH","HREFMATCH","safeHref","sanitizeHref","TARGETMATCH","POPUPMATCH","buildSVGText","positionText","sup","sub","b","a","span","em","PROTOCOLS","BR_TAG_ALL","_str","re","result","plainText","opts","len","Infinity","allowedTags","oldParts","newParts","prevTag","l","p","pLen","pLen2","ellipsis","substr","join","entityToUnicode","mu","amp","lt","gt","nbsp","times","plusmn","deg","ENTITY_MATCH","fullMatch","innerMatch","code","stringFromCodePoint","String","fromCodePoint","stringFromCharCode","fromCharCode","decodedHref","encodeURI","decodeURI","dummyAnchor1","createElement","dummyAnchor2","p1","protocol","p2","alignHTMLWith","_base","container","options","thisRect","getTop","getLeft","alignH","horizontalAlign","alignV","verticalAlign","bRect","cRect","bottom","top","right","left","this","x0","y0","_fullLayout","_calcInverseTransform","transformedCoords","apply3DTransform","_invTransform","sanitizeHTML","rootNode","lineCount","s","size","each","setOrGet","val","thisX","thisY","nodeName","onePx","makeTextShadow","color","makeEditable","context","_delegate","delegate","dispatch","handlerElement","Error","handleClick","div","cStyle","parseFloat","initialText","fontFamily","opacity","background","outline","margin","padding","contenteditable","on","_editing","textContent","mathjaxClass","transition","duration","edit","editDiv","event","activeElement","blur","which","cancel","input","selectElementContents","appendEditable","_el","el","range","createRange","selectNodeContents","window","getSelection","removeAllRanges","addRange","focus","immediate","rebind","isNumeric","isMobileOrTablet","ua","hasOwnProperty","userAgent","navigator","headers","getUserAgent","enable","tablet","featureDetect","allParts","k","prevPart","v","el3","csr","forEach","cls","dot","BADNUM","polygon","tester","ptsIn","pts","slice","xmin","xmax","ymin","ymax","Math","min","max","rectFirstEdgeTest","isRect","pt","degenerate","lastPt","contains","omitFirstEdge","xmini","ycross","imax","x1","y1","crossings","isSegmentBent","start","end","tolerance","part","partParallel","startPt","segment","segmentSquared","segmentLen","sqrt","unitPerp","abs","filter","ptsFiltered","doneRawIndex","doneFilteredIndex","addPt","prevFilterLen","iLast","splice","raw","filtered","loggers","identity","roundingError","lessThan","lessOrEqual","greaterThan","greaterOrEqual","findBin","bins","linelow","ceil","floor","n","n1","n2","c","binSize","sorterAsc","sorterDes","distinctVals","valsIn","last","vals","sort","preV","minDiff","errDiff","newVals","diff","roundUp","arrayIn","reverse","mid","low","high","dlow","dhigh","rounded","array","sortFn","notOrdered","notReversed","pairOrder","findIndexOfMin","arr","fn","ind","dfltConfig","queue","undoFunc","undoArgs","redoFunc","redoArgs","queueObj","queueIndex","undoQueue","index","sequence","autoplay","inSequence","beginSequence","undo","calls","args","redo","unshift","queueLength","shift","isNaN","plotDo","func","arg","copy","Array","isArray","extendDeep","copyArgArray","apply","isArrayOrTypedArray","npGet","cont","curPart","allSame","out","j","curCont","propStr","indexed","indices","propParts","Number","set","get","astr","obj","badContainer","npSet","ARGS_PATTERN","isDeletable","propPart","containerLevels","toDelete","setArrayAll","checkNewContainer","joinPropStr","newPart","toAdd","containerArray","innerParts","arrayVal","allSet","thisVal","thisPropStr","deleteThis","firstPart","nextPart","LN10","newVal","aggNums","f","data","mean","midRange","numArr","variance","pow","stdev","median","interp","frac","counter","head","tail","openEnded","matchBeginning","fullTail","startWithPrefix","RegExp","item","itemStr","toString","setCursor","STASHATTR","savedCursor","classes","NOTEDATA","displayLength","ts","notifierContainer","enter","thisText","note","html","killNote","lines","delay","thisIndex","isPlainObject","relinkPrivateKeys","toContainer","fromContainer","fromVal","toVal","minLen","Object","keys","constants","Drawing","_supportsPixelated","unsupportedBrowser","isIE","isSafari","isIOS","declarations","from","CSS_DECLARATIONS","supports","CSS","supportsCSS","some","d","image3","STYLE","imageRendering","getComputedStyle","value","timerCache","_clearTimeout","cache","timer","clearTimeout","throttle","minInterval","callback","now","Date","idi","exec","onDone","setTimeout","done","previousOnDone","clear","ASCEND","SIMPLEATTR","baseAttr","relativeAttr"],"sourceRoot":""}